summaryrefslogtreecommitdiff
path: root/libshouldbeinlibc
diff options
context:
space:
mode:
Diffstat (limited to 'libshouldbeinlibc')
-rw-r--r--libshouldbeinlibc/options.c227
-rw-r--r--libshouldbeinlibc/options.h79
2 files changed, 306 insertions, 0 deletions
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 <miles@gnu.ai.mit.edu>
+
+ 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 <stdlib.h>
+#include <string.h>
+#include <limits.h> /* for CHAR_BIT */
+#include <getopt.h>
+#include <cthreads.h>
+#include <options.h>
+
+#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 <miles@gnu.ai.mit.edu>
+
+ 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 <errno.h>
+#include <getopt.h>
+
+/* 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__ */
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-25 20:48:52 +0000