Added the dirent.h file used for opening and reading Directory holding image files...
[openjpeg.git] / codec / compat / getopt.c
index baf35a4067e847c97dc21f6036ed3cd5743f5793..29404b60a89d7b41772f443198fa0d3323d585a7 100644 (file)
 
 #if defined(LIBC_SCCS) && !defined(lint)
 static char sccsid[] = "@(#)getopt.c   8.3 (Berkeley) 4/27/95";
-#endif                                                                                                 /* LIBC_SCCS and not lint */
+#endif                         /* LIBC_SCCS and not lint */
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
-int opterr = 1,                                                                        /* if error message should be printed */
- optind = 1,                                                                           /* index into parent argv vector */
- optopt,                                                                                               /* character checked for validity */
- optreset;                                                                                     /* reset getopt */
-char *optarg;                                                                          /* argument associated with option */
+int opterr = 1,                        /* if error message should be printed */
+ optind = 1,                   /* index into parent argv vector */
+ optopt,                       /* character checked for validity */
+ optreset;                     /* reset getopt */
+const char *optarg;                    /* argument associated with option */
+
+typedef struct option
+{
+       char *name;
+       int has_arg;
+       int *flag;
+       int val;
+}option_t;
 
 #define        BADCH   (int)'?'
 #define        BADARG  (int)':'
 #define        EMSG    ""
 
+
+
+static void getopterror(int which) {
+       static char error1[]="Unknown option `-x'.\n";
+       static char error2[]="Missing argument for `-x'.\n";
+       if (opterr) {
+               if (which) {
+                       error2[23]=optopt;
+                       fprintf(stderr,"%s\n",error2);
+                       
+               } else {
+                       error1[17]=optopt;
+                       fprintf(stderr,"%s\n",error1);
+               }
+       }
+}
+
+
 /*
  * getopt --
  *     Parse argc/argv argument vector.
  */
