summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorMiles Bader <miles@gnu.org>1995-10-11 00:06:47 +0000
committerMiles Bader <miles@gnu.org>1995-10-11 00:06:47 +0000
commit8b8bd74b8f258cc8067ef17ca0e9a0048b497eb4 (patch)
tree5782c95962ae7c8c92411825156cef2c03a6744e
parent91849a9dcb8c3ccf6b721be198f693fbd18ac66c (diff)
(argp_parse):
Put all the group attributes into structures which get stored in the GROUPS array, rather than having a separate array for each. Implement ARGP_KEY_NO_ARGS in a better way.
-rw-r--r--libshouldbeinlibc/argp-parse.c104
1 files changed, 59 insertions, 45 deletions
diff --git a/libshouldbeinlibc/argp-parse.c b/libshouldbeinlibc/argp-parse.c
index e80a8f41..72d2ea80 100644
--- a/libshouldbeinlibc/argp-parse.c
+++ b/libshouldbeinlibc/argp-parse.c
@@ -92,6 +92,24 @@ find_long_option (struct option *long_options, const char *name)
/* Used to regulate access to the getopt routines, which are non-reentrant. */
static struct mutex getopt_lock = MUTEX_INITIALIZER;
+/* The state of a `group' during parsing. Each group corresponds to a
+ particular argp structure from the tree of such descending from the top
+ level argp passed to argp_parse. */
+struct group
+{
+ /* This group's parsing function. */
+ argp_parser_t parser;
+
+ /* Points to the point in SHORT_OPTS corresponding to the end of the short
+ options for this group. We use it to determine from which group a
+ particular short options is from. */
+ char *short_end;
+
+ /* True if this group has successfully processed a non-option argument;
+ used to determine who to call with ARGP_KEY_NO_ARGS. */
+ int processed_arg;
+};
+
/* Parse the options strings in ARGC & ARGV according to the argp in
ARGP. FLAGS is one of the ARGP_ flags above. If OPTIND is
non-NULL, the index in ARGV of the first unparsed option is returned in
@@ -102,25 +120,19 @@ error_t
argp_parse (struct argp *argp, int argc, char **argv, unsigned flags,
int *end_index)
{
- int opt;
- /* The number of separate options groups (each from a different argp). */
- unsigned num_groups = 0;
+ error_t err = 0;
/* SHORT_OPTS is the getopt short options string for the union of all the
groups of options. */
char *short_opts;
- /* GROUP_SHORT_ENDS is an array pointing to the point in SHORT_OPTS
- corresponding to the end of the short options for each different group
- of options. We use it to determine from which group a particular short
- options is from. */
- char **group_short_ends;
- /* The parsing function for each group. */
- argp_parser_t *group_parsers;
/* LONG_OPTS is the array of getop long option structures for the union of
all the groups of options. */
struct option *long_opts;
+ /* States of the various parsing groups. */
+ struct group *groups;
/* State block supplied to parsing routines. */
- struct argp_state state = { argp, argc, argv, 0, flags, 0 };
- error_t err = 0;
+ struct argp_state state = { argp, argc, argv, 0, flags };
+ int opt;
+ struct group *group;
if (! (flags & ARGP_NO_HELP))
/* Add our own options. */
@@ -143,9 +155,10 @@ argp_parse (struct argp *argp, int argc, char **argv, unsigned flags,
/* Find the merged set of getopt options, with keys appropiately prefixed. */
{
char *short_end;
- int short_len = (flags & ARGP_NO_ARGS) ? 0 : 1;
+ unsigned short_len = (flags & ARGP_NO_ARGS) ? 0 : 1;
struct option *long_end;
- int long_len = 0;
+ unsigned long_len = 0;
+ unsigned num_groups = 0;
/* For ARGP, increments NUM_GROUPS by the total number of argp structures
descended from it, and SHORT_LEN & LONG_LEN by the maximum lengths of
@@ -170,14 +183,11 @@ argp_parse (struct argp *argp, int argc, char **argv, unsigned flags,
calc_lengths (*parents++);
}
- /* Converts all options in ARGP (which has group number GROUP) and
- ancestors into getopt options stored in SHORT_OPTS and LONG_OPTS;
- SHORT_END and LONG_END are the points at which new options are added.
- Each group's entry in GROUP_PARSERS is set to point to it's parser,
- and its entry in GROUP_SHORT_ENDS is set to the point in SHORT_OPTS at
- which that groups short options start. Returns the next unused group
- number. */
- unsigned convert_options (struct argp *argp, unsigned group)
+ /* Converts all options in ARGP (which is put in GROUP) and ancestors
+ into getopt options stored in SHORT_OPTS and LONG_OPTS; SHORT_END and
+ LONG_END are the points at which new options are added. Returns the
+ next unused group entry. */
+ struct group *convert_options (struct argp *argp, struct group *group)
{
/* REAL is the most recent non-alias value of OPT. */
struct argp_option *opt, *real;
@@ -221,15 +231,17 @@ argp_parse (struct argp *argp, int argc, char **argv, unsigned flags,
the high 8 bits in all his values (the sign of the lower
bits is preserved however)... */
long_end->val =
- (opt->key & USER_MASK) + ((group + 1) << USER_BITS);
+ (opt->key & USER_MASK)
+ + (((group - groups) + 1) << USER_BITS);
/* Keep the LONG_OPTS list terminated. */
(++long_end)->name = NULL;
}
}
- group_parsers[group] = argp->parser;
- group_short_ends[group] = short_end;
+ group->parser = argp->parser;
+ group->short_end = short_end;
+ group->processed_arg = 0;
group++;
@@ -252,10 +264,10 @@ argp_parse (struct argp *argp, int argc, char **argv, unsigned flags,
long_opts = long_end = alloca ((long_len + 1) * sizeof (struct option));
long_end->name = NULL;
- group_parsers = alloca (num_groups * sizeof (argp_parser_t));
- group_short_ends = alloca (num_groups * sizeof (char *));
+ groups = alloca ((num_groups + 1) * sizeof (struct group));
- convert_options (argp, 0);
+ group = convert_options (argp, 0);
+ group->parser = 0; /* Mark the end */
}
/* Getopt is (currently) non-reentrant. */
@@ -278,7 +290,9 @@ argp_parse (struct argp *argp, int argc, char **argv, unsigned flags,
/* Now use getopt on our coalesced options lists. */
while ((opt = getopt_long (state.argc, state.argv, short_opts, long_opts, 0)) != EOF)
{
- int group = opt >> USER_BITS; /* GROUP here is actually + 1 */
+ /* The group key encoded in the high bits; 0 for short opts or
+ group_number + 1 for long opts. */
+ int group_key = opt >> USER_BITS;
err = EINVAL; /* until otherwise asserted */
@@ -288,8 +302,8 @@ argp_parse (struct argp *argp, int argc, char **argv, unsigned flags,
if (opt == 1)
/* A non-option argument; try each parser in turn. */
{
- for (group = 0; group < num_groups && err == EINVAL; group++)
- err = (*group_parsers[group])(ARGP_KEY_ARG, optarg, &state);
+ for (group = groups; group->parser && err == EINVAL; group++)
+ err = (*group->parser)(ARGP_KEY_ARG, optarg, &state);
if (err == EINVAL)
/* No parser understood this argument, return immediately. */
{
@@ -303,27 +317,28 @@ argp_parse (struct argp *argp, int argc, char **argv, unsigned flags,
/* Remember that we successfully processed a non-option
argument -- but only if the user hasn't gotten tricky and set
the clock back. */
- state.processed_arg = 1;
+ (--group)->processed_arg = 1;
}
- else if (group == 0)
+ else if (group_key == 0)
/* A short option. */
{
/* By comparing OPT's position in SHORT_OPTS to the various
- starting positions in GROUP_SHORT_ENDS, we can determine which
- group OPT came from. */
+ starting positions in each group's SHORT_END field, we can
+ determine which group OPT came from. */
char *short_index = index (short_opts, opt);
if (short_index)
- for (group = 0; group < num_groups; group++)
- if (group_short_ends[group] > short_index)
+ for (group = groups; group->parser; group++)
+ if (group->short_end > short_index)
{
- err = (*group_parsers[group])(opt, optarg, &state);
+ err = (*group->parser)(opt, optarg, &state);
break;
}
}
else
/* A long option. We use shifts instead of masking for extracting
the user value in order to preserve the sign. */
- err = (*group_parsers[group - 1])(((opt << GROUP_BITS) >> GROUP_BITS),
+ err =
+ (*groups[group_key - 1].parser)(((opt << GROUP_BITS) >> GROUP_BITS),
optarg, &state);
optind = state.index; /* Put it back in OPTIND for getopt. */
@@ -338,12 +353,11 @@ argp_parse (struct argp *argp, int argc, char **argv, unsigned flags,
/* We successfully parsed all arguments! Call all the parsers again,
just a few more times... */
{
- int group;
- if (!state.processed_arg)
- for (group = 0; group < num_groups && (!err || err == EINVAL); group++)
- err = (*group_parsers[group])(ARGP_KEY_NO_ARGS, 0, &state);
- for (group = 0; group < num_groups && (!err || err == EINVAL); group++)
- err = (*group_parsers[group])(ARGP_KEY_END, 0, &state);
+ for (group = groups; group->parser && (!err || err == EINVAL); group++)
+ if (!group->processed_arg)
+ err = (*group->parser)(ARGP_KEY_NO_ARGS, 0, &state);
+ for (group = groups; group->parser && (!err || err == EINVAL); group++)
+ err = (*group->parser)(ARGP_KEY_END, 0, &state);
if (err == EINVAL)
/* EINVAL here just means that ARGP_KEY_END wasn't understood. */
err = 0;