Q
Line Name ----- ----) 74 cmdopt_cmp ( 122 kwdef_cmp+ 189 kwstrleadlen ' 165 kwstrlen . 315 process_keyword. 214 process_options3 454 process_options_file 0 390 translate_keyword' 36 ustrncmp
BEGINNING OF FILE
V 1: /****************************************************************************/ 2: /* */ 8 3: /* FACILITY: Generic Support Library */ 4: /* */ F 5: /* MODULE: Command Line Keyword and Option Processing */ 6: /* */ O 7: /* AUTHOR: Steve Branam, Network Product Support Group, Digital */ > 8: /* Equipment Corporation, Littleton, MA, USA. */ 9: /* */ U 10: /* DESCRIPTION: This module contains routines to process command line */ V 11: /* arguments, given a dispatch table of keywords and handlers. This can be */V 12: /* used for main program command lines, or internal command lines parsed */, 13: /* in a similar manner. */ 14: /* */ * 15: /* REVISION HISTORY: */ 16: /* */ 7 17: /* V0.1-00 24-AUG-1994 Steve Branam */ 18: /* */ ( 19: /* Original version. */ 20: /* */ 7 21: /* V0.2-00 23-SEP-1994 Steve Branam */ 22: /* */ 5 23: /* Addded keyword translation code. */ 24: /* */ V 25: /****************************************************************************/ 26: 27: #include <stdio.h> 28: #include <ctype.h> 29: #include "cmdopt.h" 30: B 31: static KEYWORD_DEFINITION /* Option dispatch table, */< 32: *mOptionTable; /* used by options file */$ 33: /* processing. */ 34: V 35: /*************************************************************************++*/
36: int ustrncmp( V 37: /* Compares strings in upper-case, serving as a case-insensitive string */@ 38: /* comparison; otherwise identical to strncmp. */ 39: 40: char *aStr1, , 41: /* (READ, BY ADDR): */3 42: /* First string to compare. */ 43: 44: char *aStr2, , 45: /* (READ, BY ADDR): */3 46: /* Second string to compare. */ 47: 48: int vLength + 49: /* (READ, BY VAL): */ A 50: /* Maximum number of characters to compare. */ 51: H 52: ) /* Returns status value indicating comparison results: */0 53: /* 0 - Strings are equal. */? 54: /* < 0 - String aStr1 is less than aStr2. */ B 55: /* > 0 - String aStr1 is greater than aStr2. */O 56: /*****************************************************************--*/ 57: 58: { 59: /*+ */U 60: /* Compare upper-case version of each char in strings until unequal */ S 61: /* chars ard found, end of string is found, or maximum number of */ / 62: /* characters exceeded. */ 63: /*- */ 64: J 65: for (; toupper(*aStr1) == toupper(*aStr2); aStr1++, aStr2++) {0 66: if (*aStr1 == '\0' || --vLength == 0) {; 67: return 0; /* Strings are "equal". */
68: }5 69: } /* String are not equal. */ 5 70: return toupper(*aStr1) - toupper(*aStr2); 71: } F END ustrncmp. Go to: Beginning of routine.
72: V 73: /*************************************************************************++*/
74: static int cmdopt_cmp(T 75: /* Compares an argument string to a command line option using a case- */V 76: /* insensitive string comparison. The argument matches the option if the */S 77: /* keyword portion is at least as long as the minimum option keyword */ O 78: /* length, and matches the keyword for all specified characters. */ 79: 80: KEYWORD_DEFINITION 81: *aOption,, 82: /* (READ, BY ADDR): */I 83: /* Command line option keyword definition to compare. */ 84: 85: char *aArgStr, 86: /* (READ, BY ADDR): */L 87: /* Argument string to compare. Options are assumed to be */O 88: /* specified in one of two forms, either just the option switch */ O 89: /* char followed by the keyword (for toggle options), or the */ O 90: /* option switch char and keyword followed by an equal sign and */ D 91: /* the option value string (for value options). */ 92: P 93: ) /* Returns length of keyword portion of aArgstr (including switch */O 94: /* char) to indicate successful match, or 0 if argument does not */ % 95: /* match option. */ O 96: /********************************************************************/ 97: 98: { C 99: int kwlen; /* Length of argument keyword */ 3 100: /* portion (including switch */ # 101: /* char). */ 102: 103: /*+ */U 104: /* Find length of argument keyword portion. If it is less than minimum */ U 105: /* required length, no match. Otherwise, compare argument to option */ 5 106: /* keyword to determine match. */ 107: /*- */ 108: S 109: if ((kwlen = kwstrlen(&aArgStr[1])) < kwdef_minlen(aOption)) { 7 110: return 0; /* Too short, no match. */
111: } F 112: else if (ustrncmp(kwdef_keyword(aOption), &aArgStr[1],4 113: max(kwlen, kwdef_minlen(aOption))) == 0) {C 114: return kwlen + 1; /* Argument matches option. */
115: } 116: else {- 117: return 0; /* No match. */
118: } 119: } H END cmdopt_cmp. Go to: Beginning of routine.
120: V 121: /*************************************************************************++*/
122: static int kwdef_cmp( Q 123: /* Compares a string to a keyword using a case- insensitive string */ V 124: /* comparison. The string matches the keyword if it is at least as long as */V 125: /* the minimum keyword length, and matches the keyword for all specified */$ 126: /* characters. */ 127: 128: KEYWORD_DEFINITION 129: *aKwDef, , 130: /* (READ, BY ADDR): */8 131: /* Keyword definition to compare. */ 132: 133: char *aKwStr,, 134: /* (READ, BY ADDR): */4 135: /* Keyword string to compare. */ 136: 137: int vLengthl+ 138: /* (READ, BY VAL): */n1 139: /* Keyword string length. */H 140: - 141: ) /* Returns status flag: */i, 142: /* 1 - Successful match */9 143: /* 0 - String does not match keyword. */eQ 144: /* ****************************************************************** */ 145: 146: {H 147: /*+ */U 148: /* If string length is less than minimum required length, no match. */ U 149: /* Otherwise, compare argument to option keyword to determine match. *// 150: /* */p 151: 6 152: if (vLength < kwdef_minlen(aKwDef)) { 7 153: return 0; /* Too short, no match. */
154: }#< 155: else if (ustrncmp(kwdef_keyword(aKwDef), aKwStr,5 156: max(vLength, kwdef_minlen(aKwDef))) == 0) {*: 157: return 1; /* String matches keyword. */
158: } 159: else {- 160: return 0; /* No match. */
161: } 162: } G END kwdef_cmp. Go to: Beginning of routine.
163: V 164: /*************************************************************************++*/
d 165: int kwstrlen( V 166: /* Finds the length of a keyword string. A keyword is a contiguous string */F 167: /* of alphanumerics and the underscore character '_'. */ 168: 169: char *aKwStr , 170: /* (READ, BY ADDR): */O 171: /* Keyword string to find length of. It is assumed to contain */*O 172: /* no leading non-keyword characters (if it does, the length */3/ 173: /* returned will be 0). */ 174: P 175: ) /* Returns length of string, or 0 if the first character is not a */5 176: /* valid keyword string character. */*O 177: /********************************************************************/ 178: 179: {c: 180: int kwlen; /* Length of keyword. */ 181: 182: for (kwlen = 0;i8 183: isalnum(aKwStr[kwlen]) || aKwStr[kwlen] == '_'; 184: kwlen++); 185: return kwlen;s 186: }/ F END kwstrlen. Go to: Beginning of routine.
* 187: V 188: /*************************************************************************++*/
s
e 189: int kwstrleadlen(cV 190: /* Finds the length of leading non-keyword characters in a keyword string, */V 191: /* which may subsequently be treated as the offset to the beginning of the */! 192: /* keyword. */ 193: 194: char *aKwStrR, 195: /* (READ, BY ADDR): */J 196: /* Keyword string that may contain leading non-keyword */' 197: /* characters. */* 198: L 199: ) /* Returns length of leading characters, or 0 if the string */H 200: /* contains no leading characters (or is a null string). */O 201: /********************************************************************/ 202: 203: { > 204: int leadlen; /* Length of leading chars. */ 205: 206: for (leadlen = 0;*" 207: !isalnum(aKwStr[leadlen])N 208: && aKwStr[leadlen] != '_' && aKwStr[leadlen] != '\0'; 209: leadlen++); 210: return leadlen;g 211: }q J END kwstrleadlen. Go to: Beginning of routine.
212: V 213: /*************************************************************************++*/
a 214: int process_options(V 215: /* Parses user command line arguments for options and dispatches option */V 216: /* handler routines. Processing will terminate if any handler indicates */! 217: /* failure. */* 218: 219: int vArgc,+ 220: /* (READ, BY VAL): */rD 221: /* Number of program argument strings in aArgv. */ 222: 223: char *aArgv[],R, 224: /* (READ, BY ADDR): */: 225: /* List of program argument strings. */ 226: ! 227: int vFirstOption, + 228: /* (READ, BY VAL): */iO 229: /* Starting argument number for option. All preceding arguments */7A 230: /* are assumed to be required, not options. */o 231: 232: KEYWORD_DEFINITION 233: *aOptionTable, 234: /* (READ, BY ADDR): */
235: IO 236: /* Option definition table, containing option keywords (not */ O 237: /* including option switch character), handler routine ptrs, */ O 238: /* and keyword translation codes. The table is terminated by */ O 239: /* an entry containing a NULL keyword ptr. The interface for a *//. 240: /* handler routine is: */ 241: /* */ 9 242: /* int handler(code, valstr, n) */h 243: /* */nO 244: /* where code is the translation code for the matched keyword, */pO 245: /* valstr is the ptr to the remainder of the argument string */nN 246: /* following the matched argument characters, and n is the */O 247: /* option's argument position on the command line; however, a */iO 248: /* handler is free to ignore (and therefore not declare) any */*O 249: /* trailing subset of these parameters. The handler returns 1 */hO 250: /* if the argument is handled successfully, or 0 otherwise. */ O 251: /* This interface supports two styles of usage: common handlers */ O 252: /* may handle several different options, discriminating the */*M 253: /* matched option via the translation code; or individual */tI 254: /* handlers may be used for each option, ignoring the */ - 255: /* translation codes. */f 256: B 257: ) /* Returns status indicating processing success: */J 258: /* 1 - All options handled successfully (any unrecognized */3 259: /* arguments/options ignored). */r= 260: /* 0 - An argument could not be processed. */ O 261: /********************************************************************/ 262: 263: {{6 264: int arg; /* Argument number. */@ 265: KEYWORD_DEFINITION /* Current keyword def. */ 266: *kwdef;: 267: int kwlen; /* Length of argument */' 268: /* keyword portion */*, 269: /* (including switch char). */ 270: 271: /*+ */U 272: /* Save option table ptr in case we run into an option to process an */fU 273: /* options file, then attempt to process each command line argument */2A 274: /* following the required ones as an option. */ 275: /*- */ 276: ( 277: mOptionTable = aOptionTable;= 278: for (arg = vFirstOption; arg < vArgc; arg++) {n 279: 280: /*+ */O 281: /* If argument starts with option switch character, go through */ O 282: /* option table trying to match it. On match, call option handler */DO 283: /* and skip the rest of the option table; if the handler return */2M 284: /* failure, abort. If no match, issue warning and ignore the */ O 285: /* argument. If it did not start with switch char, issue warning */ ' 286: /* and ignore it. */) 287: /*- */ 288: 4 289: if (*aArgv[arg] == CMDLINE_OPTION_SWITCH) {P 290: for (kwdef = aOptionTable; kwdef_keyword(kwdef) != NULL; kwdef++) {8 291: if ((kwlen = cmdopt_cmp(kwdef, aArgv[arg]))) { 292: , 293: /* Match, call handler. */< 294: if (!(kwdef_handler(kwdef))(kwdef_code(kwdef),. 295: &aArgv[arg][kwlen], arg)) {4 296: return 0; /* Abort, handler failed! */ 297: }h4 298: break; /* Skip rest of table. */ 299: }/ 300: }9 301: if (!kwlen) { /* No option matches. */dJ 302: printf("ERROR: Unrecognized/ambiguous option %s\n", aArgv[arg]); 303: return 0; 304: }
305: }2 306: else { /* Not an option argument. */P 307: printf("ERROR: Unexpected command line argument %s\n", aArgv[arg]); 308: return 0;
309: }1 310: } /* All options processed */h1 311: return 1; /* successfully. */ 312: }G M END process_options. Go to: Beginning of routine.4
* 313: V 314: /*************************************************************************++*/
1
F 315: int process_keyword(T 316: /* Parses keyword strings and dispatches to keyword handler routines. */O 317: /* Processing will terminate if any handler indicates failure. */ 318: 319: char *aKwStr,, 320: /* (READ, BY ADDR): */M 321: /* Keyword string, with no leading, trailing, or enclosed */rO 322: /* whitespace. May be a single keyword, or a list of keywords, */ / 323: /* separated by commas. */, 324: 325: KEYWORD_DEFINITION 326: *aKwTable, 327: /* (READ, BY ADDR): */M 328: /* Keyword definition table, containing keywords, handler */ O 329: /* routine ptrs, and keyword translation codes. The table is */ O 330: /* terminated by an entry containing a NULL keyword ptr. The */ < 331: /* interface for a handler routine is: */ 332: /* */:0 333: /* int handler(code) */ 334: /* */8O 335: /* where code is the keyword translation code. (there are no */ O 336: /* arguments to the handler). The handler returns 1 if the */2M 337: /* argument is handled successfully, or 0 otherwise. This */;O 338: /* interface supports two styles of usage: common handlers may */ L 339: /* handle several different keywords, discriminating the */N 340: /* matched keyword via the translation code; or individual */J 341: /* handlers may be used for each keyword, ignoring the */- 342: /* translation codes. */ 343: B 344: ) /* Returns status indicating processing success: */< 345: /* 1 - All keywords handled successfully. */; 346: /* 0 - A keyword could not be processed. */gO 347: /********************************************************************/s 348: 349: {)@ 350: KEYWORD_DEFINITION /* Current keyword def. */ 351: *kwdef;: 352: int kwlen; /* Length of keyword. */< 353: int found; /* Flag indicating match. */D 354: char *savestr = aKwStr; /* Saved string ptr. */ 355: , 356: /* For each keyword in list */B 357: while (*aKwStr != '\0') { /* (or just one)... */ 358: / 359: if ((kwlen = kwstrlen(aKwStr)) == 0) { < 360: printf("ERROR: Missing keyword %s\n", savestr); 361: return 0;
362: }2 363: else { /* Scan keyword table for */ 364: /* match. */=L 365: for (kwdef = aKwTable; kwdef_keyword(kwdef) != NULL; kwdef++) {: 366: if ((found = kwdef_cmp(kwdef, aKwStr, kwlen))) { 367: , 368: /* Match, call handler with */) 369: /* translation code. */r? 370: if (!(kwdef_handler(kwdef))(kwdef_code(kwdef))) { 4 371: return 0; /* Abort, handler failed! */ 372: }n4 373: break; /* Skip rest of table. */ 374: }9 375: } 376: if (!found) {G 377: printf("ERROR: Unrecognized/ambiguous keyword %s\n", aKwStr);s 378: return 0; 379: }
380: }7 381: if (aKwStr[kwlen] == KEYWORD_LIST_SEPARATOR) { 7 382: kwlen++; /* Account for separator. *//
383: }: 384: aKwStr += kwlen; /* Advance past keyword. */ 385: } 8 386: return 1; /* All keywords processed */& 387: } /* successfully. */ M END process_keyword. Go to: Beginning of routine.I
388: V 389: /*************************************************************************++*/
390: int translate_keyword(P 391: /* Parses a single keyword string and returns a translation code. */ 392: 393: char *aKwStr,, 394: /* (READ, BY ADDR): */M 395: /* Keyword string. If it contains any leading non-keyword */rO 396: /* characters, they will be ignored. If it contains more than */oJ 397: /* one keyword, only the first one will be translated. */ 398: 399: KEYWORD_DEFINITION 400: *aKwTable, 401: /* (READ, BY ADDR): */M 402: /* Keyword definition table, containing keywords, handler */tO 403: /* routine ptrs, and keyword translation codes. The table is */nO 404: /* terminated by an entry containing a NULL keyword ptr. The */ O 405: /* handler routine is called only if its ptr is non-NULL. The */:< 406: /* interface for a handler routine is: */ 407: /* */e0 408: /* int handler(code) */ 409: /* */ O 410: /* where code is the keyword translation code. (there are no */ O 411: /* arguments to the handler). The handler returns 1 if the */sM 412: /* argument is handled successfully, or 0 otherwise. This */lO 413: /* interface supports two styles of usage: common handlers may */)L 414: /* handle several different keywords, discriminating the */N 415: /* matched keyword via the translation code; or individual */J 416: /* handlers may be used for each keyword, ignoring the */- 417: /* translation codes. */t 418: O 419: ) /* Returns matching keyword translation code, or 0 if no match */mD 420: /* found or the matching keyword handler returns 0. */O 421: /********************************************************************/ 422: 423: {e@ 424: KEYWORD_DEFINITION /* Current keyword def. */ 425: *kwdef;: 426: int kwlen; /* Length of keyword. */D 427: char *savestr = aKwStr; /* Saved string ptr. */ 428: 2 429: if ((kwlen = kwstrlen(aKwStr)) == 0) { 430: return 0;
431: }g5 432: else { /* Scan keyword table for */ 433: /* match. */ H 434: for (kwdef = aKwTable; kwdef_keyword(kwdef) != NULL; kwdef++) {3 435: if (kwdef_cmp(kwdef, aKwStr, kwlen)) {h 436: ) 437: /* Match, if handler */ , 438: /* defined, call it with */) 439: /* translation code. */o* 440: if (kwdef_handler(kwdef) != NULLF 441: && !(kwdef_handler(kwdef))(kwdef_code(kwdef))) {8 442: return 0; /* Abort, handler failed! */ 443: } 0 444: else { /* Handler ok (or not */F 445: return kwdef_code(kwdef); /* defined), return code. */ 446: }w 447: }
448: }* 449: return 0; /* No match. */
450: }2 451: }3 O END translate_keyword. Go to: Beginning of routine.o
452: V 453: /*************************************************************************++*/
]
3! 454: int process_options_file( V 455: /* Command line option handler to read an options file, where each line is */V 456: /* a single command line option, just as if it were parsed from the command */V 457: /* line. Option files may be nested, just be careful of looped files or */V 458: /* running out of resources due to excessive nesting. Comments lines and */3 459: /* trailing comment are allowed. */ 460: 461: int vKwCode,, 462: /* (READ, BY ADDR): */O 463: /* Option keyword translation code, ignored by this routine. */x 464: 465: char *aValStr, 466: /* (READ, BY ADDR): */D 467: /* Option value string, preceded by equal sign. */ 468: - 469: ) /* Returns status code: */t? 470: /* 1 - Successful processing of this option. */ K 471: /* 0 - Option file name missing, or file cannot be opened. */3O 472: /*****************************************************************--*/ 473: 474: {r? 475: FILE *optfile; /* Options file ptr. */ ? 476: int rcount; /* Routine name count. */sE 477: char option[512]; /* Option string buffer. */3? 478: char *optend; /* End-of-option ptr. *//= 479: char *optv; /* Option buffer ptr. */i 480: 3 481: /* Check for equal sign and */ 3 482: /* make sure there is a file. */eU 483: if (*aValStr++ == CMDLINE_OPTION_SEPARATOR && *aValStr != '\0') { 7 484: if ((optfile = fopen(aValStr, "r")) != NULL) { 485: 0 486: /* For each line, locate */- 487: /* beginning of text. */ E 488: while (fgets(option, sizeof(option), optfile) != NULL) {e 489: for (optv = option; P 490: *optv != '\0' && *optv != CMDLINE_OPTION_SWITCH &&. 491: *optv != CMDLINE_OPTION_COMMENT; 492: optv++);3 493: /* Ignore comment lines. Find */e2 494: /* end of option field and */+ 495: /* process option. */ 0 496: if (*optv != CMDLINE_OPTION_COMMENT) {! 497: for (optend = optv;/I 498: *optend > ' ' && *optend != CMDLINE_OPTION_COMMENT;/ 499: optend++);l 500: *optend = '\0';3D 501: if (!process_options(1, &optv, 0, mOptionTable)) { 502: printf(A 503: "ERROR: Failure processing option \"%s\" in %s\n",o 504: option, aValStr); 505: fclose(optfile);* 506: return 0; 507: }* 508: }s 509: } 510: fclose(optfile);I 511: return 1;
512: } 513: else { H 514: printf("ERROR: Unable to open options file %s for input\n", 515: aValStr);; 516: return 0;
517: }
518: }r 519: else {G 520: printf("ERROR: %coptions option requires options file name\n",w$ 521: CMDLINE_OPTION_SWITCH); 522: return 0;
523: }. 524: } R END process_options_file. Go to: Beginning of routine.
n 525:
END OF FILEt TOTAL: 9 routines, 53 Avg Length