-int getopt(nargc, nargv, ostr)
-int nargc;
-char *const *nargv;
-const char *ostr;
-{
+int getopt(int nargc, char *const *nargv, const char *ostr) {
 #  define __progname nargv[0]
-       static char *place = EMSG;              /* option letter processing */
-       char *oli;                                                                              /* option letter list index */
-
-       if (optreset || !*place) {              /* update scanning pointer */
-               optreset = 0;
-               if (optind >= nargc || *(place = nargv[optind]) != '-') {
-                       place = EMSG;
-                       return (-1);
+  static const char *place = EMSG;     /* option letter processing */
+  char *oli;                   /* option letter list index */
+
+  if (optreset || !*place) {   /* update scanning pointer */
+    optreset = 0;
+    if (optind >= nargc || *(place = nargv[optind]) != '-') {
+      place = EMSG;
+      return (-1);
+    }
+    if (place[1] && *++place == '-') { /* found "--" */
+      ++optind;
+      place = EMSG;
+      return (-1);
+    }
+  }                            /* option letter okay? */
+  if ((optopt = (int) *place++) == (int) ':' ||
+      !(oli = strchr(ostr, optopt))) {
+    /*
+     * if the user didn't specify '-' as an option,
+     * assume it means -1.
+     */
+    if (optopt == (int) '-')
+      return (-1);
+    if (!*place)
+      ++optind;
+               if (opterr && *ostr != ':') {
+      fprintf(stderr,
+                    "%s: illegal option -- %c\n", __progname, optopt);
+                       return (BADCH);
                }
-               if (place[1] && *++place == '-') {      /* found "--" */
-                       ++optind;
-                       place = EMSG;
-                       return (-1);
+  }
+  if (*++oli != ':') {         /* don't need argument */
+    optarg = NULL;
+    if (!*place)
+      ++optind;
+  } else {                     /* need an argument */
+    if (*place)                        /* no white space */
+      optarg = place;
+    else if (nargc <= ++optind) {      /* no arg */
+      place = EMSG;
+      if (*ostr == ':')
+       return (BADARG);
+                       if (opterr) {
+                               fprintf(stderr,
+                      "%s: option requires an argument -- %c\n",
+                      __progname, optopt);
+                               return (BADCH);
+                       }
+    } else                     /* white space */
+      optarg = nargv[optind];
+    place = EMSG;
+    ++optind;
+  }
+  return (optopt);             /* dump back option letter */
+}
+
+
+int getopt_long(int argc, char * const argv[], const char *optstring,
+struct option *longopts, int *longindex, int totlen) {
+       static int lastidx,lastofs;
+       char *tmp;
+       int i,len;
+again:
+       if (optind>argc || !argv[optind] || *argv[optind]!='-' || argv[optind][1]==0)
+               return -1;
+
+       if (argv[optind][0]=='-' && argv[optind][1]==0) {
+               ++optind;
+               return -1;
+       }
+
+       if (argv[optind][0]=='-') {     /* long option */
+               char* arg=argv[optind]+1;
+               char* max=strchr(arg,'=');
+               const struct option* o;
+               if (!max) max=arg+strlen(arg);
+               o=longopts;
+               len=sizeof(longopts[0]);
+
+               for (i=0;i<totlen;i=i+len,o++) {
+                       if (!strncmp(o->name,arg,(size_t)(max-arg))) {  /* match */
+                               if (longindex) *longindex=o-longopts;
+                               if (o->has_arg>0) {
+                                       if (*max=='=')
+                                               optarg=max+1;
+                                       else {
+                                               optarg=argv[optind+1];
+                                               if(optarg){
+                                                       if (strchr(optarg,'-')){ /* No argument */
+                                                               if (*optstring==':') return ':';
+                                                               if (opterr) {
+                                                                       fprintf(stderr,"%s: option requires an argument %c\n",arg, optopt);
+                                                                       return (BADCH);
+                                                               }
+                                                               ++optind;
+                                                       }
+                                               }
+                                               if (!optarg && o->has_arg==1) { /* no argument there */
+                                                       if (*optstring==':') return ':';
+                                                       if (opterr) {
+                                                               fprintf(stderr,"%s: option requires an argument %c\n",arg, optopt);
+                                                               return (BADCH);                                                 
+                                                       }
+                                                       ++optind;
+                                               }
+                                               ++optind;
+                                       }
+                               }
+                               ++optind;
+                               if (o->flag)
+                                       *(o->flag)=o->val;
+                               else
+                                       return o->val;
+                               return 0;
+                       }
+               }//(end for)
+
+               if (*optstring==':') return ':';
+
+               if (lastidx!=optind) {
+                       lastidx=optind; lastofs=0;
                }
-       }                                                                                                                       /* option letter okay? */
-       if ((optopt = (int) *place++) == (int) ':' ||
-                       !(oli = strchr(ostr, optopt))) {
-               /*
-                * if the user didn't specify '-' as an option,
-                * assume it means -1.
-                */
-               if (optopt == (int) '-')
-                       return (-1);
-               if (!*place)
+               optopt=argv[optind][lastofs+1];
+
+               if ((tmp=strchr(optstring,optopt))) {
+                       if (*tmp==0) {  /* apparently, we looked for \0, i.e. end of argument */
+                               ++optind;
+                               goto again;
+                       }
+
+                       if (tmp[1]==':') {      /* argument expected */
+                               if (tmp[2]==':' || argv[optind][lastofs+2]) {   /* "-foo", return "oo" as optarg */
+                                       if (!*(optarg=argv[optind]+lastofs+2)) optarg=0;
+                                       goto found;
+                               }
+
+                               optarg=argv[optind+1];
+                               if (!optarg) {  /* missing argument */
+                                       ++optind;
+                                       if (*optstring==':') return ':';
+                                       getopterror(1);
+                                       return ':';
+                               }
+                               ++optind;
+                       }
+                       else {
+                               ++lastofs;
+                               return optopt;
+                       }
+found:
                        ++optind;
-               if (opterr && *ostr != ':')
-                       (void) fprintf(stderr,
-                                                                                "%s: illegal option -- %c\n", __progname, optopt);
-               return (BADCH);
-       }
-       if (*++oli != ':') {                                    /* don't need argument */
-               optarg = NULL;
-               if (!*place)
+                       return optopt;
+               } 
+               else {  /* not found */
+                       getopterror(0);
                        ++optind;
-       } else {                                                                                        /* need an argument */
-               if (*place)                                                                     /* no white space */
-                       optarg = place;
-               else if (nargc <= ++optind) {   /* no arg */
-                       place = EMSG;
-                       if (*ostr == ':')
-                               return (BADARG);
-                       if (opterr)
-                               (void) fprintf(stderr,
-                                                                                        "%s: option requires an argument -- %c\n",
-                                                                                        __progname, optopt);
-                       return (BADCH);
-               } else                                                                                  /* white space */
-                       optarg = nargv[optind];
-               place = EMSG;
+                       return '?';
+               }
+               
+               fprintf(stderr,"Invalid option %s\n",arg);
                ++optind;
-       }
-       return (optopt);                                                        /* dump back option letter */
+               return '?';
+       }// end of long option
+       return (BADCH);
 }