orte/examples/ping/msvc/getopt_long.c

   1 #include <assert.h>
   2 #include <errno.h>
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <string.h>
   6 #include "getopt.h"
   7
   8 extern int        opterr;       /* if error message should be printed */
   9 extern int        optind;       /* index into parent argv vector */
  10 extern int        optopt;       /* character checked for validity */
  11 extern int        optreset;     /* reset getopt */
  12 extern char *optarg;    /* argument associated with option */
  13
  14 #define __P(x) x
  15 #define _DIAGASSERT(x) assert(x)
  16
  17 static char * __progname __P((char *));
  18 int getopt_internal __P((int, char * const *, const char *));
  19
  20 static char *
  21 __progname(nargv0)
  22         char * nargv0;
  23 {
  24         char * tmp;
  25
  26         _DIAGASSERT(nargv0 != NULL);
  27
  28         tmp = strrchr(nargv0, '/');
  29         if (tmp)
  30                 tmp++;
  31         else
  32                 tmp = nargv0;
  33         return(tmp);
  34 }
  35
  36 #define BADCH   (int)'?'
  37 #define BADARG  (int)':'
  38 #define EMSG    ""
  39
  40 /*
  41  * getopt --
  42  *      Parse argc/argv argument vector.
  43  */
  44 int
  45 getopt_internal(nargc, nargv, ostr)
  46         int nargc;
  47         char * const *nargv;
  48         const char *ostr;
  49 {
  50         static char *place = EMSG;              /* option letter processing */
  51         char *oli;                              /* option letter list index */
  52
  53         _DIAGASSERT(nargv != NULL);
  54         _DIAGASSERT(ostr != NULL);
  55
  56         if (optreset || !*place) {              /* update scanning pointer */
  57                 optreset = 0;
  58                 if (optind >= nargc || *(place = nargv[optind]) != '-') {
  59                         place = EMSG;
  60                         return (-1);
  61                 }
  62                 if (place[1] && *++place == '-') {      /* found "--" */
  63                         /* ++optind; */
  64                         place = EMSG;
  65                         return (-2);
  66                 }
  67         }                                       /* option letter okay? */
  68         if ((optopt = (int)*place++) == (int)':' ||
  69             !(oli = strchr(ostr, optopt))) {
  70                 /*
  71                  * if the user didn't specify '-' as an option,
  72                  * assume it means -1.
  73                  */
  74                 if (optopt == (int)'-')
  75                         return (-1);
  76                 if (!*place)
  77                         ++optind;
  78                 if (opterr && *ostr != ':')
  79                         (void)fprintf(stderr,
  80                             "%s: illegal option -- %c\n", __progname(nargv[0]), optopt);
  81                 return (BADCH);
  82         }
  83         if (*++oli != ':') {                    /* don't need argument */
  84                 optarg = NULL;
  85                 if (!*place)
  86                         ++optind;
  87         } else {                                /* need an argument */
  88                 if (*place)                     /* no white space */
  89                         optarg = place;
  90                 else if (nargc <= ++optind) {   /* no arg */
  91                         place = EMSG;
  92                         if ((opterr) && (*ostr != ':'))
  93                                 (void)fprintf(stderr,
  94                                     "%s: option requires an argument -- %c\n",
  95                                     __progname(nargv[0]), optopt);
  96                         return (BADARG);
  97                 } else                          /* white space */
  98                         optarg = nargv[optind];
  99                 place = EMSG;
 100                 ++optind;
 101         }
 102         return (optopt);                        /* dump back option letter */
 103 }
 104
 105 #if 0
 106 /*
 107  * getopt --
 108  *      Parse argc/argv argument vector.
 109  */
 110 int
 111 getopt2(nargc, nargv, ostr)
 112         int nargc;
 113         char * const *nargv;
 114         const char *ostr;
 115 {
 116         int retval;
 117
 118         if ((retval = getopt_internal(nargc, nargv, ostr)) == -2) {
 119                 retval = -1;
 120                 ++optind;
 121         }
 122         return(retval);
 123 }
 124 #endif
 125
 126 /*
 127  * getopt_long --
 128  *      Parse argc/argv argument vector.
 129  */
 130 int
 131 getopt_long(nargc, nargv, options, long_options, index)
 132         int nargc;
 133         char ** nargv;
 134         char * options;
 135         struct option * long_options;
 136         int * index;
 137 {
 138         int retval;
 139
 140         _DIAGASSERT(nargv != NULL);
 141         _DIAGASSERT(options != NULL);
 142         _DIAGASSERT(long_options != NULL);
 143         /* index may be NULL */
 144
 145         if ((retval = getopt_internal(nargc, nargv, options)) == -2) {
 146                 char *current_argv = nargv[optind++] + 2, *has_equal;
 147                 int i, current_argv_len, match = -1;
 148
 149                 if (*current_argv == '\0') {
 150                         return(-1);
 151                 }
 152                 if ((has_equal = strchr(current_argv, '=')) != NULL) {
 153                         current_argv_len = has_equal - current_argv;
 154                         has_equal++;
 155                 } else
 156                         current_argv_len = strlen(current_argv);
 157
 158                 for (i = 0; long_options[i].name; i++) {
 159                         if (strncmp(current_argv, long_options[i].name, current_argv_len))
 160                                 continue;
 161
 162                         if (strlen(long_options[i].name) == (unsigned)current_argv_len) {
 163                                 match = i;
 164                                 break;
 165                         }
 166                         if (match == -1)
 167                                 match = i;
 168                 }
 169                 if (match != -1) {
 170                         if (long_options[match].has_arg == required_argument ||
 171                             long_options[match].has_arg == optional_argument) {
 172                                 if (has_equal)
 173                                         optarg = has_equal;
 174                                 else
 175                                         optarg = nargv[optind++];
 176                         }
 177                         if ((long_options[match].has_arg == required_argument)
 178                             && (optarg == NULL)) {
 179                                 /*
 180                                  * Missing argument, leading :
 181                                  * indicates no error should be generated
 182                                  */
 183                                 if ((opterr) && (*options != ':'))
 184                                         (void)fprintf(stderr,
 185                                       "%s: option requires an argument -- %s\n",
 186                                       __progname(nargv[0]), current_argv);
 187                                 return (BADARG);
 188                         }
 189                 } else { /* No matching argument */
 190                         if ((opterr) && (*options != ':'))
 191                                 (void)fprintf(stderr,
 192                                     "%s: illegal option -- %s\n", __progname(nargv[0]), current_argv);
 193                         return (BADCH);
 194                 }
 195                 if (long_options[match].flag) {
 196                         *long_options[match].flag = long_options[match].val;
 197                         retval = 0;
 198                 } else
 199                         retval = long_options[match].val;
 200                 if (index)
 201                         *index = match;
 202         }
 203         return(retval);
 204 }
 205