From 2bf87c5e33be8c8df7e66b7f1a30e044312b7be2 Mon Sep 17 00:00:00 2001 From: Miles Bader Date: Sat, 20 May 1995 01:18:47 +0000 Subject: Initial revision --- libshouldbeinlibc/options.c | 227 ++++++++++++++++++++++++++++++++++++++++++++ libshouldbeinlibc/options.h | 79 +++++++++++++++ 2 files changed, 306 insertions(+) create mode 100644 libshouldbeinlibc/options.c create mode 100644 libshouldbeinlibc/options.h (limited to 'libshouldbeinlibc') diff --git a/libshouldbeinlibc/options.c b/libshouldbeinlibc/options.c new file mode 100644 index 00000000..e0c4b0c5 --- /dev/null +++ b/libshouldbeinlibc/options.c @@ -0,0 +1,227 @@ +/* Hierarchial options parsing, layered over getopt + + Copyright (C) 1995 Free Software Foundation, Inc. + + Written by Miles Bader + + This file is part of the GNU Hurd. + + The GNU Hurd is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2, or (at + your option) any later version. + + The GNU Hurd is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include +#include +#include /* for CHAR_BIT */ +#include +#include +#include + +#define EOF (-1) + +/* The number of bits we steal in a long-option value for our own use. */ +#define GROUP_BITS CHAR_BIT + +/* The number of bits available for the user value. */ +#define USER_BITS ((sizeof ((struct option *)0)->val * CHAR_BIT) - GROUP_BITS) +#define USER_MASK ((1 << USER_BITS) - 1) + +/* ---------------------------------------------------------------- */ + +/* Returns the offset into LONG_OPTIONS of a long option with called NAME, or + -1 if none is found. Passing NULL as NAME will return the number of + options. */ +static int +find_long_option (struct option *long_options, const char *name) +{ + struct option *l = long_options; + while (l->name != NULL) + if (name != NULL && strcmp (l->name, name) == 0) + return l - long_options; + else + l++; + if (name == NULL) + return l - long_options; + else + return -1; +} + +/* ---------------------------------------------------------------- */ + +/* Used to regulate access to the getopt routines, which are non-reentrant. */ +static struct mutex getopt_lock = MUTEX_INITIALIZER; + +/* Parse the options strings in ARGC & ARGV according to the options in + OPTIONS. FLAGS is one of the OPTIONS_ flags above. If OPTIND is + non-NULL, the index in ARGV of the first unparsed option is returned in + it. If an unknown option is present, EINVAL is returned; if some parser + routine returned a non-zero value, it is returned; otherwise 0 is + returned. */ +error_t +options_parse (struct options *options, + int argc, char **argv, + unsigned flags, int *arg_index) +{ + int opt; + struct options *o; + /* SHORT_OPTS is the getopt short options string for the union of all the + groups of options. */ + char *short_opts; + /* GROUP_SHORT_STARTS is an array pointing to the part of SHORT_OPTS + corresponding to each different group of options. We use it to + determine from which groupa particular short options is from. */ + char **group_short_starts; + /* LONG_OPTS is the array of getop long option structures for the union of + all the groups of options. */ + struct option *long_opts; + error_t err = 0; + + /* Find the merged set of short options. */ + { + char *short_end; + int short_len = (flags & OPTIONS_PARSE_ARGS) ? 1 : 0; + int num_groups = 0, group; + + /* Find the (maximum) amount of space necessary to store all combined + short options, plus the number of options groups in the chain. */ + for (o = options; o != NULL; o = o->parent) + { + num_groups++; + short_len += strlen (o->short_options); + } + + short_opts = short_end = alloca (short_len + 1); + if (flags & OPTIONS_PARSE_ARGS) + *short_end++ = '-'; /* Tell getopt we want to do this. */ + *short_end = '\0'; + + group_short_starts = alloca (num_groups * sizeof (char *)); + + for (o = options, group = 0; o != NULL; o = o->parent, group++) + { + char *s; + + group_short_starts[group] = short_end; + + for (s = o->short_options; *s != '\0'; s++) + /* We add *S to our set of short options only if it hasn't already + been added by some previous group. */ + if (*s != ':' && !index (short_opts, *s)) + { + *short_end++ = *s; + /* Copy all the colon modifiers following the option. */ + while (s[1] == ':') + *short_end++ = *++s; + *short_end = '\0'; + } + } + } + + /* Find the merged set of long options, with keys appropiately prefixed. */ + { + struct option *long_end; + int group; + int long_len = 0; + + for (o = options; o != NULL; o = o->parent) + long_len += find_long_option (o->long_options, NULL); + + long_opts = long_end = alloca ((long_len + 1) * sizeof (struct option)); + long_end->name = NULL; + + /* Note that GROUP starts at 1 because 0 is for short options. */ + for (o = options, group = 1; o != NULL; o = o->parent, group++) + { + struct option *l; + for (l = o->long_options; l->name != NULL; l++) + /* Only add the long option L if it hasn't been already. */ + if (find_long_option (long_opts, l->name) < 0) + { + *long_end = *l; + if (long_end->flag == NULL) + /* In the case where a long option returns a key from getopt, + we add a disambiguating code to all the user's values + (which is removed before we actually call the function to + parse the value); this means that the user loses use of + the high 8 bits in all his values (the sign of the lower + bits is preserved however)... */ + long_end->val = (l->val & USER_MASK) + (group << USER_BITS); + /* Keep the LONG_OPTS list terminated. */ + (++long_end)->name = NULL; + } + } + } + + /* Getopt is (currently) non-reentrant. */ + mutex_lock (&getopt_lock); + + if (flags & OPTIONS_PRINT_ERRS) + opterr = 1; /* Print error messages. */ + else + { + opterr = 0; + if (!(flags & OPTIONS_SKIP_ARG0)) + /* getopt always skips ARGV[0], so we have to fake it out. As long + as opterr is 0, then it shouldn't actually try to access it. */ + argv--; + } + + /* Now use getopt on our coalesced options lists. */ + while ((opt = getopt_long (argc, argv, short_opts, long_opts, 0)) != EOF) + { + int group = opt >> USER_BITS; + + err = EINVAL; /* until otherwise asserted */ + + if (opt == 1) + /* A non-option argument; try each parser in turn. */ + for (o = options; o != NULL && err == EINVAL; o = o->parent) + err = (*o->parser)(opt, optarg); + else if (group == 0) + /* A short option. */ + { + /* By comparing OPT's position in SHORT_OPTS to the various + starting positions in GROUP_SHORT_STARTS, we can determine which + group OPT came from. */ + char *short_index = index (short_opts, opt); + if (short_index) + for (o = options, group = 0; o != NULL; o = o->parent, group++) + if (o->parent == NULL + || group_short_starts[group + 1] > short_index) + { + err = (*o->parser)(opt, optarg); + break; + } + } + else + /* A long option. */ + for (o = options; o != NULL; o = o->parent) + if (--group == 0) + { + /* We use shifts instead of masking for extracting the user value + in order to preserve the sign. */ + err = (*o->parser)(((opt << GROUP_BITS) >> GROUP_BITS), optarg); + break; + } + + if (err) + break; + } + + if (arg_index != NULL) + *arg_index = optind; + + mutex_unlock (&getopt_lock); + + return err; +} diff --git a/libshouldbeinlibc/options.h b/libshouldbeinlibc/options.h new file mode 100644 index 00000000..6ac15c63 --- /dev/null +++ b/libshouldbeinlibc/options.h @@ -0,0 +1,79 @@ +/* Hierarchial options parsing, layered over getopt + + Copyright (C) 1995 Free Software Foundation, Inc. + + Written by Miles Bader + + This file is part of the GNU Hurd. + + The GNU Hurd is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2, or (at + your option) any later version. + + The GNU Hurd is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#ifndef __OPTIONS_H__ +#define __OPTIONS_H__ + +#include +#include + +/* An options structure contains a set of getopt options declarations, a + function to deal with getting one, and an optional pointer to another + options structure. When actually parsing options, getopt is called with + the union of all the options structures chained together through their + PARENT pointers, with conflicts being resolved in favor of the first + occurance in the chain. */ +struct options +{ + /* The getopt-style short options string for this group of options. */ + char *short_options; + /* An array of getopt-style long-options structures. */ + struct option *long_options; + + /* What to do with an option from this structure. KEY is either the short + option letter, or the final member of the long-option entry, as returned + by getopt, and ARG is the value of OPTARG. If a non-zero value is + returned, then parsing is stopped immediately, and that value is + returned from options_parse(). */ + error_t (*parser)(int key, char *arg); + + /* The next member in this options chain. */ + struct options *parent; +}; + +/* Flags for options_parse: */ + +/* Ignore the first element of ARGV. Useful for program command lines. */ +#define OPTIONS_SKIP_ARG0 0x1 + +/* Print error messages for unknown options to stderr; if this flag is set, + OPTIONS_SKIP_ARG0 is ignored, as ARGV[0] is used as the program name in + the error messages. */ +#define OPTIONS_PRINT_ERRS 0x2 + +/* Parse non-option args as well, similarly to getopt, by calling the parse + function with a key of 1, and the actual arg as the value. Since it's + impossible to know which parse function wants to handle it, each one is + called in turn, until one returns 0 or an error other than EINVAL. */ +#define OPTIONS_PARSE_ARGS 0x4 + + +/* Parse the options strings in ARGC & ARGV according to the options in + OPTIONS. FLAGS is one of the OPTIONS_ flags above. If ARG_INDEX is + non-NULL, the index in ARGV of the first unparsed option is returned in + it. If an unknown option is present, EINVAL is returned; if some parser + routine returned a non-zero value, it is returned; otherwise 0 is + returned. */ +error_t options_parse (struct options *options, int argc, char **argv, + unsigned flags, int *arg_index); + +#endif /* __OPTIONS_H__ */ -- cgit v1.2.3