You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
485 lines
12 KiB
485 lines
12 KiB
/*++
|
|
|
|
PARSE.C
|
|
|
|
Option parser
|
|
|
|
Split from options.c 6/9/1997 by DavidCHR
|
|
|
|
--*/
|
|
|
|
#include "private.h"
|
|
#include <malloc.h>
|
|
|
|
/* ParseOneOption:
|
|
|
|
parses a single option from argv.
|
|
returns: number of arguments eaten, or zero on error */
|
|
|
|
BOOL
|
|
ParseOneOption( int argc, // number of arguments, total
|
|
PCHAR *argv, // vector of arguments
|
|
int argi, // which argument we're to parse
|
|
ULONG flags, // applicable flags
|
|
optionStruct *options, // option structure
|
|
int *argsused, // arguments we've eaten
|
|
PBOOL pbStop, // Stop Parsing
|
|
PSAVEQUEUE pQueue // memory save area
|
|
) {
|
|
|
|
PCHAR p; // argument pointer copy
|
|
int opti; // which option we're examining
|
|
BOOL ret = FALSE; // return value
|
|
int tmp = 0; // temporary inbound value
|
|
int used = 0;
|
|
|
|
ASSERT( argc > 0 ); // there must be arguments
|
|
ASSERT( argv != NULL ); // the vector must exist
|
|
ASSERT( argi < argc ); // argument number must be INSIDE the vector
|
|
ASSERT( options != NULL ); // passed option structure must be valid
|
|
ASSERT( argsused != NULL );
|
|
|
|
p = argv[argi];
|
|
|
|
if( ISSWITCH( p[0] ) ) {
|
|
p++; /* skip the switch character */
|
|
}
|
|
|
|
OPTIONS_DEBUG("Checking option %d: \"%hs\"...", argi, p);
|
|
|
|
for (opti = 0 ; !ARRAY_TERMINATED( options+opti ) ; opti++ ) {
|
|
|
|
OPTIONS_DEBUG("against [%d]%hs...", opti, options[opti].cmd);
|
|
|
|
if ( ParseCompare( options+opti, flags, p ) ) {
|
|
/* we have a match! */
|
|
|
|
ret = StoreOption( options, argv, argc, argi, opti,
|
|
flags, &tmp, TRUE, pbStop, pQueue );
|
|
|
|
OPTIONS_DEBUG( "StoreOption returned %d, args=%d, *pbStop = %d\n",
|
|
ret, tmp, *pbStop );
|
|
|
|
if ( !ret ) {
|
|
|
|
/* failed to store options for some reason. This is
|
|
critical. */
|
|
|
|
PrintUsage( stderr, flags, options, "" );
|
|
|
|
if ( flags & OPT_FLAG_TERMINATE ) {
|
|
exit( -1 );
|
|
} else {
|
|
return FALSE;
|
|
}
|
|
|
|
}
|
|
|
|
OPTIONS_DEBUG( "ParseOneOption now returning TRUE, argsused = %d.\n",
|
|
tmp );
|
|
|
|
*argsused = tmp;
|
|
return ret; /* successful StoreOptions parses our one option. */
|
|
|
|
} /* if ParseCompare... */
|
|
|
|
OPTIONS_DEBUG( "nope.\n" );
|
|
|
|
} /* options for-loop */
|
|
|
|
OPTIONS_DEBUG( "did not find the option. Checking for OPT_DEFAULTs.\n" );
|
|
|
|
for (opti = 0 ; !ARRAY_TERMINATED( options+opti ) ; opti++ ) {
|
|
|
|
if ( options[opti].flags & OPT_DEFAULT ) {
|
|
|
|
/* WASBUG 73922: should check to see if the option is also an
|
|
OPT_SUBOPTION, then parse the suboption for OPT_DEFAULTs.
|
|
However, as it stands, this will just fail for OPT_SUBOPTIONS,
|
|
because the first pointer will probably be nonnull.
|
|
|
|
The dev enlistment doesn't contain any OPT_SUBOPTIONS, so
|
|
this is not an issue. */
|
|
|
|
ASSERT( ( options[ opti ].flags & OPT_MUTEX_MASK ) != OPT_SUBOPTION );
|
|
|
|
if ( *( ((POPTU) &options[opti].data)->raw_data) == NULL ) {
|
|
|
|
OPTIONS_DEBUG("Storing %hs in unused OPT_DEFAULT %hs\n",
|
|
argv[argi],
|
|
options[opti].cmd );
|
|
|
|
ret = StoreOption( options, argv, argc, argi, opti,
|
|
flags, &tmp, FALSE, pbStop, pQueue );
|
|
OPTIONS_DEBUG("OPT_DEFAULT: StoreOptions returned %d\n", ret);
|
|
|
|
if ( !ret ) {
|
|
PrintUsage( stderr, flags, options, "" );
|
|
exit( -1 );
|
|
}
|
|
|
|
*argsused = tmp;
|
|
return ret;
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
*argsused = 0;
|
|
|
|
if ( ( flags & OPT_FLAG_SKIP_UNKNOWNS ) ||
|
|
( flags & OPT_FLAG_REASSEMBLE ) ||
|
|
( flags & OPT_FLAG_INTERNAL_JUMPOUT )) {
|
|
|
|
return TRUE; // skip this option
|
|
|
|
} else {
|
|
|
|
fprintf(stderr, "unknown option \"%hs\".\n", argv[argi]);
|
|
PrintUsage(stderr, flags, options, "");
|
|
|
|
if ( flags & OPT_FLAG_TERMINATE ) {
|
|
exit( -1 );
|
|
}
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
ASSERT_NOTREACHED( "should be no path to this code" );
|
|
|
|
}
|
|
|
|
|
|
/* ParseOptionsEx:
|
|
|
|
initializes the option structure, which is a sentinally-terminated
|
|
vector of optionStructs.
|
|
|
|
argc, argv: arguments to main() (see K&R)
|
|
pOptionStructure: vector of optionStructs, terminated with TERMINATE_ARRAY
|
|
optionFlags: optional flags to control api behavior
|
|
ppReturnedMemory: returned handle to a list of memory to be freed before
|
|
program exit. Use CleanupOptionDataEx to free it.
|
|
|
|
new_arg[c,v]: if nonnull, a new argc and argv are returned here.
|
|
if all the options were used up, argc = 0 and argv is
|
|
NULL. Note that it is safe to provide pointers to the
|
|
original argv/argc if so desired.
|
|
|
|
The function's behavior is complex:
|
|
|
|
the function will always return FALSE on any critical error (unable to
|
|
allocate memory, or invalid argument). On WINNT, Last Error will be
|
|
set to the appropriate error.
|
|
|
|
if new_argc AND new_argv are specified,
|
|
ParseOptionsEx will always return TRUE unless help was called, and
|
|
the two parameters will be updated to reflect new values.
|
|
|
|
otherwise:
|
|
ParseOptionsEx will return TRUE if it was able to recognize ALL args
|
|
on the command line given. It will return FALSE if any of the options
|
|
were unknown. This will probably be what most people want.
|
|
*/
|
|
|
|
BOOL
|
|
ParseOptionsEx( int argc,
|
|
char **argv,
|
|
optionStruct *options,
|
|
|
|
ULONG flags,
|
|
PVOID *ppReturnedMemory,
|
|
int *new_argc,
|
|
char ***new_argv ) {
|
|
|
|
BOOL bStopParsing = FALSE;
|
|
BOOL ret = FALSE;
|
|
LONG argi; // argument index
|
|
LONG tmp; // temporary return variable
|
|
PSAVEQUEUE pSaveQueue = NULL; // memory save area
|
|
PCHAR *pUnknowns = NULL; // will alloc with alloca
|
|
int cUnknowns = 0;
|
|
|
|
flags = flags & ~OPT_FLAG_INTERNAL_RESERVED; /* mask off flags that
|
|
the user shouldn't set. */
|
|
|
|
if ( new_argc && new_argv &&
|
|
!( flags & ( OPT_FLAG_SKIP_UNKNOWNS |
|
|
OPT_FLAG_REASSEMBLE |
|
|
OPT_FLAG_TERMINATE ) ) ) {
|
|
|
|
OPTIONS_DEBUG( "\nSetting internal jumpout flag.\n" );
|
|
flags |= OPT_FLAG_INTERNAL_JUMPOUT;
|
|
}
|
|
|
|
OPTIONS_DEBUG( "ParseOptionsEx( argc = %d\n"
|
|
" argv = 0x%x\n"
|
|
" opts = 0x%x\n"
|
|
" flags = 0x%x\n"
|
|
" ppMem = 0x%x\n"
|
|
" pargc = 0x%x\n"
|
|
" pargv = 0x%x\n",
|
|
|
|
argc, argv, options, flags, ppReturnedMemory, new_argc,
|
|
new_argv );
|
|
|
|
ASSERT( ppReturnedMemory != NULL );
|
|
|
|
// first, we need to ensure we have a save area.
|
|
|
|
if ( flags & OPT_FLAG_MEMORYLIST_OK ) {
|
|
|
|
pSaveQueue = (PSAVEQUEUE) *ppReturnedMemory;
|
|
|
|
} else if ( !OptionAlloc( NULL, &pSaveQueue, sizeof( SAVEQUEUE ) ) ) {
|
|
fprintf( stderr,
|
|
"ParseOptionsEx: unable to allocate save area\n" );
|
|
return FALSE;
|
|
}
|
|
|
|
ASSERT( pSaveQueue != NULL );
|
|
|
|
/* We must initialize pUnknowns if the user specified command-line
|
|
reassembly. Otherwise, it can stay NULL. */
|
|
|
|
if ( (flags & OPT_FLAG_REASSEMBLE) && ( argc > 0 ) ) {
|
|
|
|
pUnknowns = (PCHAR *) alloca( argc * sizeof( PCHAR ) );
|
|
|
|
ASSERT( pUnknowns != NULL ); /* yes, this assertion is invalid.
|
|
However, there is no clean solution if
|
|
we run out of stack space. Something
|
|
else will just fail even more
|
|
spectacularly. */
|
|
}
|
|
|
|
OPTIONS_DEBUG("options are at 0x%x\n", options);
|
|
|
|
#ifdef DEBUG_OPTIONS
|
|
|
|
if (DebugFlag) {
|
|
|
|
for (argi = 0; argi < argc ; argi++ ) {
|
|
OPTIONS_DEBUG("option %d is %hs\n", argi, argv[argi]);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
for (argi = 0 ; argi < argc ; /* NOTHING */ ) {
|
|
|
|
int tmp;
|
|
|
|
if ( bStopParsing ) { // this gets set in the PREVIOUS iteration.
|
|
|
|
OPTIONS_DEBUG( "bStopParsing is TRUE. Terminating parse run.\n");
|
|
|
|
/* WASBUG 73924: now what do we do with the unused options?
|
|
They get leaked. This is okay, because the app terminates. */
|
|
|
|
break;
|
|
}
|
|
|
|
if ( ParseOneOption( argc, argv, argi, flags, options, &tmp,
|
|
&bStopParsing, pSaveQueue ) ) {
|
|
|
|
OPTIONS_DEBUG( "ParseOneOption succeeded with %d options.\n", tmp );
|
|
|
|
if ( tmp > 0 ) {
|
|
|
|
// we were able to successfully parse one or more options.
|
|
|
|
argi += tmp;
|
|
|
|
OPTIONS_DEBUG( "advancing argi by %d to %d\n", tmp, argi );
|
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
if ( flags & OPT_FLAG_REASSEMBLE ) {
|
|
|
|
ASSERT( pUnknowns != NULL );
|
|
ASSERT( cUnknowns < argc );
|
|
|
|
OPTIONS_DEBUG( "OPT_FLAG_REASSEMBLE: this is unknown %d\n",
|
|
cUnknowns );
|
|
|
|
pUnknowns[ cUnknowns ] = argv[ argi ];
|
|
cUnknowns ++;
|
|
argi ++; // skipping this option
|
|
|
|
} else if ( !( flags & OPT_FLAG_SKIP_UNKNOWNS ) ) {
|
|
|
|
if ( new_argv && new_argc ) {
|
|
|
|
OPTIONS_DEBUG( "new argv and argc-- breakout at "
|
|
"argi=%d\n", argi );
|
|
|
|
break; /* we're not skipping the unknown values or
|
|
reassembling the command line. We're just
|
|
supposed to quit on unknown options. */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* error or unknown option, depending on our flags. Regardless,
|
|
an error message has already been printed. */
|
|
|
|
ret = FALSE;
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
} /* command-line for-loop */
|
|
|
|
/* if we make it this far, all the options were ok.
|
|
Check for unused OPT_NONNULLs... */
|
|
|
|
OPTIONS_DEBUG( "\n*** Searching for unused options ***\n\n" );
|
|
|
|
if (!FindUnusedOptions( options, flags, NULL, pSaveQueue ) ) {
|
|
|
|
/* unused OPT_NONNULLS are a critical error. Even if the user
|
|
specifies OPT_FLAG_SKIP_UNKNOWNS, he/she still told us not to
|
|
let the user unspecify the option. We default to returning FALSE.*/
|
|
|
|
if ( flags & OPT_FLAG_TERMINATE ) {
|
|
|
|
exit( -1 );
|
|
|
|
} else {
|
|
|
|
ret = FALSE;
|
|
goto cleanup;
|
|
|
|
}
|
|
}
|
|
|
|
OPTIONS_DEBUG( "All variables are OK. Checking reassembly flag:\n" );
|
|
|
|
if ( new_argv && new_argc ) {
|
|
|
|
int i;
|
|
|
|
// we may have skipped some of the options.
|
|
|
|
if ( flags & OPT_FLAG_REASSEMBLE ) {
|
|
|
|
OPTIONS_DEBUG( "REASSEMBLY: " );
|
|
|
|
for( i = 0 ; argi + i < argc ; i++ ) {
|
|
|
|
/* tack arguments we never parsed ( OPT_STOP_PARSING can cause
|
|
this ) onto the end of the Unknown array */
|
|
|
|
OPTIONS_DEBUG( "Assembling skipped option %d (%s) as unknown %d.\n",
|
|
i, argv[ argi+i ], cUnknowns+i );
|
|
|
|
pUnknowns[ cUnknowns+i ] = argv[ argi+i ];
|
|
cUnknowns++;
|
|
|
|
}
|
|
|
|
if ( cUnknowns > 0 ) {
|
|
|
|
OPTIONS_DEBUG( "There were %d unknowns.\n", cUnknowns);
|
|
|
|
for ( i = 0 ; i < cUnknowns ; i++ ) {
|
|
|
|
ASSERT( pUnknowns != NULL );
|
|
|
|
(*new_argv)[i] = pUnknowns[i];
|
|
|
|
}
|
|
|
|
} else OPTIONS_DEBUG( "There were no unknowns. \n" );
|
|
|
|
(*new_argv)[cUnknowns] = NULL;
|
|
*new_argc = cUnknowns;
|
|
|
|
#if 0 // same outcome as if the flag didn't exist
|
|
} else if ( flags & OPT_FLAG_SKIP_UNKNOWNS ) {
|
|
|
|
OPTIONS_DEBUG( "User asked us to skip unknown options.\n"
|
|
"zeroing argv and argc.\n" );
|
|
#endif
|
|
|
|
} else if ( argi != argc ) {
|
|
|
|
/* normal operation-- go until we hit unknown options.
|
|
|
|
argi is the index of the first unknown option, so we add
|
|
it to argv and subtract it from argc. */
|
|
|
|
*new_argv = argv+argi;
|
|
*new_argc = argc-argi;
|
|
|
|
OPTIONS_DEBUG( "normal operation-- parsing was halted.\n"
|
|
"new_argv = %d. new_argc = 0x%x.\n",
|
|
|
|
*new_argv, *new_argc );
|
|
} else {
|
|
|
|
*new_argv = NULL;
|
|
*new_argc = 0;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
#if 0
|
|
if ( new_argv && new_argc ) {
|
|
|
|
OPTIONS_DEBUG( "Catch-all case. Zeroing argv and argc.\n" );
|
|
|
|
*new_argv = NULL;
|
|
*new_argc = 0;
|
|
|
|
}
|
|
#else
|
|
|
|
OPTIONS_DEBUG( "User didn't request new argv or argc.\n" );
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
OPTIONS_DEBUG( "command line survived the parser.\n" );
|
|
|
|
ret = TRUE;
|
|
|
|
cleanup:
|
|
|
|
ASSERT( pSaveQueue != NULL );
|
|
|
|
if (!( flags & OPT_FLAG_MEMORYLIST_OK ) ) {
|
|
|
|
if ( ret ) {
|
|
|
|
OPTIONS_DEBUG( "Returning SaveQueue = 0x%x\n", pSaveQueue );
|
|
|
|
*ppReturnedMemory = (PVOID) pSaveQueue;
|
|
|
|
} else {
|
|
|
|
OPTIONS_DEBUG( "function failing. cleaning up local data..." );
|
|
CleanupOptionDataEx( pSaveQueue );
|
|
OPTIONS_DEBUG( "ok.\n" );
|
|
|
|
*ppReturnedMemory = NULL;
|
|
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|