diff options
Diffstat (limited to 'src/scanopt.c')
-rw-r--r-- | src/scanopt.c | 814 |
1 files changed, 814 insertions, 0 deletions
diff --git a/src/scanopt.c b/src/scanopt.c new file mode 100644 index 0000000..a118541 --- /dev/null +++ b/src/scanopt.c @@ -0,0 +1,814 @@ +/* flex - tool to generate fast lexical analyzers */ + +/* Copyright (c) 1990 The Regents of the University of California. */ +/* All rights reserved. */ + +/* This code is derived from software contributed to Berkeley by */ +/* Vern Paxson. */ + +/* The United States Government has rights in this work pursuant */ +/* to contract no. DE-AC03-76SF00098 between the United States */ +/* Department of Energy and the University of California. */ + +/* This file is part of flex. */ + +/* Redistribution and use in source and binary forms, with or without */ +/* modification, are permitted provided that the following conditions */ +/* are met: */ + +/* 1. Redistributions of source code must retain the above copyright */ +/* notice, this list of conditions and the following disclaimer. */ +/* 2. Redistributions in binary form must reproduce the above copyright */ +/* notice, this list of conditions and the following disclaimer in the */ +/* documentation and/or other materials provided with the distribution. */ + +/* Neither the name of the University nor the names of its contributors */ +/* may be used to endorse or promote products derived from this software */ +/* without specific prior written permission. */ + +/* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */ +/* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */ +/* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */ +/* PURPOSE. */ + +#include "flexdef.h" +#include "scanopt.h" + + +/* Internal structures */ + +#define ARG_NONE 0x01 +#define ARG_REQ 0x02 +#define ARG_OPT 0x04 +#define IS_LONG 0x08 + +struct _aux { + int flags; /* The above hex flags. */ + int namelen; /* Length of the actual option word, e.g., "--file[=foo]" is 4 */ + int printlen; /* Length of entire string, e.g., "--file[=foo]" is 12 */ +}; + + +struct _scanopt_t { + const optspec_t *options; /* List of options. */ + struct _aux *aux; /* Auxiliary data about options. */ + int optc; /* Number of options. */ + int argc; /* Number of args. */ + char **argv; /* Array of strings. */ + int index; /* Used as: argv[index][subscript]. */ + int subscript; + char no_err_msg; /* If true, do not print errors. */ + char has_long; + char has_short; +}; + +/* Accessor functions. These WOULD be one-liners, but portability calls. */ +static const char *NAME(struct _scanopt_t *, int); +static int PRINTLEN(struct _scanopt_t *, int); +static int RVAL(struct _scanopt_t *, int); +static int FLAGS(struct _scanopt_t *, int); +static const char *DESC(struct _scanopt_t *, int); +static int scanopt_err(struct _scanopt_t *, int, int); +static int matchlongopt(char *, char **, int *, char **, int *); +static int find_opt(struct _scanopt_t *, int, char *, int, int *, int *opt_offset); + +static const char *NAME (struct _scanopt_t *s, int i) +{ + return s->options[i].opt_fmt + + ((s->aux[i].flags & IS_LONG) ? 2 : 1); +} + +static int PRINTLEN (struct _scanopt_t *s, int i) +{ + return s->aux[i].printlen; +} + +static int RVAL (struct _scanopt_t *s, int i) +{ + return s->options[i].r_val; +} + +static int FLAGS (struct _scanopt_t *s, int i) +{ + return s->aux[i].flags; +} + +static const char *DESC (struct _scanopt_t *s, int i) +{ + return s->options[i].desc ? s->options[i].desc : ""; +} + +#ifndef NO_SCANOPT_USAGE +static int get_cols (void); + +static int get_cols (void) +{ + char *env; + int cols = 80; /* default */ + +#ifdef HAVE_NCURSES_H + initscr (); + endwin (); + if (COLS > 0) + return COLS; +#endif + + if ((env = getenv ("COLUMNS")) != NULL) + cols = atoi (env); + + return cols; +} +#endif + +/* Macro to check for NULL before assigning a value. */ +#define SAFE_ASSIGN(ptr,val) \ + do{ \ + if((ptr)!=NULL) \ + *(ptr) = val; \ + }while(0) + +/* Macro to assure we reset subscript whenever we adjust s->index.*/ +#define INC_INDEX(s,n) \ + do{ \ + (s)->index += (n); \ + (s)->subscript= 0; \ + }while(0) + +scanopt_t *scanopt_init (const optspec_t *options, int argc, char **argv, int flags) +{ + int i; + struct _scanopt_t *s; + s = malloc(sizeof (struct _scanopt_t)); + + s->options = options; + s->optc = 0; + s->argc = argc; + s->argv = (char **) argv; + s->index = 1; + s->subscript = 0; + s->no_err_msg = (flags & SCANOPT_NO_ERR_MSG); + s->has_long = 0; + s->has_short = 0; + + /* Determine option count. (Find entry with all zeros). */ + s->optc = 0; + while (options[s->optc].opt_fmt + || options[s->optc].r_val || options[s->optc].desc) + s->optc++; + + /* Build auxiliary data */ + s->aux = malloc((size_t) s->optc * sizeof (struct _aux)); + + for (i = 0; i < s->optc; i++) { + const unsigned char *p, *pname; + const struct optspec_t *opt; + struct _aux *aux; + + opt = s->options + i; + aux = s->aux + i; + + aux->flags = ARG_NONE; + + if (opt->opt_fmt[0] == '-' && opt->opt_fmt[1] == '-') { + aux->flags |= IS_LONG; + pname = (const unsigned char *)(opt->opt_fmt + 2); + s->has_long = 1; + } + else { + pname = (const unsigned char *)(opt->opt_fmt + 1); + s->has_short = 1; + } + aux->printlen = (int) strlen (opt->opt_fmt); + + aux->namelen = 0; + for (p = pname + 1; *p; p++) { + /* detect required arg */ + if (*p == '=' || isspace ((unsigned char)*p) + || !(aux->flags & IS_LONG)) { + if (aux->namelen == 0) + aux->namelen = p - pname; + aux->flags |= ARG_REQ; + aux->flags &= ~ARG_NONE; + } + /* detect optional arg. This overrides required arg. */ + if (*p == '[') { + if (aux->namelen == 0) + aux->namelen = p - pname; + aux->flags &= ~(ARG_REQ | ARG_NONE); + aux->flags |= ARG_OPT; + break; + } + } + if (aux->namelen == 0) + aux->namelen = p - pname; + } + return (scanopt_t *) s; +} + +#ifndef NO_SCANOPT_USAGE +/* these structs are for scanopt_usage(). */ +struct usg_elem { + int idx; + struct usg_elem *next; + struct usg_elem *alias; +}; +typedef struct usg_elem usg_elem; + + +/* Prints a usage message based on contents of optlist. + * Parameters: + * scanner - The scanner, already initialized with scanopt_init(). + * fp - The file stream to write to. + * usage - Text to be prepended to option list. + * Return: Always returns 0 (zero). + * The output looks something like this: + +[indent][option, alias1, alias2...][indent][description line1 + description line2...] + */ +int scanopt_usage (scanopt_t *scanner, FILE *fp, const char *usage) +{ + struct _scanopt_t *s; + int i, columns, indent = 2; + usg_elem *byr_val = NULL; /* option indices sorted by r_val */ + usg_elem *store; /* array of preallocated elements. */ + int store_idx = 0; + usg_elem *ue; + int maxlen[2]; + int desccol = 0; + int print_run = 0; + + maxlen[0] = 0; + maxlen[1] = 0; + + s = (struct _scanopt_t *) scanner; + + if (usage) { + fprintf (fp, "%s\n", usage); + } + else { + /* Find the basename of argv[0] */ + const char *p; + + p = s->argv[0] + strlen (s->argv[0]); + while (p != s->argv[0] && *p != '/') + --p; + if (*p == '/') + p++; + + fprintf (fp, _("Usage: %s [OPTIONS]...\n"), p); + } + fprintf (fp, "\n"); + + /* Sort by r_val and string. Yes, this is O(n*n), but n is small. */ + store = malloc((size_t) s->optc * sizeof (usg_elem)); + for (i = 0; i < s->optc; i++) { + + /* grab the next preallocate node. */ + ue = store + store_idx++; + ue->idx = i; + ue->next = ue->alias = NULL; + + /* insert into list. */ + if (!byr_val) + byr_val = ue; + else { + int found_alias = 0; + usg_elem **ue_curr, **ptr_if_no_alias = NULL; + + ue_curr = &byr_val; + while (*ue_curr) { + if (RVAL (s, (*ue_curr)->idx) == + RVAL (s, ue->idx)) { + /* push onto the alias list. */ + ue_curr = &((*ue_curr)->alias); + found_alias = 1; + break; + } + if (!ptr_if_no_alias + && + strcasecmp (NAME (s, (*ue_curr)->idx), + NAME (s, ue->idx)) > 0) { + ptr_if_no_alias = ue_curr; + } + ue_curr = &((*ue_curr)->next); + } + if (!found_alias && ptr_if_no_alias) + ue_curr = ptr_if_no_alias; + ue->next = *ue_curr; + *ue_curr = ue; + } + } + +#if 0 + if (1) { + printf ("ORIGINAL:\n"); + for (i = 0; i < s->optc; i++) + printf ("%2d: %s\n", i, NAME (s, i)); + printf ("SORTED:\n"); + ue = byr_val; + while (ue) { + usg_elem *ue2; + + printf ("%2d: %s\n", ue->idx, NAME (s, ue->idx)); + for (ue2 = ue->alias; ue2; ue2 = ue2->next) + printf (" +---> %2d: %s\n", ue2->idx, + NAME (s, ue2->idx)); + ue = ue->next; + } + } +#endif + + /* Now build each row of output. */ + + /* first pass calculate how much room we need. */ + for (ue = byr_val; ue; ue = ue->next) { + usg_elem *ap; + int len = 0; + int nshort = 0, nlong = 0; + + +#define CALC_LEN(i) do {\ + if(FLAGS(s,i) & IS_LONG) \ + len += (nlong++||nshort) ? 2+PRINTLEN(s,i) : PRINTLEN(s,i);\ + else\ + len += (nshort++||nlong)? 2+PRINTLEN(s,i) : PRINTLEN(s,i);\ + }while(0) + + if (!(FLAGS (s, ue->idx) & IS_LONG)) + CALC_LEN (ue->idx); + + /* do short aliases first. */ + for (ap = ue->alias; ap; ap = ap->next) { + if (FLAGS (s, ap->idx) & IS_LONG) + continue; + CALC_LEN (ap->idx); + } + + if (FLAGS (s, ue->idx) & IS_LONG) + CALC_LEN (ue->idx); + + /* repeat the above loop, this time for long aliases. */ + for (ap = ue->alias; ap; ap = ap->next) { + if (!(FLAGS (s, ap->idx) & IS_LONG)) + continue; + CALC_LEN (ap->idx); + } + + if (len > maxlen[0]) + maxlen[0] = len; + + /* It's much easier to calculate length for description column! */ + len = (int) strlen (DESC (s, ue->idx)); + if (len > maxlen[1]) + maxlen[1] = len; + } + + /* Determine how much room we have, and how much we will allocate to each col. + * Do not address pathological cases. Output will just be ugly. */ + columns = get_cols () - 1; + if (maxlen[0] + maxlen[1] + indent * 2 > columns) { + /* col 0 gets whatever it wants. we'll wrap the desc col. */ + maxlen[1] = columns - (maxlen[0] + indent * 2); + if (maxlen[1] < 14) /* 14 is arbitrary lower limit on desc width. */ + maxlen[1] = INT_MAX; + } + desccol = maxlen[0] + indent * 2; + +#define PRINT_SPACES(fp,n)\ + do{\ + int _n;\ + _n=(n);\ + while(_n-- > 0)\ + fputc(' ',(fp));\ + }while(0) + + + /* Second pass (same as above loop), this time we print. */ + /* Sloppy hack: We iterate twice. The first time we print short and long options. + The second time we print those lines that have ONLY long options. */ + while (print_run++ < 2) { + for (ue = byr_val; ue; ue = ue->next) { + usg_elem *ap; + int nwords = 0, nchars = 0, has_short = 0; + +/* TODO: get has_short schtick to work */ + has_short = !(FLAGS (s, ue->idx) & IS_LONG); + for (ap = ue->alias; ap; ap = ap->next) { + if (!(FLAGS (s, ap->idx) & IS_LONG)) { + has_short = 1; + break; + } + } + if ((print_run == 1 && !has_short) || + (print_run == 2 && has_short)) + continue; + + PRINT_SPACES (fp, indent); + nchars += indent; + +/* Print, adding a ", " between aliases. */ +#define PRINT_IT(i) do{\ + if(nwords++)\ + nchars+=fprintf(fp,", ");\ + nchars+=fprintf(fp,"%s",s->options[i].opt_fmt);\ + }while(0) + + if (!(FLAGS (s, ue->idx) & IS_LONG)) + PRINT_IT (ue->idx); + + /* print short aliases first. */ + for (ap = ue->alias; ap; ap = ap->next) { + if (!(FLAGS (s, ap->idx) & IS_LONG)) + PRINT_IT (ap->idx); + } + + + if (FLAGS (s, ue->idx) & IS_LONG) + PRINT_IT (ue->idx); + + /* repeat the above loop, this time for long aliases. */ + for (ap = ue->alias; ap; ap = ap->next) { + if (FLAGS (s, ap->idx) & IS_LONG) + PRINT_IT (ap->idx); + } + + /* pad to desccol */ + PRINT_SPACES (fp, desccol - nchars); + + /* Print description, wrapped to maxlen[1] columns. */ + if (1) { + const char *pstart; + + pstart = DESC (s, ue->idx); + while (1) { + int n = 0; + const char *lastws = NULL, *p; + + p = pstart; + + while (*p && n < maxlen[1] + && *p != '\n') { + if (isspace ((unsigned char)(*p)) + || *p == '-') lastws = + p; + n++; + p++; + } + + if (!*p) { /* hit end of desc. done. */ + fprintf (fp, "%s\n", + pstart); + break; + } + else if (*p == '\n') { /* print everything up to here then wrap. */ + fprintf (fp, "%.*s\n", n, + pstart); + PRINT_SPACES (fp, desccol); + pstart = p + 1; + continue; + } + else { /* we hit the edge of the screen. wrap at space if possible. */ + if (lastws) { + fprintf (fp, + "%.*s\n", + (int)(lastws - pstart), + pstart); + pstart = + lastws + 1; + } + else { + fprintf (fp, + "%.*s\n", + n, + pstart); + pstart = p + 1; + } + PRINT_SPACES (fp, desccol); + continue; + } + } + } + } + } /* end while */ + free (store); + return 0; +} +#endif /* no scanopt_usage */ + + +static int scanopt_err (struct _scanopt_t *s, int is_short, int err) +{ + const char *optname = ""; + char optchar[2]; + + if (!s->no_err_msg) { + + if (s->index > 0 && s->index < s->argc) { + if (is_short) { + optchar[0] = + s->argv[s->index][s->subscript]; + optchar[1] = '\0'; + optname = optchar; + } + else { + optname = s->argv[s->index]; + } + } + + fprintf (stderr, "%s: ", s->argv[0]); + switch (err) { + case SCANOPT_ERR_ARG_NOT_ALLOWED: + fprintf (stderr, + _ + ("option `%s' doesn't allow an argument\n"), + optname); + break; + case SCANOPT_ERR_ARG_NOT_FOUND: + fprintf (stderr, + _("option `%s' requires an argument\n"), + optname); + break; + case SCANOPT_ERR_OPT_AMBIGUOUS: + fprintf (stderr, _("option `%s' is ambiguous\n"), + optname); + break; + case SCANOPT_ERR_OPT_UNRECOGNIZED: + fprintf (stderr, _("Unrecognized option `%s'\n"), + optname); + break; + default: + fprintf (stderr, _("Unknown error=(%d)\n"), err); + break; + } + } + return err; +} + + +/* Internal. Match str against the regex ^--([^=]+)(=(.*))? + * return 1 if *looks* like a long option. + * 'str' is the only input argument, the rest of the arguments are output only. + * optname will point to str + 2 + * + */ +static int matchlongopt (char *str, char **optname, int *optlen, char **arg, int *arglen) +{ + char *p; + + *optname = *arg = NULL; + *optlen = *arglen = 0; + + /* Match regex /--./ */ + p = str; + if (p[0] != '-' || p[1] != '-' || !p[2]) + return 0; + + p += 2; + *optname = p; + + /* find the end of optname */ + while (*p && *p != '=') + ++p; + + *optlen = p - *optname; + + if (!*p) + /* an option with no '=...' part. */ + return 1; + + + /* We saw an '=' char. The rest of p is the arg. */ + p++; + *arg = p; + while (*p) + ++p; + *arglen = p - *arg; + + return 1; +} + + +/* Internal. Look up long or short option by name. + * Long options must match a non-ambiguous prefix, or exact match. + * Short options must be exact. + * Return boolean true if found and no error. + * Error stored in err_code or zero if no error. */ +static int find_opt (struct _scanopt_t *s, int lookup_long, char *optstart, int + len, int *err_code, int *opt_offset) +{ + int nmatch = 0, lastr_val = 0, i; + + *err_code = 0; + *opt_offset = -1; + + if (!optstart) + return 0; + + for (i = 0; i < s->optc; i++) { + const char *optname; + + optname = s->options[i].opt_fmt + (lookup_long ? 2 : 1); + + if (lookup_long && (s->aux[i].flags & IS_LONG)) { + if (len > s->aux[i].namelen) + continue; + + if (strncmp (optname, optstart, len) == 0) { + nmatch++; + *opt_offset = i; + + /* exact match overrides all. */ + if (len == s->aux[i].namelen) { + nmatch = 1; + break; + } + + /* ambiguity is ok between aliases. */ + if (lastr_val + && lastr_val == + s->options[i].r_val) nmatch--; + lastr_val = s->options[i].r_val; + } + } + else if (!lookup_long && !(s->aux[i].flags & IS_LONG)) { + if (optname[0] == optstart[0]) { + nmatch++; + *opt_offset = i; + } + } + } + + if (nmatch == 0) { + *err_code = SCANOPT_ERR_OPT_UNRECOGNIZED; + *opt_offset = -1; + } + else if (nmatch > 1) { + *err_code = SCANOPT_ERR_OPT_AMBIGUOUS; + *opt_offset = -1; + } + + return *err_code ? 0 : 1; +} + + +int scanopt (scanopt_t *svoid, char **arg, int *optindex) +{ + char *optname = NULL, *optarg = NULL, *pstart; + int namelen = 0, arglen = 0; + int errcode = 0, has_next; + const optspec_t *optp; + struct _scanopt_t *s; + struct _aux *auxp; + int is_short; + int opt_offset = -1; + + s = (struct _scanopt_t *) svoid; + + /* Normalize return-parameters. */ + SAFE_ASSIGN (arg, NULL); + SAFE_ASSIGN (optindex, s->index); + + if (s->index >= s->argc) + return 0; + + /* pstart always points to the start of our current scan. */ + pstart = s->argv[s->index] + s->subscript; + if (!pstart) + return 0; + + if (s->subscript == 0) { + + /* test for exact match of "--" */ + if (pstart[0] == '-' && pstart[1] == '-' && !pstart[2]) { + SAFE_ASSIGN (optindex, s->index + 1); + INC_INDEX (s, 1); + return 0; + } + + /* Match an opt. */ + if (matchlongopt + (pstart, &optname, &namelen, &optarg, &arglen)) { + + /* it LOOKS like an opt, but is it one?! */ + if (!find_opt + (s, 1, optname, namelen, &errcode, + &opt_offset)) { + scanopt_err (s, 0, errcode); + return errcode; + } + /* We handle this below. */ + is_short = 0; + + /* Check for short opt. */ + } + else if (pstart[0] == '-' && pstart[1]) { + /* Pass through to below. */ + is_short = 1; + s->subscript++; + pstart++; + } + + else { + /* It's not an option. We're done. */ + return 0; + } + } + + /* We have to re-check the subscript status because it + * may have changed above. */ + + if (s->subscript != 0) { + + /* we are somewhere in a run of short opts, + * e.g., at the 'z' in `tar -xzf` */ + + optname = pstart; + namelen = 1; + is_short = 1; + + if (!find_opt + (s, 0, pstart, namelen, &errcode, &opt_offset)) { + return scanopt_err (s, 1, errcode); + } + + optarg = pstart + 1; + if (!*optarg) { + optarg = NULL; + arglen = 0; + } + else + arglen = (int) strlen (optarg); + } + + /* At this point, we have a long or short option matched at opt_offset into + * the s->options array (and corresponding aux array). + * A trailing argument is in {optarg,arglen}, if any. + */ + + /* Look ahead in argv[] to see if there is something + * that we can use as an argument (if needed). */ + has_next = s->index + 1 < s->argc + && strcmp ("--", s->argv[s->index + 1]) != 0; + + optp = s->options + opt_offset; + auxp = s->aux + opt_offset; + + /* case: no args allowed */ + if (auxp->flags & ARG_NONE) { + if (optarg && !is_short) { + scanopt_err (s, is_short, errcode = SCANOPT_ERR_ARG_NOT_ALLOWED); + INC_INDEX (s, 1); + return errcode; + } + else if (!optarg) + INC_INDEX (s, 1); + else + s->subscript++; + return optp->r_val; + } + + /* case: required */ + if (auxp->flags & ARG_REQ) { + if (!optarg && !has_next) + return scanopt_err (s, is_short, SCANOPT_ERR_ARG_NOT_FOUND); + + if (!optarg) { + /* Let the next argv element become the argument. */ + SAFE_ASSIGN (arg, s->argv[s->index + 1]); + INC_INDEX (s, 2); + } + else { + SAFE_ASSIGN (arg, (char *) optarg); + INC_INDEX (s, 1); + } + return optp->r_val; + } + + /* case: optional */ + if (auxp->flags & ARG_OPT) { + SAFE_ASSIGN (arg, optarg); + INC_INDEX (s, 1); + return optp->r_val; + } + + + /* Should not reach here. */ + return 0; +} + + +int scanopt_destroy (scanopt_t *svoid) +{ + struct _scanopt_t *s; + + s = (struct _scanopt_t *) svoid; + if (s != NULL) { + free(s->aux); + free(s); + } + return 0; +} + + +/* vim:set tabstop=8 softtabstop=4 shiftwidth=4: */ |