getopt.c

   1 /*****************************************************************************
   2  *
   3  *  MODULE NAME : GETOPT.C
   4  *
   5  *  COPYRIGHTS:
   6  *             This module contains code made available by IBM
   7  *             Corporation on an AS IS basis.  Any one receiving the
   8  *             module is considered to be licensed under IBM copyrights
   9  *             to use the IBM-provided source code in any way he or she
  10  *             deems fit, including copying it, compiling it, modifying
  11  *             it, and redistributing it, with or without
  12  *             modifications.  No license under any IBM patents or
  13  *             patent applications is to be implied from this copyright
  14  *             license.
  15  *
  16  *             A user of the module should understand that IBM cannot
  17  *             provide technical support for the module and will not be
  18  *             responsible for any consequences of use of the program.
  19  *
  20  *             Any notices, including this one, are not to be removed
  21  *             from the module without the prior written consent of
  22  *             IBM.
  23  *
  24  *  AUTHOR:   Original author:
  25  *                 G. R. Blair (BOBBLAIR at AUSVM1)
  26  *                 Internet: bobblair@bobblair.austin.ibm.com
  27  *
  28  *            Extensively revised by:
  29  *                 John Q. Walker II, Ph.D. (JOHHQ at RALVM6)
  30  *                 Internet: johnq@ralvm6.vnet.ibm.com
  31  *
  32  *****************************************************************************/
  33
  34 /******************************************************************************
  35  * getopt()
  36  *
  37  * The getopt() function is a command line parser.  It returns the next
  38  * option character in argv that matches an option character in opstring.
  39  *
  40  * The argv argument points to an array of argc+1 elements containing argc
  41  * pointers to character strings followed by a null pointer.
  42  *
  43  * The opstring argument points to a string of option characters; if an
  44  * option character is followed by a colon, the option is expected to have
  45  * an argument that may or may not be separated from it by white space.
  46  * The external variable optarg is set to point to the start of the option
  47  * argument on return from getopt().
  48  *
  49  * The getopt() function places in optind the argv index of the next argument
  50  * to be processed.  The system initializes the external variable optind to
  51  * 1 before the first call to getopt().
  52  *
  53  * When all options have been processed (that is, up to the first nonoption
  54  * argument), getopt() returns EOF.  The special option "--" may be used to
  55  * delimit the end of the options; EOF will be returned, and "--" will be
  56  * skipped.
  57  *
  58  * The getopt() function returns a question mark (?) when it encounters an
  59  * option character not included in opstring.  This error message can be
  60  * disabled by setting opterr to zero.  Otherwise, it returns the option
  61  * character that was detected.
  62  *
  63  * If the special option "--" is detected, or all options have been
  64  * processed, EOF is returned.
  65  *
  66  * Options are marked by either a minus sign (-) or a slash (/).
  67  *
  68  * No errors are defined.
  69  *****************************************************************************/
  70
  71 #ifndef WIN32
  72 #include "config.h"
  73 #endif
  74
  75 #ifndef HAVE_GETOPT
  76
  77
  78 #include <stdio.h>                  /* for EOF */
  79 #include <string.h>                 /* for strchr() */
  80
  81
  82 /* static (global) variables that are specified as exported by getopt() */
  83 char *optarg = NULL;    /* pointer to the start of the option argument  */
  84 int   optind = 1;       /* number of the next argv[] to be evaluated    */
  85 int   opterr = 1;       /* non-zero if a question mark should be returned
  86                            when a non-valid option character is detected */
  87
  88 /* handle possible future character set concerns by putting this in a macro */
  89 #define _next_char(string)  (char)(*(string+1))
  90
  91 int getopt(int argc, char *argv[], char *opstring)
  92 {
  93     static char *pIndexPosition = NULL; /* place inside current argv string */
  94     char *pArgString = NULL;        /* where to start from next */
  95     char *pOptString;               /* the string in our program */
  96
  97
  98     if (pIndexPosition != NULL) {
  99         /* we last left off inside an argv string */
 100         if (*(++pIndexPosition)) {
 101             /* there is more to come in the most recent argv */
 102             pArgString = pIndexPosition;
 103         }
 104     }
 105
 106     if (pArgString == NULL) {
 107         /* we didn't leave off in the middle of an argv string */
 108         if (optind >= argc) {
 109             /* more command-line arguments than the argument count */
 110             pIndexPosition = NULL;  /* not in the middle of anything */
 111             return EOF;             /* used up all command-line arguments */
 112         }
 113
 114         /*---------------------------------------------------------------------
 115          * If the next argv[] is not an option, there can be no more options.
 116          *-------------------------------------------------------------------*/
 117         pArgString = argv[optind++]; /* set this to the next argument ptr */
 118
 119         if (('/' != *pArgString) && /* doesn't start with a slash or a dash? */
 120             ('-' != *pArgString)) {
 121             --optind;               /* point to current arg once we're done */
 122             optarg = NULL;          /* no argument follows the option */
 123             pIndexPosition = NULL;  /* not in the middle of anything */
 124             return EOF;             /* used up all the command-line flags */
 125         }
 126
 127         /* check for special end-of-flags markers */
 128         if ((strcmp(pArgString, "-") == 0) ||
 129             (strcmp(pArgString, "--") == 0)) {
 130             optarg = NULL;          /* no argument follows the option */
 131             pIndexPosition = NULL;  /* not in the middle of anything */
 132             return EOF;             /* encountered the special flag */
 133         }
 134
 135         pArgString++;               /* look past the / or - */
 136     }
 137
 138     if (':' == *pArgString) {       /* is it a colon? */
 139         /*---------------------------------------------------------------------
 140          * Rare case: if opterr is non-zero, return a question mark;
 141          * otherwise, just return the colon we're on.
 142          *-------------------------------------------------------------------*/
 143         return (opterr ? (int)'?' : (int)':');
 144     }
 145     else if ((pOptString = strchr(opstring, *pArgString)) == 0) {
 146         /*---------------------------------------------------------------------
 147          * The letter on the command-line wasn't any good.
 148          *-------------------------------------------------------------------*/
 149         optarg = NULL;              /* no argument follows the option */
 150         pIndexPosition = NULL;      /* not in the middle of anything */
 151         return (opterr ? (int)'?' : (int)*pArgString);
 152     }
 153     else {
 154         /*---------------------------------------------------------------------
 155          * The letter on the command-line matches one we expect to see
 156          *-------------------------------------------------------------------*/
 157         if (':' == _next_char(pOptString)) { /* is the next letter a colon? */
 158             /* It is a colon.  Look for an argument string. */
 159             if ('\0' != _next_char(pArgString)) {  /* argument in this argv? */
 160                 optarg = &pArgString[1];   /* Yes, it is */
 161             }
 162             else {
 163                 /*-------------------------------------------------------------
 164                  * The argument string must be in the next argv.
 165                  * But, what if there is none (bad input from the user)?
 166                  * In that case, return the letter, and optarg as NULL.
 167                  *-----------------------------------------------------------*/
 168                 if (optind < argc)
 169                     optarg = argv[optind++];
 170                 else {
 171                     optarg = NULL;
 172                     return (opterr ? (int)'?' : (int)*pArgString);
 173                 }
 174             }
 175             pIndexPosition = NULL;  /* not in the middle of anything */
 176         }
 177         else {
 178             /* it's not a colon, so just return the letter */
 179             optarg = NULL;          /* no argument follows the option */
 180             pIndexPosition = pArgString;    /* point to the letter we're on */
 181         }
 182         return (int)*pArgString;    /* return the letter that matched */
 183     }
 184 }
 185
 186
 187 #endif