GETOPT_INLINE void GetOpt_pp::_parse_env()
{
// this will be optimized in version 3
std::string var_name;
std::string var_value;
size_t var = 0;
std::string::size_type pos;
OptionData* data;
while (environ[var] != NULL)
{
var_name = environ[var];
pos = var_name.find('=');
if (pos != std::string::npos)
{
var_value = var_name.substr(pos + 1);
var_name = var_name.substr(0, pos);
if (_longOps.find(var_name) == _longOps.end())
{
data = &_longOps[var_name];
data->token = _add_token(var_name, Token::LongOption);
data->flags = OptionData::Envir;
_add_token(var_value, Token::OptionArgument);
}
}
else
(data = &_longOps[var_name])->flags = OptionData::Envir;
var++;
}
}
GETOPT_INLINE void GetOpt_pp::_parse(int argc, char* argv[])
{
_app_name = argv[0];
bool any_option_processed = false;
// parse arguments by their '-' or '--':
// (this will be a state machine soon)
for (int i = 1; i < argc; i++)
{
const char current = argv[i][0];
const char next = argv[i][1];
if (current == '-' && (isalnum(next) || next == '-'))
{
// see what's next, differentiate whether it's short or long:
if (next == '-' && argv[i][2] != 0)
{
// long option
_longOps[&argv[i][2]].token = _add_token(&argv[i][2], Token::LongOption);
any_option_processed = true;
}
else
{
// short option
// iterate over all of them, keeping the last one in currentData
// (so the intermediates will generate 'existent' arguments, as of '-abc')
size_t j = 1;
do
{
_shortOps[argv[i][j]].token = _add_token(std::string(&argv[i][j], 1), Token::ShortOption);
j++;
}
while (argv[i][j] != 0);
any_option_processed = true;
}
}
else
{
_add_token(argv[i], any_option_processed ? Token::UnknownYet : Token::GlobalArgument);
}
}
_last = _Option::OK; // TODO: IMPROVE!!
}
GETOPT_INLINE void GetOpt_pp::_parse(const std::vector<std::string>& args)
{
bool any_option_processed = false;
const size_t argc = args.size();
size_t start = 0;
if ( _app_name.empty() )
{
_app_name = args[0];
start = 1;
}
// parse arguments by their '-' or '--':
// (this will be a state machine soon)
for (size_t i = start; i < argc; i++)
{
const std::string& currentArg = args[i];
if (currentArg[0] == '-' && currentArg.size() > 1)
{
// see what's next, differentiate whether it's short or long:
if (currentArg[1] == '-')
{
if ( currentArg.size() > 2 )
{
// long option
_longOps[currentArg.substr(2)].token = _add_token(currentArg.substr(2), Token::LongOption);
}
else
{
// it's the -- option alone
_longOps[currentArg].token = _add_token(currentArg, Token::GlobalArgument);
}
any_option_processed = true;
}
else
{
// check if it is a negative number: rules
// * floating point negative numbers are straight classified as 'arguments'
// * integer negative numbers of more than 1 digit length are also 'arguments'
// * integer negatives of 1 digit length can be either arguments or short options.
// * anything else: short options.
int anInt;
float aFloat;
std::stringstream dummy;
if ( convert(currentArg, anInt, dummy.flags()) == _Option::OK )
{
if ( currentArg.size() > 2 ) // if it's larger than -d (d=digit), then assume it's a negative number:
_add_token(currentArg, any_option_processed ? Token::UnknownYet : Token::GlobalArgument);
else // size == 2: it's a 1 digit negative number
_shortOps[currentArg[1]].token = _add_token(currentArg, Token::PossibleNegativeArgument);
}
else if ( convert(currentArg, aFloat, dummy.flags()) == _Option::OK )
_add_token(currentArg, any_option_processed ? Token::UnknownYet : Token::GlobalArgument);
else
{
// short option
// iterate over all of them, keeping the last one in currentData
// (so the intermediates will generate 'existent' arguments, as of '-abc')
for( size_t j = 1; j < currentArg.size(); j++ )
_shortOps[currentArg[j]].token = _add_token(std::string(currentArg, j, 1), Token::ShortOption);
}
any_option_processed = true;
}
}
else if ( currentArg[0] == '@' && currentArg.size() > 1 )
{
// suboptions file
_parse_sub_file(currentArg.substr(1));
}
else
{
_add_token(currentArg, any_option_processed ? Token::UnknownYet : Token::GlobalArgument);
}
}
_last = _Option::OK; // TODO: IMPROVE!!
}
