From 8f27e65bddd7d4b8515ce620fb485fdd78fcdf89 Mon Sep 17 00:00:00 2001
From: Constantin Jucovschi <cj@ubuntu.localdomain>
Date: Fri, 24 Apr 2009 07:20:22 -0400
Subject: Initial commit

---
 commline/cmlparser.cc | 915 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 915 insertions(+)
 create mode 100644 commline/cmlparser.cc

(limited to 'commline/cmlparser.cc')

diff --git a/commline/cmlparser.cc b/commline/cmlparser.cc
new file mode 100644
index 0000000..7c3d50d
--- /dev/null
+++ b/commline/cmlparser.cc
@@ -0,0 +1,915 @@
+/*
+* This file is part of rasdaman community.
+*
+* Rasdaman community 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 3 of the License, or
+* (at your option) any later version.
+*
+* Rasdaman community 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 rasdaman community.  If not, see <http://www.gnu.org/licenses/>.
+*
+* Copyright 2003, 2004, 2005, 2006, 2007, 2008, 2009 Peter Baumann /
+rasdaman GmbH.
+*
+* For more information please see <http://www.rasdaman.org>
+* or contact Peter Baumann via <baumann@rasdaman.com>.
+/
+/**
+ * SOURCE: cmlparser.cc
+ *
+ * MODULE: akinside/commline
+ *
+ * PURPOSE:
+ *
+ * COMMENTS:
+ *		None
+*/
+
+
+#include <cmlparser.hh>
+
+#include <stdio.h>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <cstring>
+
+#include <ctype.h>
+#include <vector>
+#include <iomanip>
+#include <cstdlib>
+
+using namespace std;
+
+static const char rcsid[] = "@(#)commline,cmlparser: $Id: cmlparser.cc,v 1.5 2006/01/17 07:50:07 rasdev Exp $";
+
+const char* CommandLineParserVersion = "1.0 (c) 2003 Dr. Peter Baumann";
+
+//#############################################################
+
+char*
+dupString(const char* cc)
+{
+	if(cc)
+	{
+		// strdup uses malloc, we would like to avoid it
+		char *dup = new char[strlen(cc)+1];
+		// new throws? we hope
+		strcpy(dup,cc);
+		return dup;
+	}
+
+	return NULL;
+}
+   
+CmlException::CmlException(const string& whatString)
+:problem(whatString)
+{
+}
+   
+CmlException::~CmlException() throw()
+{
+}
+   
+const char* CmlException::what() const throw()
+{
+	return problem.c_str();
+}   
+   
+   
+//############################################################
+
+const char* CommandLineParameter::defaultTitle     = "default: ";
+const char* CommandLineParameter::descSep          = " ";
+const char* CommandLineParameter::descTab          = "\t";
+const char* CommandLineParameter::descIndent       = "       ";
+const char* CommandLineParameter::descLineSep      = "\n";
+const char  CommandLineParameter::descOpen         = '<';
+const char  CommandLineParameter::descClose        = '>';
+const char* CommandLineParameter::descLeftDefault  = "(";
+const char* CommandLineParameter::descRightDefault = ")";
+
+
+
+CommandLineParameter::CommandLineParameter(char newShortName, const char* newLongName, const char* newDefaultValue) throw(CmlException)
+  : longName(NULL), defaultValue(NULL), descriptionText(NULL), paramDescription(NULL)
+{
+  
+	if((!isalnum(newShortName) || (newShortName == CommandLineParser::noShortName))
+	&& (!newLongName || !strcmp(newLongName, CommandLineParser::noLongName)))
+		throw CmlException(string("") + "Invalid option: shortName='" + newShortName + "' longName='" + (newLongName? newLongName: "NULL") + "'");
+  
+	shortName    = newShortName;
+	longName     = dupString(newLongName);
+	present      = false;
+	wasLongName  = false;
+	defaultValue = dupString(newDefaultValue);
+	
+	shNameString[0] = newShortName;
+	shNameString[1] = 0;
+	
+	paramDescription = NULL;
+	descriptionText  = NULL;
+}
+
+CommandLineParameter::CommandLineParameter(char newShortName, const char* newLongName, long newDefaultValue) throw(CmlException)
+  : longName(NULL), defaultValue(NULL), descriptionText(NULL), paramDescription(NULL)
+{
+  
+	if((!isalnum(newShortName) || (newShortName == CommandLineParser::noShortName))
+	&& (!newLongName || !strcmp(newLongName, CommandLineParser::noLongName)))
+		throw CmlException(string("") + "Invalid option: shortName='" + newShortName + "' longName='" + (newLongName? newLongName: "NULL") + "'");
+  
+	shortName    = newShortName;
+	longName     = dupString(newLongName);
+	present      = false;
+	wasLongName  = false;
+
+	// convert default to ASCII, for uniform handling
+        stringstream s;
+        s << newDefaultValue;
+	defaultValue = dupString( s.str().c_str() );
+
+	shNameString[0] = newShortName;
+	shNameString[1] = 0;
+	
+	paramDescription = NULL;
+	descriptionText  = NULL;
+}
+
+const char* CommandLineParameter::calledName()
+{
+	const char* retval=NULL;
+	
+	if(shortName == CommandLineParser::noShortName)
+		retval = longName;
+	else
+		if(!strcmp(longName, CommandLineParser::noLongName))
+			retval = shNameString;
+		else
+			retval = (wasLongName && longName) ? longName : shNameString;
+	return retval;
+}
+
+void CommandLineParameter::reset()
+{
+	present=false;
+	wasLongName=false;
+}
+
+
+CommandLineParameter::~CommandLineParameter()
+{
+	if(longName)
+		delete[] longName;
+	
+	if(defaultValue)
+		delete[] defaultValue;
+	
+	// paramDescription and descriptionText point both to the same string
+	// but depends on the context which has to be deleted
+	if(paramDescription) 
+	{
+		delete[] paramDescription;
+		paramDescription = NULL;
+		descriptionText = NULL;
+	}
+	if(descriptionText)
+		delete[] descriptionText;
+}
+
+void CommandLineParameter::setDescription(const char *desc)
+{
+	// cleaning the previous paramDescription
+	// paramDescription and descriptionText point both to the same string
+	// but depends on the context which has to be deleted
+	if(paramDescription) 
+	{
+		delete[] paramDescription;
+		paramDescription = NULL;
+		descriptionText = NULL;
+	}
+	if(descriptionText) delete[] descriptionText;
+
+	if(desc==NULL) 
+	{
+		paramDescription=NULL;
+		descriptionText =NULL;
+	}	
+	else
+	{	
+		paramDescription = dupString(desc);
+	
+		// if the string is "<text> line1...", for options with parameters
+		if(paramDescription[0]==descOpen)
+		{
+			int len = strlen(paramDescription);
+			int i=0;
+			for(i=0;i<len;i++)
+			{
+				if((paramDescription[i]==descClose) && (i<len-1))
+				{
+					paramDescription[i+1]=0;
+					descriptionText = paramDescription+i+2;
+					break;
+				}
+		  	}
+		  
+			if(i>=len-1) // I didn't find descClose
+			{
+				descriptionText=paramDescription;
+				paramDescription=NULL;
+			}
+		}  
+	 	else
+		{
+			// the string is just "line1..." for options without parameters
+			descriptionText = paramDescription;
+			paramDescription = NULL;
+		}
+	}
+
+#ifdef DEBUG  
+	cout<<"desc="<<desc<<endl;   
+	if(paramDescription==NULL)
+		cout<<"paramDescription=NULL"<<endl;
+	else
+		cout<<"paramDescription="<<paramDescription<<endl;
+
+	if(descriptionText==NULL)
+		cout<<"descriptionText=NULL"<<endl;
+	else
+		cout<<"descriptionText="<<descriptionText<<endl;
+#endif
+}
+   
+bool CommandLineParameter::doesMatch(char c)
+{
+	if(shortName==CommandLineParser::noShortName)
+		return false;
+	return shortName==c ? true:false;
+}
+
+bool CommandLineParameter::doesMatch(const char* s)
+{
+	if(longName==NULL)
+		return false;
+	if(s == NULL)
+		return false;
+	if(!strcmp(longName, CommandLineParser::noLongName))
+		return false;
+	return strcmp(longName,s)==0 ? true:false;
+}
+
+char CommandLineParameter::getShortName() const
+{
+	return shortName;
+}
+
+const char* CommandLineParameter::getLongName() const 
+{
+	return longName;    
+}
+
+/// print help text, composed from the option descriptions passwd to cml 
+ostream& CommandLineParameter::printHelp(ostream &os)
+{
+	if(descriptionText == NULL)
+		return os;
+	
+	static const unsigned int longNameLen=30;
+	static const unsigned int longParamLen=30;   
+	
+	os << CommandLineParameter::descIndent;
+
+	if(isalnum(shortName) && (shortName != CommandLineParser::noShortName))
+		os<< CommandLineParser::ShortSign <<shortName;
+	// we want a flush left display, don't adjust short/long params each -- PB 2003-jul-05
+	// else
+	//    os << "  ";
+ 
+	if((isalnum(shortName) && (shortName != CommandLineParser::noShortName)) && 
+	  (longName && strcmp(longName, CommandLineParser::noLongName)))
+		os << ", ";
+	// we want a flush left display, don't adjust short/long params each -- PB 2003-jul-05
+	// else
+	//    os << "  ";
+
+	// we want the parameter to appear right after the option, no adjustment -- PB 2003-jul-
+	// os.setf(ios::left);
+	// os << setw(longNameLen);
+	
+	if(longName && strcmp(longName, CommandLineParser::noLongName))
+	{
+		string s;
+		s += CommandLineParser::LongSign;
+		s += longName;
+		os << s.c_str();
+	}
+	else
+		os << "";
+
+	// separator between param name and value
+	os << CommandLineParameter::descSep;
+	
+	// no adjustment, again
+	// os.setf(ios::left);
+	// os << setw(longParamLen);
+	
+	// param value, such as "<database>"
+	if(paramDescription)
+		os << paramDescription;
+	
+	// separator between param value and default
+	if(defaultValue)
+		os << CommandLineParameter::descTab;
+
+	// print default, if any: "(default: 42)"
+	if(defaultValue)
+		os << CommandLineParameter::descLeftDefault << defaultTitle << defaultValue << CommandLineParameter::descRightDefault;
+
+	// in a second line, print description text (2*indent)
+	if(descriptionText)
+		os << CommandLineParameter::descLineSep << CommandLineParameter::descIndent << CommandLineParameter::descIndent << descriptionText;
+	
+	os<<flush;
+
+	return os;
+}
+  
+//#####################################################################
+
+FlagParameter::FlagParameter(char nShortName, const char* nLongName) throw(CmlException)
+:CommandLineParameter(nShortName,nLongName,(const char*)NULL)
+{
+}
+
+bool FlagParameter::needsValue()
+{ 
+	return false;
+}
+
+bool FlagParameter::takeValue(const char*)
+{ 
+	return false;
+}
+
+void FlagParameter::popValue()
+{ 
+}
+
+bool FlagParameter::isPresent()
+{
+	return present;
+}
+
+bool FlagParameter::setPresent(char c)  throw(CmlException)
+{
+	if(c && c==shortName)
+	{
+		if(present==true)
+		{
+			if(wasLongName==true)
+				throw CmlException(string("") + "Parameter '" + longName + "' clashes with parameter '" + shortName + "'");
+			else
+				throw CmlException(string("") + "Parameter '" + shortName + "' was already present");
+		}
+	 	present=true;
+	 	return true;
+	}
+	return false;
+}
+
+bool FlagParameter::setPresent(const char* s) throw(CmlException)
+{
+	if(longName != NULL && !strcmp(longName,s))
+	{
+		if(present==true)
+		{
+			if(wasLongName==true)
+				throw CmlException(string("") + "Parameter '" + longName + "' was already present");
+			else
+				throw CmlException(string("") + "Parameter '" + longName + "' clashes with parameter '" + shortName + "'");
+		}
+		wasLongName=true;
+		present=true;
+		return true;
+	}
+	return false;
+}
+
+const char* FlagParameter::getValueAsString() throw(CmlException)
+{
+	throw CmlException("Flag parameter can't return a string value");
+}
+
+long FlagParameter::getValueAsLong() throw(CmlException)
+{
+	throw CmlException("Flag parameter can't return a 'long' value");
+}
+
+double FlagParameter::getValueAsDouble() throw(CmlException)
+{
+	throw CmlException("Flag parameter can't return a 'double' value");
+}
+
+ostream& FlagParameter::printStatus(ostream &os)
+{
+	if(present)
+		os<<"option '"<<calledName()<<"' present";
+	else
+		os<<"option '"<<calledName()<<"' missing";    
+	
+	return os;  
+}
+//#####################################################################
+StringParameter::StringParameter(char nShortName, const char* nLongName, const char* newDefaultValue) throw(CmlException)
+:CommandLineParameter(nShortName,nLongName,newDefaultValue)
+{
+	value.clear();
+}
+
+StringParameter::StringParameter(char nShortName, const char* nLongName, long newDefaultValue) throw(CmlException)
+:CommandLineParameter(nShortName,nLongName,newDefaultValue)
+{
+	value.clear();
+}
+
+StringParameter::~StringParameter()
+{
+	reset();
+}    
+	
+bool StringParameter::setPresent(char c)  throw(CmlException)
+{
+	if(c && c==shortName)
+	{
+	 	present=true;
+	 	return true;
+	}
+	return false;
+}
+
+bool StringParameter::setPresent(const char* s) throw(CmlException)
+{
+	if(longName != NULL && !strcmp(longName,s))
+	{
+		wasLongName=true;
+		present=true;
+		return true;
+	}
+	return false;
+}
+
+bool StringParameter::isPresent()
+{
+	return ( ! value.empty() );
+}
+
+void StringParameter::reset()
+{
+	list<char*>::iterator iter = value.begin();
+/* FIXME: free mem to avoid mem leaks
+	while ( iter != value.end() )
+	{
+		if (*iter != NULL)
+			delete[] *iter;
+	}
+*/
+	value.clear();
+
+	CommandLineParameter::reset();
+}    
+	
+	
+bool StringParameter::needsValue()
+{ 
+	return true;
+}
+		
+bool StringParameter::takeValue(const char* s)
+{
+	char *aux = dupString(s);
+	value.push_back( aux );
+	return true;
+}
+
+void StringParameter::popValue()
+{
+	if ( ! value.empty() )
+		value.pop_front();
+}
+
+const char* StringParameter::getValueAsString() throw(CmlException)
+{
+	return ( !value.empty() ? value.front() : defaultValue );
+}
+
+long   StringParameter::getValueAsLong()   throw(CmlException)
+{
+	const char *r = ( !value.empty() ? value.front() : defaultValue );
+	
+	if(r == NULL)
+		throw CmlException(string("") + "No value for parameter '" + calledName() + "'");
+	
+	char *endptr;
+	
+	long result = strtol( r, &endptr, 0);
+	
+	if( *endptr != 0 )
+		throw CmlException(string("") + "Invalid integer value for parameter '" + calledName() + "'");
+	
+	return result;
+}
+	
+double StringParameter::getValueAsDouble() throw(CmlException)
+{
+	const char *r = ( !value.empty() ? value.front() : defaultValue );
+	
+	if(r == NULL)
+		throw CmlException(string("") + "No value for parameter '" + calledName() + "'");
+	
+	char *endptr;
+	
+	double result = strtod( r, &endptr);
+	
+	if( *endptr != 0 )
+		throw CmlException(string("") + "Invalid double value for parameter '" + calledName() + "'");
+	
+	return result;
+}
+		
+ostream& StringParameter::printStatus(ostream &os)
+{
+	if(value.empty())
+		os<<"option '"<<calledName()<<"' empty.";
+	else
+	{
+		os<<"option '"<<calledName()<<"' present: ";
+		list<char*>::iterator iter = value.begin();
+		while ( iter != value.end() )
+		{
+			os<< "'" << (*iter ? *iter : "(null)") << "' ";
+			iter++;
+		}
+	}
+	return os;  
+}
+
+//##########################################################
+const char CommandLineParser::noShortName = '-';
+const char* CommandLineParser::noLongName = "--";
+const char* CommandLineParser::ShortSign = "-";
+const char* CommandLineParser::LongSign = "--";
+	
+CommandLineParser* CommandLineParser::myself = NULL;
+
+CommandLineParser& CommandLineParser::getInstance()
+{
+	if(myself == NULL)
+		myself = new CommandLineParser;
+	return *myself;
+}
+
+CommandLineParser::CommandLineParser()
+{
+	lastParameter = NULL;
+	nextTokenIsValue = false;
+}
+
+CommandLineParser::~CommandLineParser()
+{
+	delete myself;
+	myself=NULL;
+	
+	lastParameter=NULL;
+	
+	list<CommandLineParameter*>::iterator iter = cmlParameter.begin();
+	for(unsigned int i=0;i<cmlParameter.size();i++,iter++)
+		delete *iter;
+}
+
+
+CommandLineParameter& CommandLineParser::addFlagParameter(char shortName, const char *longName, const char *description) throw(CmlException)
+{
+	CommandLineParameter *cp = new FlagParameter(shortName,longName);
+	cp->setDescription(description);
+	cmlParameter.push_back(cp);
+	return *cp;
+}
+
+CommandLineParameter& CommandLineParser::addStringParameter(char shortName, const char* longName, const char *description, const char* newDefaultValue) throw(CmlException)
+{
+	CommandLineParameter *cp = new StringParameter(shortName,longName,newDefaultValue);
+	cp->setDescription(description);
+	cmlParameter.push_back(cp);
+	return *cp;
+}
+
+CommandLineParameter& CommandLineParser::addLongParameter(char shortName, const char* longName, const char *description, long newDefaultValue) throw(CmlException)
+{
+	CommandLineParameter *cp = new StringParameter(shortName,longName,newDefaultValue);
+	cp->setDescription(description);
+	cmlParameter.push_back(cp);
+	return *cp;
+}
+
+bool CommandLineParser::isPresent(char shortName) throw(CmlException)
+{
+	StringParameter *sp;
+	FlagParameter *fp;
+	bool result;
+
+	CommandLineParameter &cml = getParameter(shortName);
+	if ((sp = dynamic_cast<StringParameter*>(&cml)))
+		result = sp->isPresent();
+        else if ((fp = dynamic_cast<FlagParameter*>(&cml)))
+		result = fp->isPresent();
+	return result;
+}
+
+bool CommandLineParser::isPresent(const char* longName) throw(CmlException)
+{
+	StringParameter *sp;
+	FlagParameter *fp;
+	bool result;
+
+	CommandLineParameter &cml = getParameter(longName);
+	if ((sp = dynamic_cast<StringParameter*>(&cml)))
+		result = sp->isPresent();
+        else if ((fp = dynamic_cast<FlagParameter*>(&cml)))
+		result = fp->isPresent();
+	return result;
+}
+
+const char* CommandLineParser::getValueAsString(char shortName) throw(CmlException)
+{
+	CommandLineParameter &cml = getParameter(shortName);
+	return cml.getValueAsString();
+}
+	
+long CommandLineParser::getValueAsLong(char shortName) throw(CmlException)
+{ 
+	CommandLineParameter &cml = getParameter(shortName);
+	return cml.getValueAsLong();
+}
+	
+double CommandLineParser::getValueAsDouble(char shortName) throw(CmlException)
+{
+	CommandLineParameter &cml = getParameter(shortName);
+	return cml.getValueAsDouble();
+}
+	 
+const char* CommandLineParser::getValueAsString(const char* longName) throw(CmlException)
+{
+	CommandLineParameter &cml = getParameter(longName);
+	return cml.getValueAsString();
+}
+	
+long CommandLineParser::getValueAsLong(const char* longName)   throw(CmlException)
+{
+	CommandLineParameter &cml = getParameter(longName); 
+	return cml.getValueAsLong();
+}
+	
+double CommandLineParser::getValueAsDouble(const char* longName) throw(CmlException)
+{
+	CommandLineParameter &cml = getParameter(longName);
+	return cml.getValueAsDouble();
+}
+
+
+void CommandLineParser::processCommandLine(int argc, char** argv) throw(CmlException)
+{
+	for(int i=1;i<argc;i++)
+	{
+		char *nextToken=argv[i];
+		
+//	bool sw1 = (nextToken[0]=='-') ? true:false;        // token starts with "-"
+//	bool sw2 = (sw1 && nextToken[1]=='-') ? true:false; // token starts with "--"
+
+		bool sw1 = (!strncmp(nextToken, ShortSign, strlen(ShortSign))) ? true:false; // token starts with ShortSign
+		bool sw2 = (!strncmp(nextToken, LongSign, strlen(LongSign))) ? true:false;   // token starts with LongSign
+
+		//check only for ShortSign/LongSign
+		if(sw1 && !strcmp(nextToken, ShortSign))
+			throw CmlException(string("") + "Syntax error: '" + ShortSign + "' with no parameter in command line");   	
+		if(sw2 && !strcmp(nextToken, LongSign))
+			throw CmlException(string("") + "Syntax error: '" + LongSign  + "' with no parameter in command line");   	
+		
+		if(nextTokenIsValue)	
+			setValue(nextToken);
+		else if(sw2) 
+			longNameParameter(nextToken);
+		else if(sw1) 
+			shortNameParameter(nextToken);
+		else
+		{ 
+			throw CmlException(string("") + "Syntax error: unexpected token '" + nextToken + "' in command line");
+		}
+	}
+	if(nextTokenIsValue)
+		throw CmlException(string("") + "Syntax error: missing value for parameter '" + lastParameter->calledName() + "' in command line");   
+}
+
+
+CommandLineParameter& CommandLineParser::getParameter(char shortName) throw(CmlException)
+{
+	list<CommandLineParameter*>::iterator iter = cmlParameter.begin();
+	
+	for(unsigned int i=0;i<cmlParameter.size();i++,iter++)
+	{ 
+		if( (*iter)->doesMatch(shortName) )   
+		{
+			return *(*iter);
+		}
+	}
+	throw CmlException(string("") + "Syntax error: unknown parameter '" + shortName + "' in command line");   
+}	
+	
+CommandLineParameter& CommandLineParser::getParameter(const char* longName) throw(CmlException)
+{
+	list<CommandLineParameter*>::iterator iter = cmlParameter.begin();
+	
+	for(unsigned int i=0;i<cmlParameter.size();i++,iter++)
+	{ 
+		if( (*iter)->doesMatch(longName) )   
+		{
+			return *(*iter);
+		}
+	}
+	throw CmlException(string("") + "Syntax error: unknown parameter '" + longName + "' in command line");   
+}
+	
+
+void CommandLineParser::setValue(const char* value) throw(CmlException)
+{
+	if(lastParameter == NULL)
+	{
+		throw CmlException("internal error: setValue - lastParameter==null");
+	}
+	lastParameter->takeValue(value);
+	nextTokenIsValue=false;
+}
+
+void CommandLineParser::longNameParameter(const char *nextToken) throw(CmlException)
+{
+	const char* longName = nextToken + strlen(LongSign); // sari peste LongSign (former "--")
+
+	CommandLineParameter &cml = getParameter(longName);
+	cml.setPresent(longName);
+	if(cml.needsValue())
+	{
+		lastParameter = &cml;
+		nextTokenIsValue=true;
+	}
+}
+
+void CommandLineParser::shortNameParameter(const char *nextToken) throw(CmlException)
+{
+	int tokenLength = strlen(nextToken);
+	 
+	for(int i=strlen(ShortSign);i<tokenLength;i++) //former i=1 for '-'
+	{
+		char shortName = nextToken[i];
+		CommandLineParameter &cml = getParameter(shortName);
+		cml.setPresent(shortName);
+	 
+		if(cml.needsValue())
+		{
+			if(i==tokenLength-1)
+			{
+				lastParameter = &cml;
+				nextTokenIsValue=true;
+			}
+			else
+			{
+				const char *value = nextToken + i+1;
+				cml.takeValue(value);
+			}
+			break;	    
+		}
+	}
+	
+}
+	
+void CommandLineParser::printHelp()
+{
+	std::list<CommandLineParameter*>::const_iterator iter=cmlParameter.begin();
+	std::list<CommandLineParameter*>::const_iterator iterEnd=cmlParameter.end();
+	for(; iter!=iterEnd; ++iter)
+	{
+		CommandLineParameter* ptr=*iter;
+		ptr->printHelp( std::cout );
+		std::cout << std::endl;
+	}
+	return;
+}
+
+void CommandLineParser::printStatus()
+{
+	std::list<CommandLineParameter*>::const_iterator iter=cmlParameter.begin();
+	std::list<CommandLineParameter*>::const_iterator iterEnd=cmlParameter.end();
+	
+	for(; iter!=iterEnd; ++iter)
+	{
+		CommandLineParameter* ptr=*iter;
+		ptr->printStatus( std::cout ) << std::endl;
+	}
+		
+	std::cout <<std::endl;
+
+}
+
+bool CommandLineParser::testProcessCommandLine(const char *testCml)
+{
+	std::list<CommandLineParameter*>::const_iterator iter=cmlParameter.begin();
+	std::list<CommandLineParameter*>::const_iterator iterEnd=cmlParameter.end();
+	string test;
+	string::size_type posStart, posEnd;
+	const char* spaceSep = " \t\v\f\n\r";
+	const char* prgName = "program";
+	std::vector<std::string> argList;
+	char  **argv=NULL;
+	unsigned int argc=0, i=0, n=0;
+	static unsigned int counter=1;
+	 
+	if(!testCml)
+	{
+		std::cout << "Error: test_cml is null" << endl;
+		printStatus();
+		return false;
+	}
+	 
+	std::cout << "Test " << counter << " commandline='" << testCml << "'" << std::endl;
+	 
+	//converting to argc, argv
+	test=testCml; 
+	posEnd=0;
+	while(true)
+	{
+		posStart=test.find_first_not_of(spaceSep, posEnd);
+		if(posStart != string::npos)
+		{
+			posEnd=test.find_first_of(spaceSep, posStart);
+			if(posEnd != string::npos)
+			{
+				std::cout << "arg " << argList.size() + 1 << "='" << test.substr(posStart, posEnd-posStart) << "'" << std::endl;	       
+				argList.push_back(test.substr(posStart, posEnd-posStart));
+			}
+		 	else //last element
+			{
+				std::cout << "arg " << argList.size() + 1 << "='" << test.substr(posStart, test.size()-posStart) << "'" << std::endl;
+				argList.push_back(test.substr(posStart, test.size()-posStart));
+				break;
+			}
+		}
+		else
+  			break;
+	}
+
+	//build argv in C style       
+	n=argList.size();
+	argc = n + 1;
+	argv=new char*[ argc ];
+	argv[0] = dupString(prgName);
+	for(i=0; i <  n; i++)
+		argv[i + 1] = dupString(argList[i].c_str());
+
+	std::cout << "Test " << counter++ << " output:" << std::endl;         
+	
+	try
+	{
+		//reset all options
+		for(; iter!=iterEnd; ++iter)
+		{
+			(*iter)->reset();
+		}
+		//process commandline	
+		processCommandLine(argc, argv);
+	}
+	catch(CmlException &e)
+	{
+		std::cout<<"Error: "<<e.what()<<std::endl;
+		for(i=0; i < argc; i++)
+			delete [] argv[i];
+		delete[] argv;
+
+		printStatus();
+		return false;
+	}
+	
+	for(i=0; i < argc; i++)
+		delete [] argv[i];
+	delete[] argv;
+	
+	printStatus();
+	return true;
+}
+
-- 
cgit