From 4ab923c488adf11a9fd2be93afc8a8d9828268b8 Mon Sep 17 00:00:00 2001 From: mdw Date: Thu, 19 Aug 1999 18:35:27 +0000 Subject: [PATCH] Lots of reformatting. Spurious wing comments expunged. --- mdwopt.c | 235 ++++++++++++++++++++++++++++++++------------------------------- 1 file changed, 119 insertions(+), 116 deletions(-) diff --git a/mdwopt.c b/mdwopt.c index 1717d2d..fcea1b6 100644 --- a/mdwopt.c +++ b/mdwopt.c @@ -1,6 +1,6 @@ /* -*-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@ * @@ -30,6 +30,9 @@ /*----- 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. * @@ -190,17 +193,17 @@ static void permute(char *const *argv, mdwopt_data *data) 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); @@ -406,15 +409,15 @@ int mdwopt(int argc, char *const *argv, { /* --- 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 --- */ @@ -422,22 +425,22 @@ int mdwopt(int argc, char *const *argv, /* --- 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; } @@ -479,12 +482,12 @@ int mdwopt(int argc, char *const *argv, 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 } @@ -492,17 +495,17 @@ int mdwopt(int argc, char *const *argv, /* --- 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; } } @@ -531,10 +534,10 @@ int mdwopt(int argc, char *const *argv, 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 --- */ @@ -554,40 +557,40 @@ int mdwopt(int argc, char *const *argv, * 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 --- * * @@ -614,63 +617,63 @@ int mdwopt(int argc, char *const *argv, 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, @@ -679,18 +682,18 @@ int mdwopt(int argc, char *const *argv, 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, @@ -702,11 +705,11 @@ int mdwopt(int argc, char *const *argv, } 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, @@ -719,7 +722,7 @@ int mdwopt(int argc, char *const *argv, } break; - case optional_argument: + case OPTF_ARGOPT: /* Who cares? */ break; } @@ -727,7 +730,7 @@ int mdwopt(int argc, char *const *argv, /* --- 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; @@ -739,7 +742,7 @@ int mdwopt(int argc, char *const *argv, 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); @@ -751,19 +754,19 @@ int mdwopt(int argc, char *const *argv, /* --- 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, @@ -773,19 +776,19 @@ int mdwopt(int argc, char *const *argv, 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, -- 2.11.0