static __inline__
int getopt_verify( const CHAR *nextchar, const CHAR *optstring )
{
/* Helper function, called by getopt_parse() when invoked
* by getopt_long_only(), to verify when an unmatched or an
* ambiguously matched long form option string is valid as
* a short form option specification.
*/
if( ! (nextchar && *nextchar && optstring && *optstring) )
/*
* There are no characters to be matched, or there are no
* valid short form option characters to which they can be
* matched, so this can never be valid.
*/
return 0;
while( *nextchar )
{
/* For each command line character in turn ...
*/
const CHAR *test;
if( (test = getopt_match( *nextchar++, optstring )) == NULL )
/*
* ... there is no short form option to match the current
* candidate, so the entire argument fails.
*/
return 0;
if( test[1] == getopt_takes_argument )
/*
* The current candidate is valid, and it matches an option
* which takes an argument, so this command line argument is
* a valid short form option specification; accept it.
*/
return 1;
}
/* If we get to here, then every character in the command line
* argument was valid as a short form option; accept it.
*/
return 1;
}
static
#define getopt_std_args int argc, CHAR *const argv[], const CHAR *optstring
int getopt_parse( int mode, getopt_std_args, ... )
{
/* Common core implementation for ALL `getopt' functions.
*/
static int argind = 0;
static int optbase = 0;
static const CHAR *nextchar = NULL;
static int optmark = 0;
if( (optreset |= (optind < 1)) || (optind < optbase) )
{
/* POSIX does not prescribe any definitive mechanism for restarting
* a `getopt' scan, but some applications may require such capability.
* We will support it, by allowing the caller to adjust the value of
* `optind' downwards, (nominally setting it to zero). Since POSIX
* wants `optind' to have an initial value of one, but we want all
* of our internal place holders to be initialised to zero, when we
* are called for the first time, we will handle such a reset by
* adjusting all of the internal place holders to one less than
* the adjusted `optind' value, (but never to less than zero).
*/
if( optreset )
{
/* User has explicitly requested reinitialisation...
* We need to reset `optind' to it's normal initial value of 1,
* to avoid a potential infinitely recursive loop; by doing this
* up front, we also ensure that the remaining place holders
* will be correctly reinitialised to no less than zero.
*/
optind = 1;
/* We also need to clear the `optreset' request...
*/
optreset = 0;
}
/* Now, we may safely reinitialise the internal place holders, to
* one less than `optind', without fear of making them negative.
*/
optmark = optbase = argind = optind - 1;
nextchar = NULL;
}
/* From a POSIX perspective, the following is `undefined behaviour';
* we implement it thus, for compatibility with GNU and BSD getopt.
*/
else if( optind > (argind + 1) )
{
/* Some applications expect to be able to manipulate `optind',
* causing `getopt' to skip over one or more elements of `argv';
* POSIX doesn't require us to support this brain-damaged concept;
* (indeed, POSIX defines no particular behaviour, in the event of
* such usage, so it must be considered a bug for an application
* to rely on any particular outcome); nonetheless, Mac-OS-X and
* BSD actually provide *documented* support for this capability,
* so we ensure that our internal place holders keep track of
* external `optind' increments; (`argind' must lag by one).
*/
argind = optind - 1;
/* When `optind' is misused, in this fashion, we also abandon any
* residual text in the argument we had been parsing; this is done
* without any further processing of such abandoned text, assuming
* that the caller is equipped to handle it appropriately.
*/
nextchar = NULL;
}
if( nextchar && *nextchar )
{
/* we are parsing a standard, or short format, option argument ...
*/
const CHAR *optchar;
if( (optchar = getopt_match( optopt = *nextchar++, optstring )) != NULL )
{
/* we have identified it as valid ...
*/
if( optchar[1] == getopt_takes_argument )
{
/* and determined that it requires an associated argument ...
*/
if( ! *(optarg = (char *)(nextchar)) )
{
/* the argument is NOT attached ...
*/
if( optchar[2] == getopt_takes_argument )
/*
* but this GNU extension marks it as optional,
* so we don't provide one on this occasion.
*/
optarg = NULL;
/* otherwise this option takes a mandatory argument,
* so, provided there is one available ...
*/
else if( (argc - argind) > 1 )
/*
* we take the following command line argument,
* as the appropriate option argument.
*/
optarg = argv[++argind];
/* but if no further argument is available,
* then there is nothing we can do, except for
* issuing the requisite diagnostic message.
*/
else
{
complain( "option requires an argument -- %c", optopt );
return getopt_missing_arg( optstring );
}
}
optind = argind + 1;
nextchar = NULL;
}
else
optarg = NULL;
optind = (nextchar && *nextchar) ? argind : argind + 1;
return optopt;
}
/* if we didn't find a valid match for the specified option character,
* then we fall through to here, so take appropriate diagnostic action.
*/
if( mode == getopt_mode_long_only )
{
complain( "unrecognised option `-%s'", --nextchar );
nextchar = NULL;
optopt = 0;
}
else
complain( "invalid option -- %c", optopt );
optind = (nextchar && *nextchar) ? argind : argind + 1;
return getopt_unknown;
}
if( optmark > optbase )
{
/* This can happen, in GNU parsing mode ONLY, when we have
* skipped over non-option arguments, and found a subsequent
* option argument; in this case we permute the arguments.
*/
int index;
/*
* `optspan' specifies the number of contiguous arguments
* which are spanned by the current option, and so must be
* moved together during permutation.
*/
int optspan = argind - optmark + 1;
/*
* we use `this_arg' to store these temporarily.
*/
CHAR *this_arg[optspan];
/*
* we cannot manipulate `argv' directly, since the `getopt'
* API prototypes it as `read-only'; this cast to `arglist'
* allows us to work around that restriction.
*/
CHAR **arglist = (char **)(argv);
/* save temporary copies of the arguments which are associated
* with the current option ...
*/
for( index = 0; index < optspan; ++index )
this_arg[index] = arglist[optmark + index];
/* move all preceding non-option arguments to the right,
* overwriting these saved arguments, while making space
* to replace them in their permuted location.
*/
for( --optmark; optmark >= optbase; --optmark )
arglist[optmark + optspan] = arglist[optmark];
/* restore the temporarily saved option arguments to
* their permuted location.
*/
for( index = 0; index < optspan; ++index )
arglist[optbase + index] = this_arg[index];
/* adjust `optbase', to account for the relocated option.
*/
optbase += optspan;
}
else
/* no permutation occurred ...
* simply adjust `optbase' for all options parsed so far.
*/
optbase = argind + 1;
/* enter main parsing loop ...
*/
while( argc > ++argind )
{
/* inspect each argument in turn, identifying possible options ...
*/
if( is_switchar( *(nextchar = argv[optmark = argind]) ) && *++nextchar )
{
/* we've found a candidate option argument ... */
if( is_switchar( *nextchar ) )
{
/* it's a double hyphen argument ... */
const CHAR *refchar = nextchar;
if( *++refchar )
{
/* and it looks like a long format option ...
* `getopt_long' mode must be active to accept it as such,
* `getopt_long_only' also qualifies, but we must downgrade
* it to force explicit handling as a long format option.
*/
if( mode >= getopt_mode_long )
{
nextchar = refchar;
mode = getopt_mode_long;
}
}
else
{
/* this is an explicit `--' end of options marker, so wrap up now!
*/
if( optmark > optbase )
{
/* permuting the argument list as necessary ...
* (note use of `this_arg' and `arglist', as above).
*/
CHAR *this_arg = argv[optmark];
CHAR **arglist = (CHAR **)(argv);
/* move all preceding non-option arguments to the right ...
*/
do arglist[optmark] = arglist[optmark - 1];
while( optmark-- > optbase );
/* reinstate the `--' marker, in its permuted location.
*/
arglist[optbase] = this_arg;
}
/* ... before finally bumping `optbase' past the `--' marker,
* and returning the `all done' completion indicator.
*/
optind = ++optbase;
return getopt_all_done;
}
}
else if( mode < getopt_mode_long_only )
{
/* it's not an explicit long option, and `getopt_long_only' isn't active,
* so we must explicitly try to match it as a short option.
*/
mode = getopt_mode_standard;
}
if( mode >= getopt_mode_long )
{
/* the current argument is a long form option, (either explicitly,
* introduced by a double hyphen, or implicitly because we were called
* by `getopt_long_only'); this is where we parse it.
*/
int lookup;
int matched = -1;
/* we need to fetch the `extra' function arguments, which are
* specified for the `getopt_long' APIs.
*/
va_list refptr;
va_start( refptr, optstring );
struct option *longopts = va_arg( refptr, struct option * );
int *optindex = va_arg( refptr, int * );
va_end( refptr );
/* ensuring that `optarg' does not inherit any junk, from parsing
* preceding arguments ...
*/
optarg = NULL;
for( lookup = 0; longopts && longopts[lookup].name; ++lookup )
{
/* scan the list of defined long form options ...
*/
switch( getopt_match_long( nextchar, longopts[lookup].name ) )
{
/* looking for possible matches for the current argument.
*/
case getopt_exact_match:
/*
* when an exact match is found,
* return it immediately, setting `nextchar' to NULL,
* to ensure we don't mistakenly try to match any
* subsequent characters as short form options.
*/
nextchar = NULL;
return getopt_resolved( mode, argc, argv, &argind,
longopts, lookup, optindex, optstring );
case getopt_abbreviated_match:
/*
* but, for a partial (initial substring) match ...
*/
if( matched >= 0 )
{
/* if this is not the first, then we have an ambiguity ...
*/
optopt = 0;
nextchar = NULL;
optind = argind + 1;
complain( "option `%s' is ambiguous", argv[argind] );
return getopt_unknown;
}
/* otherwise just note that we've found a possible match ...
*/
matched = lookup;
}
}
if( matched >= 0 )
{
/* if we get to here, then we found exactly one partial match,
* so return it, as for an exact match.
*/
nextchar = NULL;
return getopt_resolved( mode, argc, argv, &argind,
longopts, matched, optindex, optstring );
}
if( mode < getopt_mode_long_only )
{
/* if here, then we had what SHOULD have been a long form option,
* but it is unmatched; (perversely, `mode == getopt_mode_long_only'
* allows us to still try to match it as a short form option).
*/
optopt = 0;
nextchar = NULL;
optind = argind + 1;
complain( "unrecognised option `%s'", argv[argind] );
return getopt_unknown;
}
}
/* fall through to handle standard short form options...
* when the option argument format is neither explictly identified
* as long, nor implicitly matched as such, and the argument isn't
* just a bare hyphen, (which isn't an option), then we make one
* recursive call to explicitly interpret it as short format.
*/
if( *nextchar )
return getopt_parse( mode, argc, argv, optstring );
}
/* if we get to here, then we've parsed a non-option argument ...
* in GNU compatibility mode, we step over it, so we can permute
* any subsequent option arguments, but ...
*/
if( *optstring == getopt_switchar )
{
/* if `optstring' begins with a `-' character, this special
* GNU specific behaviour requires us to return the non-option
* arguments in strict order, as pseudo-arguments to a special
* option, with return value defined as `getopt_ordered'.
*/
nextchar = NULL;
optind = argind + 1;
optarg = argv[argind];
return getopt_ordered;
}
if( getopt_conventions( *optstring ) & getopt_posixly_correct )
/*
* otherwise ...
* for POSIXLY_CORRECT behaviour, or if `optstring' begins with
* a `+' character, then we break out of the parsing loop, so that
* the scan ends at the current argument, with no permutation.
*/
break;
}
