getopt-1.0.3a/getopt.c

   1 /*
   2     getopt.c - Enhanced implementation of BSD getopt(1)
   3     Copyright (c) 1997, 1998  Frodo Looijaard <frodol@dds.nl>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18 */
  19
  20 /*
  21  * Version 1.0-b4: Tue Sep 23 1997. First public release.
  22  * Version 1.0: Wed Nov 19 1997.
  23  *   Bumped up the version number to 1.0
  24  *   Fixed minor typo (CSH instead of TCSH)
  25  * Version 1.0.1: Tue Jun 3 1998
  26  *   Fixed sizeof instead of strlen bug
  27  *   Bumped up the version number to 1.0.1
  28  * Version 1.0.2: Thu Jun 11 1998 (not present)
  29  *   Fixed gcc-2.8.1 warnings
  30  *   Fixed --version/-V option (not present)
  31  */
  32
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <unistd.h>
  37 #include <ctype.h>
  38
  39 #if LIBCGETOPT
  40 #include <getopt.h>
  41 #else
  42 #include "getopt.h"
  43 #endif
  44
  45 /* NON_OPT is the code that is returned when a non-option is found in '+'
  46    mode */
  47 #define NON_OPT 1
  48 /* LONG_OPT is the code that is returned when a long option is found. */
  49 #define LONG_OPT 2
  50
  51 /* The shells recognized. */
  52 typedef enum {BASH,TCSH} shell_t;
  53
  54
  55 /* Some global variables that tells us how to parse. */
  56 shell_t shell=BASH; /* The shell we generate output for. */
  57 int quiet_errors=0; /* 0 is not quiet. */
  58 int quiet_output=0; /* 0 is not quiet. */
  59 int quote=1; /* 1 is do quote. */
  60 int alternative=0; /* 0 is getopt_long, 1 is getopt_long_only */
  61
  62 /* Function prototypes */
  63 void *our_malloc(size_t size);
  64 void *our_realloc(void *ptr, size_t size);
  65 const char *normalize(const char *arg);
  66 int generate_output(char * argv[],int argc,const char *optstr,
  67                     const struct option *longopts);
  68 int main(int argc, char *argv[]);
  69 void parse_error(const char *message);
  70 void add_long_options(char *options);
  71 void add_longopt(const char *name,int has_arg);
  72 void print_help(void);
  73 void set_shell(const char *new_shell);
  74 void set_initial_shell(void);
  75
  76 void *our_malloc(size_t size)
  77 {
  78         void *ret=malloc(size);
  79         if (! ret) {
  80                 fputs("getopt: Out of memory!",stderr);
  81                 exit(3);
  82         }
  83         return(ret);
  84 }
  85
  86 void *our_realloc(void *ptr, size_t size)
  87 {
  88         void *ret=realloc(ptr,size);
  89         if (! ret && size) {
  90                 fputs("getopt: Out of memory!",stderr);
  91                 exit(3);
  92         }
  93         return(ret);
  94 }
  95
  96 /*
  97  * This function 'normalizes' a single argument: it puts single quotes around
  98  * it and escapes other special characters. If quote is false, it just
  99  * returns its argument.
 100  * Bash only needs special treatment for single quotes; tcsh also recognizes
 101  * exclamation marks within single quotes, and nukes whitespace.
 102  * This function returns a pointer to a buffer that is overwritten by
 103  * each call.
 104  */
 105 const char *normalize(const char *arg)
 106 {
 107         static char *BUFFER=NULL;
 108         const char *argptr=arg;
 109         char *bufptr;
 110
 111         if (BUFFER != NULL)
 112                 free(BUFFER);
 113
 114         if (!quote) { /* Just copy arg */
 115                 BUFFER=our_malloc(strlen(arg)+1);
 116
 117                 strcpy(BUFFER,arg);
 118                 return BUFFER;
 119         }
 120
 121         /* Each character in arg may take upto four characters in the result:
 122            For a quote we need a closing quote, a backslash, a quote and an
 123            opening quote! We need also the global opening and closing quote,
 124            and one extra character for '\0'. */
 125         BUFFER=our_malloc(strlen(arg)*4+3);
 126
 127         bufptr=BUFFER;
 128         *bufptr++='\'';
 129
 130         while (*argptr) {
 131                 if (*argptr == '\'') {
 132                         /* Quote: replace it with: '\'' */
 133                         *bufptr++='\'';
 134                         *bufptr++='\\';
 135                         *bufptr++='\'';
 136                         *bufptr++='\'';
 137                 } else if (shell==TCSH && *argptr=='!') {
 138                         /* Exclamation mark: replace it with: \! */
 139                         *bufptr++='\'';
 140                         *bufptr++='\\';
 141                         *bufptr++='!';
 142                         *bufptr++='\'';
 143                 } else if (shell==TCSH && *argptr=='\n') {
 144                         /* Newline: replace it with: \n */
 145                         *bufptr++='\\';
 146                         *bufptr++='n';
 147                 } else if (shell==TCSH && isspace(*argptr)) {
 148                         /* Non-newline whitespace: replace it with \<ws> */
 149                         *bufptr++='\'';
 150                         *bufptr++='\\';
 151                         *bufptr++=*argptr;
 152                         *bufptr++='\'';
 153                 } else
 154                         /* Just copy */
 155                         *bufptr++=*argptr;
 156                 argptr++;
 157         }
 158         *bufptr++='\'';
 159         *bufptr++='\0';
 160         return BUFFER;
 161 }
 162
 163 /*
 164  * Generate the output. argv[0] is the program name (used for reporting errors).
 165  * argv[1..] contains the options to be parsed. argc must be the number of
 166  * elements in argv (ie. 1 if there are no options, only the program name),
 167  * optstr must contain the short options, and longopts the long options.
 168  * Other settings are found in global variables.
 169  */
 170 int generate_output(char * argv[],int argc,const char *optstr,
 171                     const struct option *longopts)
 172 {
 173         int exit_code = 0; /* We assume everything will be OK */
 174         int opt;
 175         int longindex;
 176         const char *charptr;
 177
 178         if (quiet_errors) /* No error reporting from getopt(3) */
 179                 opterr=0;
 180         optind=0; /* Reset getopt(3) */
 181
 182         while ((opt = (alternative?
 183                       getopt_long_only(argc,argv,optstr,longopts,&longindex):
 184                       getopt_long(argc,argv,optstr,longopts,&longindex)))
 185                != EOF)
 186                 if (opt == '?' || opt == ':' )
 187                         exit_code = 1;
 188                 else if (!quiet_output)
 189                 {
 190                         if (opt == LONG_OPT) {
 191                                 printf(" --%s",longopts[longindex].name);
 192                                 if (longopts[longindex].has_arg)
 193                                         printf(" %s",
 194                                                normalize(optarg?optarg:""));
 195                         } else if (opt == NON_OPT)
 196                                 printf(" %s",normalize(optarg));
 197                         else {
 198                                 printf(" -%c",opt);
 199                                 charptr = strchr(optstr,opt);
 200                                 if (charptr != NULL && *++charptr == ':')
 201                                         printf(" %s",
 202                                                normalize(optarg?optarg:""));
 203                         }
 204                 }
 205
 206         if (! quiet_output) {
 207                 printf(" --");
 208                 while (optind < argc)
 209                         printf(" %s",normalize(argv[optind++]));
 210                 printf("\n");
 211         }
 212         return exit_code;
 213 }
 214
 215 /*
 216  * Report an error when parsing getopt's own arguments.
 217  * If message is NULL, we already sent a message, we just exit with a helpful
 218  * hint.
 219  */
 220 void parse_error(const char *message)
 221 {
 222         if (message)
 223                 fprintf(stderr,"getopt: %s\n",message);
 224         fputs("Try `getopt --help' for more information.\n",stderr);
 225         exit(2);
 226 }
 227
 228 static struct option *long_options=NULL;
 229 static int long_options_length=0; /* Length of array */
 230 static int long_options_nr=0; /* Nr of used elements in array */
 231 #define LONG_OPTIONS_INCR 10
 232 #define init_longopt() add_longopt(NULL,0)
 233
 234 /* Register a long option. The contents of name is copied. */
 235 void add_longopt(const char *name,int has_arg)
 236 {
 237         char *tmp;
 238         if (!name) { /* init */
 239                 free(long_options);
 240                 long_options=NULL;
 241                 long_options_length=0;
 242                 long_options_nr=0;
 243         }
 244
 245         if (long_options_nr == long_options_length) {
 246                 long_options_length += LONG_OPTIONS_INCR;
 247                 long_options=our_realloc(long_options,
 248                                          sizeof(struct option) *
 249                                            long_options_length);
 250         }
 251
 252         long_options[long_options_nr].name=NULL;
 253         long_options[long_options_nr].has_arg=0;
 254         long_options[long_options_nr].flag=NULL;
 255         long_options[long_options_nr].val=0;
 256
 257         if (long_options_nr) { /* Not for init! */
 258                 long_options[long_options_nr-1].has_arg=has_arg;
 259                 long_options[long_options_nr-1].flag=NULL;
 260                 long_options[long_options_nr-1].val=LONG_OPT;
 261                 tmp = our_malloc(strlen(name)+1);
 262                 strcpy(tmp,name);
 263                 long_options[long_options_nr-1].name=tmp;
 264         }
 265         long_options_nr++;
 266 }
 267
 268
 269 /*
 270  * Register several long options. options is a string of long options,
 271  * separated by commas or whitespace.
 272  * This nukes options!
 273  */
 274 void add_long_options(char *options)
 275 {
 276         int arg_opt;
 277         char *tokptr=strtok(options,", \t\n");
 278         while (tokptr) {
 279                 arg_opt=no_argument;
 280                 if (strlen(tokptr) > 0) {
 281                         if (tokptr[strlen(tokptr)-1] == ':') {
 282                                 if (tokptr[strlen(tokptr)-2] == ':') {
 283                                         tokptr[strlen(tokptr)-2]='\0';
 284                                         arg_opt=optional_argument;
 285                                 } else {
 286                                         tokptr[strlen(tokptr)-1]='\0';
 287                                         arg_opt=required_argument;
 288                                 }
 289                                 if (strlen(tokptr) == 0)
 290                                         parse_error("empty long option after "
 291                                                       "-l or --long argument");
 292                         }
 293                         add_longopt(tokptr,arg_opt);
 294                 }
 295                 tokptr=strtok(NULL,", \t\n");
 296         }
 297 }
 298
 299 void set_shell(const char *new_shell)
 300 {
 301         if (!strcmp(new_shell,"bash"))
 302                 shell=BASH;
 303         else if (!strcmp(new_shell,"tcsh"))
 304                 shell=TCSH;
 305         else if (!strcmp(new_shell,"sh"))
 306                 shell=BASH;
 307         else if (!strcmp(new_shell,"csh"))
 308                 shell=TCSH;
 309         else
 310                 parse_error("unknown shell after -s or --shell argument");
 311 }
 312
 313 void print_help(void)
 314 {
 315         fputs("Usage: getopt optstring parameters\n",stderr);
 316         fputs("       getopt [options] [--] optstring parameters\n",stderr);
 317         fputs("       getopt [options] -o|--options optstring [options] [--]\n",stderr);
 318         fputs("              parameters\n",stderr);
 319         fputs("  -a, --alternative            Allow long options starting with single -\n",stderr);
 320         fputs("  -h, --help                   This small usage guide\n",stderr);
 321         fputs("  -l, --longoptions=longopts   Long options to be recognized\n",stderr);
 322         fputs("  -n, --name=progname          The name under which errors are reported\n",stderr);
 323         fputs("  -o, --options=optstring      Short options to be recognized\n",stderr);
 324         fputs("  -q, --quiet                  Disable error reporting by getopt(3)\n",stderr);
 325         fputs("  -Q, --quiet-output           No normal output\n",stderr);
 326         fputs("  -s, --shell=shell            Set shell quoting conventions\n",stderr);
 327         fputs("  -T, --test                   Test for getopt(1) version\n",stderr);
 328         fputs("  -V, --version                Output version information\n",stderr);
 329         exit(2);
 330 }
 331
 332 /* Exit codes:
 333  *   0) No errors, succesful operation.
 334  *   1) getopt(3) returned an error.
 335  *   2) A problem with parameter parsing for getopt(1).
 336  *   3) Internal error, out of memory
 337  *   4) Returned for -T
 338  */
 339
 340 static struct option longopts[]={ {"options",required_argument,NULL,'o'},
 341                                   {"longoptions",required_argument,NULL,'l'},
 342                                   {"quiet",no_argument,NULL,'q'},
 343                                   {"quiet-output",no_argument,NULL,'Q'},
 344                                   {"shell",required_argument,NULL,'s'},
 345                                   {"test",no_argument,NULL,'T'},
 346                                   {"unquoted",no_argument,NULL,'u'},
 347                                   {"help",no_argument,NULL,'h'},
 348                                   {"alternative",no_argument,NULL,'a'},
 349                                   {"name",required_argument,NULL,'n'},
 350                                   {"version",no_argument,NULL,'V'},
 351                                   {NULL,0,NULL,0}
 352                                 };
 353
 354 /* Stop scanning as soon as a non-option argument is found! */
 355 static const char *shortopts="+ao:l:n:qQs:TuhV";
 356
 357 int main(int argc, char *argv[])
 358 {
 359         char *optstr=NULL;
 360         char *name=NULL;
 361         int opt;
 362         int compatible=0;
 363
 364         init_longopt();
 365
 366         if (getenv("GETOPT_COMPATIBLE"))
 367                 compatible=1;
 368
 369         if (argc == 1)
 370         {
 371                 if (compatible) {
 372                         /* For some reason, the original getopt gave no error
 373                            when there were no arguments. */
 374                         printf(" --\n");
 375                         exit(0);
 376                 }
 377                 else
 378                         parse_error("missing optstring argument");
 379         }
 380
 381         if (argv[1][0] != '-' || compatible) {
 382                 quote=0;
 383                 optstr=our_malloc(strlen(argv[1])+1);
 384                 strcpy(optstr,argv[1]+strspn(argv[1],"-+"));
 385                 argv[1]=argv[0];
 386                 exit(generate_output(argv+1,argc-1,optstr,long_options));
 387         }
 388
 389         while ((opt=getopt_long(argc,argv,shortopts,longopts,NULL)) != EOF)
 390                 switch (opt) {
 391                 case 'a':
 392                         alternative=1;
 393                         break;
 394                 case 'h':
 395                         print_help();
 396                         exit(0);
 397                 case 'o':
 398                         if (optstr)
 399                                 free(optstr);
 400                         optstr=our_malloc(strlen(optarg)+1);
 401                         strcpy(optstr,optarg);
 402                         break;
 403                 case 'l':
 404                         add_long_options(optarg);
 405                         break;
 406                 case 'n':
 407                         if (name)
 408                                 free(name);
 409                         name=our_malloc(strlen(optarg)+1);
 410                         strcpy(name,optarg);
 411                         break;
 412                 case 'q':
 413                         quiet_errors=1;
 414                         break;
 415                 case 'Q':
 416                         quiet_output=1;
 417                         break;
 418                 case 's':
 419                         set_shell(optarg);
 420                         break;
 421                 case 'T':
 422                         exit(4);
 423                 case 'V':
 424                         printf("getopt (enhanced) 1.0.3\n");
 425                         exit(0);
 426                 case '?':
 427                 case ':':
 428                         parse_error(NULL);
 429                 default:
 430                         parse_error("internal error, contact the author.");
 431                 }
 432
 433         if (!optstr)
 434         {
 435                 if (optind >= argc)
 436                         parse_error("missing optstring argument");
 437                 else {
 438                         optstr=our_malloc(strlen(argv[optind])+1);
 439                         strcpy(optstr,argv[optind]);
 440                         optind++;
 441                 }
 442         }
 443         if (name)
 444                 argv[optind-1]=name;
 445         else
 446                 argv[optind-1]=argv[0];
 447         exit(generate_output(argv+optind-1,argc-optind+1,optstr,long_options));
 448 }