277 lines
6.7 KiB
C
277 lines
6.7 KiB
C
/*
|
|
* 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
|
|
*/
|
|
|
|
/*
|
|
* If you want, include stdio.h or something where EOF and NULL are defined.
|
|
* However, egetopt() is written so as not to need stdio.h, which should
|
|
* make it significantly smaller on some systems.
|
|
*/
|
|
|
|
#ifndef EOF
|
|
# define EOF (-1)
|
|
#endif /* ! EOF */
|
|
|
|
#ifndef NULL
|
|
# define NULL (char *)0
|
|
#endif /* ! NULL */
|
|
|
|
/*
|
|
* None of these constants are referenced in the executable portion of
|
|
* the code ... their sole purpose is to initialize global variables.
|
|
*/
|
|
#define BADCH (int)'?'
|
|
#define NEEDSEP (int)':'
|
|
#define MAYBESEP (int)'\0'
|
|
#define ERRFD 2
|
|
#define EMSG ""
|
|
#define START "-"
|
|
|
|
/*
|
|
* Here are all the pertinent global variables.
|
|
*/
|
|
int opterr = 1; /* if true, output error message */
|
|
int optind = 1; /* index into parent argv vector */
|
|
int optopt; /* character checked for validity */
|
|
int optbad = BADCH; /* character returned on error */
|
|
int optchar = 0; /* character that begins returned option */
|
|
int optneed = NEEDSEP; /* flag for mandatory argument */
|
|
int optmaybe = MAYBESEP;/* flag for optional argument */
|
|
int opterrfd = ERRFD; /* file descriptor for error text */
|
|
char *optarg; /* argument associated with option */
|
|
char *optstart = START; /* list of characters that start options */
|
|
|
|
|
|
/*
|
|
* Macros.
|
|
*/
|
|
|
|
/*
|
|
* Conditionally print out an error message and return (depends on the
|
|
* setting of 'opterr' and 'opterrfd'). Note that this version of
|
|
* TELL() doesn't require the existence of stdio.h.
|
|
*/
|
|
#define TELL(S) { \
|
|
if (opterr && opterrfd >= 0) { \
|
|
char option = optopt; \
|
|
write(opterrfd, *nargv, strlen(*nargv)); \
|
|
write(opterrfd, (S), strlen(S)); \
|
|
write(opterrfd, &option, 1); \
|
|
write(opterrfd, "\n", 1); \
|
|
} \
|
|
return (optbad); \
|
|
}
|
|
|
|
/*
|
|
* This works similarly to index() and strchr(). I include it so that you
|
|
* don't need to be concerned as to which one your system has.
|
|
*/
|
|
static char *
|
|
_sindex(string, ch)
|
|
char *string;
|
|
int ch;
|
|
{
|
|
if (string != NULL) {
|
|
for (; *string != '\0'; ++string) {
|
|
if (*string == (char)ch) {
|
|
return (string);
|
|
}
|
|
}
|
|
}
|
|
|
|
return (NULL);
|
|
}
|
|
|
|
/*
|
|
* Here it is:
|
|
*/
|
|
int
|
|
egetopt(nargc, nargv, ostr)
|
|
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 <= optind || nargv[optind] == NULL) {
|
|
return (EOF);
|
|
}
|
|
|
|
if (place == NULL) {
|
|
place = EMSG;
|
|
}
|
|
|
|
/*
|
|
* Update scanning pointer.
|
|
*/
|
|
if (*place == '\0') {
|
|
place = nargv[optind];
|
|
if (place == NULL) {
|
|
return (EOF);
|
|
}
|
|
osi = _sindex(optstart, *place);
|
|
if (osi != NULL) {
|
|
optchar = (int)*osi;
|
|
}
|
|
if (optind >= nargc || osi == NULL || *++place == '\0') {
|
|
return (EOF);
|
|
}
|
|
|
|
/*
|
|
* Two adjacent, identical flag characters were found.
|
|
* This takes care of "--", for example.
|
|
*/
|
|
if (*place == place[-1]) {
|
|
++optind;
|
|
return (EOF);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If the option is a separator or the option isn't in the list,
|
|
* we've got an error.
|
|
*/
|
|
optopt = (int)*place++;
|
|
oli = _sindex(ostr, optopt);
|
|
if (optopt == optneed || optopt == optmaybe || oli == NULL) {
|
|
/*
|
|
* If we're at the end of the current argument, bump the
|
|
* argument index.
|
|
*/
|
|
if (*place == '\0') {
|
|
++optind;
|
|
}
|
|
TELL(": illegal option -- "); /* byebye */
|
|
}
|
|
|
|
/*
|
|
* If there is no argument indicator, then we don't even try to
|
|
* return an argument.
|
|
*/
|
|
++oli;
|
|
if (*oli == '\0' || (*oli != optneed && *oli != optmaybe)) {
|
|
/*
|
|
* If we're at the end of the current argument, bump the
|
|
* argument index.
|
|
*/
|
|
if (*place == '\0') {
|
|
++optind;
|
|
}
|
|
optarg = 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') {
|
|
optarg = 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 == optneed) {
|
|
/*
|
|
* If we're at the end of the argument list, there
|
|
* isn't an argument and hence we have an error.
|
|
* Otherwise, make 'optarg' point to the argument.
|
|
*/
|
|
if (nargc <= ++optind) {
|
|
place = EMSG;
|
|
TELL(": option requires an argument -- ");
|
|
}
|
|
else {
|
|
optarg = nargv[optind];
|
|
}
|
|
}
|
|
/*
|
|
* If we're here it must have been an optional argument.
|
|
*/
|
|
else {
|
|
if (nargc <= ++optind) {
|
|
place = EMSG;
|
|
optarg = NULL;
|
|
}
|
|
else {
|
|
optarg = nargv[optind];
|
|
if (optarg == NULL) {
|
|
place = EMSG;
|
|
}
|
|
/*
|
|
* If the next item begins with a flag
|
|
* character, we treat it like a new
|
|
* argument. This is accomplished by
|
|
* decrementing 'optind' and returning
|
|
* a null argument.
|
|
*/
|
|
else if (_sindex(optstart, *optarg) != NULL) {
|
|
--optind;
|
|
optarg = NULL;
|
|
}
|
|
}
|
|
}
|
|
place = EMSG;
|
|
++optind;
|
|
}
|
|
|
|
/*
|
|
* Return option letter.
|
|
*/
|
|
return (optopt);
|
|
}
|