/* -*-c-*-
*
- * $Id: mdwopt.c,v 1.7 1999/06/18 21:59:46 mdw Exp $
+ * $Id: mdwopt.c,v 1.8 1999/08/19 18:35:27 mdw Exp $
*
* Options parsing, similar to GNU @getopt_long@
*
/*----- Revision history --------------------------------------------------*
*
* $Log: mdwopt.c,v $
+ * Revision 1.8 1999/08/19 18:35:27 mdw
+ * Lots of reformatting. Spurious wing comments expunged.
+ *
* Revision 1.7 1999/06/18 21:59:46 mdw
* Fix stupid bug which only read one word from environment variables.
*
static const char *findOpt(int o, const char *shortopt,
mdwopt_data *data)
{
- const char *p = shortopt; /* Point to short opts table */
+ const char *p = shortopt;
for (;;) {
- if (!*p) /* No more options left */
+ if (!*p)
return (0);
if (o != *p || (p[1] != '+' && data->order & ORD_NEGATE)) {
- p++; /* Skip this option entry */
- while (*p == '+') /* Jump a `%|+|%' sign */
+ p++;
+ while (*p == '+')
+ p++;
+ while (*p == ':')
p++;
- while (*p == ':') /* And jump any `%|:|%' characters */
- p++; /* Just in case there are any */
}
else
return (p + 1);
{
/* --- Local variables --- */
- char *p, *q, *r; /* Some useful things to have */
- char *prefix; /* Prefix from this option */
- int i; /* Always useful */
- char noarg = '?'; /* Standard missing-arg char */
+ char *p, *q, *r;
+ char *prefix;
+ int i;
+ char noarg = '?';
/* --- Sort out our data --- */
- if (!data) /* If default data requested */
- data = &mdwopt_global; /* Then use the global stuff */
+ if (!data)
+ data = &mdwopt_global;
/* --- See if this is the first time --- */
/* --- Sort out default returning order --- */
- if (getenv("_POSIX_OPTION_ORDER") || /* Examine environment for opts */
- getenv("POSIXLY_CORRECT")) /* To see if we disable features */
- data->order = ORD_POSIX; /* If set, use POSIX ordering */
+ if (getenv("_POSIX_OPTION_ORDER") ||
+ getenv("POSIXLY_CORRECT"))
+ data->order = ORD_POSIX;
else
- data->order = ORD_PERMUTE; /* Otherwise mangle the options */
+ data->order = ORD_PERMUTE;
/* --- Now see what the caller actually wants --- */
- switch (shortopt[0]) { /* Look at the first character */
- case '-': /* `%|-|%' turns on in-orderness */
+ switch (shortopt[0]) {
+ case '-':
data->order = ORD_RETURN;
break;
- case '+': /* `%|+|%' turns on POSIXness */
+ case '+':
data->order = ORD_POSIX;
break;
- case '!': /* `%|!|%' ignores POSIXness */
+ case '!':
data->order = ORD_PERMUTE;
break;
}
if (!p) {
#endif
- p = buf; /* Point to a buffer */
- q = data->prog; /* Point to program name */
- while (*q) /* While characters left here */
- *p++ = toupper(*q++); /* Copy and uppercase */
- *p++ = 0; /* Terminate my copy of this */
- p = getenv(buf); /* Get the value of the variable */
+ p = buf;
+ q = data->prog;
+ while (*q)
+ *p++ = toupper(*q++);
+ *p++ = 0;
+ p = getenv(buf);
#ifdef __riscos
}
/* --- Copy the options string into a buffer --- */
- if (p) { /* If it is defined */
- q = malloc(strlen(p) + 1); /* Allocate space for a copy */
- if (!q) { /* If that failed */
- fprintf(stderr, /* Report a nice error */
+ if (p) {
+ q = malloc(strlen(p) + 1);
+ if (!q) {
+ fprintf(stderr,
"%s: Not enough memory to read settings in "
"environment variable\n",
data->prog);
- } else { /* Otherwise */
- strcpy(q, p); /* Copy the text over */
- data->ind = -1; /* Mark that we're parsing envvar */
- data->env = data->estart = q; /* And store the pointer away */
+ } else {
+ strcpy(q, p);
+ data->ind = -1;
+ data->env = data->estart = q;
}
}
shortopt++;
}
- if (longind) /* Allow longind to be null */
- *longind = -1; /* Clear this to avoid confusion */
- data->opt = -1; /* And this too */
- data->arg = 0; /* No option set up here */
+ if (longind)
+ *longind = -1;
+ data->opt = -1;
+ data->arg = 0;
/* --- Now go off and search for an option --- */
* There are some added little wrinkles, which we'll meet as we go.
*/
- for (;;) { /* Keep looping for a while */
- p = nextWord(argc, argv, data); /* Get the next word out */
- if (!p) /* If there's no next word */
- return (EOF); /* There's no more now */
+ for (;;) {
+ p = nextWord(argc, argv, data);
+ if (!p)
+ return (EOF);
/* --- See if we've found an option --- */
if ((p[0] == '-' || (p[0] == '+' && flags & OPTF_NEGATION)) &&
p[1] != 0) {
- if (strcmp(p, "--") == 0) { /* If this is the magic marker */
- permute(argv, data); /* Stow the magic marker item */
- return (EOF); /* There's nothing else to do */
+ if (strcmp(p, "--") == 0) {
+ permute(argv, data);
+ return (EOF);
}
- break; /* We've found something! */
+ break;
}
/* --- Figure out how to proceed --- */
switch (data->order & 3) {
- case ORD_POSIX: /* POSIX option order */
- return (EOF); /* This is easy */
+ case ORD_POSIX:
+ return (EOF);
break;
- case ORD_PERMUTE: /* Permute the option order */
+ case ORD_PERMUTE:
break;
- case ORD_RETURN: /* Return each argument */
- permute(argv, data); /* Insert word in same place */
- data->arg = p; /* Point to the argument */
- return (0); /* Return the value */
+ case ORD_RETURN:
+ permute(argv, data);
+ data->arg = p;
+ return (0);
}
}
/* --- We found an option --- */
- permute(argv, data); /* Do any permuting necessary */
+ permute(argv, data);
/* --- Check for a numeric option --- *
*
if (((p[0] == '-' && p[1] == '-') ||
(flags & OPTF_NOSHORTS && !findOpt(p[1], shortopt, data))) &&
- (~flags & OPTF_NOLONGS)) /* Is this a long option? */
+ (~flags & OPTF_NOLONGS))
{
- int match = -1; /* Count matches as we go */
+ int match = -1;
- if (p[0] == '+') { /* If it's negated */
- data->order |= ORD_NEGATE; /* Set the negate flag */
- p++; /* Point to the main text */
- prefix = "+"; /* Set the prefix string up */
- } else if (p[1] == '-') { /* If this is a `%|--|%' option */
+ if (p[0] == '+') {
+ data->order |= ORD_NEGATE;
+ p++;
+ prefix = "+";
+ } else if (p[1] == '-') {
if ((flags & OPTF_NEGATION) && strncmp(p + 2, "no-", 3) == 0) {
- p += 5; /* Point to main text */
- prefix = "--no-"; /* And set the prefix */
- data->order |= ORD_NEGATE; /* Set the negatedness flag */
+ p += 5;
+ prefix = "--no-";
+ data->order |= ORD_NEGATE;
} else {
- p += 2; /* Point to the main text */
- prefix = "--"; /* Remember the prefix string */
+ p += 2;
+ prefix = "--";
}
} else {
if ((flags & OPTF_NEGATION) && strncmp(p + 1, "no-", 3) == 0) {
- p += 4; /* Find the text */
- prefix = "-no-"; /* Set the prefix */
- data->order |= ORD_NEGATE; /* Set negatedness flag */
+ p += 4;
+ prefix = "-no-";
+ data->order |= ORD_NEGATE;
} else {
- p++; /* Otherwise find the text */
- prefix = "-"; /* And remember the prefix */
+ p++;
+ prefix = "-";
}
}
- for (i = 0; longopts[i].name; i++) { /* Loop through the options */
+ for (i = 0; longopts[i].name; i++) {
if ((data->order & ORD_NEGATE) &&
(~longopts[i].has_arg & OPTF_NEGATE))
- continue; /* If neg and opt doesn't allow */
-
- r = (char *) longopts[i].name; /* Point to the name string */
- q = p; /* Point to the string start */
- for (;;) { /* Do a loop here */
- if (*q == 0 || *q == '=') { /* End of the option string? */
- if (*r == 0) { /* If end of other string */
- match = i; /* This is the match */
- goto botched; /* And exit the loop now */
+ continue;
+
+ r = (char *) longopts[i].name;
+ q = p;
+ for (;;) {
+ if (*q == 0 || *q == '=') {
+ if (*r == 0) {
+ match = i;
+ goto botched;
}
- if (match == -1) { /* If no match currently */
- match = i; /* Then this is it, here */
- break; /* Stop looking now */
+ if (match == -1) {
+ match = i;
+ break;
} else {
- match = -1; /* Else it's ambiguous */
- goto botched; /* So give up right now */
+ match = -1;
+ goto botched;
}
}
- else if (*q != *r) /* Otherwise if mismatch */
- break; /* Abort this loop */
- q++, r++; /* Increment the counters */
+ else if (*q != *r)
+ break;
+ q++, r++;
}
}
botched:
- if (match == -1) { /* If we couldn't find a match */
+ if (match == -1) {
if (data->err) {
fprintf(stderr, "%s: unrecognized option `%s%s'\n",
data->prog,
return ('?');
}
- if (longind) /* Allow longind to be null */
- *longind = match; /* Store the match away */
+ if (longind)
+ *longind = match;
/* --- Handle argument behaviour --- */
- while (*p != 0 && *p != '=') /* Find the argument string */
+ while (*p != 0 && *p != '=')
p++;
- p = (*p ? p + 1 : 0); /* Sort out argument presence */
- q = (char *) longopts[match].name; /* Remember the name here */
+ p = (*p ? p + 1 : 0);
+ q = (char *) longopts[match].name;
- switch (longopts[match].has_arg & 3) {
- case no_argument:
+ switch (longopts[match].has_arg & OPTF_ARG) {
+ case OPTF_NOARG:
if (p) {
if (data->err) {
fprintf(stderr,
}
break;
- case required_argument:
- if (!p) { /* If no argument given */
+ case OPTF_ARGREQ:
+ if (!p) {
p = nextWord(argc, argv, data);
- if (!p) { /* If no more arguments */
+ if (!p) {
if (data->err) {
fprintf(stderr, "%s: option `%s%s' requires an argument\n",
data->prog,
}
break;
- case optional_argument:
+ case OPTF_ARGOPT:
/* Who cares? */
break;
}
/* --- Do correct things now we have a match --- */
- if (longopts[match].flag) { /* If he has a @flag@ argument */
+ if (longopts[match].flag) {
if (longopts[match].has_arg & OPTF_SWITCH) {
if (data->order & ORD_NEGATE)
*longopts[match].flag &= ~longopts[match].val;
else
*longopts[match].flag = longopts[match].val;
}
- return (0); /* And return something */
+ return (0);
} else {
if (data->order & ORD_NEGATE)
return (longopts[match].val | OPTF_NEGATED);
/* --- Do short options things --- */
else {
- if (p[0] == '+') /* If starts with a `%|+|%' */
+ if (p[0] == '+')
data->order |= ORD_NEGATE;
- data->list = p + 1; /* Omit leading `%|-|%'/`%|+|%' */
+ data->list = p + 1;
}
}
/* --- Now process the short options --- */
- i = *data->list++; /* Get the next option letter */
- data->opt = i; /* Store this away nicely */
+ i = *data->list++;
+ data->opt = i;
p = (char *) findOpt(i, shortopt, data);
- if (!p) { /* No more options left */
+ if (!p) {
if (data->err) {
fprintf(stderr, "%s: unknown option `%c%c'\n",
data->prog,
return ('?');
}
- data->opt = i; /* Store this for the caller */
+ data->opt = i;
/* --- Sort out an argument, if we expect one --- */
- if (p[0] == ':') { /* If we expect an option */
- q = (data->list[0] ? data->list : 0); /* If argument expected, use it */
- data->list = 0; /* Kill the remaining options */
- if (p[1] != ':' && !q) { /* If no arg, and not optional */
+ if (p[0] == ':') {
+ q = (data->list[0] ? data->list : 0);
+ data->list = 0;
+ if (p[1] != ':' && !q) {
/* --- Same code as before --- */
- q = nextWord(argc, argv, data); /* Read the next word */
- if (!q) { /* If no more arguments */
+ q = nextWord(argc, argv, data);
+ if (!q) {
if (data->err) {
fprintf(stderr, "%s: option `%c%c' requires an argument\n",
data->prog,
~mdw / cfd / commitdiff