***************
*** 0 ****
--- 1,215 ----
+ /***************************************************************************
+  *   Copyright (C) 2005 by Mircea Bardac                                   *
+  *   dev@mircea.bardac.net                                             *
+  *                                                                         *
+  *   This program is free software; you can redistribute it and/or modify  *
+  *   it under the terms of the GNU General Public License as published by  *
+  *   the Free Software Foundation; either version 2 of the License, or     *
+  *   (at your option) any later version.                                   *
+  *                                                                         *
+  *   This program is distributed in the hope that it will be useful,       *
+  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+  *   GNU General Public License for more details.                          *
+  *                                                                         *
+  *   You should have received a copy of the GNU General Public License     *
+  *   along with this program; if not, write to the                         *
+  *   Free Software Foundation, Inc.,                                       *
+  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+  ***************************************************************************/
+ 
+ #include "argumentparser.h"
+ 
+ /**
+  @author Mircea Bardac
+  @version 1.0 
+ */
+ 
+ 
+ /**
+  * Class Constructor (takes main() function arguments and initializes
+  * the parser engine
+  * \param c number of arguments
+  * \param v pointer to the char* arguments
+  */
+ ArgumentParser::ArgumentParser (int c, char **v):
+ 	argc(c), argv(v), stopOnUnknownArg(false) {};
+ 
+ /**
+  * Class Destructor
+  */
+ ArgumentParser::~ArgumentParser() { };
+ 
+ /**
+  * Function to convert an abbreviation to its true name
+  * \param abbrev abbreviation
+  * \return the corresponding real name of the parameter
+  */
+ QString ArgumentParser::convertAbbrev(const QString abbrev)
+ {
+ 	QMap<QString,QString>::Iterator a=abbrevs.find(abbrev);
+ 	if (a!=abbrevs.end())
+ 	{
+ 		return a.data();
+ 	}
+ 	else
+ 	{
+ 		if (stopOnUnknownArg) gotError=100;
+ 			// just an internal signal
+ 			// (will be modified to point the correct argument index)
+ 		return "";
+ 	}
+ }
+ 
+ /**
+  * Function to test if an argument takes a value or not
+  * \param argname the argument tested
+  * \return TRUE if argument takes a value or FALSE otherwise
+ */
+ bool ArgumentParser::takesValue(const QString argname)
+ {
+ 	QMap<QString,ArgumentDetails>::Iterator hv=argData.find(argname);
+ 	if (hv==argData.end()) return false;
+ 	return (hv.data().takesValue);
+ }
+ 
+ /**
+  * Function to test if an argument is known or not
+  * \param argname the argument tested
+  * \return TRUE if argument is known or FALSE otherwise
+ */
+ bool ArgumentParser::knownArg(const QString argname)
+ {
+ 	return (argData.contains(argname));
+ }
+ 
+ /**
+  * Function to parse the arguments
+  * (the 'brain' of the class)
+  */
+ void ArgumentParser::parse()
+ {
+ //	printf("Number of arguments: %d\n",argc-1);
+ 	gotError=0;
+ 	for(int i=1;i<argc;i++)
+ 	{
+ 		QString argcurrent(argv[i]);
+ 		QString argname,argvalue="";
+ 		if (argcurrent.left(2)=="--")
+ 		{
+ 			// new argument
+ 			int p;
+ 			argcurrent.remove(0,2);
+ 			if ((p=argcurrent.find('=')) != -1)	//test for "--param=value"
+ 			{ //value given
+ 				argname=argcurrent.left(p);
+ 				argcurrent.remove(0,p+1);
+ 				argvalue=argcurrent;
+ 			}
+ 			else
+ 			{ //no value given = "--param"
+ 				argname=argcurrent;
+ 				if (takesValue(argname)) { gotError=i; return; }
+ 			}
+ //			 printf("arg(%s) value(%s)\n",argname.latin1(),argvalue.latin1());
+ 			if (argname!="") arguments.insert(argname,argvalue);
+ 			continue;
+ 		}
+ 		if (argcurrent.left(1)=="-") // test for "-param value"
+ 		{
+ 			argcurrent.remove(0,1);
+ 			if (argcurrent=="") continue;
+ 			argname=convertAbbrev(argcurrent);
+ //			printf("- converted argument: %s to %s\n",argcurrent.latin1(),argname.latin1());
+ 			if (gotError>0) { gotError=i; return;} 
+ 			if (takesValue(argname)) // "value" might be missing
+ 			{
+ 				i++;
+ 				if (i==argc) { gotError=i-1; return; }
+ 				argvalue=QString(argv[i]);
+ 			}
+ 			arguments.insert(argname,argvalue);
+ 			continue;
+ 		}
+ //		printf("Ignored argument: %s\n",argcurrent.latin1());
+ 	}
+ }
+ 
+ /*
+ void ArgumentParser::showArgs()
+ {
+ 	if (gotError>0) printf("!!! Error at argument %d!\n",gotError);
+ 	QMap<QString,QString>::Iterator it;
+ 	for (it=arguments.begin(); it!=arguments.end(); ++it)
+ 	{
+ 		printf("ARG: %s -- VALUE: %s\n",it.key().latin1(),it.data().latin1());
+ 	}
+ }
+ */
+ 
+ /**
+  * Function to add an argument to the list of recognized arguments
+  * \param argname full name of the argument
+  * \param abbrev abbreviation of the argument (optional)
+  * \param takesValue indicates wether the argument must have a value or not
+  * \param helpdesc help description for the given argument
+  */
+ void ArgumentParser::addArgument
+   (const QString argname, const QString abbrev,
+    const bool takesValue, const QString helpdesc)
+ {
+ 	ArgumentDetails d; d.takesValue=takesValue; d.helpdesc=helpdesc;
+ 	argData.insert(argname,d);
+ 	//	printf(">abbrev: %s -> %s\n",abbrev.latin1(),argname.latin1());
+ 	if (abbrev!="") abbrevs.insert(abbrev,argname);
+ }
+ 
+ 
+ /**
+  * Function to test if an agument was passed to the program
+  * \param argname full name of the argument
+  */
+ bool ArgumentParser::existsArg(const QString argname)
+ {
+ 	QMap<QString,QString>::Iterator a=arguments.find(argname);
+ 	return (a!=arguments.end());
+ }
+ 
+ /**
+  * Function to read the int value of a given argument
+  * \param argname argument name
+  * \return the argument int value 
+  */
+ int ArgumentParser::getInt(const QString argname)
+ {
+ 	QMap<QString,QString>::Iterator a=arguments.find(argname);
+ 	if (a!=arguments.end())
+ 		return a.data().toInt();
+ 	if (!knownArg(argname))
+ 	{
+ 		printf("Warning: reading unknown argument \"%s\"!\n",argname.latin1());
+ 		return 0;
+ 	}
+ 	return 0;
+ }
+ 
+ 
+ /**
+  * Function to read the string value of a given argument
+  * \param argname argument name
+  * \return the argument string value 
+  */
+ QString ArgumentParser::getString(QString argname)
+ {
+ 	QMap<QString,QString>::Iterator a=arguments.find(argname);
+ 	if (a!=arguments.end())
+ 		return a.data();
+ 	if (!knownArg(argname))
+ 	{
+ 		printf("Warning: reading unknown argument \"%s\"!\n",argname.latin1());
+ 		return "";
+ 	}
+ 	return "";
+ }
+ 
+