/*++ UTEST.C Test program for the options subsystem. Must compile under NT and UNIX Created, 5/24/1997 by DavidCHR --*/ #include "private.h" optEnumStruct enums[] = { { "one", (PVOID) 1, "should end up 1" }, { "two", (PVOID) 2, "should end up 2" }, { "beef", (PVOID) 0xdeadbeef, "should be 0xdeadbeef" }, { "beefs", (PVOID) 0xbadf00d, "should be 0xbadf00d" }, { "secret", (PVOID) 60, }, // shouldn't show in help TERMINATE_ARRAY }; ULONG enumTestVariable=0; PCHAR SubString = NULL; optionStruct substructOptions[] = { { "h", NULL, OPT_HELP }, { "substr", &SubString, OPT_STRING, "Substring option" }, TERMINATE_ARRAY }; PCHAR FuncString1 = NULL; PCHAR FuncString2 = NULL; PCHAR StringOption = NULL; int IntegerOption = 0L; BOOL BooleanOption = FALSE; float FloatOption = 0.0; PCHAR UndocumentedString = NULL; PWCHAR WideCharOption = NULL; UNICODE_STRING UnicodeStringOption = { 0 }; int MyOptFunc( IN int argc, IN PCHAR *argv ); BOOL MyOptFunc2( IN BOOL fHelp, IN POPT_FUNC_PARAMETER_DATA pData ); optionStruct sampleOptions[ ] = { { "help", NULL, OPT_HELP }, { "?", NULL, OPT_HELP }, { NULL, NULL, OPT_DUMMY, "-----------------------------" }, { NULL, NULL, OPT_CONTINUE, "These are the useful options:" }, { NULL, NULL, OPT_DUMMY, "-----------------------------" }, { "enum", &enumTestVariable, OPT_ENUMERATED, "Test enumerated type", enums }, { "mask", &enumTestVariable, OPT_ENUMERATED | OPT_ENUM_IS_MASK, "Test enumerated type with OPT_ENUM_IS_MASK", enums }, { "substruct", substructOptions, OPT_SUBOPTION | OPT_RECURSE, "substruct:help for help" }, { "recurse", sampleOptions, OPT_SUBOPTION, "recurse:help for help" }, { "string", &StringOption, OPT_STRING | OPT_ENVIRONMENT, "String Option", "StringOption" }, { NULL, NULL, OPT_CONTINUE, "Use this option to request a string" }, { "int", &IntegerOption, OPT_INT | OPT_ENVIRONMENT, "integer option", "IntegerOption" }, { NULL, NULL, OPT_CONTINUE, "Use this option to request an integer" }, { "func", MyOptFunc, OPT_FUNC, "function option" }, { NULL, NULL, OPT_CONTINUE, "Use this option to request two strings" }, { "func2", &IntegerOption, OPT_FUNC2, "FUNC2 option", MyOptFunc2 }, { "bool", &BooleanOption, OPT_BOOL, "boolean option" }, { NULL, NULL, OPT_CONTINUE, "Use this option to request a boolean" }, { "float", &FloatOption, OPT_FLOAT, "floating point option" }, { NULL, NULL, OPT_CONTINUE, "Use this option to request a float" }, { "wstring",&WideCharOption, OPT_WSTRING | OPT_ENVIRONMENT, "Wide Char String option", "WideCharOption" }, { "ustring",&UnicodeStringOption, OPT_USTRING | OPT_ENVIRONMENT, "Unicode String Option", "UnicodeStringOption" }, { "hidden", &UndocumentedString, OPT_STRING | OPT_HIDDEN, "you should never see this line. This option is OPT_HIDDEN" }, { "stop", NULL, OPT_STOP_PARSING, "halts parsing of the command line." }, { NULL, NULL, OPT_DUMMY | OPT_NOHEADER, "" }, { NULL, NULL, OPT_DUMMY | OPT_NOHEADER, "Example: utest /string \"foo bar baz\" /int 0x15 +bool /float 3.14" }, { NULL, NULL, OPT_PAUSE }, TERMINATE_ARRAY }; int MyOptFunc( int argc, PCHAR *argv ) { if ( ( argv == NULL ) || (argc < 3 ) ) { /* this means the user requested help */ fprintf( stderr, "func [string1] [string2]\n" ); return 0; } printf( "MyOptFunc was called. argc=%d.\n", argc ); FuncString1 = argv[1]; FuncString2 = argv[2]; return 3; /* number of arguments eaten-- -func argv[1] argv[2] == 3 options */ } VOID DumpArgs( int argc, PCHAR argv[] ) { int i; for ( i = 0 ; i < argc ; i++ ) { fprintf( stderr, "arg %d = %s\n", i, argv[i] ); } } BOOL MyOptFunc2( IN BOOL fHelp, IN POPT_FUNC_PARAMETER_DATA pData ) { #if OPT_FUNC_PARAMETER_VERSION != 1 #error "OptFuncParameterVersion has changed. Update this function." #endif optionStruct OptFunc2Options[] = { { "help", NULL, OPT_HELP }, { "FuncString1", &FuncString1, OPT_INT }, { "FuncString2", &FuncString2, OPT_INT }, { "recurse", sampleOptions, OPT_SUBOPTION, "points back to the toplevel structure. Very amusing. :-)" }, { "STOP", NULL, OPT_STOP_PARSING, "halts parsing within the Func2." }, TERMINATE_ARRAY }; if ( fHelp ) { CHAR buffer[ 255 ]; PrintUsageEntry( stderr, "[-/+]", // switch characters pData->argv[0], // command GUARANTEED TO EXIST "->", // separator "Exercises the OPT_FUNC2 interface. Options follow", FALSE ); // FALSE--> do not repeat switch. sprintf( buffer, "-> options %s takes ", pData->argv[0] ); PrintUsageEntry( stderr, NULL, NULL, "-=", // the NULLs will fill with this string. buffer, TRUE ); sprintf( buffer, "(%s) ", pData->argv[0] ); PrintUsage( stderr, 0L, // flags OptFunc2Options, buffer ); PrintUsageEntry( stderr, NULL, NULL, "-*", "-> (end of OPT_FUNC2 options)", TRUE ); return TRUE; } else { if ( pData->optionVersion != OPT_FUNC_PARAMETER_VERSION ) { fprintf( stderr, "WARNING: option library out of sync with header\n" ); } fprintf( stderr, "MyOptFunc2 called. Data follows:\n" "pData->optionVersion = %d\n" "pData->dataField = 0x%p\n" "pData->argc = %d\n" "pData->argv = 0x%p\n" "pData->optionFlags = 0x%x\n" "pData->pSaveQueue = 0x%p\n", pData->optionVersion, pData->dataFieldPointer, pData->argc, pData->argv, pData->optionFlags, pData->pSaveQueue ); fprintf( stderr, "%s arguments are:\n", pData->argv[0] ); DumpArgs( pData->argc, pData->argv ); if ( ParseOptionsEx( pData->argc-1, pData->argv+1, OptFunc2Options, pData->optionFlags, &pData->pSaveQueue, &pData->argsused, &pData->argv ) ) { fprintf( stderr, "pData->argsused IN = %d\n", pData->argsused ); pData->argsused = pData->argc - pData->argsused; fprintf( stderr, "pData->argsused OUT = %d\n", pData->argsused ); } else return FALSE; } fprintf( stderr, "\n Leaving OPT_FUNC2. \n\n" ); return TRUE; } int main( int argc, char *argv[] ) { BOOL foo; PVOID pCleanup = NULL; optEnumStruct parserOptions[] = { { "skip", (PVOID) OPT_FLAG_SKIP_UNKNOWNS, "OPT_FLAG_SKIP_UNKNOWNS" }, { "reassemble", (PVOID) OPT_FLAG_REASSEMBLE, "OPT_FLAG_REASSEMBLE" }, { "terminate", (PVOID) OPT_FLAG_TERMINATE, "OPT_FLAG_TERMINATE" }, TERMINATE_ARRAY }; ULONG ParserFlag = OPT_FLAG_REASSEMBLE; #ifndef DEBUG_OPTIONS BOOL DebugFlag = 0; // will be ignored... just here for convenience #endif optionStruct singleOption[] = { { "utestHelp", NULL, OPT_HELP }, { "parserFlag", &ParserFlag, OPT_ENUMERATED, "flags to pass to ParseOptionsEx", parserOptions }, { "headerlength", &OptMaxHeaderLength, OPT_INT, "OptMaxHeaderLength value (formatting)" }, { "commandLength", &OptMaxCommandLength, OPT_INT, "OptMaxCommandLength value (formatting)" }, { "separatorLength", &OptMaxSeparatorLength, OPT_INT, "OptMaxSeparatorLength value (formatting)" }, { "descriptionLength", &OptMaxDescriptionLength, OPT_INT, "OptMaxDescriptionLength value (formatting)" }, { "debug", &DebugFlag, OPT_INT, "Debugger status" }, TERMINATE_ARRAY }; DebugFlag |= OPTION_DEBUGGING_LEVEL; foo = ParseOptionsEx( argc-1, argv+1, singleOption, 0, &pCleanup, &argc, &argv ); ParserFlag |= OPT_FLAG_MEMORYLIST_OK; fprintf( stderr, "first ParseOptionsEx returned 0x%x \n" " saveQueue 0x%p \n" " passing in flags 0x%x \n", foo, pCleanup, ParserFlag ); if ( argc ) { ULONG i; fprintf( stderr, "%d new options: \n", argc ); DumpArgs( argc, argv ); fprintf( stderr, "\n" ); } foo = ParseOptionsEx( argc, argv, sampleOptions, ParserFlag, &pCleanup, &argc, &argv ); fprintf( stderr, "ParseOptionsEx returns %d\n" " new argv = 0x%p\n" " new argc = %d \n", foo, argv, argc ); DumpArgs( argc, argv ); printf( "Formatting values were:\n" "\tOptMaxHeaderLength = %d\n" "\tOptMaxCommandLength = %d\n" "\tOptMaxSeparatorLength = %d\n" "\tOptMaxDescriptionLength = %d\n", OptMaxHeaderLength, OptMaxCommandLength, OptMaxSeparatorLength, OptMaxDescriptionLength ); printf( "\nOptions used:\n" "\tstring = \"%hs\"\n" "\tint = %d \n" "\tBool = 0x%x \n" /* "Float = %f \n" */ "\twstring = L\"%ws\"\n" "\tustring = (unicode string) %wZ \n" "\thidden = \"%hs\"\n" "\tsubstruct:substr = \"%hs\"\n" "\tfuncString1 = \"%hs\"\n" "\tfuncString2 = \"%hs\"\n" "\tenum = %d (0x%x)\n", StringOption, IntegerOption, BooleanOption, /* FloatOption, */ /* floating point not loaded? What does that mean?! */ WideCharOption, &UnicodeStringOption, UndocumentedString, SubString, FuncString1, FuncString2, enumTestVariable, enumTestVariable ); CleanupOptionDataEx( pCleanup ); return foo; }