| /**************************************************************************** |
| * |
| * ======================================================================== |
| * |
| * The contents of this file are subject to the SciTech MGL Public |
| * License Version 1.0 (the "License"); you may not use this file |
| * except in compliance with the License. You may obtain a copy of |
| * the License at http://www.scitechsoft.com/mgl-license.txt |
| * |
| * Software distributed under the License is distributed on an |
| * "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or |
| * implied. See the License for the specific language governing |
| * rights and limitations under the License. |
| * |
| * The Original Code is Copyright (C) 1991-1998 SciTech Software, Inc. |
| * |
| * The Initial Developer of the Original Code is SciTech Software, Inc. |
| * All Rights Reserved. |
| * |
| * ======================================================================== |
| * |
| * Language: ANSI C |
| * Environment: any |
| * |
| * Description: This module contains code to parse the command line, |
| * extracting options and parameters in standard System V |
| * style. |
| * |
| ****************************************************************************/ |
| |
| #include <stdio.h> |
| #include <string.h> |
| #include <ctype.h> |
| #include "cmdline.h" |
| |
| /*------------------------- Global variables ------------------------------*/ |
| |
| int nextargv = 1; /* Index into argv array */ |
| char *nextchar = NULL; /* Pointer to next character */ |
| |
| /*-------------------------- Implementation -------------------------------*/ |
| |
| #define IS_SWITCH_CHAR(c) ((c) == '-') |
| #define IS_NOT_SWITCH_CHAR(c) ((c) != '-') |
| |
| /**************************************************************************** |
| DESCRIPTION: |
| Parse the command line for specific options |
| |
| HEADER: |
| cmdline.h |
| |
| PARAMETERS: |
| argc - Value passed to program through argc variable |
| argv - Pointer to the argv array passed to the program |
| format - A string representing the expected format of the command line |
| argument - Pointer to optional argument on command line |
| |
| RETURNS: |
| Character code representing the next option parsed from the command line by |
| getcmdopt. Returns ALLDONE (-1) when there are no more parameters to be parsed |
| on the command line, PARAMETER (-2) when the argument being parsed is a |
| parameter and not an option switch and lastly INVALID (-3) if an error |
| occured while parsing the command line. |
| |
| REMARKS: |
| Function to parse the command line option switches in UNIX System V style. |
| When getcmdopt is called, it returns the character code of the next valid |
| option that is parsed from the command line as specified by the Format |
| string. The format string should be in the following form: |
| |
| "abcd:e:f:" |
| |
| where a,b and c represent single switch style options and the character |
| code returned by getcmdopt is the only value returned. Also d, e and f |
| represent options that expect arguments immediately after them on the |
| command line. The argument that follows the option on the command line is |
| returned via a reference in the pointer argument. Thus a valid command line |
| for this format string might be: |
| |
| myprogram -adlines -b -f format infile outfile |
| |
| where a and b will be returned as single character options with no argument, |
| while d is returned with the argument lines and f is returned with the |
| argument format. |
| |
| When getcmdopt returns with PARAMETER (we attempted to parse a paramter, not |
| an option), the global variable NextArgv will hold an index in the argv |
| array to the argument on the command line AFTER the options, ie in the |
| above example the string 'infile'. If the parameter is successfully used, |
| NextArgv should be incremented and getcmdopt can be called again to parse any |
| more options. Thus you can also have options interspersed throught the |
| command line. eg: |
| |
| myprogram -adlines infile -b outfile -f format |
| |
| can be made to be a valid form of the above command line. |
| ****************************************************************************/ |
| int getcmdopt( |
| int argc, |
| char **argv, |
| char *format, |
| char **argument) |
| { |
| char ch; |
| char *formatchar; |
| |
| if (argc > nextargv) { |
| if (nextchar == NULL) { |
| nextchar = argv[nextargv]; /* Index next argument */ |
| if (nextchar == NULL) { |
| nextargv++; |
| return ALLDONE; /* No more options */ |
| } |
| if (IS_NOT_SWITCH_CHAR(*nextchar)) { |
| nextchar = NULL; |
| return PARAMETER; /* We have a parameter */ |
| } |
| nextchar++; /* Move past switch operator */ |
| if (IS_SWITCH_CHAR(*nextchar)) { |
| nextchar = NULL; |
| return INVALID; /* Ignore rest of line */ |
| } |
| } |
| if ((ch = *(nextchar++)) == 0) { |
| nextchar = NULL; |
| return INVALID; /* No options on line */ |
| } |
| |
| if (ch == ':' || (formatchar = strchr(format, ch)) == NULL) |
| return INVALID; |
| |
| if (*(++formatchar) == ':') { /* Expect an argument after option */ |
| nextargv++; |
| if (*nextchar == 0) { |
| if (argc <= nextargv) |
| return INVALID; |
| nextchar = argv[nextargv++]; |
| } |
| *argument = nextchar; |
| nextchar = NULL; |
| } |
| else { /* We have a switch style option */ |
| if (*nextchar == 0) { |
| nextargv++; |
| nextchar = NULL; |
| } |
| *argument = NULL; |
| } |
| return ch; /* return the option specifier */ |
| } |
| nextchar = NULL; |
| nextargv++; |
| return ALLDONE; /* no arguments on command line */ |
| } |
| |
| /**************************************************************************** |
| PARAMETERS: |
| optarr - Description for the option we are parsing |
| argument - String to parse |
| |
| RETURNS: |
| INVALID on error, ALLDONE on success. |
| |
| REMARKS: |
| Parses the argument string depending on the type of argument that is |
| expected, filling in the argument for that option. Note that to parse a |
| string, we simply return a pointer to argument. |
| ****************************************************************************/ |
| static int parse_option( |
| Option *optarr, |
| char *argument) |
| { |
| int num_read; |
| |
| switch ((int)(optarr->type)) { |
| case OPT_INTEGER: |
| num_read = sscanf(argument,"%d",(int*)optarr->arg); |
| break; |
| case OPT_HEX: |
| num_read = sscanf(argument,"%x",(int*)optarr->arg); |
| break; |
| case OPT_OCTAL: |
| num_read = sscanf(argument,"%o",(int*)optarr->arg); |
| break; |
| case OPT_UNSIGNED: |
| num_read = sscanf(argument,"%u",(uint*)optarr->arg); |
| break; |
| case OPT_LINTEGER: |
| num_read = sscanf(argument,"%ld",(long*)optarr->arg); |
| break; |
| case OPT_LHEX: |
| num_read = sscanf(argument,"%lx",(long*)optarr->arg); |
| break; |
| case OPT_LOCTAL: |
| num_read = sscanf(argument,"%lo",(long*)optarr->arg); |
| break; |
| case OPT_LUNSIGNED: |
| num_read = sscanf(argument,"%lu",(ulong*)optarr->arg); |
| break; |
| case OPT_FLOAT: |
| num_read = sscanf(argument,"%f",(float*)optarr->arg); |
| break; |
| case OPT_DOUBLE: |
| num_read = sscanf(argument,"%lf",(double*)optarr->arg); |
| break; |
| case OPT_LDOUBLE: |
| num_read = sscanf(argument,"%Lf",(long double*)optarr->arg); |
| break; |
| case OPT_STRING: |
| num_read = 1; /* This always works */ |
| *((char**)optarr->arg) = argument; |
| break; |
| default: |
| return INVALID; |
| } |
| |
| if (num_read == 0) |
| return INVALID; |
| else |
| return ALLDONE; |
| } |
| |
| /**************************************************************************** |
| HEADER: |
| cmdline.h |
| |
| PARAMETERS: |
| argc - Number of arguments on command line |
| argv - Array of command line arguments |
| num_opt - Number of options in option array |
| optarr - Array to specify how to parse the command line |
| do_param - Routine to handle a command line parameter |
| |
| RETURNS: |
| ALLDONE, INVALID or HELP |
| |
| REMARKS: |
| Function to parse the command line according to a table of options. This |
| routine calls getcmdopt above to parse each individual option and attempts |
| to parse each option into a variable of the specified type. The routine |
| can parse integers and long integers in either decimal, octal, hexadecimal |
| notation, unsigned integers and unsigned longs, strings and option switches. |
| Option switches are simply boolean variables that get turned on if the |
| switch was parsed. |
| |
| Parameters are extracted from the command line by calling a user supplied |
| routine do_param() to handle each parameter as it is encountered. The |
| routine do_param() should accept a pointer to the parameter on the command |
| line and an integer representing how many parameters have been encountered |
| (ie: 1 if this is the first parameter, 10 if it is the 10th etc), and return |
| ALLDONE upon successfully parsing it or INVALID if the parameter was invalid. |
| |
| We return either ALLDONE if all the options were successfully parsed, |
| INVALID if an invalid option was encountered or HELP if any of -h, -H or |
| -? were present on the command line. |
| ****************************************************************************/ |
| int getargs( |
| int argc, |
| char *argv[], |
| int num_opt, |
| Option optarr[], |
| int (*do_param)( |
| char *param, |
| int num)) |
| { |
| int i,opt; |
| char *argument; |
| int param_num = 1; |
| char cmdstr[MAXARG*2 + 4]; |
| |
| /* Build the command string from the array of options */ |
| |
| strcpy(cmdstr,"hH?"); |
| for (i = 0,opt = 3; i < num_opt; i++,opt++) { |
| cmdstr[opt] = optarr[i].opt; |
| if (optarr[i].type != OPT_SWITCH) { |
| cmdstr[++opt] = ':'; |
| } |
| } |
| cmdstr[opt] = '\0'; |
| |
| for (;;) { |
| opt = getcmdopt(argc,argv,cmdstr,&argument); |
| switch (opt) { |
| case 'H': |
| case 'h': |
| case '?': |
| return HELP; |
| case ALLDONE: |
| return ALLDONE; |
| case INVALID: |
| return INVALID; |
| case PARAMETER: |
| if (do_param == NULL) |
| return INVALID; |
| if (do_param(argv[nextargv],param_num) == INVALID) |
| return INVALID; |
| nextargv++; |
| param_num++; |
| break; |
| default: |
| |
| /* Search for the option in the option array. We are |
| * guaranteed to find it. |
| */ |
| |
| for (i = 0; i < num_opt; i++) { |
| if (optarr[i].opt == opt) |
| break; |
| } |
| if (optarr[i].type == OPT_SWITCH) |
| *((ibool*)optarr[i].arg) = true; |
| else { |
| if (parse_option(&optarr[i],argument) == INVALID) |
| return INVALID; |
| } |
| break; |
| } |
| } |
| } |
| |
| /**************************************************************************** |
| HEADER: |
| cmdline.h |
| |
| PARAMETERS: |
| num_opt - Number of options in the table |
| optarr - Table of option descriptions |
| |
| REMARKS: |
| Prints the description of each option in a standard format to the standard |
| output device. The description for each option is obtained from the table |
| of options. |
| ****************************************************************************/ |
| void print_desc( |
| int num_opt, |
| Option optarr[]) |
| { |
| int i; |
| |
| for (i = 0; i < num_opt; i++) { |
| if (optarr[i].type == OPT_SWITCH) |
| printf(" -%c %s\n",optarr[i].opt,optarr[i].desc); |
| else |
| printf(" -%c<arg> %s\n",optarr[i].opt,optarr[i].desc); |
| } |
| } |
| |
| /**************************************************************************** |
| HEADER: |
| cmdline.h |
| |
| PARAMETERS: |
| moduleName - Module name for program |
| cmdLine - Command line to parse |
| pargc - Pointer to 'argc' parameter |
| pargv - Pointer to 'argv' parameter |
| maxArgc - Maximum argv array index |
| |
| REMARKS: |
| Parses a command line from a single string into the C style 'argc' and |
| 'argv' format. Most useful for Windows programs where the command line |
| is passed in verbatim. |
| ****************************************************************************/ |
| int parse_commandline( |
| char *moduleName, |
| char *cmdLine, |
| int *pargc, |
| char *argv[], |
| int maxArgv) |
| { |
| static char str[512]; |
| static char filename[260]; |
| char *prevWord = NULL; |
| ibool inQuote = FALSE; |
| ibool noStrip = FALSE; |
| int argc; |
| |
| argc = 0; |
| strcpy(filename,moduleName); |
| argv[argc++] = filename; |
| cmdLine = strncpy(str, cmdLine, sizeof(str)-1); |
| while (*cmdLine) { |
| switch (*cmdLine) { |
| case '"' : |
| if (prevWord != NULL) { |
| if (inQuote) { |
| if (!noStrip) |
| *cmdLine = '\0'; |
| argv [argc++] = prevWord; |
| prevWord = NULL; |
| } |
| else |
| noStrip = TRUE; |
| } |
| inQuote = !inQuote; |
| break; |
| case ' ' : |
| case '\t' : |
| if (!inQuote) { |
| if (prevWord != NULL) { |
| *cmdLine = '\0'; |
| argv [argc++] = prevWord; |
| prevWord = NULL; |
| noStrip = FALSE; |
| } |
| } |
| break; |
| default : |
| if (prevWord == NULL) |
| prevWord = cmdLine; |
| break; |
| } |
| if (argc >= maxArgv - 1) |
| break; |
| cmdLine++; |
| } |
| |
| if ((prevWord != NULL || (inQuote && prevWord != NULL)) && argc < maxArgv - 1) { |
| *cmdLine = '\0'; |
| argv [argc++] = prevWord; |
| } |
| argv[argc] = NULL; |
| |
| /* Return updated parameters */ |
| return (*pargc = argc); |
| } |
