src/bin/common/opj_getopt.c

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