applications/common/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         const 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 /* As this class remembers its values from one Java call to the other, reset the values before each use */
  63 void reset_options_reading() {
  64         opterr = 1;
  65         optind = 1;
  66 }
  67
  68 /*
  69  * getopt --
  70  *      Parse argc/argv argument vector.
  71  */
  72 int getopt(int nargc, char *const *nargv, const char *ostr) {
  73 #  define __progname nargv[0]
  74   static const char *place = EMSG;      /* option letter processing */
  75   char *oli;                    /* option letter list index */
  76
  77   if (optreset || !*place) {    /* update scanning pointer */
  78     optreset = 0;
  79     if (optind >= nargc || *(place = nargv[optind]) != '-') {
  80       place = EMSG;
  81       return (-1);
  82     }
  83     if (place[1] && *++place == '-') {  /* found "--" */
  84       ++optind;
  85       place = EMSG;
  86       return (-1);
  87     }
  88   }                             /* option letter okay? */
  89   if ((optopt = (int) *place++) == (int) ':' ||
  90       !(oli = strchr(ostr, optopt))) {
  91     /*
  92      * if the user didn't specify '-' as an option,
  93      * assume it means -1.
  94      */
  95     if (optopt == (int) '-')
  96       return (-1);
  97     if (!*place)
  98       ++optind;
  99                 if (opterr && *ostr != ':') {
 100       fprintf(stderr,
 101                      "%s: illegal option -- %c\n", __progname, optopt);
 102                         return (BADCH);
 103                 }
 104   }
 105   if (*++oli != ':') {          /* don't need argument */
 106     optarg = NULL;
 107     if (!*place)
 108       ++optind;
 109   } else {                      /* need an argument */
 110     if (*place)                 /* no white space */
 111       optarg = place;
 112     else if (nargc <= ++optind) {       /* no arg */
 113       place = EMSG;
 114       if (*ostr == ':')
 115         return (BADARG);
 116                         if (opterr) {
 117                                 fprintf(stderr,
 118                        "%s: option requires an argument -- %c\n",
 119                        __progname, optopt);
 120                                 return (BADCH);
 121                         }
 122     } else                      /* white space */
 123       optarg = nargv[optind];
 124     place = EMSG;
 125     ++optind;
 126   }
 127   return (optopt);              /* dump back option letter */
 128 }
 129
 130
 131 int getopt_long(int argc, char * const argv[], const char *optstring,
 132 const struct option *longopts, int totlen) {
 133         static int lastidx,lastofs;
 134         char *tmp;
 135         int i,len;
 136         char param = 1;
 137
 138 again:
 139         if (optind >= argc || !argv[optind] || *argv[optind]!='-')
 140                 return -1;
 141
 142         if (argv[optind][0]=='-' && argv[optind][1]==0) {
 143                 if(optind >= (argc - 1)){ /* no more input parameters */
 144                         param = 0;
 145                 }
 146                 else{ /* more input parameters */
 147                         if(argv[optind + 1][0] == '-'){
 148                                 param = 0; /* Missing parameter after '-' */
 149                         }
 150                         else{
 151                                 param = 2;
 152                         }
 153                 }
 154         }
 155
 156         if (param == 0) {
 157                 ++optind;
 158                 return (BADCH);
 159         }
 160
 161         if (argv[optind][0]=='-') {     /* long option */
 162                 char* arg=argv[optind]+1;
 163                 const struct option* o;
 164                 o=longopts;
 165                 len=sizeof(longopts[0]);
 166
 167                 if (param > 1){
 168                         arg = argv[optind+1];
 169                         optind++;
 170                 }
 171                 else
 172                         arg = argv[optind]+1;
 173
 174                 if(strlen(arg)>1){
 175                         for (i=0;i<totlen;i=i+len,o++) {
 176                                 if (!strcmp(o->name,arg)) {     /* match */
 177                                         if (o->has_arg == 0) {
 178                                                 if ((argv[optind+1])&&(!(argv[optind+1][0]=='-'))){
 179                                                         fprintf(stderr,"%s: option does not require an argument. Ignoring %s\n",arg,argv[optind+1]);
 180                                                         ++optind;
 181                                                 }
 182                                         }else{
 183                                                 optarg=argv[optind+1];
 184                                                 if(optarg){
 185                                                         if (optarg[0] == '-'){ /* Has read next input parameter: No arg for current parameter */
 186                                                                 if (opterr) {
 187                                                                         fprintf(stderr,"%s: option requires an argument\n",arg);
 188                                                                         return (BADCH);
 189                                                                 }
 190                                                         }
 191                                                 }
 192                                                 if (!optarg && o->has_arg==1) { /* no argument there */
 193                                                         if (opterr) {
 194                                                                 fprintf(stderr,"%s: option requires an argument \n",arg);
 195                                                                 return (BADCH);
 196                                                         }
 197                                                 }
 198                                                 ++optind;
 199                                         }
 200                                         ++optind;
 201                                         if (o->flag)
 202                                                 *(o->flag)=o->val;
 203                                         else
 204                                                 return o->val;
 205                                         return 0;
 206                                 }
 207                         }//(end for)String not found in the list
 208                         fprintf(stderr,"Invalid option %s\n",arg);
 209                         ++optind;
 210                         return (BADCH);
 211                 }else{ /*Single character input parameter*/
 212                         if (*optstring==':') return ':';
 213                         if (lastidx!=optind) {
 214                                 lastidx=optind; lastofs=0;
 215                         }
 216                         optopt=argv[optind][lastofs+1];
 217                         if ((tmp=strchr(optstring,optopt))) {/*Found input parameter in list*/
 218                                 if (*tmp==0) {  /* apparently, we looked for \0, i.e. end of argument */
 219                                         ++optind;
 220                                         goto again;
 221                                 }
 222                                 if (tmp[1]==':') {      /* argument expected */
 223                                         if (tmp[2]==':' || argv[optind][lastofs+2]) {   /* "-foo", return "oo" as optarg */
 224                                                 if (!*(optarg=argv[optind]+lastofs+2)) optarg=0;
 225                                                 goto found;
 226                                         }
 227                                         optarg=argv[optind+1];
 228                                         if(optarg){
 229                                                 if (optarg[0] == '-'){ /* Has read next input parameter: No arg for current parameter */
 230                                                         if (opterr) {
 231                                                                 fprintf(stderr,"%s: option requires an argument\n",arg);
 232                                                                 return (BADCH);
 233                                                         }
 234                                                 }
 235                                         }
 236                                         if (!optarg) {  /* missing argument */
 237                                                 if (opterr) {
 238                                                         fprintf(stderr,"%s: option requires an argument\n",arg);
 239                                                         return (BADCH);
 240                                                 }
 241                                         }
 242                                         ++optind;
 243                                 }else {/*Argument not expected*/
 244                                         ++lastofs;
 245                                         return optopt;
 246                                 }
 247 found:
 248                                 ++optind;
 249                                 return optopt;
 250                         }       else {  /* not found */
 251                                 fprintf(stderr,"Invalid option %s\n",arg);
 252                                 ++optind;
 253                                 return (BADCH);
 254                         }//end of not found
 255
 256                 }// end of single character
 257         }//end '-'
 258         fprintf(stderr,"Invalid option\n");
 259         ++optind;
 260         return (BADCH);;
 261 }//end function