summaryrefslogtreecommitdiff
path: root/libshouldbeinlibc
diff options
context:
space:
mode:
authorMiles Bader <miles@gnu.org>1995-10-11 23:44:57 +0000
committerMiles Bader <miles@gnu.org>1995-10-11 23:44:57 +0000
commit164bdcc7ba092116e1bc3a21b33844cf725584fe (patch)
treefc8186c931deb98839e4ad6bf1035e47b55d5337 /libshouldbeinlibc
parent201324becb0f2660708bbda5d47f0af6cce4dfa4 (diff)
(argp_parse):
Update STATE.argp when adding a wrapper to implement the --help option. In general, use the version of variables that are in STATE. Update STATE.index in the case where getopt returns EOF. Correctly translate options. (argp_default_parser, argp_parse): Rename uses of argp_usage* to argp_help*. (argp_parse): Deal with null parser or option fields. If an argp has neither a parser or any options, don't put it in GROUPS. Use comparison with EGROUP, rather than testing the parser field, the end test for iteration over GROUPS. (argp_parse): Pass in the right value for GROUPS to convert_options.
Diffstat (limited to 'libshouldbeinlibc')
-rw-r--r--libshouldbeinlibc/argp-parse.c178
1 files changed, 97 insertions, 81 deletions
diff --git a/libshouldbeinlibc/argp-parse.c b/libshouldbeinlibc/argp-parse.c
index 72d2ea80..60881c58 100644
--- a/libshouldbeinlibc/argp-parse.c
+++ b/libshouldbeinlibc/argp-parse.c
@@ -50,13 +50,13 @@ static struct argp_option argp_default_options[] =
static error_t
argp_default_parser (int key, char *arg, struct argp_state *state)
{
- unsigned usage_flags = ARGP_USAGE_STD_HELP;
+ unsigned usage_flags = ARGP_HELP_STD_HELP;
switch (key)
{
case OPT_HELP:
if (state->flags & ARGP_NO_EXIT)
- usage_flags &= ~(ARGP_USAGE_EXIT_OK | ARGP_USAGE_EXIT_ERR);
- argp_usage (state->argp, stdout, usage_flags);
+ usage_flags &= ~ARGP_HELP_EXIT;
+ argp_help (state->argp, stdout, usage_flags);
return 0;
default:
return EINVAL;
@@ -120,6 +120,7 @@ error_t
argp_parse (struct argp *argp, int argc, char **argv, unsigned flags,
int *end_index)
{
+ int opt;
error_t err = 0;
/* SHORT_OPTS is the getopt short options string for the union of all the
groups of options. */
@@ -129,12 +130,14 @@ argp_parse (struct argp *argp, int argc, char **argv, unsigned flags,
struct option *long_opts;
/* States of the various parsing groups. */
struct group *groups;
+ /* The end of the GROUPS array. */
+ struct group *egroup;
+ /* A pointer for people to use for iteration over GROUPS. */
+ struct group *group;
/* State block supplied to parsing routines. */
struct argp_state state = { argp, argc, argv, 0, flags };
- int opt;
- struct group *group;
- if (! (flags & ARGP_NO_HELP))
+ if (! (state.flags & ARGP_NO_HELP))
/* Add our own options. */
{
struct argp **plist = alloca (3 * sizeof (struct argp *));
@@ -145,17 +148,17 @@ argp_parse (struct argp *argp, int argc, char **argv, unsigned flags,
bzero (top_argp, sizeof (*top_argp));
top_argp->parents = plist;
- plist[0] = argp;
+ plist[0] = state.argp;
plist[1] = &argp_default_argp;
plist[2] = 0;
- argp = top_argp;
+ state.argp = top_argp;
}
/* Find the merged set of getopt options, with keys appropiately prefixed. */
{
char *short_end;
- unsigned short_len = (flags & ARGP_NO_ARGS) ? 0 : 1;
+ unsigned short_len = (state.flags & ARGP_NO_ARGS) ? 0 : 1;
struct option *long_end;
unsigned long_len = 0;
unsigned num_groups = 0;
@@ -166,17 +169,21 @@ argp_parse (struct argp *argp, int argc, char **argv, unsigned flags,
array, respectively. */
void calc_lengths (struct argp *argp)
{
- int num_opts = 0;
struct argp **parents = argp->parents;
struct argp_option *opt = argp->options;
- num_groups++;
-
- while (!_option_is_end (opt++))
- num_opts++;
-
- short_len += num_opts * 3; /* opt + up to 2 `:'s */
- long_len += num_opts;
+ if (opt || argp->parser)
+ {
+ num_groups++;
+ if (opt)
+ {
+ int num_opts = 0;
+ while (!_option_is_end (opt++))
+ num_opts++;
+ short_len += num_opts * 3; /* opt + up to 2 `:'s */
+ long_len += num_opts;
+ }
+ }
if (parents)
while (*parents)
@@ -190,60 +197,65 @@ argp_parse (struct argp *argp, int argc, char **argv, unsigned flags,
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;
+ struct argp_option *real = argp->options;
struct argp **parents = argp->parents;
- for (opt = argp->options, real = opt; ! _option_is_end (opt); opt++)
- /* Only add the long option OPT if it hasn't been already. */
- if (find_long_option (long_opts, opt->name) < 0)
- {
- if (! (opt->flags & OPTION_ALIAS))
- /* OPT isn't an alias, so we can use values from it. */
- real = opt;
+ if (real || argp->parser)
+ {
+ struct argp_option *opt;
- if (_option_is_short (opt))
- /* OPT can be used as a short option. */
+ if (real)
+ for (opt = real; !_option_is_end (opt); opt++)
{
- *short_end++ = opt->key;
- if (real->arg)
+ if (! (opt->flags & OPTION_ALIAS))
+ /* OPT isn't an alias, so we can use values from it. */
+ real = opt;
+
+ if (_option_is_short (opt))
+ /* OPT can be used as a short option. */
{
- *short_end++ = ':';
- if (! (real->flags & OPTION_ARG_OPTIONAL))
- *short_end++ = ':';
+ *short_end++ = opt->key;
+ if (real->arg)
+ {
+ *short_end++ = ':';
+ if (! (real->flags & OPTION_ARG_OPTIONAL))
+ *short_end++ = ':';
+ }
+ *short_end = '\0'; /* keep 0 terminated */
}
- *short_end = '\0'; /* keep 0 terminated */
- }
- if (opt->name)
- /* OPT can be used as a long option. */
- {
- long_end->name = opt->name;
- long_end->has_arg =
- (real->arg
- ? (real->flags & OPTION_ARG_OPTIONAL
- ? optional_argument
- : required_argument)
- : no_argument);
- long_end->flag = 0;
- /* 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 =
- (opt->key & USER_MASK)
- + (((group - groups) + 1) << USER_BITS);
-
- /* Keep the LONG_OPTS list terminated. */
- (++long_end)->name = NULL;
- }
- }
+ if (opt->name && find_long_option (long_opts, opt->name) < 0)
+ /* OPT can be used as a long option. */
+ {
+ long_end->name = opt->name;
+ long_end->has_arg =
+ (real->arg
+ ? (real->flags & OPTION_ARG_OPTIONAL
+ ? optional_argument
+ : required_argument)
+ : no_argument);
+ long_end->flag = 0;
+ /* 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 =
+ (opt->key & USER_MASK)
+ + (((group - groups) + 1) << USER_BITS);
+
+ /* Keep the LONG_OPTS list terminated. */
+ (++long_end)->name = NULL;
+ }
+ }
- group->parser = argp->parser;
- group->short_end = short_end;
- group->processed_arg = 0;
+ group->parser = argp->parser;
+ group->short_end = short_end;
+ group->processed_arg = 0;
- group++;
+ group++;
+ }
if (parents)
while (*parents)
@@ -252,12 +264,12 @@ argp_parse (struct argp *argp, int argc, char **argv, unsigned flags,
return group;
}
- calc_lengths (argp);
+ calc_lengths (state.argp);
short_opts = short_end = alloca (short_len + 1);
- if (flags & ARGP_IN_ORDER)
+ if (state.flags & ARGP_IN_ORDER)
*short_end++ = '-';
- else if (! (flags & ARGP_NO_ARGS))
+ else if (! (state.flags & ARGP_NO_ARGS))
*short_end++ = '-';
*short_end = '\0';
@@ -266,8 +278,7 @@ argp_parse (struct argp *argp, int argc, char **argv, unsigned flags,
groups = alloca ((num_groups + 1) * sizeof (struct group));
- group = convert_options (argp, 0);
- group->parser = 0; /* Mark the end */
+ egroup = convert_options (state.argp, groups);
}
/* Getopt is (currently) non-reentrant. */
@@ -276,13 +287,13 @@ argp_parse (struct argp *argp, int argc, char **argv, unsigned flags,
/* Tell getopt to initialize. */
optind = state.index = 0;
- if (flags & ARGP_NO_ERRS)
+ if (state.flags & ARGP_NO_ERRS)
{
opterr = 0;
- if (flags & ARGP_PARSE_ARGV0)
+ if (state.flags & ARGP_PARSE_ARGV0)
/* 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--, argc++;
+ state.argv--, state.argc++;
}
else
opterr = 1; /* Print error messages. */
@@ -302,8 +313,9 @@ 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 = groups; group->parser && err == EINVAL; group++)
- err = (*group->parser)(ARGP_KEY_ARG, optarg, &state);
+ for (group = groups; group < egroup && err == EINVAL; group++)
+ if (group->parser)
+ err = (*group->parser)(ARGP_KEY_ARG, optarg, &state);
if (err == EINVAL)
/* No parser understood this argument, return immediately. */
{
@@ -327,8 +339,8 @@ argp_parse (struct argp *argp, int argc, char **argv, unsigned flags,
determine which group OPT came from. */
char *short_index = index (short_opts, opt);
if (short_index)
- for (group = groups; group->parser; group++)
- if (group->short_end > short_index)
+ for (group = groups; group < egroup; group++)
+ if (group->short_end > short_index && group->parser)
{
err = (*group->parser)(opt, optarg, &state);
break;
@@ -347,17 +359,21 @@ argp_parse (struct argp *argp, int argc, char **argv, unsigned flags,
break;
}
+ if (opt == EOF)
+ state.index = optind; /* Only update INDEX if getopt just failed. */
+
mutex_unlock (&getopt_lock);
if (!err && !state.argv[state.index])
/* We successfully parsed all arguments! Call all the parsers again,
just a few more times... */
{
- for (group = groups; group->parser && (!err || err == EINVAL); group++)
- if (!group->processed_arg)
+ for (group = groups; group < egroup && (!err || err == EINVAL); group++)
+ if (!group->processed_arg && group->parser)
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);
+ for (group = groups; group < egroup && (!err || err == EINVAL); group++)
+ if (group->parser)
+ err = (*group->parser)(ARGP_KEY_END, 0, &state);
if (err == EINVAL)
/* EINVAL here just means that ARGP_KEY_END wasn't understood. */
err = 0;
@@ -368,10 +384,10 @@ argp_parse (struct argp *argp, int argc, char **argv, unsigned flags,
if (err && !(state.flags & ARGP_NO_HELP))
{
- unsigned usage_flags = ARGP_USAGE_STD;
+ unsigned usage_flags = ARGP_HELP_STD_ERR;
if (state.flags & ARGP_NO_EXIT)
- usage_flags &= ~(ARGP_USAGE_EXIT_OK | ARGP_USAGE_EXIT_ERR);
- argp_usage (argp, stderr, usage_flags);
+ usage_flags &= ~ARGP_HELP_EXIT;
+ argp_help (state.argp, stderr, usage_flags);
}
return err;