home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Reference Guide / C-C++ Interactive Reference Guide.iso / c_ref / csource5 / 332_01 / getopt.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-03-30  |  8.2 KB  |  295 lines
  1. /*----------------------------------------------------*- Fundamental -*-
  2.  
  3. Module:        getopt()    [X/OPEN]
  4.  
  5. File:        getopt.c
  6.  
  7. Assoc. files:    config.h    (but see below)
  8.  
  9. Description:    This module implements a command line parser. It 
  10.         returns option flags (specified by the user) and
  11.         associated values (if any) to the calling program.
  12.  
  13. Notes:        This module began life as a Pascal routine for Oregon
  14.         Software's Pascal-2 compiler, and was later rewritten
  15.         into C.  
  16.  
  17. Acknowl.:    Some features of the AT&T public domain getopt()
  18.         released to Usenet have been incorporated:
  19.  
  20.         *  It is now possible to use syscalls for error
  21.            messages. I disagree slightly with this: the
  22.            only reason I can think of is to avoid getting
  23.            the stdio-package in linkage. getopt() is likely
  24.            to be used in programs where code size is a minor
  25.            issue. However, I've made it configurable.
  26.  
  27. Author:        Anders Thulin
  28.         Rydsvagen 288
  29.         S-582 50 Linkoping
  30.         SWEDEN
  31.  
  32. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  33.  
  34. This program/module/routine has been developed as a part of `The Source Code
  35. Project', a personal attempt at producing well-written, portable software
  36. primarily intended to be executed in the ANSI C and POSIX / X/OPEN Unix
  37. environments.
  38.  
  39. The program/module/routine is hereby placed in the public domain, which
  40. means that it may be freely copied, sold for profit or for fun, praised or
  41. buried as your fancy takes you.
  42.  
  43. Comments on the portability and adaptability of the program/module/routine
  44. will be appreciated, and, if they result in modifications, acknowledged in
  45. future releases.
  46.  
  47. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
  48.  
  49. Edit history :
  50.  
  51. Vers  Ed   Date        By                Comments
  52. ----  ---  ----------  ----------------  -------------------------------
  53.  1.0    0  1987-12-18  Anders Thulin     Initial version
  54.         1  1988-06-06  Anders Thulin     Got a copy of the AT&T public
  55.                      domain getopt(). Changed
  56.                      a few things to the better.
  57.  
  58. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  59.  
  60. /* #include "config.h" -- included below:  */
  61.  
  62. /*----------------------------------------------------*- Fundamental -*-
  63.  
  64. Module:            getopt(3c)
  65.  
  66. File:            config.h
  67.  
  68. Associated files:    getopt.c
  69.  
  70. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  71.  
  72. /*---  Configuration:  ------------------------------------------------
  73.  
  74. getopt() may write error messages to stderr. 
  75.  
  76.   USE_STDIO == 0    Use write(2, ...) for error messages
  77.   USE_STDIO == 1    Use fprintf(stderr, ...) for error messages
  78.  
  79. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  80.  
  81. #define USE_STDIO    1    /* Default is 1 */
  82.  
  83. /* -- end of "config.h" */
  84.  
  85. #include <assert.h>
  86. #include <stdio.h>        /* for EOF and (optionally) fprintf() */
  87. #include <string.h>
  88.  
  89. char   *optarg = (char *) 0;    /* Points to option argument (if any)    */
  90. int    opterr = 1;        /* Enable error reporting        */
  91. int    optind = 1;        /* Begin with argv[optind]        */
  92.  
  93.  
  94. #define BUMP(p)    (*++p == '\0' ? (optind++, (char *) 0) : p)
  95.  
  96. #if USE_STDIO
  97. # define ERROR(pname, s, ch)        \
  98.     do {                                \
  99.       if (opterr != 0) {                        \
  100.              fprintf(stderr, "%s: %s -- '%c'\n", pname, (s), (ch));    \
  101.           }                                \
  102.         } while (0)
  103. #else
  104. # define ERROR(pname, s, c)    do {                    \
  105.               if (opterr != 0) {            \
  106. #if __STDC__ != 0                        \
  107.                     extern int write(int, char *, unsigned);     \
  108. #else                                \
  109.                 extern int write();            \
  110. #endif                                \
  111.                 char errbuf[4];            \
  112.                 errbuf[0] = errbuf[2] = '\'';    \
  113.                 errbuf[1] = (c); errbuf[3] = '\0';    \
  114.                 write(2, (pname), strlen(pname));    \
  115.                 write(2, ": " s " -- ", strlen(s)+6); \
  116.                 write(2, errbuf,  strlen(errbuf));    \
  117.               }                    \
  118.             } while (1 == 0)
  119. #endif /* USE_STDIO */
  120.  
  121.  
  122. /*----------------------------------------------------------------------
  123.  
  124. Routine:    getopt
  125.  
  126. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  127.  
  128. int getopt(argc, argv, optstring)
  129. int   argc;
  130. char *argv[];
  131. char *optstring;
  132. {
  133.   static char *ap = (char *) 0;
  134.   char  *vp;
  135.   char   ch;
  136.  
  137.   optarg = (char *) 0;        /* Presume no-argument option        */
  138.  
  139.   if (optind >= argc) {        /* Reached end of argv[]        */
  140.     return EOF;
  141.   }
  142.  
  143.  /*
  144.   *  ap points into argv[optind], and is used to keep track of how far
  145.   *  we have parsed the current option string.  Remember that an argv[]
  146.   *  string may contain several separate option letters (e.g.  the line
  147.   *  'foo -abc -x -y' contains five option letters, but only three 
  148.   *  arguments).
  149.   *
  150.   *  If ap == 0, we have reached a new string.  Check that it *is* a
  151.   *  legal option, that is:
  152.   *
  153.   *  +  check that the first character is '-'
  154.   *  +  check that the string isn't "-"
  155.   *  +  check that the string isn't "--"
  156.   *
  157.   */
  158.  
  159.   if (ap == (char *) 0) {
  160.     ap = argv[optind];
  161.  
  162.     if (*ap != '-') {        /* Doesn't begin with '-' -- not an option */
  163.       ap = (char *) 0;
  164.       return EOF;
  165.     }
  166.  
  167.     ap++;            /* Examine second character */
  168.  
  169.     if (*ap == '\0') {        /* String was "-" -- not an option */
  170.       ap = (char *) 0;
  171.       return EOF;
  172.     }
  173.  
  174.     if (*ap == '-' && *(ap+1) == '\0') {    /* String is "--" -- n.a.o. */
  175.       ap = (char *) 0;
  176.       optind++;
  177.       return EOF;
  178.     }
  179.   }
  180.  
  181.  /*
  182.   *  At this point we know that the string appears to be an option string.
  183.   *  Check that the current character really is one of those specified in
  184.   *  'optstring' (remember, ':' is NOT a permissible option character, as
  185.   *  it is used in optstring to specify that the option takes an argument).
  186.   *
  187.   *  Also note that strchr() treats the terminating NUL character as a part
  188.   *  of the string -- hence strchr() always finds NUL in optstring.  The
  189.   *  routine relies on ch never taking the value NUL.
  190.   *
  191.   */
  192.  
  193.   ch = *ap;
  194.   assert(ch != '\0');
  195.  
  196.   if (ch == ':' || (vp = strchr(optstring, ch)) == (char *) 0) {
  197.     ERROR(argv[0], "illegal option", ch);
  198.     ap = BUMP(ap);
  199.     return '?';
  200.   }
  201.  
  202.  /*
  203.   *  ch is a permissible option letter, and vp points to it in optstring.
  204.   *  If it takes an argument, that is it is followed by ':' in optstring,
  205.   *  extract the argument, and set optarg to point to it.  If not, just
  206.   *  return the option letter.
  207.   *
  208.   */
  209.  
  210.   if (*++vp == ':') {
  211.     optarg = BUMP(ap);
  212.     if (optarg == (char *) 0) {     /* option value might be in next argument */
  213.       if (optind >= argc) {     /* No, it wasn't */
  214.         ERROR(argv[0], "option requires an argument", ch);
  215.         ch = '?';
  216.       }
  217.       else {
  218.         optarg = argv[optind];
  219.       }
  220.     }
  221.     optind++;
  222.     ap = (char *) 0;
  223.   }
  224.   else {
  225.     ap = BUMP(ap);
  226.   }
  227.  
  228.   return ch;
  229. }
  230.     
  231. #ifdef TEST
  232.  
  233. /*----------------------------------------------------------------------
  234.  
  235. Routine:    main()
  236.  
  237. Description:    This routine provides confidence testing of the
  238.         getopt() routine.  It is rather    crude at present.  A
  239.         better way of doing things would be to build argument
  240.         structures in memory, sending them to getopt(), and
  241.         check that the returned values are as expected.  
  242.  
  243. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  244.  
  245. int main(argc, argv)
  246. int    argc;
  247. char   *argv[];
  248. {
  249.   int    c;
  250.   char *opts = "abcd:g0%";
  251.  
  252.   extern char *optarg;
  253.   extern int   optind;
  254.  
  255.   fprintf(stderr, "optstring = '%s'\n", opts);
  256.  
  257.   while ( (c = getopt(argc, argv, opts)) != EOF) {
  258.     switch(c) {
  259.       default :
  260.         fprintf(stderr, "getopt() returned unknown character (0x%x)\n", c);
  261.         break;
  262.  
  263.       case '?' :
  264.         fprintf(stderr, "getopt() returned '?' -- error detected\n");
  265.         break;
  266.  
  267.       case 'a' :
  268.       case 'b' :
  269.       case 'c' :
  270.       case 'g' :
  271.       case '0' :
  272.       case '%' :
  273.         fprintf(stderr, "getopt() returned option letter %c\n", c);
  274.         break;
  275.  
  276.       case 'd' :
  277.         fprintf(stderr, "getopt() returned option letter %c\n", c);
  278.         fprintf(stderr, "option value is '%s'\n", optarg);
  279.         break;
  280.    
  281.     }
  282.   }
  283.  
  284.   fprintf(stderr, "end of option list detected\n");
  285.   if (optind < argc) {
  286.     fprintf(stderr, "remaining arguments are:\n");
  287.     for ( ; optind <argc; optind++) {
  288.       fprintf(stderr, "argv[%d] = '%s'\n", optind, argv[optind]);
  289.     }
  290.   }
  291.  
  292.   return 0;
  293. }
  294. #endif
  295.