/** * check for preset values from a config files or envrionment variables * * @param[in,out] opts the structure with the option names to check */ static tSuccess do_presets(tOptions * opts) { tOptDesc * od = NULL; if (! SUCCESSFUL(immediate_opts(opts))) return FAILURE; /* * IF this option set has a --save-opts option, then it also * has a --load-opts option. See if a command line option has disabled * option presetting. */ if ( (opts->specOptIdx.save_opts != NO_EQUIVALENT) && (opts->specOptIdx.save_opts != 0)) { od = opts->pOptDesc + opts->specOptIdx.save_opts + 1; if (DISABLED_OPT(od)) return SUCCESS; } /* * Until we return from this procedure, disable non-presettable opts */ opts->fOptSet |= OPTPROC_PRESETTING; /* * IF there are no config files, * THEN do any environment presets and leave. */ if (opts->papzHomeList == NULL) { env_presets(opts, ENV_ALL); } else { env_presets(opts, ENV_IMM); /* * Check to see if environment variables have disabled presetting. */ if ((od != NULL) && ! DISABLED_OPT(od)) intern_file_load(opts); /* * ${PROGRAM_LOAD_OPTS} value of "no" cannot disable other environment * variable options. Only the loading of .rc files. */ env_presets(opts, ENV_NON_IMM); } opts->fOptSet &= ~OPTPROC_PRESETTING; return SUCCESS; }
/*=export_func optionLoadOpt * private: * * what: Load an option rc/ini file * arg: + tOptions* + pOpts + program options descriptor + * arg: + tOptDesc* + pOptDesc + the descriptor for this arg + * * doc: * Processes the options found in the file named with * pOptDesc->optArg.argString. =*/ void optionLoadOpt( tOptions* pOpts, tOptDesc* pOptDesc ) { /* * IF the option is not being disabled, THEN load the file. There must * be a file. (If it is being disabled, then the disablement processing * already took place. It must be done to suppress preloading of ini/rc * files.) */ if (! DISABLED_OPT( pOptDesc )) { struct stat sb; if (stat( pOptDesc->optArg.argString, &sb ) != 0) { if ((pOpts->fOptSet & OPTPROC_ERRSTOP) == 0) return; fprintf( stderr, zFSErrOptLoad, errno, strerror( errno ), pOptDesc->optArg.argString ); exit(EX_NOINPUT); /* NOT REACHED */ } if (! S_ISREG( sb.st_mode )) { if ((pOpts->fOptSet & OPTPROC_ERRSTOP) == 0) return; fprintf( stderr, zNotFile, pOptDesc->optArg.argString ); exit(EX_NOINPUT); /* NOT REACHED */ } filePreset(pOpts, pOptDesc->optArg.argString, DIRECTION_CALLED); } }
static void prt_no_arg_opt(FILE * fp, tOptDesc * p, tOptDesc * pOD) { /* * The aliased to argument indicates whether or not the option * is "disabled". However, the original option has the name * string, so we get that there, not with "p". */ char const * pznm = (DISABLED_OPT(p)) ? pOD->pz_DisableName : pOD->pz_Name; /* * If the option was disabled and the disablement name is NULL, * then the disablement was caused by aliasing. * Use the name as the string to emit. */ if (pznm == NULL) pznm = pOD->pz_Name; fprintf(fp, "%s\n", pznm); }
/*=export_func optionLoadOpt * private: * * what: Load an option rc/ini file * arg: + tOptions* + opts + program options descriptor + * arg: + tOptDesc* + odesc + the descriptor for this arg + * * doc: * Processes the options found in the file named with * odesc->optArg.argString. =*/ void optionLoadOpt(tOptions * opts, tOptDesc * odesc) { struct stat sb; if (opts <= OPTPROC_EMIT_LIMIT) return; /* * IF the option is not being disabled, THEN load the file. There must * be a file. (If it is being disabled, then the disablement processing * already took place. It must be done to suppress preloading of ini/rc * files.) */ if ( DISABLED_OPT(odesc) || ((odesc->fOptState & OPTST_RESET) != 0)) return; if (stat(odesc->optArg.argString, &sb) != 0) { if ((opts->fOptSet & OPTPROC_ERRSTOP) == 0) return; fserr_exit(opts->pzProgName, "stat", odesc->optArg.argString); /* NOT REACHED */ } if (! S_ISREG(sb.st_mode)) { if ((opts->fOptSet & OPTPROC_ERRSTOP) == 0) return; errno = EINVAL; fserr_exit(opts->pzProgName, "stat", odesc->optArg.argString); /* NOT REACHED */ } file_preset(opts, odesc->optArg.argString, DIRECTION_CALLED); }
/** * Load a configuration file. This may be invoked either from * scanning the "homerc" list, or from a specific file request. * (see "optionFileLoad()", the implementation for --load-opts) */ LOCAL void intern_file_load(tOptions * opts) { uint32_t svfl; int idx; int inc; char f_name[ AG_PATH_MAX+1 ]; if (opts->papzHomeList == NULL) return; svfl = opts->fOptSet; inc = DIRECTION_PRESET; /* * Never stop on errors in config files. */ opts->fOptSet &= ~OPTPROC_ERRSTOP; /* * Find the last RC entry (highest priority entry) */ for (idx = 0; opts->papzHomeList[ idx+1 ] != NULL; ++idx) ; /* * For every path in the home list, ... *TWICE* We start at the last * (highest priority) entry, work our way down to the lowest priority, * handling the immediate options. * Then we go back up, doing the normal options. */ for (;;) { struct stat sb; cch_t * path; /* * IF we've reached the bottom end, change direction */ if (idx < 0) { inc = DIRECTION_PROCESS; idx = 0; } path = opts->papzHomeList[ idx ]; /* * IF we've reached the top end, bail out */ if (path == NULL) break; idx += inc; if (! optionMakePath(f_name, (int)sizeof(f_name), path, opts->pzProgPath)) continue; /* * IF the file name we constructed is a directory, * THEN append the Resource Configuration file name * ELSE we must have the complete file name */ if (stat(f_name, &sb) != 0) continue; /* bogus name - skip the home list entry */ if (S_ISDIR(sb.st_mode)) { size_t len = strlen(f_name); size_t nln = strlen(opts->pzRcName) + 1; char * pz = f_name + len; if (len + 1 + nln >= sizeof(f_name)) continue; if (pz[-1] != DIRCH) *(pz++) = DIRCH; memcpy(pz, opts->pzRcName, nln); } file_preset(opts, f_name, inc); /* * IF we are now to skip config files AND we are presetting, * THEN change direction. We must go the other way. */ { tOptDesc * od = opts->pOptDesc + opts->specOptIdx.save_opts + 1; if (DISABLED_OPT(od) && PRESETTING(inc)) { idx -= inc; /* go back and reprocess current file */ inc = DIRECTION_PROCESS; } } } /* twice for every path in the home list, ... */ opts->fOptSet = svfl; }
/*=export_func optionPutShell * what: write a portable shell script to parse options * private: * arg: tOptions *, pOpts, the program options descriptor * doc: This routine will emit portable shell script text for parsing * the options described in the option definitions. =*/ void optionPutShell(tOptions * pOpts) { int optIx = 0; printf(zOptCtFmt, pOpts->curOptIdx-1); do { tOptDesc * pOD = pOpts->pOptDesc + optIx; if ((pOD->fOptState & OPTST_NO_OUTPUT_MASK) != 0) continue; /* * Equivalence classes are hard to deal with. Where the * option data wind up kind of squishes around. For the purposes * of emitting shell state, they are not recommended, but we'll * do something. I guess we'll emit the equivalenced-to option * at the point in time when the base option is found. */ if (pOD->optEquivIndex != NO_EQUIVALENT) continue; /* equivalence to a different option */ /* * Equivalenced to a different option. Process the current option * as the equivalenced-to option. Keep the persistent state bits, * but copy over the set-state bits. */ if (pOD->optActualIndex != optIx) { tOptDesc * p = pOpts->pOptDesc + pOD->optActualIndex; p->optArg = pOD->optArg; p->fOptState &= OPTST_PERSISTENT_MASK; p->fOptState |= pOD->fOptState & ~OPTST_PERSISTENT_MASK; printf(zEquivMode, pOpts->pzPROGNAME, pOD->pz_NAME, p->pz_NAME); pOD = p; } /* * If the argument type is a set membership bitmask, then we always * emit the thing. We do this because it will always have some sort * of bitmask value and we need to emit the bit values. */ if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_MEMBERSHIP) { print_membership(pOpts, pOD); continue; } /* * IF the option was either specified or it wakes up enabled, * then we will emit information. Otherwise, skip it. * The idea is that if someone defines an option to initialize * enabled, we should tell our shell script that it is enabled. */ if (UNUSED_OPT(pOD) && DISABLED_OPT(pOD)) continue; /* * Handle stacked arguments */ if ( (pOD->fOptState & OPTST_STACKED) && (pOD->optCookie != NULL) ) { print_stacked_arg(pOpts, pOD); continue; } /* * If the argument has been disabled, * Then set its value to the disablement string */ if ((pOD->fOptState & OPTST_DISABLED) != 0) { printf(zOptDisabl, pOpts->pzPROGNAME, pOD->pz_NAME, (pOD->pz_DisablePfx != NULL) ? pOD->pz_DisablePfx : "false"); continue; } /* * If the argument type is numeric, the last arg pointer * is really the VALUE of the string that was pointed to. */ if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_NUMERIC) { printf(zOptNumFmt, pOpts->pzPROGNAME, pOD->pz_NAME, (int)pOD->optArg.argInt); continue; } /* * If the argument type is an enumeration, then it is much * like a text value, except we call the callback function * to emit the value corresponding to the "optArg" number. */ if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_ENUMERATION) { print_enumeration(pOpts, pOD); continue; } /* * If the argument type is numeric, the last arg pointer * is really the VALUE of the string that was pointed to. */ if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_BOOLEAN) { printf(zFullOptFmt, pOpts->pzPROGNAME, pOD->pz_NAME, (pOD->optArg.argBool == 0) ? "false" : "true"); continue; } /* * IF the option has an empty value, * THEN we set the argument to the occurrence count. */ if ( (pOD->optArg.argString == NULL) || (pOD->optArg.argString[0] == NUL) ) { printf(zOptNumFmt, pOpts->pzPROGNAME, pOD->pz_NAME, pOD->optOccCt); continue; } /* * This option has a text value */ printf(OPT_VAL_FMT, pOpts->pzPROGNAME, pOD->pz_NAME); print_quot_str(pOD->optArg.argString); printf(OPT_END_FMT, pOpts->pzPROGNAME, pOD->pz_NAME); } while (++optIx < pOpts->presetOptCt ); if ( ((pOpts->fOptSet & OPTPROC_REORDER) != 0) && (pOpts->curOptIdx < pOpts->origArgCt)) print_reordering(pOpts); fflush(stdout); }
/* internalFileLoad * * Load a configuration file. This may be invoked either from * scanning the "homerc" list, or from a specific file request. * (see "optionFileLoad()", the implementation for --load-opts) */ LOCAL void internalFileLoad( tOptions* pOpts ) { int idx; int inc = DIRECTION_PRESET; char zFileName[ AG_PATH_MAX+1 ]; if (pOpts->papzHomeList == NULL) return; /* * Find the last RC entry (highest priority entry) */ for (idx = 0; pOpts->papzHomeList[ idx+1 ] != NULL; ++idx) ; /* * For every path in the home list, ... *TWICE* We start at the last * (highest priority) entry, work our way down to the lowest priority, * handling the immediate options. * Then we go back up, doing the normal options. */ for (;;) { struct stat StatBuf; cch_t* pzPath; /* * IF we've reached the bottom end, change direction */ if (idx < 0) { inc = DIRECTION_PROCESS; idx = 0; } pzPath = pOpts->papzHomeList[ idx ]; /* * IF we've reached the top end, bail out */ if (pzPath == NULL) break; idx += inc; if (! optionMakePath( zFileName, (int)sizeof(zFileName), pzPath, pOpts->pzProgPath )) continue; /* * IF the file name we constructed is a directory, * THEN append the Resource Configuration file name * ELSE we must have the complete file name */ if (stat( zFileName, &StatBuf ) != 0) continue; /* bogus name - skip the home list entry */ if (S_ISDIR( StatBuf.st_mode )) { size_t len = strlen( zFileName ); char* pz; if (len + 1 + strlen( pOpts->pzRcName ) >= sizeof( zFileName )) continue; pz = zFileName + len; if (pz[-1] != DIRCH) *(pz++) = DIRCH; strcpy( pz, pOpts->pzRcName ); } filePreset( pOpts, zFileName, inc ); /* * IF we are now to skip config files AND we are presetting, * THEN change direction. We must go the other way. */ { tOptDesc * pOD = pOpts->pOptDesc + pOpts->specOptIdx.save_opts+1; if (DISABLED_OPT(pOD) && PRESETTING(inc)) { idx -= inc; /* go back and reprocess current file */ inc = DIRECTION_PROCESS; } } } /* twice for every path in the home list, ... */ }
/** * print one option entry to the save file. * * @param[in] fp the file pointer for the save file * @param[in] od the option descriptor to print * @param[in] l_arg the last argument for the option */ static void prt_entry(FILE * fp, tOptDesc * od, char const * l_arg) { int space_ct; /* * There is an argument. Pad the name so values line up. * Not disabled *OR* this got equivalenced to another opt, * then use current option name. * Otherwise, there must be a disablement name. */ { char const * pz = (! DISABLED_OPT(od) || (od->optEquivIndex != NO_EQUIVALENT)) ? od->pz_Name : od->pz_DisableName; space_ct = 17 - strlen(pz); fputs(pz, fp); } if ( (l_arg == NULL) && (OPTST_GET_ARGTYPE(od->fOptState) != OPARG_TYPE_NUMERIC)) goto end_entry; fputs(" = ", fp); while (space_ct-- > 0) fputc(' ', fp); /* * IF the option is numeric only, * THEN the char pointer is really the number */ if (OPTST_GET_ARGTYPE(od->fOptState) == OPARG_TYPE_NUMERIC) fprintf(fp, "%d", (int)(t_word)l_arg); else { for (;;) { char const * eol = strchr(l_arg, NL); /* * IF this is the last line * THEN bail and print it */ if (eol == NULL) break; /* * Print the continuation and the text from the current line */ (void)fwrite(l_arg, (size_t)(eol - l_arg), (size_t)1, fp); l_arg = eol+1; /* advance the Last Arg pointer */ fputs("\\\n", fp); } /* * Terminate the entry */ fputs(l_arg, fp); } end_entry: fputc(NL, fp); }
/*=export_func optionPutShell * what: write a portable shell script to parse options * private: * arg: tOptions*, pOpts, the program options descriptor * doc: This routine will emit portable shell script text for parsing * the options described in the option definitions. =*/ void optionPutShell( tOptions* pOpts ) { int optIx = 0; tSCC zOptCtFmt[] = "OPTION_CT=%d\nexport OPTION_CT\n"; tSCC zOptNumFmt[] = "%1$s_%2$s=%3$d # 0x%3$X\nexport %1$s_%2$s\n"; tSCC zOptDisabl[] = "%1$s_%2$s=%3$s\nexport %1$s_%2$s\n"; tSCC zOptValFmt[] = "%s_%s="; tSCC zOptEnd[] = "\nexport %s_%s\n"; tSCC zFullOptFmt[]= "%1$s_%2$s='%3$s'\nexport %1$s_%2$s\n"; tSCC zEquivMode[] = "%1$s_%2$s_MODE='%3$s'\nexport %1$s_%2$s_MODE\n"; printf( zOptCtFmt, pOpts->curOptIdx-1 ); do { tOptDesc* pOD = pOpts->pOptDesc + optIx; if (SKIP_OPT(pOD)) continue; /* * Equivalence classes are hard to deal with. Where the * option data wind up kind of squishes around. For the purposes * of emitting shell state, they are not recommended, but we'll * do something. I guess we'll emit the equivalenced-to option * at the point in time when the base option is found. */ if (pOD->optEquivIndex != NO_EQUIVALENT) continue; /* equivalence to a different option */ /* * Equivalenced to a different option. Process the current option * as the equivalenced-to option. Keep the persistent state bits, * but copy over the set-state bits. */ if (pOD->optActualIndex != optIx) { tOptDesc* p = pOpts->pOptDesc + pOD->optActualIndex; p->optArg = pOD->optArg; p->fOptState &= OPTST_PERSISTENT_MASK; p->fOptState |= pOD->fOptState & ~OPTST_PERSISTENT_MASK; printf( zEquivMode, pOpts->pzPROGNAME, pOD->pz_NAME, p->pz_NAME ); pOD = p; } /* * If the argument type is a set membership bitmask, then we always * emit the thing. We do this because it will always have some sort * of bitmask value and we need to emit the bit values. */ if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_MEMBERSHIP) { char const * pz; uintptr_t val = 1; printf( zOptNumFmt, pOpts->pzPROGNAME, pOD->pz_NAME, (int)(uintptr_t)(pOD->optCookie) ); pOD->optCookie = (void*)(uintptr_t)~0UL; (*(pOD->pOptProc))( (tOptions*)2UL, pOD ); /* * We are building the typeset list. The list returned starts with * 'none + ' for use by option saving stuff. We must ignore that. */ pz = pOD->optArg.argString + 7; while (*pz != NUL) { printf( "typeset -x -i %s_", pOD->pz_NAME ); pz += strspn( pz, " +\t\n\f" ); for (;;) { int ch = *(pz++); if (islower( ch )) fputc( toupper( ch ), stdout ); else if (isalnum( ch )) fputc( ch, stdout ); else if (isspace( ch ) || (ch == '+')) goto name_done; else if (ch == NUL) { pz--; goto name_done; } else fputc( '_', stdout ); } name_done:; printf( "=%1$lu # 0x%1$lX\n", (unsigned long)val ); val <<= 1; } AGFREE(pOD->optArg.argString); pOD->optArg.argString = NULL; pOD->fOptState &= ~OPTST_ALLOC_ARG; continue; } /* * IF the option was either specified or it wakes up enabled, * then we will emit information. Otherwise, skip it. * The idea is that if someone defines an option to initialize * enabled, we should tell our shell script that it is enabled. */ if (UNUSED_OPT( pOD ) && DISABLED_OPT( pOD )) continue; /* * Handle stacked arguments */ if ( (pOD->fOptState & OPTST_STACKED) && (pOD->optCookie != NULL) ) { tSCC zOptCookieCt[] = "%1$s_%2$s_CT=%3$d\nexport %1$s_%2$s_CT\n"; tArgList* pAL = (tArgList*)pOD->optCookie; tCC** ppz = pAL->apzArgs; int ct = pAL->useCt; printf( zOptCookieCt, pOpts->pzPROGNAME, pOD->pz_NAME, ct ); while (--ct >= 0) { tSCC numarg_z[] = "%s_%s_%d="; tSCC end_z[] = "\nexport %s_%s_%d\n"; printf( numarg_z, pOpts->pzPROGNAME, pOD->pz_NAME, pAL->useCt - ct ); putQuotedStr( *(ppz++) ); printf( end_z, pOpts->pzPROGNAME, pOD->pz_NAME, pAL->useCt - ct ); } } /* * If the argument has been disabled, * Then set its value to the disablement string */ else if ((pOD->fOptState & OPTST_DISABLED) != 0) printf( zOptDisabl, pOpts->pzPROGNAME, pOD->pz_NAME, (pOD->pz_DisablePfx != NULL) ? pOD->pz_DisablePfx : "false" ); /* * If the argument type is numeric, the last arg pointer * is really the VALUE of the string that was pointed to. */ else if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_NUMERIC) printf( zOptNumFmt, pOpts->pzPROGNAME, pOD->pz_NAME, (int)pOD->optArg.argInt ); /* * If the argument type is an enumeration, then it is much * like a text value, except we call the callback function * to emit the value corresponding to the "optArg" number. */ else if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_ENUMERATION) { printf( zOptValFmt, pOpts->pzPROGNAME, pOD->pz_NAME ); fputc( '\'', stdout ); (*(pOD->pOptProc))( (tOptions*)1UL, pOD ); fputc( '\'', stdout ); printf( zOptEnd, pOpts->pzPROGNAME, pOD->pz_NAME ); } /* * If the argument type is numeric, the last arg pointer * is really the VALUE of the string that was pointed to. */ else if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_BOOLEAN) printf( zFullOptFmt, pOpts->pzPROGNAME, pOD->pz_NAME, (pOD->optArg.argBool == 0) ? "false" : "true" ); /* * IF the option has an empty value, * THEN we set the argument to the occurrence count. */ else if ( (pOD->optArg.argString == NULL) || (pOD->optArg.argString[0] == NUL) ) printf( zOptNumFmt, pOpts->pzPROGNAME, pOD->pz_NAME, pOD->optOccCt ); /* * This option has a text value */ else { printf( zOptValFmt, pOpts->pzPROGNAME, pOD->pz_NAME ); putQuotedStr( pOD->optArg.argString ); printf( zOptEnd, pOpts->pzPROGNAME, pOD->pz_NAME ); } } while (++optIx < pOpts->presetOptCt ); if ( ((pOpts->fOptSet & OPTPROC_REORDER) != 0) && (pOpts->curOptIdx < pOpts->origArgCt)) { fputs( "set --", stdout ); for (optIx = pOpts->curOptIdx; optIx < pOpts->origArgCt; optIx++) { char* pzArg = pOpts->origArgVect[ optIx ]; if (strchr( pzArg, '\'' ) == NULL) printf( " '%s'", pzArg ); else { fputs( " '", stdout ); for (;;) { char ch = *(pzArg++); switch (ch) { case '\'': fputs( "'\\''", stdout ); break; case NUL: goto arg_done; default: fputc( ch, stdout ); break; } } arg_done:; fputc( '\'', stdout ); } } fputs( "\nOPTION_CT=0\n", stdout ); } }
/*=export_func optionSaveFile * * what: saves the option state to a file * * arg: tOptions*, pOpts, program options descriptor * * doc: * * This routine will save the state of option processing to a file. The name * of that file can be specified with the argument to the @code{--save-opts} * option, or by appending the @code{rcfile} attribute to the last * @code{homerc} attribute. If no @code{rcfile} attribute was specified, it * will default to @code{.@i{programname}rc}. If you wish to specify another * file, you should invoke the @code{SET_OPT_SAVE_OPTS( @i{filename} )} macro. * * err: * * If no @code{homerc} file was specified, this routine will silently return * and do nothing. If the output file cannot be created or updated, a message * will be printed to @code{stderr} and the routine will return. =*/ void optionSaveFile( tOptions* pOpts ) { tOptDesc* pOD; int ct; FILE* fp; { int free_name = 0; tCC* pzFName = findFileName( pOpts, &free_name ); if (pzFName == NULL) return; fp = fopen( pzFName, "w" FOPEN_BINARY_FLAG ); if (fp == NULL) { fprintf( stderr, zWarn, pOpts->pzProgName ); fprintf( stderr, zNoCreat, errno, strerror( errno ), pzFName ); if (free_name) AGFREE((void*) pzFName ); return; } if (free_name) AGFREE( (void*)pzFName ); } { char const* pz = pOpts->pzUsageTitle; fputs( "# ", fp ); do { fputc( *pz, fp ); } while (*(pz++) != '\n'); } { time_t timeVal = time( NULL ); char* pzTime = ctime( &timeVal ); fprintf( fp, zPresetFile, pzTime ); #ifdef HAVE_ALLOCATED_CTIME /* * The return values for ctime(), localtime(), and gmtime() * normally point to static data that is overwritten by each call. * The test to detect allocated ctime, so we leak the memory. */ AGFREE( (void*)pzTime ); #endif } /* * FOR each of the defined options, ... */ ct = pOpts->presetOptCt; pOD = pOpts->pOptDesc; do { int arg_state; tOptDesc* p; /* * IF the option has not been defined * OR it does not take an initialization value * OR it is equivalenced to another option * THEN continue (ignore it) */ if (UNUSED_OPT( pOD )) continue; if ((pOD->fOptState & (OPTST_NO_INIT|OPTST_DOCUMENT|OPTST_OMITTED)) != 0) continue; if ( (pOD->optEquivIndex != NO_EQUIVALENT) && (pOD->optEquivIndex != pOD->optIndex)) continue; /* * Set a temporary pointer to the real option description * (i.e. account for equivalencing) */ p = ((pOD->fOptState & OPTST_EQUIVALENCE) != 0) ? (pOpts->pOptDesc + pOD->optActualIndex) : pOD; /* * IF no arguments are allowed * THEN just print the name and continue */ if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_NONE) { char const * pznm = (DISABLED_OPT( p )) ? p->pz_DisableName : p->pz_Name; /* * If the option was disabled and the disablement name is NULL, * then the disablement was caused by aliasing. * Use the name as the string to emit. */ if (pznm == NULL) pznm = p->pz_Name; fprintf(fp, "%s\n", pznm); continue; } arg_state = OPTST_GET_ARGTYPE(p->fOptState); switch (arg_state) { case 0: case OPARG_TYPE_NUMERIC: printEntry( fp, p, (void*)(p->optArg.argInt)); break; case OPARG_TYPE_STRING: if (p->fOptState & OPTST_STACKED) { tArgList* pAL = (tArgList*)p->optCookie; int uct = pAL->useCt; tCC** ppz = pAL->apzArgs; /* * Disallow multiple copies of disabled options. */ if (uct > 1) p->fOptState &= ~OPTST_DISABLED; while (uct-- > 0) printEntry( fp, p, *(ppz++) ); } else { printEntry( fp, p, p->optArg.argString ); } break; case OPARG_TYPE_ENUMERATION: case OPARG_TYPE_MEMBERSHIP: { uintptr_t val = p->optArg.argEnum; /* * This is a magic incantation that will convert the * bit flag values back into a string suitable for printing. */ (*(p->pOptProc))( (tOptions*)2UL, p ); printEntry( fp, p, (void*)(p->optArg.argString)); if ( (p->optArg.argString != NULL) && (arg_state != OPARG_TYPE_ENUMERATION)) { /* * set membership strings get allocated */ AGFREE( (void*)p->optArg.argString ); p->fOptState &= ~OPTST_ALLOC_ARG; } p->optArg.argEnum = val; break; } case OPARG_TYPE_BOOLEAN: printEntry( fp, p, p->optArg.argBool ? "true" : "false" ); break; default: break; /* cannot handle - skip it */ } } while ( (pOD++), (--ct > 0)); fclose( fp ); }
static void printEntry( FILE * fp, tOptDesc * p, tCC* pzLA ) { /* * There is an argument. Pad the name so values line up. * Not disabled *OR* this got equivalenced to another opt, * then use current option name. * Otherwise, there must be a disablement name. */ { char const * pz; if (! DISABLED_OPT(p) || (p->optEquivIndex != NO_EQUIVALENT)) pz = p->pz_Name; else pz = p->pz_DisableName; fprintf(fp, "%-18s", pz); } /* * IF the option is numeric only, * THEN the char pointer is really the number */ if (OPTST_GET_ARGTYPE(p->fOptState) == OPARG_TYPE_NUMERIC) fprintf( fp, " %d\n", (int)(t_word)pzLA ); /* * OTHERWISE, FOR each line of the value text, ... */ else if (pzLA == NULL) fputc( '\n', fp ); else { fputc( ' ', fp ); fputc( ' ', fp ); for (;;) { tCC* pzNl = strchr( pzLA, '\n' ); /* * IF this is the last line * THEN bail and print it */ if (pzNl == NULL) break; /* * Print the continuation and the text from the current line */ (void)fwrite( pzLA, (size_t)(pzNl - pzLA), (size_t)1, fp ); pzLA = pzNl+1; /* advance the Last Arg pointer */ fputs( "\\\n", fp ); } /* * Terminate the entry */ fputs( pzLA, fp ); fputc( '\n', fp ); } }