1:
2: /**
3: * \file autoopts.c
4: *
5: * Time-stamp: "2011-03-25 17:55:07 bkorb"
6: *
7: * This file contains all of the routines that must be linked into
8: * an executable to use the generated option processing. The optional
9: * routines are in separately compiled modules so that they will not
10: * necessarily be linked in.
11: *
12: * This file is part of AutoOpts, a companion to AutoGen.
13: * AutoOpts is free software.
14: * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved
15: *
16: * AutoOpts is available under any one of two licenses. The license
17: * in use must be one of these two and the choice is under the control
18: * of the user of the license.
19: *
20: * The GNU Lesser General Public License, version 3 or later
21: * See the files "COPYING.lgplv3" and "COPYING.gplv3"
22: *
23: * The Modified Berkeley Software Distribution License
24: * See the file "COPYING.mbsd"
25: *
26: * These files have the following md5sums:
27: *
28: * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
29: * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
30: * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
31: */
32:
33: #ifndef PKGDATADIR
34: # define PKGDATADIR ""
35: #endif
36:
37: static char const zNil[] = "";
38: static arg_types_t argTypes = { NULL };
39: static char zOptFmtLine[16] = { NUL };
40: static ag_bool displayEnum = AG_FALSE;
41: static char const pkgdatadir_default[] = PKGDATADIR;
42: static char const * program_pkgdatadir = pkgdatadir_default;
43: static tOptionLoadMode option_load_mode = OPTION_LOAD_UNCOOKED;
44: static tePagerState pagerState = PAGER_STATE_INITIAL;
45:
46: FILE * option_usage_fp = NULL;
47:
48: /* = = = START-STATIC-FORWARD = = = */
49: static tSuccess
50: findOptDesc(tOptions* pOpts, tOptState* pOptState);
51:
52: static tSuccess
53: next_opt_arg_must(tOptions* pOpts, tOptState* pOptState);
54:
55: static tSuccess
56: next_opt_arg_may(tOptions* pOpts, tOptState* pOptState);
57:
58: static tSuccess
59: next_opt_arg_none(tOptions* pOpts, tOptState* pOptState);
60:
61: static tSuccess
62: nextOption(tOptions* pOpts, tOptState* pOptState);
63:
64: static tSuccess
65: doPresets(tOptions* pOpts);
66:
67: static int
68: checkConsistency(tOptions* pOpts);
69: /* = = = END-STATIC-FORWARD = = = */
70:
71: LOCAL void *
72: ao_malloc(size_t sz)
73: {
74: void * res = malloc(sz);
75: if (res == NULL) {
76: fprintf(stderr, zAO_Alloc, (int)sz);
77: exit(EXIT_FAILURE);
78: }
79: return res;
80: }
81: #undef malloc
82: #define malloc(_s) ao_malloc(_s)
83:
84: LOCAL void *
85: ao_realloc(void *p, size_t sz)
86: {
87: void * res = (p == NULL) ? malloc(sz) : realloc(p, sz);
88: if (res == NULL) {
89: fprintf(stderr, zAO_Realloc, (int)sz, p);
90: exit(EXIT_FAILURE);
91: }
92: return res;
93: }
94: #undef realloc
95: #define realloc(_p,_s) ao_realloc(_p,_s)
96:
97: LOCAL char *
98: ao_strdup(char const *str)
99: {
100: char * res = strdup(str);
101: if (res == NULL) {
102: fprintf(stderr, zAO_Strdup, (int)strlen(str));
103: exit(EXIT_FAILURE);
104: }
105: return res;
106: }
107: #undef strdup
108: #define strdup(_p) ao_strdup(_p)
109:
110: #ifndef HAVE_PATHFIND
111: # include "compat/pathfind.c"
112: #endif
113:
114: #ifndef HAVE_SNPRINTF
115: # include "compat/snprintf.c"
116: #endif
117:
118: #ifndef HAVE_STRDUP
119: # include "compat/strdup.c"
120: #endif
121:
122: #ifndef HAVE_STRCHR
123: # include "compat/strchr.c"
124: #endif
125:
126: /*
127: * handle_opt
128: *
129: * This routine handles equivalencing, sets the option state flags and
130: * invokes the handler procedure, if any.
131: */
132: LOCAL tSuccess
133: handle_opt(tOptions* pOpts, tOptState* pOptState)
134: {
135: /*
136: * Save a copy of the option procedure pointer.
137: * If this is an equivalence class option, we still want this proc.
138: */
139: tOptDesc* pOD = pOptState->pOD;
140: tOptProc* pOP = pOD->pOptProc;
141: if (pOD->fOptState & OPTST_ALLOC_ARG)
142: AGFREE(pOD->optArg.argString);
143:
144: pOD->optArg.argString = pOptState->pzOptArg;
145:
146: /*
147: * IF we are presetting options, then we will ignore any un-presettable
148: * options. They are the ones either marked as such.
149: */
150: if ( ((pOpts->fOptSet & OPTPROC_PRESETTING) != 0)
151: && ((pOD->fOptState & OPTST_NO_INIT) != 0)
152: )
153: return PROBLEM;
154:
155: /*
156: * IF this is an equivalence class option,
157: * THEN
158: * Save the option value that got us to this option
159: * entry. (It may not be pOD->optChar[0], if this is an
160: * equivalence entry.)
161: * set the pointer to the equivalence class base
162: */
163: if (pOD->optEquivIndex != NO_EQUIVALENT) {
164: tOptDesc* p = pOpts->pOptDesc + pOD->optEquivIndex;
165:
166: /*
167: * IF the current option state has not been defined (set on the
168: * command line), THEN we will allow continued resetting of
169: * the value. Once "defined", then it must not change.
170: */
171: if ((pOD->fOptState & OPTST_DEFINED) != 0) {
172: /*
173: * The equivalenced-to option has been found on the command
174: * line before. Make sure new occurrences are the same type.
175: *
176: * IF this option has been previously equivalenced and
177: * it was not the same equivalenced-to option,
178: * THEN we have a usage problem.
179: */
180: if (p->optActualIndex != pOD->optIndex) {
181: fprintf(stderr, (char*)zMultiEquiv, p->pz_Name, pOD->pz_Name,
182: (pOpts->pOptDesc + p->optActualIndex)->pz_Name);
183: return FAILURE;
184: }
185: } else {
186: /*
187: * Set the equivalenced-to actual option index to no-equivalent
188: * so that we set all the entries below. This option may either
189: * never have been selected before, or else it was selected by
190: * some sort of "presetting" mechanism.
191: */
192: p->optActualIndex = NO_EQUIVALENT;
193: }
194:
195: if (p->optActualIndex != pOD->optIndex) {
196: /*
197: * First time through, copy over the state
198: * and add in the equivalence flag
199: */
200: p->optActualValue = pOD->optValue;
201: p->optActualIndex = pOD->optIndex;
202: pOptState->flags |= OPTST_EQUIVALENCE;
203: }
204:
205: /*
206: * Copy the most recent option argument. set membership state
207: * is kept in ``p->optCookie''. Do not overwrite.
208: */
209: p->optArg.argString = pOD->optArg.argString;
210: pOD = p;
211:
212: } else {
213: pOD->optActualValue = pOD->optValue;
214: pOD->optActualIndex = pOD->optIndex;
215: }
216:
217: pOD->fOptState &= OPTST_PERSISTENT_MASK;
218: pOD->fOptState |= (pOptState->flags & ~OPTST_PERSISTENT_MASK);
219:
220: /*
221: * Keep track of count only for DEFINED (command line) options.
222: * IF we have too many, build up an error message and bail.
223: */
224: if ( (pOD->fOptState & OPTST_DEFINED)
225: && (++pOD->optOccCt > pOD->optMaxCt) ) {
226:
227: if ((pOpts->fOptSet & OPTPROC_ERRSTOP) != 0) {
228: char const * pzEqv =
229: (pOD->optEquivIndex != NO_EQUIVALENT) ? zEquiv : zNil;
230:
231: fputs(zErrOnly, stderr);
232:
233: if (pOD->optMaxCt > 1)
234: fprintf(stderr, zAtMost, pOD->optMaxCt, pOD->pz_Name, pzEqv);
235: else
236: fprintf(stderr, zOnlyOne, pOD->pz_Name, pzEqv);
237: }
238:
239: return FAILURE;
240: }
241:
242: /*
243: * If provided a procedure to call, call it
244: */
245: if (pOP != NULL)
246: (*pOP)(pOpts, pOD);
247:
248: return SUCCESS;
249: }
250:
251:
252: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
253: *
254: * HUNT FOR OPTIONS IN THE ARGUMENT LIST
255: *
256: * The next four procedures are "private" to nextOption().
257: * nextOption() uses findOptDesc() to find the next descriptor and it, in
258: * turn, uses longOptionFind() and shortOptionFind() to actually do the hunt.
259: *
260: * longOptionFind
261: *
262: * Find the long option descriptor for the current option
263: */
264: LOCAL tSuccess
265: longOptionFind(tOptions* pOpts, char* pzOptName, tOptState* pOptState)
266: {
267: ag_bool disable = AG_FALSE;
268: char* pzEq = strchr(pzOptName, '=');
269: tOptDesc* pOD = pOpts->pOptDesc;
270: int idx = 0;
271: int idxLim = pOpts->optCt;
272: int matchCt = 0;
273: int matchIdx = 0;
274: int nameLen;
275: char opt_name_buf[128];
276:
277: /*
278: * IF the value is attached to the name,
279: * copy it off so we can NUL terminate.
280: */
281: if (pzEq != NULL) {
282: nameLen = (int)(pzEq - pzOptName);
283: if (nameLen >= sizeof(opt_name_buf))
284: return FAILURE;
285: memcpy(opt_name_buf, pzOptName, nameLen);
286: opt_name_buf[nameLen] = NUL;
287: pzOptName = opt_name_buf;
288: pzEq++;
289:
290: } else nameLen = strlen(pzOptName);
291:
292: do {
293: /*
294: * If option disabled or a doc option, skip to next
295: */
296: if (pOD->pz_Name == NULL)
297: continue;
298:
299: if ( SKIP_OPT(pOD)
300: && (pOD->fOptState != (OPTST_OMITTED | OPTST_NO_INIT)))
301: continue;
302:
303: if (strneqvcmp(pzOptName, pOD->pz_Name, nameLen) == 0) {
304: /*
305: * IF we have a complete match
306: * THEN it takes priority over any already located partial
307: */
308: if (pOD->pz_Name[ nameLen ] == NUL) {
309: matchCt = 1;
310: matchIdx = idx;
311: break;
312: }
313: }
314:
315: /*
316: * IF there is a disable name
317: * *AND* no argument value has been supplied
318: * (disabled options may have no argument)
319: * *AND* the option name matches the disable name
320: * THEN ...
321: */
322: else if ( (pOD->pz_DisableName != NULL)
323: && (strneqvcmp(pzOptName, pOD->pz_DisableName, nameLen) == 0)
324: ) {
325: disable = AG_TRUE;
326:
327: /*
328: * IF we have a complete match
329: * THEN it takes priority over any already located partial
330: */
331: if (pOD->pz_DisableName[ nameLen ] == NUL) {
332: matchCt = 1;
333: matchIdx = idx;
334: break;
335: }
336: }
337:
338: else
339: continue;
340:
341: /*
342: * We found a partial match, either regular or disabling.
343: * Remember the index for later.
344: */
345: matchIdx = idx;
346:
347: if (++matchCt > 1)
348: break;
349:
350: } while (pOD++, (++idx < idxLim));
351:
352: /*
353: * Make sure we either found an exact match or found only one partial
354: */
355: if (matchCt == 1) {
356: pOD = pOpts->pOptDesc + matchIdx;
357:
358: if (SKIP_OPT(pOD)) {
359: fprintf(stderr, zDisabledErr, pOpts->pzProgName, pOD->pz_Name);
360: if (pOD->pzText != NULL)
361: fprintf(stderr, " -- %s", pOD->pzText);
362: fputc('\n', stderr);
363: (*pOpts->pUsageProc)(pOpts, EXIT_FAILURE);
364: /* NOTREACHED */
365: }
366:
367: /*
368: * IF we found a disablement name,
369: * THEN set the bit in the callers' flag word
370: */
371: if (disable)
372: pOptState->flags |= OPTST_DISABLED;
373:
374: pOptState->pOD = pOD;
375: pOptState->pzOptArg = pzEq;
376: pOptState->optType = TOPT_LONG;
377: return SUCCESS;
378: }
379:
380: /*
381: * IF there is no equal sign
382: * *AND* we are using named arguments
383: * *AND* there is a default named option,
384: * THEN return that option.
385: */
386: if ( (pzEq == NULL)
387: && NAMED_OPTS(pOpts)
388: && (pOpts->specOptIdx.default_opt != NO_EQUIVALENT)) {
389: pOptState->pOD = pOpts->pOptDesc + pOpts->specOptIdx.default_opt;
390:
391: pOptState->pzOptArg = pzOptName;
392: pOptState->optType = TOPT_DEFAULT;
393: return SUCCESS;
394: }
395:
396: /*
397: * IF we are to stop on errors (the default, actually)
398: * THEN call the usage procedure.
399: */
400: if ((pOpts->fOptSet & OPTPROC_ERRSTOP) != 0) {
401: fprintf(stderr, (matchCt == 0) ? zIllOptStr : zAmbigOptStr,
402: pOpts->pzProgPath, pzOptName);
403: (*pOpts->pUsageProc)(pOpts, EXIT_FAILURE);
404: }
405:
406: return FAILURE;
407: }
408:
409:
410: /*
411: * shortOptionFind
412: *
413: * Find the short option descriptor for the current option
414: */
415: LOCAL tSuccess
416: shortOptionFind(tOptions* pOpts, uint_t optValue, tOptState* pOptState)
417: {
418: tOptDesc* pRes = pOpts->pOptDesc;
419: int ct = pOpts->optCt;
420:
421: /*
422: * Search the option list
423: */
424: do {
425: if (optValue != pRes->optValue)
426: continue;
427:
428: if (SKIP_OPT(pRes)) {
429: if ( (pRes->fOptState == (OPTST_OMITTED | OPTST_NO_INIT))
430: && (pRes->pz_Name != NULL)) {
431: fprintf(stderr, zDisabledErr, pOpts->pzProgPath, pRes->pz_Name);
432: if (pRes->pzText != NULL)
433: fprintf(stderr, " -- %s", pRes->pzText);
434: fputc('\n', stderr);
435: (*pOpts->pUsageProc)(pOpts, EXIT_FAILURE);
436: /* NOTREACHED */
437: }
438: goto short_opt_error;
439: }
440:
441: pOptState->pOD = pRes;
442: pOptState->optType = TOPT_SHORT;
443: return SUCCESS;
444:
445: } while (pRes++, --ct > 0);
446:
447: /*
448: * IF the character value is a digit
449: * AND there is a special number option ("-n")
450: * THEN the result is the "option" itself and the
451: * option is the specially marked "number" option.
452: */
453: if ( IS_DEC_DIGIT_CHAR(optValue)
454: && (pOpts->specOptIdx.number_option != NO_EQUIVALENT) ) {
455: pOptState->pOD = \
456: pRes = pOpts->pOptDesc + pOpts->specOptIdx.number_option;
457: (pOpts->pzCurOpt)--;
458: pOptState->optType = TOPT_SHORT;
459: return SUCCESS;
460: }
461:
462: short_opt_error:
463:
464: /*
465: * IF we are to stop on errors (the default, actually)
466: * THEN call the usage procedure.
467: */
468: if ((pOpts->fOptSet & OPTPROC_ERRSTOP) != 0) {
469: fprintf(stderr, zIllOptChr, pOpts->pzProgPath, optValue);
470: (*pOpts->pUsageProc)(pOpts, EXIT_FAILURE);
471: }
472:
473: return FAILURE;
474: }
475:
476:
477: /*
478: * findOptDesc
479: *
480: * Find the option descriptor for the current option
481: */
482: static tSuccess
483: findOptDesc(tOptions* pOpts, tOptState* pOptState)
484: {
485: /*
486: * IF we are continuing a short option list (e.g. -xyz...)
487: * THEN continue a single flag option.
488: * OTHERWISE see if there is room to advance and then do so.
489: */
490: if ((pOpts->pzCurOpt != NULL) && (*pOpts->pzCurOpt != NUL))
491: return shortOptionFind(pOpts, (tAoUC)*(pOpts->pzCurOpt), pOptState);
492:
493: if (pOpts->curOptIdx >= pOpts->origArgCt)
494: return PROBLEM; /* NORMAL COMPLETION */
495:
496: pOpts->pzCurOpt = pOpts->origArgVect[ pOpts->curOptIdx ];
497:
498: /*
499: * IF all arguments must be named options, ...
500: */
501: if (NAMED_OPTS(pOpts)) {
502: char * pz = pOpts->pzCurOpt;
503: int def;
504: tSuccess res;
505: tAoUS * def_opt;
506:
507: pOpts->curOptIdx++;
508:
509: if (*pz != '-')
510: return longOptionFind(pOpts, pz, pOptState);
511:
512: /*
513: * The name is prefixed with one or more hyphens. Strip them off
514: * and disable the "default_opt" setting. Use heavy recasting to
515: * strip off the "const" quality of the "default_opt" field.
516: */
517: while (*(++pz) == '-') ;
518: def_opt = (void *)&(pOpts->specOptIdx.default_opt);
519: def = *def_opt;
520: *def_opt = NO_EQUIVALENT;
521: res = longOptionFind(pOpts, pz, pOptState);
522: *def_opt = def;
523: return res;
524: }
525:
526: /*
527: * Note the kind of flag/option marker
528: */
529: if (*((pOpts->pzCurOpt)++) != '-')
530: return PROBLEM; /* NORMAL COMPLETION - this + rest are operands */
531:
532: /*
533: * Special hack for a hyphen by itself
534: */
535: if (*(pOpts->pzCurOpt) == NUL)
536: return PROBLEM; /* NORMAL COMPLETION - this + rest are operands */
537:
538: /*
539: * The current argument is to be processed as an option argument
540: */
541: pOpts->curOptIdx++;
542:
543: /*
544: * We have an option marker.
545: * Test the next character for long option indication
546: */
547: if (pOpts->pzCurOpt[0] == '-') {
548: if (*++(pOpts->pzCurOpt) == NUL)
549: /*
550: * NORMAL COMPLETION - NOT this arg, but rest are operands
551: */
552: return PROBLEM;
553:
554: /*
555: * We do not allow the hyphen to be used as a flag value.
556: * Therefore, if long options are not to be accepted, we punt.
557: */
558: if ((pOpts->fOptSet & OPTPROC_LONGOPT) == 0) {
559: fprintf(stderr, zIllOptStr, pOpts->pzProgPath,
560: zIllegal, pOpts->pzCurOpt-2);
561: return FAILURE;
562: }
563:
564: return longOptionFind(pOpts, pOpts->pzCurOpt, pOptState);
565: }
566:
567: /*
568: * If short options are not allowed, then do long
569: * option processing. Otherwise the character must be a
570: * short (i.e. single character) option.
571: */
572: if ((pOpts->fOptSet & OPTPROC_SHORTOPT) != 0)
573: return shortOptionFind(pOpts, (tAoUC)*(pOpts->pzCurOpt), pOptState);
574:
575: return longOptionFind(pOpts, pOpts->pzCurOpt, pOptState);
576: }
577:
578:
579: static tSuccess
580: next_opt_arg_must(tOptions* pOpts, tOptState* pOptState)
581: {
582: /*
583: * An option argument is required. Long options can either have
584: * a separate command line argument, or an argument attached by
585: * the '=' character. Figure out which.
586: */
587: switch (pOptState->optType) {
588: case TOPT_SHORT:
589: /*
590: * See if an arg string follows the flag character
591: */
592: if (*++(pOpts->pzCurOpt) == NUL)
593: pOpts->pzCurOpt = pOpts->origArgVect[ pOpts->curOptIdx++ ];
594: pOptState->pzOptArg = pOpts->pzCurOpt;
595: break;
596:
597: case TOPT_LONG:
598: /*
599: * See if an arg string has already been assigned (glued on
600: * with an `=' character)
601: */
602: if (pOptState->pzOptArg == NULL)
603: pOptState->pzOptArg = pOpts->origArgVect[ pOpts->curOptIdx++ ];
604: break;
605:
606: default:
607: #ifdef DEBUG
608: fputs("AutoOpts lib error: option type not selected\n", stderr);
609: exit(EXIT_FAILURE);
610: #endif
611:
612: case TOPT_DEFAULT:
613: /*
614: * The option was selected by default. The current token is
615: * the option argument.
616: */
617: break;
618: }
619:
620: /*
621: * Make sure we did not overflow the argument list.
622: */
623: if (pOpts->curOptIdx > pOpts->origArgCt) {
624: fprintf(stderr, zMisArg, pOpts->pzProgPath, pOptState->pOD->pz_Name);
625: return FAILURE;
626: }
627:
628: pOpts->pzCurOpt = NULL; /* next time advance to next arg */
629: return SUCCESS;
630: }
631:
632:
633: static tSuccess
634: next_opt_arg_may(tOptions* pOpts, tOptState* pOptState)
635: {
636: /*
637: * An option argument is optional.
638: */
639: switch (pOptState->optType) {
640: case TOPT_SHORT:
641: if (*++pOpts->pzCurOpt != NUL)
642: pOptState->pzOptArg = pOpts->pzCurOpt;
643: else {
644: char* pzLA = pOpts->origArgVect[ pOpts->curOptIdx ];
645:
646: /*
647: * BECAUSE it is optional, we must make sure
648: * we did not find another flag and that there
649: * is such an argument.
650: */
651: if ((pzLA == NULL) || (*pzLA == '-'))
652: pOptState->pzOptArg = NULL;
653: else {
654: pOpts->curOptIdx++; /* argument found */
655: pOptState->pzOptArg = pzLA;
656: }
657: }
658: break;
659:
660: case TOPT_LONG:
661: /*
662: * Look for an argument if we don't already have one (glued on
663: * with a `=' character) *AND* we are not in named argument mode
664: */
665: if ( (pOptState->pzOptArg == NULL)
666: && (! NAMED_OPTS(pOpts))) {
667: char* pzLA = pOpts->origArgVect[ pOpts->curOptIdx ];
668:
669: /*
670: * BECAUSE it is optional, we must make sure
671: * we did not find another flag and that there
672: * is such an argument.
673: */
674: if ((pzLA == NULL) || (*pzLA == '-'))
675: pOptState->pzOptArg = NULL;
676: else {
677: pOpts->curOptIdx++; /* argument found */
678: pOptState->pzOptArg = pzLA;
679: }
680: }
681: break;
682:
683: default:
684: case TOPT_DEFAULT:
685: fputs(zAO_Woops, stderr );
686: exit(EX_SOFTWARE);
687: }
688:
689: /*
690: * After an option with an optional argument, we will
691: * *always* start with the next option because if there
692: * were any characters following the option name/flag,
693: * they would be interpreted as the argument.
694: */
695: pOpts->pzCurOpt = NULL;
696: return SUCCESS;
697: }
698:
699:
700: static tSuccess
701: next_opt_arg_none(tOptions* pOpts, tOptState* pOptState)
702: {
703: /*
704: * No option argument. Make sure next time around we find
705: * the correct option flag character for short options
706: */
707: if (pOptState->optType == TOPT_SHORT)
708: (pOpts->pzCurOpt)++;
709:
710: /*
711: * It is a long option. Make sure there was no ``=xxx'' argument
712: */
713: else if (pOptState->pzOptArg != NULL) {
714: fprintf(stderr, zNoArg, pOpts->pzProgPath, pOptState->pOD->pz_Name);
715: return FAILURE;
716: }
717:
718: /*
719: * It is a long option. Advance to next command line argument.
720: */
721: else
722: pOpts->pzCurOpt = NULL;
723: return SUCCESS;
724: }
725:
726: /*
727: * nextOption
728: *
729: * Find the option descriptor and option argument (if any) for the
730: * next command line argument. DO NOT modify the descriptor. Put
731: * all the state in the state argument so that the option can be skipped
732: * without consequence (side effect).
733: */
734: static tSuccess
735: nextOption(tOptions* pOpts, tOptState* pOptState)
736: {
737: {
738: tSuccess res;
739: res = findOptDesc(pOpts, pOptState);
740: if (! SUCCESSFUL(res))
741: return res;
742: }
743:
744: if ( ((pOptState->flags & OPTST_DEFINED) != 0)
745: && ((pOptState->pOD->fOptState & OPTST_NO_COMMAND) != 0)) {
746: fprintf(stderr, zNotCmdOpt, pOptState->pOD->pz_Name);
747: return FAILURE;
748: }
749:
750: pOptState->flags |= (pOptState->pOD->fOptState & OPTST_PERSISTENT_MASK);
751:
752: /*
753: * Figure out what to do about option arguments. An argument may be
754: * required, not associated with the option, or be optional. We detect the
755: * latter by examining for an option marker on the next possible argument.
756: * Disabled mode option selection also disables option arguments.
757: */
758: {
759: enum { ARG_NONE, ARG_MAY, ARG_MUST } arg_type = ARG_NONE;
760: tSuccess res;
761:
762: if ((pOptState->flags & OPTST_DISABLED) != 0)
763: arg_type = ARG_NONE;
764:
765: else if (OPTST_GET_ARGTYPE(pOptState->flags) == OPARG_TYPE_NONE)
766: arg_type = ARG_NONE;
767:
768: else if (pOptState->flags & OPTST_ARG_OPTIONAL)
769: arg_type = ARG_MAY;
770:
771: else
772: arg_type = ARG_MUST;
773:
774: switch (arg_type) {
775: case ARG_MUST: res = next_opt_arg_must(pOpts, pOptState); break;
776: case ARG_MAY: res = next_opt_arg_may( pOpts, pOptState); break;
777: case ARG_NONE: res = next_opt_arg_none(pOpts, pOptState); break;
778: }
779:
780: return res;
781: }
782: }
783:
784:
785: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
786: *
787: * DO PRESETS
788: *
789: * The next several routines do the immediate action pass on the command
790: * line options, then the environment variables, then the config files in
791: * reverse order. Once done with that, the order is reversed and all
792: * the config files and environment variables are processed again, this
793: * time only processing the non-immediate action options. doPresets()
794: * will then return for optionProcess() to do the final pass on the command
795: * line arguments.
796: */
797:
798: /**
799: * scan the command line for immediate action options.
800: * This is only called the first time through.
801: */
802: LOCAL tSuccess
803: doImmediateOpts(tOptions* pOpts)
804: {
805: pOpts->curOptIdx = 1; /* start by skipping program name */
806: pOpts->pzCurOpt = NULL;
807:
808: /*
809: * Examine all the options from the start. We process any options that
810: * are marked for immediate processing.
811: */
812: for (;;) {
813: tOptState optState = OPTSTATE_INITIALIZER(PRESET);
814:
815: switch (nextOption(pOpts, &optState)) {
816: case FAILURE: goto failed_option;
817: case PROBLEM: return SUCCESS; /* no more args */
818: case SUCCESS: break;
819: }
820:
821: /*
822: * IF this is an immediate-attribute option, then do it.
823: */
824: if (! DO_IMMEDIATELY(optState.flags))
825: continue;
826:
827: if (! SUCCESSFUL(handle_opt(pOpts, &optState)))
828: break;
829: } failed_option:;
830:
831: if ((pOpts->fOptSet & OPTPROC_ERRSTOP) != 0)
832: (*pOpts->pUsageProc)(pOpts, EXIT_FAILURE);
833:
834: return FAILURE;
835: }
836:
837: /**
838: * Process all the options from our current position onward. (This allows
839: * interspersed options and arguments for the few non-standard programs that
840: * require it.) Thus, do not rewind option indexes because some programs
841: * choose to re-invoke after a non-option.
842: */
843: LOCAL tSuccess
844: doRegularOpts(tOptions* pOpts)
845: {
846: for (;;) {
847: tOptState optState = OPTSTATE_INITIALIZER(DEFINED);
848:
849: switch (nextOption(pOpts, &optState)) {
850: case FAILURE: goto failed_option;
851: case PROBLEM: return SUCCESS; /* no more args */
852: case SUCCESS: break;
853: }
854:
855: /*
856: * IF this is an immediate action option,
857: * THEN skip it (unless we are supposed to do it a second time).
858: */
859: if (! DO_NORMALLY(optState.flags)) {
860: if (! DO_SECOND_TIME(optState.flags))
861: continue;
862: optState.pOD->optOccCt--; /* don't count this repetition */
863: }
864:
865: if (! SUCCESSFUL(handle_opt(pOpts, &optState)))
866: break;
867: } failed_option:;
868:
869: if ((pOpts->fOptSet & OPTPROC_ERRSTOP) != 0)
870: (*pOpts->pUsageProc)(pOpts, EXIT_FAILURE);
871:
872: return FAILURE;
873: }
874:
875:
876: /**
877: * check for preset values from a config files or envrionment variables
878: */
879: static tSuccess
880: doPresets(tOptions* pOpts)
881: {
882: tOptDesc * pOD = NULL;
883:
884: if (! SUCCESSFUL(doImmediateOpts(pOpts)))
885: return FAILURE;
886:
887: /*
888: * IF this option set has a --save-opts option, then it also
889: * has a --load-opts option. See if a command line option has disabled
890: * option presetting.
891: */
892: if ( (pOpts->specOptIdx.save_opts != NO_EQUIVALENT)
893: && (pOpts->specOptIdx.save_opts != 0)) {
894: pOD = pOpts->pOptDesc + pOpts->specOptIdx.save_opts + 1;
895: if (DISABLED_OPT(pOD))
896: return SUCCESS;
897: }
898:
899: /*
900: * Until we return from this procedure, disable non-presettable opts
901: */
902: pOpts->fOptSet |= OPTPROC_PRESETTING;
903: /*
904: * IF there are no config files,
905: * THEN do any environment presets and leave.
906: */
907: if (pOpts->papzHomeList == NULL) {
908: doEnvPresets(pOpts, ENV_ALL);
909: }
910: else {
911: doEnvPresets(pOpts, ENV_IMM);
912:
913: /*
914: * Check to see if environment variables have disabled presetting.
915: */
916: if ((pOD != NULL) && ! DISABLED_OPT(pOD))
917: internalFileLoad(pOpts);
918:
919: /*
920: * ${PROGRAM_LOAD_OPTS} value of "no" cannot disable other environment
921: * variable options. Only the loading of .rc files.
922: */
923: doEnvPresets(pOpts, ENV_NON_IMM);
924: }
925: pOpts->fOptSet &= ~OPTPROC_PRESETTING;
926:
927: return SUCCESS;
928: }
929:
930:
931: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
932: *
933: * VERIFY OPTION CONSISTENCY
934: *
935: * Make sure that the argument list passes our consistency tests.
936: */
937: static int
938: checkConsistency(tOptions* pOpts)
939: {
940: int errCt = 0;
941: tOptDesc* pOD = pOpts->pOptDesc;
942: int oCt = pOpts->presetOptCt;
943:
944: /*
945: * FOR each of "oCt" options, ...
946: */
947: for (;;) {
948: const int* pMust = pOD->pOptMust;
949: const int* pCant = pOD->pOptCant;
950:
951: /*
952: * IF the current option was provided on the command line
953: * THEN ensure that any "MUST" requirements are not
954: * "DEFAULT" (unspecified) *AND* ensure that any
955: * "CANT" options have not been SET or DEFINED.
956: */
957: if (SELECTED_OPT(pOD)) {
958: if (pMust != NULL) for (;;) {
959: tOptDesc* p = pOpts->pOptDesc + *(pMust++);
960: if (UNUSED_OPT(p)) {
961: const tOptDesc* pN = pOpts->pOptDesc + pMust[-1];
962: errCt++;
963: fprintf(stderr, zReqFmt, pOD->pz_Name, pN->pz_Name);
964: }
965:
966: if (*pMust == NO_EQUIVALENT)
967: break;
968: }
969:
970: if (pCant != NULL) for (;;) {
971: tOptDesc* p = pOpts->pOptDesc + *(pCant++);
972: if (SELECTED_OPT(p)) {
973: const tOptDesc* pN = pOpts->pOptDesc + pCant[-1];
974: errCt++;
975: fprintf(stderr, zCantFmt, pOD->pz_Name, pN->pz_Name);
976: }
977:
978: if (*pCant == NO_EQUIVALENT)
979: break;
980: }
981: }
982:
983: /*
984: * IF this option is not equivalenced to another,
985: * OR it is equivalenced to itself (is the equiv. root)
986: * THEN we need to make sure it occurs often enough.
987: */
988: if ( (pOD->optEquivIndex == NO_EQUIVALENT)
989: || (pOD->optEquivIndex == pOD->optIndex) ) do {
990: /*
991: * IF the occurrence counts have been satisfied,
992: * THEN there is no problem.
993: */
994: if (pOD->optOccCt >= pOD->optMinCt)
995: break;
996:
997: /*
998: * IF MUST_SET means SET and PRESET are okay,
999: * so min occurrence count doesn't count
1000: */
1001: if ( (pOD->fOptState & OPTST_MUST_SET)
1002: && (pOD->fOptState & (OPTST_PRESET | OPTST_SET)) )
1003: break;
1004:
1005: errCt++;
1006: if (pOD->optMinCt > 1)
1007: fprintf(stderr, zNotEnough, pOD->pz_Name, pOD->optMinCt);
1008: else fprintf(stderr, zNeedOne, pOD->pz_Name);
1009: } while (0);
1010:
1011: if (--oCt <= 0)
1012: break;
1013: pOD++;
1014: }
1015:
1016: /*
1017: * IF we are stopping on errors, check to see if any remaining
1018: * arguments are required to be there or prohibited from being there.
1019: */
1020: if ((pOpts->fOptSet & OPTPROC_ERRSTOP) != 0) {
1021:
1022: /*
1023: * Check for prohibition
1024: */
1025: if ((pOpts->fOptSet & OPTPROC_NO_ARGS) != 0) {
1026: if (pOpts->origArgCt > pOpts->curOptIdx) {
1027: fprintf(stderr, zNoArgs, pOpts->pzProgName);
1028: ++errCt;
1029: }
1030: }
1031:
1032: /*
1033: * ELSE not prohibited, check for being required
1034: */
1035: else if ((pOpts->fOptSet & OPTPROC_ARGS_REQ) != 0) {
1036: if (pOpts->origArgCt <= pOpts->curOptIdx) {
1037: fprintf(stderr, zArgsMust, pOpts->pzProgName);
1038: ++errCt;
1039: }
1040: }
1041: }
1042:
1043: return errCt;
1044: }
1045:
1046:
1047: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
1048: *
1049: * THESE ROUTINES ARE CALLABLE FROM THE GENERATED OPTION PROCESSING CODE
1050: */
1051: /*=--subblock=arg=arg_type,arg_name,arg_desc =*/
1052: /*=*
1053: * library: opts
1054: * header: your-opts.h
1055: *
1056: * lib_description:
1057: *
1058: * These are the routines that libopts users may call directly from their
1059: * code. There are several other routines that can be called by code
1060: * generated by the libopts option templates, but they are not to be
1061: * called from any other user code. The @file{options.h} header is
1062: * fairly clear about this, too.
1063: =*/
1064:
1065: /*=export_func optionProcess
1066: *
1067: * what: this is the main option processing routine
1068: *
1069: * arg: + tOptions* + pOpts + program options descriptor +
1070: * arg: + int + argc + program arg count +
1071: * arg: + char** + argv + program arg vector +
1072: *
1073: * ret_type: int
1074: * ret_desc: the count of the arguments processed
1075: *
1076: * doc:
1077: *
1078: * This is the main entry point for processing options. It is intended
1079: * that this procedure be called once at the beginning of the execution of
1080: * a program. Depending on options selected earlier, it is sometimes
1081: * necessary to stop and restart option processing, or to select completely
1082: * different sets of options. This can be done easily, but you generally
1083: * do not want to do this.
1084: *
1085: * The number of arguments processed always includes the program name.
1086: * If one of the arguments is "--", then it is counted and the processing
1087: * stops. If an error was encountered and errors are to be tolerated, then
1088: * the returned value is the index of the argument causing the error.
1089: * A hyphen by itself ("-") will also cause processing to stop and will
1090: * @emph{not} be counted among the processed arguments. A hyphen by itself
1091: * is treated as an operand. Encountering an operand stops option
1092: * processing.
1093: *
1094: * err: Errors will cause diagnostics to be printed. @code{exit(3)} may
1095: * or may not be called. It depends upon whether or not the options
1096: * were generated with the "allow-errors" attribute, or if the
1097: * ERRSKIP_OPTERR or ERRSTOP_OPTERR macros were invoked.
1098: =*/
1099: int
1100: optionProcess(tOptions * pOpts, int argCt, char ** argVect)
1101: {
1102: if (! SUCCESSFUL(validateOptionsStruct(pOpts, argVect[0])))
1103: exit(EX_SOFTWARE);
1104:
1105: /*
1106: * Establish the real program name, the program full path,
1107: * and do all the presetting the first time thru only.
1108: */
1109: if ((pOpts->fOptSet & OPTPROC_INITDONE) == 0) {
1110: pOpts->origArgCt = argCt;
1111: pOpts->origArgVect = argVect;
1112: pOpts->fOptSet |= OPTPROC_INITDONE;
1113: if (HAS_pzPkgDataDir(pOpts))
1114: program_pkgdatadir = pOpts->pzPkgDataDir;
1115:
1116: if (! SUCCESSFUL(doPresets(pOpts)))
1117: return 0;
1118:
1119: /*
1120: * IF option name conversion was suppressed but it is not suppressed
1121: * for the command line, then it's time to translate option names.
1122: * Usage text will not get retranslated.
1123: */
1124: if ( ((pOpts->fOptSet & OPTPROC_TRANSLATE) != 0)
1125: && (pOpts->pTransProc != NULL)
1126: && ((pOpts->fOptSet & OPTPROC_NO_XLAT_MASK)
1127: == OPTPROC_NXLAT_OPT_CFG) ) {
1128:
1129: pOpts->fOptSet &= ~OPTPROC_NXLAT_OPT_CFG;
1130: (*pOpts->pTransProc)();
1131: }
1132:
1133: if ((pOpts->fOptSet & OPTPROC_REORDER) != 0)
1134: optionSort(pOpts);
1135:
1136: pOpts->curOptIdx = 1;
1137: pOpts->pzCurOpt = NULL;
1138: }
1139:
1140: /*
1141: * IF we are (re)starting,
1142: * THEN reset option location
1143: */
1144: else if (pOpts->curOptIdx <= 0) {
1145: pOpts->curOptIdx = 1;
1146: pOpts->pzCurOpt = NULL;
1147: }
1148:
1149: if (! SUCCESSFUL(doRegularOpts(pOpts)))
1150: return pOpts->origArgCt;
1151:
1152: /*
1153: * IF there were no errors
1154: * AND we have RC/INI files
1155: * AND there is a request to save the files
1156: * THEN do that now before testing for conflicts.
1157: * (conflicts are ignored in preset options)
1158: */
1159: if ( (pOpts->specOptIdx.save_opts != NO_EQUIVALENT)
1160: && (pOpts->specOptIdx.save_opts != 0)) {
1161: tOptDesc* pOD = pOpts->pOptDesc + pOpts->specOptIdx.save_opts;
1162:
1163: if (SELECTED_OPT(pOD)) {
1164: optionSaveFile(pOpts);
1165: exit(EXIT_SUCCESS);
1166: }
1167: }
1168:
1169: /*
1170: * IF we are checking for errors,
1171: * THEN look for too few occurrences of required options
1172: */
1173: if ((pOpts->fOptSet & OPTPROC_ERRSTOP) != 0) {
1174: if (checkConsistency(pOpts) != 0)
1175: (*pOpts->pUsageProc)(pOpts, EXIT_FAILURE);
1176: }
1177:
1178: return pOpts->curOptIdx;
1179: }
1180:
1181: /*
1182: * Local Variables:
1183: * mode: C
1184: * c-file-style: "stroustrup"
1185: * indent-tabs-mode: nil
1186: * End:
1187: * end of autoopts/autoopts.c */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to autoopts.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / sntp / libopts