1 /*****************************************************************************
2 *
3 * MODULE NAME : GETOPT.C
4 *
5 * COPYRIGHTS:
6 * This module contains code made available by IBM
7 * Corporation on an AS IS basis. Any one receiving the
8 * module is considered to be licensed under IBM copyrights
9 * to use the IBM-provided source code in any way he or she
10 * deems fit, including copying it, compiling it, modifying
11 * it, and redistributing it, with or without
12 * modifications. No license under any IBM patents or
13 * patent applications is to be implied from this copyright
14 * license.
15 *
16 * A user of the module should understand that IBM cannot
17 * provide technical support for the module and will not be
18 * responsible for any consequences of use of the program.
19 *
20 * Any notices, including this one, are not to be removed
21 * from the module without the prior written consent of
22 * IBM.
23 *
24 * AUTHOR: Original author:
25 * G. R. Blair (BOBBLAIR at AUSVM1)
26 * Internet: bobblair@bobblair.austin.ibm.com
27 *
28 * Extensively revised by:
29 * John Q. Walker II, Ph.D. (JOHHQ at RALVM6)
30 * Internet: johnq@ralvm6.vnet.ibm.com
31 *
32 *****************************************************************************/
33 /******************************************************************************
34 * getopt()
35 *
36 * The getopt() function is a command line parser. It returns the next
37 * option character in argv that matches an option character in opstring.
38 *
39 * The argv argument points to an array of argc+1 elements containing argc
40 * pointers to character strings followed by a null pointer.
41 *
42 * The opstring argument points to a string of option characters; if an
43 * option character is followed by a colon, the option is expected to have
44 * an argument that may or may not be separated from it by white space.
45 * The external variable optarg is set to point to the start of the option
46 * argument on return from getopt().
47 *
48 * The getopt() function places in optind the argv index of the next argument
49 * to be processed. The system initializes the external variable optind to
50 * 1 before the first call to getopt().
51 *
52 * When all options have been processed (that is, up to the first nonoption
53 * argument), getopt() returns EOF. The special option "--" may be used to
54 * delimit the end of the options; EOF will be returned, and "--" will be
55 * skipped.
56 *
57 * The getopt() function returns a question mark (?) when it encounters an
58 * option character not included in opstring. This error message can be
59 * disabled by setting opterr to zero. Otherwise, it returns the option
60 * character that was detected.
61 *
62 * If the special option "--" is detected, or all options have been
63 * processed, EOF is returned.
64 *
65 * Options are marked by either a minus sign (-) or a slash (/).
66 *
67 * No errors are defined.
68 *****************************************************************************/
69
70 #include <dxconfig.h>
71 #if !defined(HAVE_GETOPT)
72
73 #include <stdio.h> /* for EOF */
74 #include <string.h> /* for strchr() */
75 /* static (global) variables that are specified as exported by getopt() */
76 char *optarg = NULL; /* pointer to the start of the option argument */
77 int optind = 1; /* number of the next argv[] to be evaluated */
78 int opterr = 1; /* non-zero if a question mark should be returned
79 when a non-valid option character is detected */
80 /* handle possible future character set concerns by putting this in a macro */
81 #define _next_char(string) (char)(*(string+1))
getopt(int argc,char * argv[],char * opstring)82 int getopt(int argc, char *argv[], char *opstring)
83 {
84 static char *pIndexPosition = NULL; /* place inside current argv string */
85 char *pArgString = NULL; /* where to start from next */
86 char *pOptString; /* the string in our program */
87 if (pIndexPosition != NULL) {
88 /* we last left off inside an argv string */
89 if (*(++pIndexPosition)) {
90 /* there is more to come in the most recent argv */
91 pArgString = pIndexPosition;
92 }
93 }
94 if (pArgString == NULL) {
95 /* we didn't leave off in the middle of an argv string */
96 if (optind >= argc) {
97 /* more command-line arguments than the argument count */
98 pIndexPosition = NULL; /* not in the middle of anything */
99 return EOF; /* used up all command-line arguments */
100 }
101 /*---------------------------------------------------------------------
102 * If the next argv[] is not an option, there can be no more options.
103 *-------------------------------------------------------------------*/
104 pArgString = argv[optind++]; /* set this to the next argument ptr */
105 if (('/' != *pArgString) && /* doesn't start with a slash or a dash? */
106 ('-' != *pArgString)) {
107 --optind; /* point to current arg once we're done */
108 optarg = NULL; /* no argument follows the option */
109 pIndexPosition = NULL; /* not in the middle of anything */
110 return EOF; /* used up all the command-line flags */
111 }
112 /* check for special end-of-flags markers */
113 if ((strcmp(pArgString, "-") == 0) ||
114 (strcmp(pArgString, "--") == 0)) {
115 optarg = NULL; /* no argument follows the option */
116 pIndexPosition = NULL; /* not in the middle of anything */
117 return EOF; /* encountered the special flag */
118 }
119 pArgString++; /* look past the / or - */
120 }
121 if (':' == *pArgString) { /* is it a colon? */
122 /*---------------------------------------------------------------------
123 * Rare case: if opterr is non-zero, return a question mark;
124 * otherwise, just return the colon we're on.
125 *-------------------------------------------------------------------*/
126 return (opterr ? (int)'?' : (int)':');
127 }
128 else if ((pOptString = strchr(opstring, *pArgString)) == 0) {
129 /*---------------------------------------------------------------------
130 * The letter on the command-line wasn't any good.
131 *-------------------------------------------------------------------*/
132 optarg = NULL; /* no argument follows the option */
133 pIndexPosition = NULL; /* not in the middle of anything */
134 return (opterr ? (int)'?' : (int)*pArgString);
135 }
136 else {
137 /*---------------------------------------------------------------------
138 * The letter on the command-line matches one we expect to see
139 *-------------------------------------------------------------------*/
140 if (':' == _next_char(pOptString)) { /* is the next letter a colon? */
141 /* It is a colon. Look for an argument string. */
142 if ('\0' != _next_char(pArgString)) { /* argument in this argv? */
143 optarg = &pArgString[1]; /* Yes, it is */
144 }
145 else {
146 /*-------------------------------------------------------------
147 * The argument string must be in the next argv.
148 * But, what if there is none (bad input from the user)?
149 * In that case, return the letter, and optarg as NULL.
150 *-----------------------------------------------------------*/
151 if (optind < argc)
152 optarg = argv[optind++];
153 else {
154 optarg = NULL;
155 return (opterr ? (int)'?' : (int)*pArgString);
156 }
157 }
158 pIndexPosition = NULL; /* not in the middle of anything */
159 }
160 else {
161 /* it's not a colon, so just return the letter */
162 optarg = NULL; /* no argument follows the option */
163 pIndexPosition = pArgString; /* point to the letter we're on */
164 }
165 return (int)*pArgString; /* return the letter that matched */
166 }
167 }
168
169 #endif
170