456 lines
11 KiB
C++
456 lines
11 KiB
C++
#include <osg/ArgumentParser>
|
|
#include <osg/ApplicationUsage>
|
|
#include <osg/Notify>
|
|
|
|
#include <set>
|
|
#include <iostream>
|
|
|
|
using namespace osg;
|
|
|
|
bool ArgumentParser::isOption(const char* str)
|
|
{
|
|
return str && str[0]=='-';
|
|
}
|
|
|
|
bool ArgumentParser::isString(const char* str)
|
|
{
|
|
if (!str) return false;
|
|
return true;
|
|
//return !isOption(str);
|
|
}
|
|
|
|
bool ArgumentParser::isNumber(const char* str)
|
|
{
|
|
if (!str) return false;
|
|
|
|
bool hadPlusMinus = false;
|
|
bool hadDecimalPlace = false;
|
|
bool hadExponent = false;
|
|
bool couldBeInt = true;
|
|
bool couldBeFloat = true;
|
|
int noZeroToNine = 0;
|
|
|
|
const char* ptr = str;
|
|
|
|
// check if could be a hex number.
|
|
if (strncmp(ptr,"0x",2)==0)
|
|
{
|
|
// skip over leading 0x, and then go through rest of string
|
|
// checking to make sure all values are 0...9 or a..f.
|
|
ptr+=2;
|
|
while (
|
|
*ptr!=0 &&
|
|
((*ptr>='0' && *ptr<='9') ||
|
|
(*ptr>='a' && *ptr<='f') ||
|
|
(*ptr>='A' && *ptr<='F'))
|
|
)
|
|
{
|
|
++ptr;
|
|
}
|
|
|
|
// got to end of string without failure, therefore must be a hex integer.
|
|
if (*ptr==0) return true;
|
|
}
|
|
|
|
ptr = str;
|
|
|
|
// check if a float or an int.
|
|
while (*ptr!=0 && couldBeFloat)
|
|
{
|
|
if (*ptr=='+' || *ptr=='-')
|
|
{
|
|
if (hadPlusMinus)
|
|
{
|
|
couldBeInt = false;
|
|
couldBeFloat = false;
|
|
} else hadPlusMinus = true;
|
|
}
|
|
else if (*ptr>='0' && *ptr<='9')
|
|
{
|
|
noZeroToNine++;
|
|
}
|
|
else if (*ptr=='.')
|
|
{
|
|
if (hadDecimalPlace)
|
|
{
|
|
couldBeInt = false;
|
|
couldBeFloat = false;
|
|
}
|
|
else
|
|
{
|
|
hadDecimalPlace = true;
|
|
couldBeInt = false;
|
|
}
|
|
}
|
|
else if (*ptr=='e' || *ptr=='E')
|
|
{
|
|
if (hadExponent || noZeroToNine==0)
|
|
{
|
|
couldBeInt = false;
|
|
couldBeFloat = false;
|
|
}
|
|
else
|
|
{
|
|
hadExponent = true;
|
|
couldBeInt = false;
|
|
hadDecimalPlace = false;
|
|
hadPlusMinus = false;
|
|
noZeroToNine=0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
couldBeInt = false;
|
|
couldBeFloat = false;
|
|
}
|
|
++ptr;
|
|
}
|
|
|
|
if (couldBeInt && noZeroToNine>0) return true;
|
|
if (couldBeFloat && noZeroToNine>0) return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
bool ArgumentParser::Parameter::valid(const char* str) const
|
|
{
|
|
switch(_type)
|
|
{
|
|
case Parameter::FLOAT_PARAMETER: return isNumber(str); break;
|
|
case Parameter::DOUBLE_PARAMETER: return isNumber(str); break;
|
|
case Parameter::INT_PARAMETER: return isNumber(str); break;
|
|
case Parameter::UNSIGNED_INT_PARAMETER: return isNumber(str); break;
|
|
case Parameter::STRING_PARAMETER: return isString(str); break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool ArgumentParser::Parameter::assign(const char* str)
|
|
{
|
|
if (valid(str))
|
|
{
|
|
switch(_type)
|
|
{
|
|
case Parameter::FLOAT_PARAMETER: *_value._float = atof(str); break;
|
|
case Parameter::DOUBLE_PARAMETER: *_value._double = atof(str); break;
|
|
case Parameter::INT_PARAMETER: *_value._int = atoi(str); break;
|
|
case Parameter::UNSIGNED_INT_PARAMETER: *_value._uint = atoi(str); break;
|
|
case Parameter::STRING_PARAMETER: *_value._string = str; break;
|
|
}
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
ArgumentParser::ArgumentParser(int* argc,char **argv):
|
|
_argc(argc),
|
|
_argv(argv),
|
|
_usage(ApplicationUsage::instance())
|
|
{
|
|
}
|
|
|
|
std::string ArgumentParser::getApplicationName() const
|
|
{
|
|
if (_argc && *_argc>0 ) return std::string(_argv[0]);
|
|
return "";
|
|
}
|
|
|
|
|
|
bool ArgumentParser::isOption(int pos) const
|
|
{
|
|
return pos<*_argc && isOption(_argv[pos]);
|
|
}
|
|
|
|
bool ArgumentParser::isString(int pos) const
|
|
{
|
|
return pos < *_argc && isString(_argv[pos]);
|
|
}
|
|
|
|
bool ArgumentParser::isNumber(int pos) const
|
|
{
|
|
return pos < *_argc && isNumber(_argv[pos]);
|
|
}
|
|
|
|
|
|
int ArgumentParser::find(const std::string& str) const
|
|
{
|
|
for(int pos=1;pos<*_argc;++pos)
|
|
{
|
|
if (str==_argv[pos])
|
|
{
|
|
return pos;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
bool ArgumentParser::match(int pos, const std::string& str) const
|
|
{
|
|
return pos<*_argc && str==_argv[pos];
|
|
}
|
|
|
|
|
|
bool ArgumentParser::containsOptions() const
|
|
{
|
|
for(int pos=1;pos<*_argc;++pos)
|
|
{
|
|
if (isOption(pos)) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
void ArgumentParser::remove(int pos,int num)
|
|
{
|
|
if (num==0) return;
|
|
|
|
for(;pos+num<*_argc;++pos)
|
|
{
|
|
_argv[pos]=_argv[pos+num];
|
|
}
|
|
for(;pos<*_argc;++pos)
|
|
{
|
|
_argv[pos]=0;
|
|
}
|
|
*_argc-=num;
|
|
}
|
|
|
|
bool ArgumentParser::read(const std::string& str)
|
|
{
|
|
int pos=find(str);
|
|
if (pos<=0) return false;
|
|
remove(pos);
|
|
return true;
|
|
}
|
|
|
|
bool ArgumentParser::read(const std::string& str, Parameter value1)
|
|
{
|
|
int pos=find(str);
|
|
if (pos<=0) return false;
|
|
if (!value1.valid(_argv[pos+1]))
|
|
{
|
|
reportError("argument to `"+str+"` is missing");
|
|
return false;
|
|
}
|
|
value1.assign(_argv[pos+1]);
|
|
remove(pos,2);
|
|
return true;
|
|
}
|
|
|
|
bool ArgumentParser::read(const std::string& str, Parameter value1, Parameter value2)
|
|
{
|
|
int pos=find(str);
|
|
if (pos<=0) return false;
|
|
if (!value1.valid(_argv[pos+1]) ||
|
|
!value2.valid(_argv[pos+2]))
|
|
{
|
|
reportError("argument to `"+str+"` is missing");
|
|
return false;
|
|
}
|
|
value1.assign(_argv[pos+1]);
|
|
value2.assign(_argv[pos+2]);
|
|
remove(pos,3);
|
|
return true;
|
|
}
|
|
|
|
bool ArgumentParser::read(const std::string& str, Parameter value1, Parameter value2, Parameter value3)
|
|
{
|
|
int pos=find(str);
|
|
if (pos<=0) return false;
|
|
if (!value1.valid(_argv[pos+1]) ||
|
|
!value2.valid(_argv[pos+2]) ||
|
|
!value2.valid(_argv[pos+3]))
|
|
{
|
|
reportError("argument to `"+str+"` is missing");
|
|
return false;
|
|
}
|
|
value1.assign(_argv[pos+1]);
|
|
value2.assign(_argv[pos+2]);
|
|
value3.assign(_argv[pos+3]);
|
|
remove(pos,4);
|
|
return true;
|
|
}
|
|
|
|
bool ArgumentParser::read(const std::string& str, Parameter value1, Parameter value2, Parameter value3, Parameter value4)
|
|
{
|
|
int pos=find(str);
|
|
if (pos<=0) return false;
|
|
if (!value1.valid(_argv[pos+1]) ||
|
|
!value2.valid(_argv[pos+2]) ||
|
|
!value2.valid(_argv[pos+3]) ||
|
|
!value3.valid(_argv[pos+4]))
|
|
{
|
|
reportError("argument to `"+str+"` is missing");
|
|
return false;
|
|
}
|
|
value1.assign(_argv[pos+1]);
|
|
value2.assign(_argv[pos+2]);
|
|
value3.assign(_argv[pos+3]);
|
|
value4.assign(_argv[pos+4]);
|
|
remove(pos,5);
|
|
return true;
|
|
}
|
|
|
|
|
|
/** if the argument value at the psotion pos matches specified string, and subsequent
|
|
* paramters are also matched then set the paramter values and remove the from the list of arguments.*/
|
|
bool ArgumentParser::read(int pos, const std::string& str)
|
|
{
|
|
if (match(pos,str))
|
|
{
|
|
remove(pos,1);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool ArgumentParser::read(int pos, const std::string& str, Parameter value1)
|
|
{
|
|
if (match(pos,str) &&
|
|
value1.valid(_argv[pos+1]))
|
|
{
|
|
value1.assign(_argv[pos+1]);
|
|
remove(pos,2);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool ArgumentParser::read(int pos, const std::string& str, Parameter value1, Parameter value2)
|
|
{
|
|
if (match(pos,str) &&
|
|
value1.valid(_argv[pos+1]) &&
|
|
value2.valid(_argv[pos+2]))
|
|
{
|
|
value1.assign(_argv[pos+1]);
|
|
value2.assign(_argv[pos+2]);
|
|
remove(pos,3);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool ArgumentParser::read(int pos, const std::string& str, Parameter value1, Parameter value2, Parameter value3)
|
|
{
|
|
if (match(pos,str) &&
|
|
value1.valid(_argv[pos+1]) &&
|
|
value2.valid(_argv[pos+2]) &&
|
|
value3.valid(_argv[pos+3]))
|
|
{
|
|
value1.assign(_argv[pos+1]);
|
|
value2.assign(_argv[pos+2]);
|
|
value3.assign(_argv[pos+3]);
|
|
remove(pos,4);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool ArgumentParser::read(int pos, const std::string& str, Parameter value1, Parameter value2, Parameter value3, Parameter value4)
|
|
{
|
|
if (match(pos,str) &&
|
|
value1.valid(_argv[pos+1]) &&
|
|
value2.valid(_argv[pos+2]) &&
|
|
value3.valid(_argv[pos+3]) &&
|
|
value4.valid(_argv[pos+4]))
|
|
{
|
|
value1.assign(_argv[pos+1]);
|
|
value2.assign(_argv[pos+2]);
|
|
value3.assign(_argv[pos+3]);
|
|
value4.assign(_argv[pos+4]);
|
|
remove(pos,5);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
bool ArgumentParser::errors(ErrorSeverity severity) const
|
|
{
|
|
for(ErrorMessageMap::const_iterator itr=_errorMessageMap.begin();
|
|
itr!=_errorMessageMap.end();
|
|
++itr)
|
|
{
|
|
if (itr->second>=severity) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void ArgumentParser::reportError(const std::string& message,ErrorSeverity severity)
|
|
{
|
|
_errorMessageMap[message]=severity;
|
|
}
|
|
|
|
void ArgumentParser::reportRemainingOptionsAsUnrecognized(ErrorSeverity severity)
|
|
{
|
|
std::set<std::string> options;
|
|
if (_usage)
|
|
{
|
|
// parse the usage options to get all the option that the application can potential handle.
|
|
for(ApplicationUsage::UsageMap::const_iterator itr=_usage->getCommandLineOptions().begin();
|
|
itr!=_usage->getCommandLineOptions().end();
|
|
++itr)
|
|
{
|
|
const std::string& option = itr->first;
|
|
std::string::size_type prevpos = 0, pos = 0;
|
|
while ((pos=option.find(' ',prevpos))!=std::string::npos)
|
|
{
|
|
if (option[prevpos]=='-')
|
|
{
|
|
options.insert(std::string(option,prevpos,pos-prevpos));
|
|
}
|
|
prevpos=pos+1;
|
|
}
|
|
if (option[prevpos]=='-')
|
|
{
|
|
|
|
options.insert(std::string(option,prevpos,std::string::npos));
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
for(int pos=1;pos<argc();++pos)
|
|
{
|
|
// if an option and havn't been previous querried for report as unrecognized.
|
|
if (isOption(pos) && options.find(_argv[pos])==options.end())
|
|
{
|
|
reportError(getApplicationName() +": unrecognized option "+_argv[pos],severity);
|
|
}
|
|
}
|
|
}
|
|
void ArgumentParser::writeErrorMessages(std::ostream& output,ErrorSeverity severity)
|
|
{
|
|
for(ErrorMessageMap::iterator itr=_errorMessageMap.begin();
|
|
itr!=_errorMessageMap.end();
|
|
++itr)
|
|
{
|
|
if (itr->second>=severity)
|
|
{
|
|
output<< getApplicationName() << ": " << itr->first << std::endl;
|
|
}
|
|
}
|
|
}
|