home *** CD-ROM | disk | FTP | other *** search
/ World of Graphics / WOGRAPH.BIN / 458.GETOPT.C < prev    next >
C/C++ Source or Header  |  1993-02-11  |  12KB  |  358 lines
  1. /****************************************************************************
  2. *
  3. *                   Copyright (C) 1993 Kendall Bennett.
  4. *                            All rights reserved.
  5. *
  6. * Filename:        $RCSfile: getopt.c $
  7. * Version:        $Revision: 1.5 $
  8. *
  9. * Language:        ANSI C
  10. * Environment:    any
  11. *
  12. * Description:    This module contains code to parse the command line,
  13. *                extracting options and parameters in standard System V
  14. *                style.
  15. *
  16. * $Id: getopt.c 1.5 1991/12/31 19:39:55 kjb Exp $
  17. *
  18. * Revision History:
  19. * -----------------
  20. *
  21. * $Log: getopt.c $
  22. * Revision 1.5  1991/12/31  19:39:55  kjb
  23. * Modified include file directories.
  24. *
  25. * Revision 1.4  91/10/28  03:17:02  kjb
  26. * Ported to the Iris.
  27. * 
  28. * Revision 1.3  91/09/24  19:48:05  kjb
  29. * Added getargs() to parse the entire command line and converting the
  30. * parameters to the types specified in a table of options.
  31. * Added routine print_desc() to print the option description from the
  32. * table to the standard output device.
  33. * 
  34. * Revision 1.2  91/09/03  18:27:52  ROOT_DOS
  35. * Ported to UNIX.
  36. * 
  37. * Revision 1.1  91/08/16  10:45:36  ROOT_DOS
  38. * Initial revision
  39. * 
  40. ****************************************************************************/
  41.  
  42. #include <stdio.h>
  43. #include <string.h>
  44. #include <ctype.h>
  45. #include "debug.h"
  46. #include "getopt.h"
  47.  
  48. /*------------------------- Global variables ------------------------------*/
  49.  
  50. int        nextargv    =    1;            /* Index into argv array            */
  51. char    *nextchar    =    NULL;        /* Pointer to next character        */
  52.  
  53. /*-------------------------- Implementation -------------------------------*/
  54.  
  55. #ifdef    __MSDOS__
  56. #define    IS_SWITCH_CHAR(c)        (c == '-') || (c == '/')
  57. #define    IS_NOT_SWITCH_CHAR(c)    (c != '-') && (c != '/')
  58. #else
  59. #define    IS_SWITCH_CHAR(c)        (c == '-')
  60. #define    IS_NOT_SWITCH_CHAR(c)    (c != '-')
  61. #endif
  62.  
  63. PUBLIC int getopt(int argc,char **argv,char *format,char **argument)
  64. /****************************************************************************
  65. *
  66. * Function:        getopt
  67. * Parameters:    argc        -    Value passed to program through argc
  68. *                                variable in the function main.
  69. *                argv        -     Pointer to the argv array that is passed to
  70. *                                the program in function main.
  71. *                format        -    A string representing the expected format
  72. *                                of the command line options that need to be
  73. *                                parsed.
  74. *                argument    -     Pointer to optional argument on command
  75. *                                line.
  76. *
  77. * Returns:        Character code representing the next option parsed from the
  78. *                command line by getopt. Returns ALLDONE (-1) when there are
  79. *                no more parameters to be parsed on the command line,
  80. *                PARAMETER (-2) when the argument being parsed is a
  81. *                parameter and not an option switch and lastly INVALID (-3)
  82. *                if an error occured while parsing the command line.
  83. *
  84. * Description:    Function to parse the command line option switches in
  85. *                UNIX System V style. When getopt is called, it returns the
  86. *                character code of the next valid option that is parsed from
  87. *                the command line as specified by the Format string. The
  88. *                format string should be in the following form:
  89. *
  90. *                        "abcd:e:f:"
  91. *
  92. *                where a,b and c represent single switch style options and
  93. *                the character code returned by getopt is the only value
  94. *                returned. Also d, e and f represent options that expect
  95. *                arguments immediately after them on the command line. The
  96. *                argument that follows the option on the command line is
  97. *                returned via a reference in the pointer argument. Thus
  98. *                a valid command line for this format string might be:
  99. *
  100. *                    myprogram -adlines /b /f format infile outfile
  101. *
  102. *                where a and b will be returned as single character options
  103. *                with no argument, while d is returned with the argument
  104. *                lines and f is returned with the argument format. Note that
  105. *                either UNIX style or MS-DOS command switches may be used
  106. *                interchangeably under MSDOS, but under UNIX only the UNIX
  107. *                style switches are supported.
  108. *
  109. *                When getopt returns with PARAMETER (we attempted to parse
  110. *                a paramter, not an option), the global variable NextArgv
  111. *                will hold an index in the argv array to the argument on the
  112. *                command line AFTER the options, ie in the above example the
  113. *                string 'infile'. If the parameter is successfully used,
  114. *                NextArgv should be incremented and getopt can be called
  115. *                again to parse any more options. Thus you can also have
  116. *                options interspersed throught the command line. eg:
  117. *
  118. *                    myprogram -adlines infile /b outfile /f format
  119. *
  120. *                can be made to be a valid form of the above command line.
  121. *
  122. ****************************************************************************/
  123. {
  124.     char    ch;
  125.     char    *formatchar;
  126.  
  127.     if (argc > nextargv) {
  128.         if (nextchar == NULL) {
  129.             nextchar = argv[nextargv];        /* Index next argument         */
  130.             if(nextchar == NULL) {
  131.                 nextargv++;
  132.                 return ALLDONE;                /* No more options             */
  133.                 }
  134.             if(IS_NOT_SWITCH_CHAR(*nextchar)) {
  135.                 nextchar = NULL;
  136.                 return PARAMETER;            /* We have a parameter         */
  137.                 }
  138.             nextchar++;                    /* Move past switch operator    */
  139.             if(IS_SWITCH_CHAR(*nextchar)) {
  140.                 nextchar = NULL;
  141.                 return INVALID;                /* Ignore rest of line         */
  142.                 }
  143.             }
  144.  
  145.         if ((ch = *(nextchar++)) == 0) {
  146.             nextchar = NULL;
  147.             return INVALID;                    /* No options on line         */
  148.             }
  149.  
  150.         if (ch == ':' ||  (formatchar = strchr(format, ch)) == NULL)
  151.             return INVALID;
  152.  
  153.         if (*(++formatchar) == ':') {    /* Expect an argument after option */
  154.             nextargv++;
  155.             if (*nextchar == 0) {
  156.                 if (argc <= nextargv)
  157.                     return INVALID;
  158.                 nextchar = argv[nextargv++];
  159.                 }
  160.             *argument = nextchar;
  161.             nextchar = NULL;
  162.             }
  163.         else {                        /* We have a switch style option    */
  164.             if (*nextchar == 0) {
  165.                 nextargv++;
  166.                 nextchar = NULL;
  167.             }
  168.             *argument = NULL;
  169.             }
  170.         return ch;                    /* return the option specifier         */
  171.         }
  172.     nextchar = NULL;
  173.     nextargv++;
  174.     return ALLDONE;                    /* no arguments on command line     */
  175. }
  176.  
  177. PRIVATE int parse_option(Option *optarr,char *argument)
  178. /****************************************************************************
  179. *
  180. * Function:        parse_option
  181. * Parameters:    optarr        - Description for the option we are parsing
  182. *                argument    - String to parse
  183. * Returns:        INVALID on error, ALLDONE on success.
  184. *
  185. * Description:    Parses the argument string depending on the type of argument
  186. *                that is expected, filling in the argument for that option.
  187. *                Note that to parse a string, we simply return a pointer
  188. *                to argument.
  189. *
  190. ****************************************************************************/
  191. {
  192.     int        num_read = 0;
  193.  
  194.     switch ((int)(optarr->type)) {
  195.         case OPT_INTEGER:
  196.             num_read = sscanf(argument,"%d",optarr->arg);
  197.             break;
  198.         case OPT_HEX:
  199.             num_read = sscanf(argument,"%x",optarr->arg);
  200.             break;
  201.         case OPT_OCTAL:
  202.             num_read = sscanf(argument,"%o",optarr->arg);
  203.             break;
  204.         case OPT_UNSIGNED:
  205.             num_read = sscanf(argument,"%u",optarr->arg);
  206.             break;
  207.         case OPT_LINTEGER:
  208.             num_read = sscanf(argument,"%ld",optarr->arg);
  209.             break;
  210.         case OPT_LHEX:
  211.             num_read = sscanf(argument,"%lx",optarr->arg);
  212.             break;
  213.         case OPT_LOCTAL:
  214.             num_read = sscanf(argument,"%lo",optarr->arg);
  215.             break;
  216.         case OPT_LUNSIGNED:
  217.             num_read = sscanf(argument,"%lu",optarr->arg);
  218.             break;
  219.         case OPT_FLOAT:
  220.             num_read = sscanf(argument,"%f",optarr->arg);
  221.             break;
  222.         case OPT_DOUBLE:
  223.             num_read = sscanf(argument,"%lf",optarr->arg);
  224.             break;
  225.         case OPT_LDOUBLE:
  226.             num_read = sscanf(argument,"%Lf",optarr->arg);
  227.             break;
  228.         case OPT_STRING:
  229.             num_read = 1;            /* This always works    */
  230.             *((char**)optarr->arg) = argument;
  231.             break;
  232.         default:
  233.             return INVALID;
  234.         }
  235.  
  236.     if (num_read == 0)
  237.         return INVALID;
  238.     else
  239.         return ALLDONE;
  240. }
  241.  
  242. PUBLIC int getargs(int argc,char *argv[],int num_opt,Option optarr[],
  243.                    int (*do_param)(char *param,int num))
  244. /****************************************************************************
  245. *
  246. * Function:        getargs
  247. * Parameters:    argc        - Number of arguments on command line
  248. *                argv        - Array of command line arguments
  249. *                num_opt        - Number of options in option array
  250. *                optarr        - Array to specify how to parse the command line
  251. *                do_param    - Routine to handle a command line parameter
  252. * Returns:        ALLDONE, INVALID or HELP
  253. *
  254. * Description:    Function to parse the command line according to a table of
  255. *                options. This routine calls getopt above to parse each
  256. *                individual option and attempts to parse each option into
  257. *                a variable of the specified type. The routine can parse
  258. *                integers and long integers in either decimal, octal,
  259. *                hexadecimal notation, unsigned integers and unsigned longs,
  260. *                strings and option switches. Option switches are simply
  261. *                boolean variables that get turned on if the switch was
  262. *                parsed.
  263. *
  264. *                Parameters are extracted from the command line by calling
  265. *                a user supplied routine do_param() to handle each parameter
  266. *                as it is encountered. The routine do_param() should accept
  267. *                a pointer to the parameter on the command line and an
  268. *                integer representing how many parameters have been
  269. *                encountered (ie: 1 if this is the first parameter, 10 if
  270. *                it is the 10th etc), and return ALLDONE upon successfully
  271. *                parsing it or INVALID if the parameter was invalid.
  272. *
  273. *                We return either ALLDONE if all the options were
  274. *                successfully parsed, INVALID if an invalid option was
  275. *                encountered or HELP if any of -h, -H or -? were present
  276. *                on the command line.
  277. *
  278. ****************************************************************************/
  279. {
  280.     int        i,opt;
  281.     char    *argument;
  282.     int        param_num = 1;
  283.     char    cmdstr[MAXARG*2 + 4];
  284.  
  285.     /* Build the command string from the array of options    */
  286.  
  287.     strcpy(cmdstr,"hH?");
  288.     for (i = 0,opt = 3; i < num_opt; i++,opt++) {
  289.         cmdstr[opt] = optarr[i].opt;
  290.         if (optarr[i].type != OPT_SWITCH) {
  291.             cmdstr[++opt] = ':';
  292.             }
  293.         }
  294.     cmdstr[opt] = '\0';
  295.  
  296.     while (true) {
  297.         opt = getopt(argc,argv,cmdstr,&argument);
  298.         switch (opt) {
  299.             case 'H':
  300.             case 'h':
  301.             case '?':
  302.                 return HELP;
  303.             case ALLDONE:
  304.                 return ALLDONE;
  305.             case INVALID:
  306.                 return INVALID;
  307.             case PARAMETER:
  308.                 if (do_param == NULL)
  309.                     return INVALID;
  310.                 if (do_param(argv[nextargv],param_num) == INVALID)
  311.                     return INVALID;
  312.                 nextargv++;
  313.                 param_num++;
  314.                 break;
  315.             default:
  316.  
  317.                 /* Search for the option in the option array. We are
  318.                  * guaranteed to find it.
  319.                  */
  320.  
  321.                 for (i = 0; i < num_opt; i++) {
  322.                     if (optarr[i].opt == opt)
  323.                         break;
  324.                     }
  325.                 if (optarr[i].type == OPT_SWITCH)
  326.                     *((bool*)optarr[i].arg) = true;
  327.                 else {
  328.                     if (parse_option(&optarr[i],argument) == INVALID)
  329.                         return INVALID;
  330.                     }
  331.                 break;
  332.             }
  333.         }
  334. }
  335.  
  336. PUBLIC void print_desc(int num_opt,Option optarr[])
  337. /****************************************************************************
  338. *
  339. * Function:        print_desc
  340. * Parameters:    num_opt    - Number of options in the table
  341. *                optarr    - Table of option descriptions
  342. *
  343. * Description:    Prints the description of each option in a standard format
  344. *                to the standard output device. The description for each
  345. *                option is obtained from the table of options.
  346. *
  347. ****************************************************************************/
  348. {
  349.     int        i;
  350.  
  351.     for (i = 0; i < num_opt; i++) {
  352.         if (optarr[i].type == OPT_SWITCH)
  353.             printf("  -%c       %s\n",optarr[i].opt,optarr[i].desc);
  354.         else
  355.             printf("  -%c<arg>  %s\n",optarr[i].opt,optarr[i].desc);
  356.         }
  357. }
  358.