[Scummvm-cvs-logs] SF.net SVN: scummvm:[42853] tools/branches/gsoc2009-gui

Remere at users.sourceforge.net Remere at users.sourceforge.net
Tue Jul 28 01:28:07 CEST 2009


Revision: 42853
          http://scummvm.svn.sourceforge.net/scummvm/?rev=42853&view=rev
Author:   Remere
Date:     2009-07-27 23:28:06 +0000 (Mon, 27 Jul 2009)

Log Message:
-----------
*You can now use --help compress_agos instead of --tool compress_agos --help to get help about a specific tool.
*Avoided some nasty use of char ** by converting old parse functions to accept std::vector<std::string> instead. Avoided crash from ugly typecasts as well.

Modified Paths:
--------------
    tools/branches/gsoc2009-gui/compress.cpp
    tools/branches/gsoc2009-gui/compress.h
    tools/branches/gsoc2009-gui/tool.cpp
    tools/branches/gsoc2009-gui/tool.h
    tools/branches/gsoc2009-gui/tools.cpp
    tools/branches/gsoc2009-gui/tools.h
    tools/branches/gsoc2009-gui/tools_cli.cpp

Modified: tools/branches/gsoc2009-gui/compress.cpp
===================================================================
--- tools/branches/gsoc2009-gui/compress.cpp	2009-07-27 21:05:00 UTC (rev 42852)
+++ tools/branches/gsoc2009-gui/compress.cpp	2009-07-27 23:28:06 UTC (rev 42853)
@@ -673,14 +673,17 @@
 	encodeAudio(outName, true, real_samplerate, tempEncoded, compMode);
 }
 
