Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  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. 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
  262.