1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
|
/* egetopt.c -- Extended 'getopt'.
*
* A while back, a public-domain version of getopt() was posted to the
* net. A bit later, a gentleman by the name of Keith Bostic made some
* enhancements and reposted it.
*
* In recent weeks (i.e., early-to-mid 1988) there's been some
* heated discussion in comp.lang.c about the merits and drawbacks
* of getopt(), especially with regard to its handling of '?'.
*
* In light of this, I have taken Mr. Bostic's public-domain getopt()
* and have made some changes that I hope will be considered to be
* improvements. I call this routine 'egetopt' ("Extended getopt").
* The default behavior of this routine is the same as that of getopt(),
* but it has some optional features that make it more useful. These
* options are controlled by the settings of some global variables.
* By not setting any of these extra global variables, you will have
* the same functionality as getopt(), which should satisfy those
* purists who believe getopt() is perfect and can never be improved.
* If, on the other hand, you are someone who isn't satisfied with the
* status quo, egetopt() may very well give you the added capabilities
* you want.
*
* Look at the enclosed README file for a description of egetopt()'s
* new features.
*
* The code was originally posted to the net as getopt.c by ...
*
* Keith Bostic
* ARPA: keith@seismo
* UUCP: seismo!keith
*
* Current version: added enhancements and comments, reformatted code.
*
* Lloyd Zusman
* Master Byte Software
* Los Gatos, California
* Internet: ljz@fx.com
* UUCP: ...!ames!fxgrp!ljz
*
* May, 1988
*
* This version is slightly adapted for use by smenu.
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include "getopt.h"
/* Here are all the pertinent global variables. */
/* """""""""""""""""""""""""""""""""""""""""""" */
int eopterr = 1; /* if true, output error message */
int eoptind = 1; /* index into parent argv vector */
int eoptopt; /* character checked for validity */
int eoptbad = BADCH; /* character returned on error */
int eoptchar = 0; /* character that begins returned option */
int eoptneed = NEEDSEP; /* flag for mandatory argument */
int eoptmaybe = MAYBESEP; /* flag for optional argument */
int eopterrfd = ERRFD; /* file descriptor for error text */
char * eoptarg = NULL; /* argument associated with option */
char * eoptstart = START; /* list of characters that start options */
/* Here it is: */
/* """"""""""" */
int
egetopt(int nargc, char ** nargv, char * ostr)
{
static char * place = EMSG; /* option letter processing */
register char * oli; /* option letter list index */
register char * osi = NULL; /* option start list index */
if (nargv == (char **)NULL)
return (EOF);
if (nargc <= eoptind || nargv[eoptind] == NULL)
return (EOF);
if (place == NULL)
place = EMSG;
/* Update scanning pointer. */
/* """""""""""""""""""""""" */
if (*place == '\0')
{
place = nargv[eoptind];
if (place == NULL)
return (EOF);
else if (*place == '\0')
return (EOF);
osi = strchr(eoptstart, *place);
if (osi != NULL)
eoptchar = (int)*osi;
if (eoptind >= nargc || osi == NULL || *++place == '\0')
return (EOF);
/* Two adjacent, identical flag characters were found. */
/* This takes care of "--", for example. */
/* """"""""""""""""""""""""""""""""""""""""""""""""""" */
if (*place == place[-1])
{
++eoptind;
return (EOF);
}
}
/* If the option is a separator or the option isn't in the list, */
/* we've got an error. */
/* """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""" */
eoptopt = (int)*place++;
oli = strchr(ostr, eoptopt);
if (eoptopt == eoptneed || eoptopt == (int)eoptmaybe || oli == NULL)
{
/* If we're at the end of the current argument, bump the */
/* argument index. */
/* """"""""""""""""""""""""""""""""""""""""""""""""""""" */
if (*place == '\0')
++eoptind;
TELL("Illegal option -- "); /* bye bye */
return (eoptbad);
}
/* If there is no argument indicator, then we don't even try to */
/* return an argument. */
/* """""""""""""""""""""""""""""""""""""""""""""""""""""""""""" */
++oli;
if (*oli == '\0' || (*oli != (char)eoptneed && *oli != (char)eoptmaybe))
{
/* If we're at the end of the current argument, bump the */
/* argument index. */
/* """"""""""""""""""""""""""""""""""""""""""""""""""""" */
if (*place == '\0')
++eoptind;
eoptarg = NULL;
}
/* If we're here, there's an argument indicator. It's handled */
/* differently depending on whether it's a mandatory or an */
/* optional argument. */
/* """"""""""""""""""""""""""""""""""""""""""""""""""""""""""" */
else
{
/* If there's no white space, use the rest of the */
/* string as the argument. In this case, it doesn't */
/* matter if the argument is mandatory or optional. */
/* """"""""""""""""""""""""""""""""""""""""""""""""" */
if (*place != '\0')
eoptarg = place;
/* If we're here, there's whitespace after the option. */
/* */
/* Is it a mandatory argument? If so, return the */
/* next command-line argument if there is one. */
/* """"""""""""""""""""""""""""""""""""""""""""""""""" */
else if (*oli == (char)eoptneed)
{
/* If we're at the end of the argument list, there */
/* isn't an argument and hence we have an error. */
/* Otherwise, make 'eoptarg' point to the argument. */
/* """""""""""""""""""""""""""""""""""""""""""""""" */
if (nargc <= ++eoptind)
{
place = EMSG;
TELL("Option requires an argument -- ");
return (eoptbad);
}
else
eoptarg = nargv[eoptind];
}
/* If we're here it must have been an optional argument. */
/* """"""""""""""""""""""""""""""""""""""""""""""""""""" */
else
{
if (nargc <= ++eoptind)
{
place = EMSG;
eoptarg = NULL;
}
else
{
eoptarg = nargv[eoptind];
if (eoptarg == NULL)
place = EMSG;
/* If the next item begins with a flag */
/* character, we treat it like a new */
/* argument. This is accomplished by */
/* decrementing 'eoptind' and returning */
/* a null argument. */
/* """""""""""""""""""""""""""""""""""" */
else if (strchr(eoptstart, *eoptarg) != NULL)
{
--eoptind;
eoptarg = NULL;
}
}
}
place = EMSG;
++eoptind;
}
/* Return option letter. */
/* """"""""""""""""""""" */
return (eoptopt);
}
|