-int CompressionTool::processMp3Parms(int argc, char *argv[], int* i) {
-	for (; *i < argc; (*i)++) {
-		if (strcmp(argv[*i], "--vbr") == 0) {
+bool CompressionTool::processMp3Parms() {
+	while (_arguments_parsed < _arguments.size()) {
+		std::string arg = _arguments[_arguments_parsed];
+
+		if (arg == "--vbr") {
 			encparms.abr = 0;
-		} else if (strcmp(argv[*i], "--abr") == 0) {
+		} else if (arg == "--abr") {
 			encparms.abr = 1;
-		} else if (strcmp(argv[*i], "-b") == 0) {
-			encparms.minBitr = atoi(argv[*i + 1]);
+		} else if (arg == "-b") {
+			++_arguments_parsed;
+			encparms.minBitr = atoi(_arguments[_arguments_parsed].c_str());
 
 			if ((encparms.minBitr % 8) != 0) {
 				encparms.minBitr -= encparms.minBitr % 8;
@@ -694,9 +697,9 @@
 				encparms.minBitr = 8;
 			}
 
-			(*i)++;
-		} else if (strcmp(argv[*i], "-B") == 0) {
-			encparms.maxBitr = atoi(argv[*i + 1]);
+		} else if (arg == "-B") {
+			++_arguments_parsed;
+			encparms.maxBitr = atoi(_arguments[_arguments_parsed].c_str());
 
 			if ((encparms.maxBitr % 8) != 0) {
 				encparms.maxBitr -= encparms.maxBitr % 8;
@@ -710,9 +713,9 @@
 				encparms.maxBitr = 8;
 			}
 
-			(*i)++;
-		} else if (strcmp(argv[*i], "-V") == 0) {
-			encparms.vbrqual = atoi(argv[*i + 1]);
+		} else if (arg == "-V") {
+			++_arguments_parsed;
+			encparms.vbrqual = atoi(_arguments[_arguments_parsed].c_str());
 
 			if (encparms.vbrqual < 0) {
 				encparms.vbrqual = 0;
@@ -722,9 +725,9 @@
 				encparms.vbrqual = 9;
 			}
 
-			(*i)++;
-		} else if (strcmp(argv[*i], "-q") == 0) {
-			encparms.algqual = atoi(argv[*i + 1]);
+		} else if (arg == "-q") {
+			++_arguments_parsed;
+			encparms.algqual = atoi(_arguments[_arguments_parsed].c_str());
 
 			if (encparms.algqual < 0) {
 				encparms.algqual = 0;
@@ -734,28 +737,26 @@
 				encparms.algqual = 9;
 			}
 
-			(*i)++;
-		} else if (strcmp(argv[*i], "--silent") == 0) {
+		} else if (arg == "--silent") {
 			encparms.silent = 1;
-		} else if (strcmp(argv[*i], "--help") == 0) {
-			return 0;
 		} else {
 			break;
 		}
-	}
 
-	if (*i != (argc - 1)) {
-		return 0;
+		++_arguments_parsed;
 	}
 
-	return 1;
+	return true;
 }
 
-int CompressionTool::processOggParms(int argc, char *argv[], int* i) {
-	for (; *i < argc; (*i)++) {
-		if (strcmp(argv[*i], "-b") == 0) {
-			oggparms.nominalBitr = atoi(argv[*i + 1]);
+bool CompressionTool::processOggParms() {
+	while (_arguments_parsed < _arguments.size()) {
+		std::string arg = _arguments[_arguments_parsed];
 
+		if (arg == "-b") {
+			++_arguments_parsed;
+			oggparms.nominalBitr = atoi(_arguments[_arguments_parsed].c_str());
+
 			if ((oggparms.nominalBitr % 8) != 0) {
 				oggparms.nominalBitr -= oggparms.nominalBitr % 8;
 			}
@@ -768,9 +769,9 @@
 				oggparms.nominalBitr = 8;
 			}
 
-			(*i)++;
-		} else if (strcmp(argv[*i], "-m") == 0) {
-			oggparms.minBitr = atoi(argv[*i + 1]);
+		} else if (arg == "-m") {
+			++_arguments_parsed;
+			oggparms.minBitr = atoi(_arguments[_arguments_parsed].c_str());
 
 			if ((oggparms.minBitr % 8) != 0) {
 				oggparms.minBitr -= oggparms.minBitr % 8;
@@ -784,9 +785,9 @@
 				oggparms.minBitr = 8;
 			}
 
-			(*i)++;
-		} else if (strcmp(argv[*i], "-M") == 0) {
-			oggparms.maxBitr = atoi(argv[*i + 1]);
+		} else if (arg == "-M") {
+			++_arguments_parsed;
+			oggparms.maxBitr = atoi(_arguments[_arguments_parsed].c_str());
 
 			if ((oggparms.maxBitr % 8) != 0) {
 				oggparms.maxBitr -= encparms.minBitr % 8;
@@ -800,73 +801,60 @@
 				oggparms.maxBitr = 8;
 			}
 
-			(*i)++;
-		} else if (strcmp(argv[*i], "-q") == 0) {
-			oggparms.quality = (float)atoi(argv[*i + 1]);
-			(*i)++;
-		} else if (strcmp(argv[*i], "--silent") == 0) {
+		} else if (arg == "-q") {
+			++_arguments_parsed;
+			oggparms.quality = (float)atoi(_arguments[_arguments_parsed].c_str());
+		} else if (arg == "--silent") {
 			oggparms.silent = 1;
-		} else if (strcmp(argv[*i], "--help") == 0) {
-			return 0;
-		} else if (argv[*i][0] == '-') {
-			return 0;
 		} else {
 			break;
 		}
-	}
 
-	if (*i != argc - 1) {
-		return 0;
+		++_arguments_parsed;
 	}
 
-	return 1;
+	return true;
 }
 
-int CompressionTool::processFlacParms(int argc, char *argv[], int *i){
-	for (; *i < argc; (*i)++) {
-		if (strcmp(argv[*i], "-b") == 0) {
-			flacparms.blocksize = atoi(argv[*i + 1]);
-			(*i)++;
-		} else if (strcmp(argv[*i], "--fast") == 0) {
+bool CompressionTool::processFlacParms(){
+	while (_arguments_parsed < _arguments.size()) {
+		std::string arg = _arguments[_arguments_parsed];
+
+		if (arg == "-b") {
+			++_arguments_parsed;
+			flacparms.blocksize = atoi(_arguments[_arguments_parsed].c_str());
+		} else if (arg == "--fast") {
 			flacparms.compressionLevel = 0;
-		} else if (strcmp(argv[*i], "--best") == 0) {
+		} else if (arg == "--best") {
 			flacparms.compressionLevel = 8;
-		} else if (strcmp(argv[*i], "-0") == 0) {
+		} else if (arg == "-0") {
 			flacparms.compressionLevel = 0;
-		} else if (strcmp(argv[*i], "-1") == 0) {
+		} else if (arg == "-1") {
 			flacparms.compressionLevel = 1;
-		} else if (strcmp(argv[*i], "-2") == 0) {
+		} else if (arg == "-2") {
 			flacparms.compressionLevel = 2;
-		} else if (strcmp(argv[*i], "-3") == 0) {
+		} else if (arg == "-3") {
 			flacparms.compressionLevel = 3;
-		} else if (strcmp(argv[*i], "-4") == 0) {
+		} else if (arg == "-4") {
 			flacparms.compressionLevel = 4;
-		} else if (strcmp(argv[*i], "-5") == 0) {
+		} else if (arg == "-5") {
 			flacparms.compressionLevel = 5;
-		} else if (strcmp(argv[*i], "-6") == 0) {
+		} else if (arg == "-6") {
 			flacparms.compressionLevel = 6;
-		} else if (strcmp(argv[*i], "-7") == 0) {
+		} else if (arg == "-7") {
 			flacparms.compressionLevel = 7;
-		} else if (strcmp(argv[*i], "-8") == 0) {
+		} else if (arg == "-8") {
 			flacparms.compressionLevel = 8;
-		} else if (strcmp(argv[*i], "--verify") == 0) {
+		} else if (arg == "--verify") {
 			flacparms.verify = true;
-		} else if (strcmp(argv[*i], "--silent") == 0) {
+		} else if (arg == "--silent") {
 			flacparms.silent = true;
-		} else if (strcmp(argv[*i], "--help") == 0) {
-			return 0;
-		} else if (argv[*i][0] == '-') {
-			return 0;
 		} else {
 			break;
 		}
 	}
 
-	if (*i != argc - 1) {
-		return 0;
-	}
-
-	return 1;
+	return true;
 }
 
 // Compression tool interface
@@ -898,17 +886,17 @@
 	switch (_format) {
 	case AUDIO_MP3:
 		tempEncoded = TEMP_MP3;
-		if (!processMp3Parms(_arguments.size() - 2, _argv, &arg))
+		if (!processMp3Parms())
 			throw ToolException("Could not parse command line arguments, use --help for options");
 		break;
 	case AUDIO_VORBIS:
 		tempEncoded = TEMP_OGG;
-		if (!processOggParms(_arguments.size() - 2, _argv, &arg))
+		if (!processOggParms())
 			throw ToolException("Could not parse command line arguments, use --help for options");
 		break;
 	case AUDIO_FLAC:
 		tempEncoded = TEMP_FLAC;
-		if (!processFlacParms(_arguments.size() - 2, _argv, &arg))
+		if (!processFlacParms())
 			throw ToolException("Could not parse arguments: Use --help for options");
 		break;
 	default: // cannot occur but we check anyway to avoid compiler warnings

Modified: tools/branches/gsoc2009-gui/compress.h
===================================================================
--- tools/branches/gsoc2009-gui/compress.h	2009-07-27 21:05:00 UTC (rev 42852)
+++ tools/branches/gsoc2009-gui/compress.h	2009-07-27 23:28:06 UTC (rev 42853)
@@ -94,9 +94,9 @@
 	std::string _oggMaxBitrate;
 	
 public:
-	int processMp3Parms(int argc, char *argv[], int* i);
-	int processOggParms(int argc, char *argv[], int* i);
-	int processFlacParms(int argc, char *argv[], int* i);
+	bool processMp3Parms();
+	bool processOggParms();
+	bool processFlacParms();
 
 	void extractAndEncodeVOC(const char *outName, File &input, AudioFormat compMode);
 	void extractAndEncodeWAV(const char *outName, File &input, AudioFormat compMode);

Modified: tools/branches/gsoc2009-gui/tool.cpp
===================================================================
--- tools/branches/gsoc2009-gui/tool.cpp	2009-07-27 21:05:00 UTC (rev 42852)
+++ tools/branches/gsoc2009-gui/tool.cpp	2009-07-27 23:28:06 UTC (rev 42853)
@@ -31,7 +31,6 @@
 	_type = type;
 
 	_arguments_parsed = 0;
-	_argv = NULL;
 
 	_outputToDirectory = true;
 	_supportedFormats = AUDIO_ALL;
@@ -59,12 +58,20 @@
 	argc -= 1;
 	argv += 1; 
 
-	_arguments.clear();
+	std::vector<std::string> args;
 	for (int i = 0; i < argc; ++i)
-		_arguments.push_back(argv[i]);
+		args.push_back(argv[i]);
+
+	return run(args);
+}
+
+int Tool::run(std::vector<std::string> args) {
+	_arguments = args;
 	_arguments_parsed = 0;
-	_argv = 0;
 
+	// Pop the first argument (name of ourselves)
+	_arguments.erase(_arguments.begin());
+
 	// Check for help
 	if (_arguments.empty() || _arguments[0] == "-h" || _arguments[0] == "--help") {
 		print(getHelp().c_str());

Modified: tools/branches/gsoc2009-gui/tool.h
===================================================================
--- tools/branches/gsoc2009-gui/tool.h	2009-07-27 21:05:00 UTC (rev 42852)
+++ tools/branches/gsoc2009-gui/tool.h	2009-07-27 23:28:06 UTC (rev 42853)
@@ -63,11 +63,21 @@
 	Tool(const std::string &name, ToolType type);
 	virtual ~Tool();
 
-	// Run with CLI args (parses them, and then calls run())
-	// This version also catches all errors and prints them before exiting
+	/**
+	 * Run tool with CLI args (parses them, and then calls run())
+	 * This version also catches all errors and prints them before exiting
+	 *
+	 * @param argc Argument count
+	 * @param argv Argument values
+	 */
 	int run(int argc, char *argv[]);
-	// Parse with args set already
-	// passes through errors
+	/** Same as the above, but accepts vector of string instead */
+	int run(std::vector<std::string> args);
+
+	/**
+	 * Parse with args set already (modify the public members to set them)
+	 * Exceptions are not caught, so this function may throw
+	 */
 	void run();
 
 	/**
@@ -188,10 +198,6 @@
 	std::vector<std::string> _arguments;
 	/* How many of the arguments we have parsed so far */
 	size_t _arguments_parsed;
-	/**
-	 * The raw arguments, necossary to invoke some functions properly, 
-	 * argc is the same as _arguments.size() */
-	char **_argv;
 
 	/** If this tools outputs to a directory, not a file. */
 	bool _outputToDirectory;

Modified: tools/branches/gsoc2009-gui/tools.cpp
===================================================================
--- tools/branches/gsoc2009-gui/tools.cpp	2009-07-27 21:05:00 UTC (rev 42852)
+++ tools/branches/gsoc2009-gui/tools.cpp	2009-07-27 23:28:06 UTC (rev 42853)
@@ -86,12 +86,12 @@
 		delete *iter;
 }
 
-Tools::ToolList Tools::inspectInput(ToolType type, std::deque<char *> files) const {
+Tools::ToolList Tools::inspectInput(ToolType type, std::deque<std::string> files) const {
 	ToolList choices;
 	for (ToolList::const_iterator tool = _tools.begin(); tool != _tools.end(); ++tool) {
 		if (type == TOOLTYPE_ALL || (*tool)->getType() == type) {
 			if ((*tool)->_inputPaths.size() == files.size()) {
-				for (std::deque<char *>::const_iterator filename = files.begin(); filename != files.end(); ++filename) {
+				for (std::deque<std::string>::const_iterator filename = files.begin(); filename != files.end(); ++filename) {
 					if((*tool)->inspectInput(*filename)) {
 						choices.push_back(*tool);
 						break;

Modified: tools/branches/gsoc2009-gui/tools.h
===================================================================
--- tools/branches/gsoc2009-gui/tools.h	2009-07-27 21:05:00 UTC (rev 42852)
+++ tools/branches/gsoc2009-gui/tools.h	2009-07-27 23:28:06 UTC (rev 42853)
@@ -43,7 +43,7 @@
 	 * Returns a list of the tools that supports opening the input file
 	 * specified in the input list.
 	 */
-	ToolList inspectInput(ToolType type, std::deque<char *> files) const;
+	ToolList inspectInput(ToolType type, std::deque<std::string> files) const;
 
 protected:
 	/** List of all tools */

Modified: tools/branches/gsoc2009-gui/tools_cli.cpp
===================================================================
--- tools/branches/gsoc2009-gui/tools_cli.cpp	2009-07-27 21:05:00 UTC (rev 42852)
+++ tools/branches/gsoc2009-gui/tools_cli.cpp	2009-07-27 23:28:06 UTC (rev 42853)
@@ -37,10 +37,10 @@
 	if (argc == 1) {
 		// Run without any arguments
 		printHelp();
-		return 0;
+		return 2;
 	}
 
-	std::deque<char *> arguments(argv, argv + argc);
+	std::deque<std::string> arguments(argv, argv + argc);
 	arguments.pop_front(); // Pop our own name
 
 	ToolType type = TOOLTYPE_ALL;
@@ -53,13 +53,27 @@
 			Tool *tool = *iter;
 			if (arguments.front() == tool->getName()) {
 				// Run the tool, first argument will be name, very nice!
-				return tool->run(arguments.size(), &arguments.front());
+				return tool->run(std::vector<std::string>(arguments.begin(), arguments.end()));
 			}
 		}
 		std::cout << "\tUnknown tool, make sure you input one of the following:\n";
 		printTools();
 	} else if (option == "--help" || option == "-h") {
+		arguments.pop_front();
+
+		if(arguments.size()) {
+			for (ToolList::iterator iter = _tools.begin(); iter != _tools.end(); ++iter) {
+				Tool *tool = *iter;
+				if (arguments.front() == tool->getName()) {
+					// Run the tool, first argument will be name, very nice!
+					std::cout << tool->getHelp() << std::endl;
+					return 2;
+				}
+			}
+			std::cout << "\nUnknown help topic '" << arguments[1] << "'\n";
+		}
 		printHelp();
+		return 2;
 	} else if (option == "--list" || option == "-l") {
 		printTools();
 	} else {
@@ -114,10 +128,8 @@
 		std::cout << "\tRunning using " << tool->getName() << "\n";
 		
 		// Run the tool, with the remaining arguments
-		// We also add the name of the tool so it can displayed (requires an evil cast but it's safe)
-		std::string name = tool->getName();
-		arguments.push_front(const_cast<char *>(name.c_str()));
-		return tool->run(arguments.size(), &arguments.front());
+		arguments.push_front(tool->getName());
+		return tool->run(std::vector<std::string>(arguments.begin(), arguments.end()));
 	}
 
 	return 0;


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.




More information about the Scummvm-git-logs mailing list