Annotation of embedaddon/ntp/sntp/libopts/enumeration.c, revision 1.1.1.1
1.1 misho 1:
2: /**
3: * \file enumeration.c
4: *
5: * Time-stamp: "2011-04-06 10:48:22 bkorb"
6: *
7: * Automated Options Paged Usage module.
8: *
9: * This routine will run run-on options through a pager so the
10: * user may examine, print or edit them at their leisure.
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: static char const * pz_enum_err_fmt;
34:
35: /* = = = START-STATIC-FORWARD = = = */
36: static void
37: enum_err(tOptions * pOpts, tOptDesc * pOD,
38: char const * const * paz_names, int name_ct);
39:
40: static uintptr_t
41: find_name(char const * pzName, tOptions * pOpts, tOptDesc * pOD,
42: char const * const * paz_names, unsigned int name_ct);
43:
44: static void
45: set_memb_usage(tOptions * pOpts, tOptDesc * pOD, char const * const * paz_names,
46: unsigned int name_ct);
47:
48: static void
49: set_memb_shell(tOptions * pOpts, tOptDesc * pOD, char const * const * paz_names,
50: unsigned int name_ct);
51:
52: static void
53: set_memb_names(tOptions * pOpts, tOptDesc * pOD, char const * const * paz_names,
54: unsigned int name_ct);
55: /* = = = END-STATIC-FORWARD = = = */
56:
57: static void
58: enum_err(tOptions * pOpts, tOptDesc * pOD,
59: char const * const * paz_names, int name_ct)
60: {
61: size_t max_len = 0;
62: size_t ttl_len = 0;
63: int ct_down = name_ct;
64: int hidden = 0;
65:
66: /*
67: * A real "pOpts" pointer means someone messed up. Give a real error.
68: */
69: if (pOpts > OPTPROC_EMIT_LIMIT)
70: fprintf(option_usage_fp, pz_enum_err_fmt, pOpts->pzProgName,
71: pOD->optArg.argString, pOD->pz_Name);
72:
73: fprintf(option_usage_fp, zValidKeys, pOD->pz_Name);
74:
75: /*
76: * If the first name starts with this funny character, then we have
77: * a first value with an unspellable name. You cannot specify it.
78: * So, we don't list it either.
79: */
80: if (**paz_names == 0x7F) {
81: paz_names++;
82: hidden = 1;
83: ct_down = --name_ct;
84: }
85:
86: /*
87: * Figure out the maximum length of any name, plus the total length
88: * of all the names.
89: */
90: {
91: char const * const * paz = paz_names;
92:
93: do {
94: size_t len = strlen(*(paz++)) + 1;
95: if (len > max_len)
96: max_len = len;
97: ttl_len += len;
98: } while (--ct_down > 0);
99:
100: ct_down = name_ct;
101: }
102:
103: /*
104: * IF any one entry is about 1/2 line or longer, print one per line
105: */
106: if (max_len > 35) {
107: do {
108: fprintf(option_usage_fp, " %s\n", *(paz_names++));
109: } while (--ct_down > 0);
110: }
111:
112: /*
113: * ELSE IF they all fit on one line, then do so.
114: */
115: else if (ttl_len < 76) {
116: fputc(' ', option_usage_fp);
117: do {
118: fputc(' ', option_usage_fp);
119: fputs(*(paz_names++), option_usage_fp);
120: } while (--ct_down > 0);
121: fputc('\n', option_usage_fp);
122: }
123:
124: /*
125: * Otherwise, columnize the output
126: */
127: else {
128: int ent_no = 0;
129: char zFmt[16]; /* format for all-but-last entries on a line */
130:
131: sprintf(zFmt, "%%-%ds", (int)max_len);
132: max_len = 78 / max_len; /* max_len is now max entries on a line */
133: fputs(" ", option_usage_fp);
134:
135: /*
136: * Loop through all but the last entry
137: */
138: ct_down = name_ct;
139: while (--ct_down > 0) {
140: if (++ent_no == max_len) {
141: /*
142: * Last entry on a line. Start next line, too.
143: */
144: fprintf(option_usage_fp, "%s\n ", *(paz_names++));
145: ent_no = 0;
146: }
147:
148: else
149: fprintf(option_usage_fp, zFmt, *(paz_names++) );
150: }
151: fprintf(option_usage_fp, "%s\n", *paz_names);
152: }
153:
154: if (pOpts > OPTPROC_EMIT_LIMIT) {
155: fprintf(option_usage_fp, zIntRange, hidden, name_ct - 1 + hidden);
156:
157: (*(pOpts->pUsageProc))(pOpts, EXIT_FAILURE);
158: /* NOTREACHED */
159: }
160:
161: if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_MEMBERSHIP) {
162: fprintf(option_usage_fp, zLowerBits, name_ct);
163: fputs(zSetMemberSettings, option_usage_fp);
164: } else {
165: fprintf(option_usage_fp, zIntRange, hidden, name_ct - 1 + hidden);
166: }
167: }
168:
169:
170: static uintptr_t
171: find_name(char const * pzName, tOptions * pOpts, tOptDesc * pOD,
172: char const * const * paz_names, unsigned int name_ct)
173: {
174: /*
175: * Return the matching index as a pointer sized integer.
176: * The result gets stashed in a char* pointer.
177: */
178: uintptr_t res = name_ct;
179: size_t len = strlen((char*)pzName);
180: uintptr_t idx;
181:
182: if (IS_DEC_DIGIT_CHAR(*pzName)) {
183: char * pz = (char *)(void *)pzName;
184: unsigned long val = strtoul(pz, &pz, 0);
185: if ((*pz == NUL) && (val < name_ct))
186: return (uintptr_t)val;
187: enum_err(pOpts, pOD, paz_names, (int)name_ct);
188: return name_ct;
189: }
190:
191: /*
192: * Look for an exact match, but remember any partial matches.
193: * Multiple partial matches means we have an ambiguous match.
194: */
195: for (idx = 0; idx < name_ct; idx++) {
196: if (strncmp((char*)paz_names[idx], (char*)pzName, len) == 0) {
197: if (paz_names[idx][len] == NUL)
198: return idx; /* full match */
199:
200: res = (res != name_ct) ? ~0 : idx; /* save partial match */
201: }
202: }
203:
204: if (res < name_ct)
205: return res; /* partial match */
206:
207: pz_enum_err_fmt = (res == name_ct) ? zNoKey : zAmbigKey;
208: option_usage_fp = stderr;
209: enum_err(pOpts, pOD, paz_names, (int)name_ct);
210: return name_ct;
211: }
212:
213:
214: /*=export_func optionKeywordName
215: * what: Convert between enumeration values and strings
216: * private:
217: *
218: * arg: tOptDesc*, pOD, enumeration option description
219: * arg: unsigned int, enum_val, the enumeration value to map
220: *
221: * ret_type: char const *
222: * ret_desc: the enumeration name from const memory
223: *
224: * doc: This converts an enumeration value into the matching string.
225: =*/
226: char const *
227: optionKeywordName(tOptDesc * pOD, unsigned int enum_val)
228: {
229: tOptDesc od;
230:
231: od.optArg.argEnum = enum_val;
232: (*(pOD->pOptProc))(OPTPROC_RETURN_VALNAME, &od );
233: return od.optArg.argString;
234: }
235:
236:
237: /*=export_func optionEnumerationVal
238: * what: Convert from a string to an enumeration value
239: * private:
240: *
241: * arg: tOptions*, pOpts, the program options descriptor
242: * arg: tOptDesc*, pOD, enumeration option description
243: * arg: char const * const *, paz_names, list of enumeration names
244: * arg: unsigned int, name_ct, number of names in list
245: *
246: * ret_type: uintptr_t
247: * ret_desc: the enumeration value
248: *
249: * doc: This converts the optArg.argString string from the option description
250: * into the index corresponding to an entry in the name list.
251: * This will match the generated enumeration value.
252: * Full matches are always accepted. Partial matches are accepted
253: * if there is only one partial match.
254: =*/
255: uintptr_t
256: optionEnumerationVal(tOptions * pOpts, tOptDesc * pOD,
257: char const * const * paz_names, unsigned int name_ct)
258: {
259: uintptr_t res = 0UL;
260:
261: /*
262: * IF the program option descriptor pointer is invalid,
263: * then it is some sort of special request.
264: */
265: switch ((uintptr_t)pOpts) {
266: case (uintptr_t)OPTPROC_EMIT_USAGE:
267: /*
268: * print the list of enumeration names.
269: */
270: enum_err(pOpts, pOD, paz_names, (int)name_ct);
271: break;
272:
273: case (uintptr_t)OPTPROC_EMIT_SHELL:
274: {
275: unsigned int ix = pOD->optArg.argEnum;
276: /*
277: * print the name string.
278: */
279: if (ix >= name_ct)
280: printf("INVALID-%d", ix);
281: else
282: fputs(paz_names[ ix ], stdout);
283:
284: break;
285: }
286:
287: case (uintptr_t)OPTPROC_RETURN_VALNAME:
288: {
289: tSCC zInval[] = "*INVALID*";
290: unsigned int ix = pOD->optArg.argEnum;
291: /*
292: * Replace the enumeration value with the name string.
293: */
294: if (ix >= name_ct)
295: return (uintptr_t)zInval;
296:
297: pOD->optArg.argString = paz_names[ix];
298: break;
299: }
300:
301: default:
302: res = find_name(pOD->optArg.argString, pOpts, pOD, paz_names, name_ct);
303:
304: if (pOD->fOptState & OPTST_ALLOC_ARG) {
305: AGFREE(pOD->optArg.argString);
306: pOD->fOptState &= ~OPTST_ALLOC_ARG;
307: pOD->optArg.argString = NULL;
308: }
309: }
310:
311: return res;
312: }
313:
314: static void
315: set_memb_usage(tOptions * pOpts, tOptDesc * pOD, char const * const * paz_names,
316: unsigned int name_ct)
317: {
318: /*
319: * print the list of enumeration names.
320: */
321: enum_err(OPTPROC_EMIT_USAGE, pOD, paz_names, (int)name_ct );
322: }
323:
324: static void
325: set_memb_shell(tOptions * pOpts, tOptDesc * pOD, char const * const * paz_names,
326: unsigned int name_ct)
327: {
328: /*
329: * print the name string.
330: */
331: int ix = 0;
332: uintptr_t bits = (uintptr_t)pOD->optCookie;
333: size_t len = 0;
334:
335: bits &= ((uintptr_t)1 << (uintptr_t)name_ct) - (uintptr_t)1;
336:
337: while (bits != 0) {
338: if (bits & 1) {
339: if (len++ > 0) fputs(" | ", stdout);
340: fputs(paz_names[ix], stdout);
341: }
342: if (++ix >= name_ct) break;
343: bits >>= 1;
344: }
345: }
346:
347: static void
348: set_memb_names(tOptions * pOpts, tOptDesc * pOD, char const * const * paz_names,
349: unsigned int name_ct)
350: {
351: static char const none[] = "none";
352: static char const plus[3] = " + ";
353:
354: char * pz;
355: uintptr_t bits = (uintptr_t)pOD->optCookie;
356: int ix = 0;
357: size_t len = sizeof(none);
358:
359: bits &= ((uintptr_t)1 << (uintptr_t)name_ct) - (uintptr_t)1;
360:
361: /*
362: * Replace the enumeration value with the name string.
363: * First, determine the needed length, then allocate and fill in.
364: */
365: while (bits != 0) {
366: if (bits & 1)
367: len += strlen(paz_names[ix]) + sizeof(plus);
368: if (++ix >= name_ct) break;
369: bits >>= 1;
370: }
371:
372: pOD->optArg.argString = pz = AGALOC(len, "enum name");
373:
374: /*
375: * Start by clearing all the bits. We want to turn off any defaults
376: * because we will be restoring to current state, not adding to
377: * the default set of bits.
378: */
379: memcpy(pz, none, sizeof(none)-1);
380: pz += sizeof(none)-1;
381: bits = (uintptr_t)pOD->optCookie;
382: bits &= ((uintptr_t)1 << (uintptr_t)name_ct) - (uintptr_t)1;
383: ix = 0;
384:
385: while (bits != 0) {
386: if (bits & 1) {
387: size_t nln = strlen(paz_names[ix]);
388: memcpy(pz, plus, sizeof(plus));
389: memcpy(pz+sizeof(plus), paz_names[ix], nln);
390: pz += strlen(paz_names[ix]) + 3;
391: }
392: if (++ix >= name_ct) break;
393: bits >>= 1;
394: }
395: *pz = NUL;
396: }
397:
398: /*=export_func optionSetMembers
399: * what: Convert between bit flag values and strings
400: * private:
401: *
402: * arg: tOptions*, pOpts, the program options descriptor
403: * arg: tOptDesc*, pOD, enumeration option description
404: * arg: char const * const *,
405: * paz_names, list of enumeration names
406: * arg: unsigned int, name_ct, number of names in list
407: *
408: * doc: This converts the optArg.argString string from the option description
409: * into the index corresponding to an entry in the name list.
410: * This will match the generated enumeration value.
411: * Full matches are always accepted. Partial matches are accepted
412: * if there is only one partial match.
413: =*/
414: void
415: optionSetMembers(tOptions * pOpts, tOptDesc * pOD,
416: char const* const * paz_names, unsigned int name_ct)
417: {
418: /*
419: * IF the program option descriptor pointer is invalid,
420: * then it is some sort of special request.
421: */
422: switch ((uintptr_t)pOpts) {
423: case (uintptr_t)OPTPROC_EMIT_USAGE:
424: set_memb_usage(pOpts, pOD, paz_names, name_ct);
425: return;
426:
427: case (uintptr_t)OPTPROC_EMIT_SHELL:
428: set_memb_shell(pOpts, pOD, paz_names, name_ct);
429: return;
430:
431: case (uintptr_t)OPTPROC_RETURN_VALNAME:
432: set_memb_names(pOpts, pOD, paz_names, name_ct);
433: return;
434:
435: default:
436: break;
437: }
438:
439: if ((pOD->fOptState & OPTST_RESET) != 0)
440: return;
441:
442: {
443: char const* pzArg = pOD->optArg.argString;
444: uintptr_t res;
445: if ((pzArg == NULL) || (*pzArg == NUL)) {
446: pOD->optCookie = (void*)0;
447: return;
448: }
449:
450: res = (uintptr_t)pOD->optCookie;
451: for (;;) {
452: tSCC zSpn[] = " ,|+\t\r\f\n";
453: int iv, len;
454:
455: pzArg += strspn(pzArg, zSpn);
456: iv = (*pzArg == '!');
457: if (iv)
458: pzArg += strspn(pzArg+1, zSpn) + 1;
459:
460: len = strcspn(pzArg, zSpn);
461: if (len == 0)
462: break;
463:
464: if ((len == 3) && (strncmp(pzArg, zAll, 3) == 0)) {
465: if (iv)
466: res = 0;
467: else res = ~0UL;
468: }
469: else if ((len == 4) && (strncmp(pzArg, zNone, 4) == 0)) {
470: if (! iv)
471: res = 0;
472: }
473: else do {
474: char* pz;
475: uintptr_t bit = strtoul(pzArg, &pz, 0);
476:
477: if (pz != pzArg + len) {
478: char z[ AO_NAME_SIZE ];
479: char const* p;
480: int shift_ct;
481:
482: if (*pz != NUL) {
483: if (len >= AO_NAME_LIMIT)
484: break;
485: memcpy(z, pzArg, (size_t)len);
486: z[len] = NUL;
487: p = z;
488: } else {
489: p = pzArg;
490: }
491:
492: shift_ct = find_name(p, pOpts, pOD, paz_names, name_ct);
493: if (shift_ct >= name_ct) {
494: pOD->optCookie = (void*)0;
495: return;
496: }
497: bit = 1UL << shift_ct;
498: }
499: if (iv)
500: res &= ~bit;
501: else res |= bit;
502: } while (0);
503:
504: if (pzArg[len] == NUL)
505: break;
506: pzArg += len + 1;
507: }
508: if (name_ct < (8 * sizeof(uintptr_t))) {
509: res &= (1UL << name_ct) - 1UL;
510: }
511:
512: pOD->optCookie = (void*)res;
513: }
514: }
515:
516: /*
517: * Local Variables:
518: * mode: C
519: * c-file-style: "stroustrup"
520: * indent-tabs-mode: nil
521: * End:
522: * end of autoopts/enumeration.c */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to enumeration.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