codec/compat/getopt.c

   1 /*
   2  * Copyright (c) 1987, 1993, 1994
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by the University of
  16  *      California, Berkeley and its contributors.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 /* last review : october 29th, 2002 */
  35
  36 #if defined(LIBC_SCCS) && !defined(lint)
  37 static char sccsid[] = "@(#)getopt.c    8.3 (Berkeley) 4/27/95";
  38 #endif                          /* LIBC_SCCS and not lint */
  39
  40 #include <stdio.h>
  41 #include <stdlib.h>
  42 #include <string.h>
  43
  44 int opterr = 1,                 /* if error message should be printed */
  45  optind = 1,                    /* index into parent argv vector */
  46  optopt,                        /* character checked for validity */
  47  optreset;                      /* reset getopt */
  48 const char *optarg;                     /* argument associated with option */
  49
  50 typedef struct option
  51 {
  52         char *name;
  53         int has_arg;
  54         int *flag;
  55         int val;
  56 }option_t;
  57
  58 #define BADCH   (int)'?'
  59 #define BADARG  (int)':'
  60 #define EMSG    ""
  61
  62
  63
  64 static void getopterror(int which) {
  65         static char error1[]="Unknown option `-x'.\n";
  66         static char error2[]="Missing argument for `-x'.\n";
  67         if (opterr) {
  68                 if (which) {
  69                         error2[23]=optopt;
  70                         fprintf(stderr,"%s\n",error2);
  71
  72                 } else {
  73                         error1[17]=optopt;
  74                         fprintf(stderr,"%s\n",error1);
  75                 }
  76         }
  77 }
  78
  79
  80 /*
  81  * getopt --
  82  *      Parse argc/argv argument vector.
  83  */
  84 int getopt(int nargc, char *const *nargv, const char *ostr) {
  85 #  define __progname nargv[0]
  86   static const char *place = EMSG;      /* option letter processing */
  87   char *oli;                    /* option letter list index */
  88
  89   if (optreset || !*place) {    /* update scanning pointer */
  90     optreset = 0;
  91     if (optind >= nargc || *(place = nargv[optind]) != '-') {
  92       place = EMSG;
  93       return (-1);
  94     }
  95     if (place[1] && *++place == '-') {  /* found "--" */
  96       ++optind;
  97       place = EMSG;
  98       return (-1);
  99     }
 100   }                             /* option letter okay? */
 101   if ((optopt = (int) *place++) == (int) ':' ||
 102       !(oli = strchr(ostr, optopt))) {
 103     /*
 104      * if the user didn't specify '-' as an option,
 105      * assume it means -1.
 106      */
 107     if (optopt == (int) '-')
 108       return (-1);
 109     if (!*place)
 110       ++optind;
 111     if (opterr && *ostr != ':')
 112       (void) fprintf(stderr,
 113                      "%s: illegal option -- %c\n", __progname, optopt);
 114     return (BADCH);
 115   }
 116   if (*++oli != ':') {          /* don't need argument */
 117     optarg = NULL;
 118     if (!*place)
 119       ++optind;
 120   } else {                      /* need an argument */
 121     if (*place)                 /* no white space */
 122       optarg = place;
 123     else if (nargc <= ++optind) {       /* no arg */
 124       place = EMSG;
 125       if (*ostr == ':')
 126         return (BADARG);
 127       if (opterr)
 128         (void) fprintf(stderr,
 129                        "%s: option requires an argument -- %c\n",
 130                        __progname, optopt);
 131       return (BADCH);
 132     } else                      /* white space */
 133       optarg = nargv[optind];
 134     place = EMSG;
 135     ++optind;
 136   }
 137   return (optopt);              /* dump back option letter */
 138 }
 139
 140
 141 int getopt_long(int argc, char * const argv[], const char *optstring,
 142 struct option *longopts, int *longindex, int totlen) {
 143         static int lastidx,lastofs;
 144         char *tmp;
 145         int i,len;
 146 again:
 147         if (optind>argc || !argv[optind] || *argv[optind]!='-' || argv[optind][1]==0)
 148                 return -1;
 149
 150         if (argv[optind][0]=='-' && argv[optind][1]==0) {
 151                 ++optind;
 152                 return -1;
 153         }
 154
 155         if (argv[optind][0]=='-') {     /* long option */
 156                 char* arg=argv[optind]+1;
 157                 char* max=strchr(arg,'=');
 158                 const struct option* o;
 159                 if (!max) max=arg+strlen(arg);
 160                 o=longopts;
 161                 len=sizeof(longopts[0]);
 162
 163                 for (i=0;i<totlen;i=i+len,o++) {
 164                         if (!strncmp(o->name,arg,(size_t)(max-arg))) {  /* match */
 165                                 if (longindex) *longindex=o-longopts;
 166                                 if (o->has_arg>0) {
 167                                         if (*max=='=')
 168                                                 optarg=max+1;
 169                                         else {
 170                                                 optarg=argv[optind+1];
 171                                                 if(optarg){
 172                                                         if (strchr(optarg,'-')){ /* No argument */
 173                                                                 if (*optstring==':') return ':';
 174                                                                 if (opterr)
 175                                                                 (void) fprintf(stderr,"%s: option requires an argument %c\n",arg, optopt);
 176                                                                 return (BADCH);
 177                                                                 ++optind;
 178                                                         }
 179                                                 }
 180                                                 if (!optarg && o->has_arg==1) { /* no argument there */
 181                                                         if (*optstring==':') return ':';
 182                                                         if (opterr)
 183                                                         (void) fprintf(stderr,"%s: option requires an argument %c\n",arg, optopt);
 184                                                         return (BADCH);
 185                                                         ++optind;
 186                                                 }
 187                                                 ++optind;
 188                                         }
 189                                 }
 190                                 ++optind;
 191                                 if (o->flag)
 192                                         *(o->flag)=o->val;
 193                                 else
 194                                         return o->val;
 195                                 return 0;
 196                         }
 197                 }//(end for)
 198
 199                 if (*optstring==':') return ':';
 200
 201                 if (lastidx!=optind) {
 202                         lastidx=optind; lastofs=0;
 203                 }
 204                 optopt=argv[optind][lastofs+1];
 205
 206                 if ((tmp=strchr(optstring,optopt))) {
 207                         if (*tmp==0) {  /* apparently, we looked for \0, i.e. end of argument */
 208                                 ++optind;
 209                                 goto again;
 210                         }
 211
 212                         if (tmp[1]==':') {      /* argument expected */
 213                                 if (tmp[2]==':' || argv[optind][lastofs+2]) {   /* "-foo", return "oo" as optarg */
 214                                         if (!*(optarg=argv[optind]+lastofs+2)) optarg=0;
 215                                         goto found;
 216                                 }
 217
 218                                 optarg=argv[optind+1];
 219                                 if (!optarg) {  /* missing argument */
 220                                         ++optind;
 221                                         if (*optstring==':') return ':';
 222                                         getopterror(1);
 223                                         return ':';
 224                                 }
 225                                 ++optind;
 226                         }
 227                         else {
 228                                 ++lastofs;
 229                                 return optopt;
 230                         }
 231 found:
 232                         ++optind;
 233                         return optopt;
 234                 }
 235                 else {  /* not found */
 236                         getopterror(0);
 237                         ++optind;
 238                         return '?';
 239                 }
 240
 241                 fprintf(stderr,"Invalid option %s\n",arg);
 242                 ++optind;
 243                 return '?';
 244         }// end of long option
 245 }