/* Hierarchial argument parsing, layered over getopt
|
/* Hierarchial argument parsing, layered over getopt
|
Copyright (C) 1995, 96, 97, 98, 99, 2000 Free Software Foundation, Inc.
|
Copyright (C) 1995, 96, 97, 98, 99, 2000 Free Software Foundation, Inc.
|
This file is part of the GNU C Library.
|
This file is part of the GNU C Library.
|
Written by Miles Bader <miles@gnu.ai.mit.edu>.
|
Written by Miles Bader <miles@gnu.ai.mit.edu>.
|
|
|
The GNU C Library is free software; you can redistribute it and/or
|
The GNU C Library is free software; you can redistribute it and/or
|
modify it under the terms of the GNU Lesser General Public
|
modify it under the terms of the GNU Lesser General Public
|
License as published by the Free Software Foundation; either
|
License as published by the Free Software Foundation; either
|
version 2.1 of the License, or (at your option) any later version.
|
version 2.1 of the License, or (at your option) any later version.
|
|
|
The GNU C Library is distributed in the hope that it will be useful,
|
The GNU C Library is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
Lesser General Public License for more details.
|
Lesser General Public License for more details.
|
|
|
You should have received a copy of the GNU Lesser General Public
|
You should have received a copy of the GNU Lesser General Public
|
License along with the GNU C Library; if not, write to the Free
|
License along with the GNU C Library; if not, write to the Free
|
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
02111-1307 USA. */
|
02111-1307 USA. */
|
|
|
#ifdef HAVE_CONFIG_H
|
#ifdef HAVE_CONFIG_H
|
#include <config.h>
|
#include <config.h>
|
#endif
|
#endif
|
|
|
#include <stdlib.h>
|
#include <stdlib.h>
|
#include <string.h>
|
#include <string.h>
|
#include <unistd.h>
|
#include <unistd.h>
|
#include <limits.h>
|
#include <limits.h>
|
#include <getopt.h>
|
#include <getopt.h>
|
|
|
#ifndef _
|
#ifndef _
|
/* This is for other GNU distributions with internationalized messages.
|
/* This is for other GNU distributions with internationalized messages.
|
When compiling libc, the _ macro is predefined. */
|
When compiling libc, the _ macro is predefined. */
|
# if defined HAVE_LIBINTL_H || defined _LIBC
|
# if defined HAVE_LIBINTL_H || defined _LIBC
|
# include <libintl.h>
|
# include <libintl.h>
|
# ifdef _LIBC
|
# ifdef _LIBC
|
# undef dgettext
|
# undef dgettext
|
# define dgettext(domain, msgid) __dcgettext (domain, msgid, LC_MESSAGES)
|
# define dgettext(domain, msgid) __dcgettext (domain, msgid, LC_MESSAGES)
|
# endif
|
# endif
|
# else
|
# else
|
# define dgettext(domain, msgid) (msgid)
|
# define dgettext(domain, msgid) (msgid)
|
# define gettext(msgid) (msgid)
|
# define gettext(msgid) (msgid)
|
# endif
|
# endif
|
#endif
|
#endif
|
#ifndef N_
|
#ifndef N_
|
# define N_(msgid) (msgid)
|
# define N_(msgid) (msgid)
|
#endif
|
#endif
|
|
|
#if _LIBC - 0
|
#if _LIBC - 0
|
#include <bits/libc-lock.h>
|
#include <bits/libc-lock.h>
|
#else
|
#else
|
#ifdef HAVE_CTHREADS_H
|
#ifdef HAVE_CTHREADS_H
|
#include <cthreads.h>
|
#include <cthreads.h>
|
#endif
|
#endif
|
#endif /* _LIBC */
|
#endif /* _LIBC */
|
|
|
#include <argp.h>
|
#include <argp.h>
|
#include "argp-namefrob.h"
|
#include "argp-namefrob.h"
|
|
|
/* Getopt return values. */
|
/* Getopt return values. */
|
#define KEY_END (-1) /* The end of the options. */
|
#define KEY_END (-1) /* The end of the options. */
|
#define KEY_ARG 1 /* A non-option argument. */
|
#define KEY_ARG 1 /* A non-option argument. */
|
#define KEY_ERR '?' /* An error parsing the options. */
|
#define KEY_ERR '?' /* An error parsing the options. */
|
|
|
/* The meta-argument used to prevent any further arguments being interpreted
|
/* The meta-argument used to prevent any further arguments being interpreted
|
as options. */
|
as options. */
|
#define QUOTE "--"
|
#define QUOTE "--"
|
|
|
/* The number of bits we steal in a long-option value for our own use. */
|
/* The number of bits we steal in a long-option value for our own use. */
|
#define GROUP_BITS CHAR_BIT
|
#define GROUP_BITS CHAR_BIT
|
|
|
/* The number of bits available for the user value. */
|
/* The number of bits available for the user value. */
|
#define USER_BITS ((sizeof ((struct option *)0)->val * CHAR_BIT) - GROUP_BITS)
|
#define USER_BITS ((sizeof ((struct option *)0)->val * CHAR_BIT) - GROUP_BITS)
|
#define USER_MASK ((1 << USER_BITS) - 1)
|
#define USER_MASK ((1 << USER_BITS) - 1)
|
|
|
/* EZ alias for ARGP_ERR_UNKNOWN. */
|
/* EZ alias for ARGP_ERR_UNKNOWN. */
|
#define EBADKEY ARGP_ERR_UNKNOWN
|
#define EBADKEY ARGP_ERR_UNKNOWN
|
|
|
/* Default options. */
|
/* Default options. */
|
|
|
/* When argp is given the --HANG switch, _ARGP_HANG is set and argp will sleep
|
/* When argp is given the --HANG switch, _ARGP_HANG is set and argp will sleep
|
for one second intervals, decrementing _ARGP_HANG until it's zero. Thus
|
for one second intervals, decrementing _ARGP_HANG until it's zero. Thus
|
you can force the program to continue by attaching a debugger and setting
|
you can force the program to continue by attaching a debugger and setting
|
it to 0 yourself. */
|
it to 0 yourself. */
|
volatile int _argp_hang;
|
volatile int _argp_hang;
|
|
|
#define OPT_PROGNAME -2
|
#define OPT_PROGNAME -2
|
#define OPT_USAGE -3
|
#define OPT_USAGE -3
|
#define OPT_HANG -4
|
#define OPT_HANG -4
|
|
|
static const struct argp_option argp_default_options[] =
|
static const struct argp_option argp_default_options[] =
|
{
|
{
|
{"help", '?', 0, 0, N_("Give this help list"), -1},
|
{"help", '?', 0, 0, N_("Give this help list"), -1},
|
{"usage", OPT_USAGE, 0, 0, N_("Give a short usage message")},
|
{"usage", OPT_USAGE, 0, 0, N_("Give a short usage message")},
|
{"program-name",OPT_PROGNAME,"NAME", OPTION_HIDDEN, N_("Set the program name")},
|
{"program-name",OPT_PROGNAME,"NAME", OPTION_HIDDEN, N_("Set the program name")},
|
{"HANG", OPT_HANG, "SECS", OPTION_ARG_OPTIONAL | OPTION_HIDDEN,
|
{"HANG", OPT_HANG, "SECS", OPTION_ARG_OPTIONAL | OPTION_HIDDEN,
|
N_("Hang for SECS seconds (default 3600)")},
|
N_("Hang for SECS seconds (default 3600)")},
|
{0, 0}
|
{0, 0}
|
};
|
};
|
|
|
static error_t
|
static error_t
|
argp_default_parser (int key, char *arg, struct argp_state *state)
|
argp_default_parser (int key, char *arg, struct argp_state *state)
|
{
|
{
|
switch (key)
|
switch (key)
|
{
|
{
|
case '?':
|
case '?':
|
__argp_state_help (state, state->out_stream, ARGP_HELP_STD_HELP);
|
__argp_state_help (state, state->out_stream, ARGP_HELP_STD_HELP);
|
break;
|
break;
|
case OPT_USAGE:
|
case OPT_USAGE:
|
__argp_state_help (state, state->out_stream,
|
__argp_state_help (state, state->out_stream,
|
ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
|
ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
|
break;
|
break;
|
|
|
case OPT_PROGNAME: /* Set the program name. */
|
case OPT_PROGNAME: /* Set the program name. */
|
program_invocation_name = arg;
|
program_invocation_name = arg;
|
|
|
/* [Note that some systems only have PROGRAM_INVOCATION_SHORT_NAME (aka
|
/* [Note that some systems only have PROGRAM_INVOCATION_SHORT_NAME (aka
|
__PROGNAME), in which case, PROGRAM_INVOCATION_NAME is just defined
|
__PROGNAME), in which case, PROGRAM_INVOCATION_NAME is just defined
|
to be that, so we have to be a bit careful here.] */
|
to be that, so we have to be a bit careful here.] */
|
arg = strrchr (arg, '/');
|
arg = strrchr (arg, '/');
|
if (arg)
|
if (arg)
|
program_invocation_short_name = arg + 1;
|
program_invocation_short_name = arg + 1;
|
else
|
else
|
program_invocation_short_name = program_invocation_name;
|
program_invocation_short_name = program_invocation_name;
|
|
|
/* Update what we use for messages. */
|
/* Update what we use for messages. */
|
state->name = program_invocation_short_name;
|
state->name = program_invocation_short_name;
|
|
|
if ((state->flags & (ARGP_PARSE_ARGV0 | ARGP_NO_ERRS))
|
if ((state->flags & (ARGP_PARSE_ARGV0 | ARGP_NO_ERRS))
|
== ARGP_PARSE_ARGV0)
|
== ARGP_PARSE_ARGV0)
|
/* Update what getopt uses too. */
|
/* Update what getopt uses too. */
|
state->argv[0] = program_invocation_name;
|
state->argv[0] = program_invocation_name;
|
|
|
break;
|
break;
|
|
|
case OPT_HANG:
|
case OPT_HANG:
|
_argp_hang = atoi (arg ? arg : "3600");
|
_argp_hang = atoi (arg ? arg : "3600");
|
while (_argp_hang-- > 0)
|
while (_argp_hang-- > 0)
|
__sleep (1);
|
__sleep (1);
|
break;
|
break;
|
|
|
default:
|
default:
|
return EBADKEY;
|
return EBADKEY;
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static const struct argp argp_default_argp =
|
static const struct argp argp_default_argp =
|
{argp_default_options, &argp_default_parser, NULL, NULL, NULL, NULL, "libc"};
|
{argp_default_options, &argp_default_parser, NULL, NULL, NULL, NULL, "libc"};
|
|
|
|
|
static const struct argp_option argp_version_options[] =
|
static const struct argp_option argp_version_options[] =
|
{
|
{
|
{"version", 'V', 0, 0, N_("Print program version"), -1},
|
{"version", 'V', 0, 0, N_("Print program version"), -1},
|
{0, 0}
|
{0, 0}
|
};
|
};
|
|
|
static error_t
|
static error_t
|
argp_version_parser (int key, char *arg, struct argp_state *state)
|
argp_version_parser (int key, char *arg, struct argp_state *state)
|
{
|
{
|
switch (key)
|
switch (key)
|
{
|
{
|
case 'V':
|
case 'V':
|
if (argp_program_version_hook)
|
if (argp_program_version_hook)
|
(*argp_program_version_hook) (state->out_stream, state);
|
(*argp_program_version_hook) (state->out_stream, state);
|
else if (argp_program_version)
|
else if (argp_program_version)
|
fprintf (state->out_stream, "%s\n", argp_program_version);
|
fprintf (state->out_stream, "%s\n", argp_program_version);
|
else
|
else
|
__argp_error (state, dgettext (state->root_argp->argp_domain,
|
__argp_error (state, dgettext (state->root_argp->argp_domain,
|
"(PROGRAM ERROR) No version known!?"));
|
"(PROGRAM ERROR) No version known!?"));
|
if (! (state->flags & ARGP_NO_EXIT))
|
if (! (state->flags & ARGP_NO_EXIT))
|
exit (0);
|
exit (0);
|
break;
|
break;
|
default:
|
default:
|
return EBADKEY;
|
return EBADKEY;
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static const struct argp argp_version_argp =
|
static const struct argp argp_version_argp =
|
{argp_version_options, &argp_version_parser, NULL, NULL, NULL, NULL, "libc"};
|
{argp_version_options, &argp_version_parser, NULL, NULL, NULL, NULL, "libc"};
|
|
|
/* Returns the offset into the getopt long options array LONG_OPTIONS of a
|
/* Returns the offset into the getopt long options array LONG_OPTIONS of a
|
long option with called NAME, or -1 if none is found. Passing NULL as
|
long option with called NAME, or -1 if none is found. Passing NULL as
|
NAME will return the number of options. */
|
NAME will return the number of options. */
|
static int
|
static int
|
find_long_option (struct option *long_options, const char *name)
|
find_long_option (struct option *long_options, const char *name)
|
{
|
{
|
struct option *l = long_options;
|
struct option *l = long_options;
|
while (l->name != NULL)
|
while (l->name != NULL)
|
if (name != NULL && strcmp (l->name, name) == 0)
|
if (name != NULL && strcmp (l->name, name) == 0)
|
return l - long_options;
|
return l - long_options;
|
else
|
else
|
l++;
|
l++;
|
if (name == NULL)
|
if (name == NULL)
|
return l - long_options;
|
return l - long_options;
|
else
|
else
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/* If we can, we regulate access to getopt, which is non-reentrant, with a
|
/* If we can, we regulate access to getopt, which is non-reentrant, with a
|
mutex. Since the case we're trying to guard against is two different
|
mutex. Since the case we're trying to guard against is two different
|
threads interfering, and it's possible that someone might want to call
|
threads interfering, and it's possible that someone might want to call
|
argp_parse recursively (they're careful), we use a recursive lock if
|
argp_parse recursively (they're careful), we use a recursive lock if
|
possible. */
|
possible. */
|
|
|
#if _LIBC - 0
|
#if _LIBC - 0
|
|
|
__libc_lock_define_initialized_recursive (static, getopt_lock)
|
__libc_lock_define_initialized_recursive (static, getopt_lock)
|
#define LOCK_GETOPT __libc_lock_lock_recursive (getopt_lock)
|
#define LOCK_GETOPT __libc_lock_lock_recursive (getopt_lock)
|
#define UNLOCK_GETOPT __libc_lock_unlock_recursive (getopt_lock)
|
#define UNLOCK_GETOPT __libc_lock_unlock_recursive (getopt_lock)
|
|
|
#else /* !_LIBC */
|
#else /* !_LIBC */
|
#ifdef HAVE_CTHREADS_H
|
#ifdef HAVE_CTHREADS_H
|
|
|
static struct mutex getopt_lock = MUTEX_INITIALIZER;
|
static struct mutex getopt_lock = MUTEX_INITIALIZER;
|
#define LOCK_GETOPT mutex_lock (&getopt_lock)
|
#define LOCK_GETOPT mutex_lock (&getopt_lock)
|
#define UNLOCK_GETOPT mutex_unlock (&getopt_lock)
|
#define UNLOCK_GETOPT mutex_unlock (&getopt_lock)
|
|
|
#else /* !HAVE_CTHREADS_H */
|
#else /* !HAVE_CTHREADS_H */
|
|
|
#define LOCK_GETOPT (void)0
|
#define LOCK_GETOPT (void)0
|
#define UNLOCK_GETOPT (void)0
|
#define UNLOCK_GETOPT (void)0
|
|
|
#endif /* HAVE_CTHREADS_H */
|
#endif /* HAVE_CTHREADS_H */
|
#endif /* _LIBC */
|
#endif /* _LIBC */
|
|
|
/* This hack to allow programs that know what's going on to call argp
|
/* This hack to allow programs that know what's going on to call argp
|
recursively. If someday argp is changed not to use the non-reentrant
|
recursively. If someday argp is changed not to use the non-reentrant
|
getopt interface, we can get rid of this shit. XXX */
|
getopt interface, we can get rid of this shit. XXX */
|
void
|
void
|
_argp_unlock_xxx (void)
|
_argp_unlock_xxx (void)
|
{
|
{
|
UNLOCK_GETOPT;
|
UNLOCK_GETOPT;
|
}
|
}
|
|
|
/* The state of a `group' during parsing. Each group corresponds to a
|
/* The state of a `group' during parsing. Each group corresponds to a
|
particular argp structure from the tree of such descending from the top
|
particular argp structure from the tree of such descending from the top
|
level argp passed to argp_parse. */
|
level argp passed to argp_parse. */
|
struct group
|
struct group
|
{
|
{
|
/* This group's parsing function. */
|
/* This group's parsing function. */
|
argp_parser_t parser;
|
argp_parser_t parser;
|
|
|
/* Which argp this group is from. */
|
/* Which argp this group is from. */
|
const struct argp *argp;
|
const struct argp *argp;
|
|
|
/* Points to the point in SHORT_OPTS corresponding to the end of the short
|
/* 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
|
options for this group. We use it to determine from which group a
|
particular short options is from. */
|
particular short options is from. */
|
char *short_end;
|
char *short_end;
|
|
|
/* The number of non-option args sucessfully handled by this parser. */
|
/* The number of non-option args sucessfully handled by this parser. */
|
unsigned args_processed;
|
unsigned args_processed;
|
|
|
/* This group's parser's parent's group. */
|
/* This group's parser's parent's group. */
|
struct group *parent;
|
struct group *parent;
|
unsigned parent_index; /* And the our position in the parent. */
|
unsigned parent_index; /* And the our position in the parent. */
|
|
|
/* These fields are swapped into and out of the state structure when
|
/* These fields are swapped into and out of the state structure when
|
calling this group's parser. */
|
calling this group's parser. */
|
void *input, **child_inputs;
|
void *input, **child_inputs;
|
void *hook;
|
void *hook;
|
};
|
};
|
|
|
/* Call GROUP's parser with KEY and ARG, swapping any group-specific info
|
/* Call GROUP's parser with KEY and ARG, swapping any group-specific info
|
from STATE before calling, and back into state afterwards. If GROUP has
|
from STATE before calling, and back into state afterwards. If GROUP has
|
no parser, EBADKEY is returned. */
|
no parser, EBADKEY is returned. */
|
static error_t
|
static error_t
|
group_parse (struct group *group, struct argp_state *state, int key, char *arg)
|
group_parse (struct group *group, struct argp_state *state, int key, char *arg)
|
{
|
{
|
if (group->parser)
|
if (group->parser)
|
{
|
{
|
error_t err;
|
error_t err;
|
state->hook = group->hook;
|
state->hook = group->hook;
|
state->input = group->input;
|
state->input = group->input;
|
state->child_inputs = group->child_inputs;
|
state->child_inputs = group->child_inputs;
|
state->arg_num = group->args_processed;
|
state->arg_num = group->args_processed;
|
err = (*group->parser)(key, arg, state);
|
err = (*group->parser)(key, arg, state);
|
group->hook = state->hook;
|
group->hook = state->hook;
|
return err;
|
return err;
|
}
|
}
|
else
|
else
|
return EBADKEY;
|
return EBADKEY;
|
}
|
}
|
|
|
struct parser
|
struct parser
|
{
|
{
|
const struct argp *argp;
|
const struct argp *argp;
|
|
|
/* SHORT_OPTS is the getopt short options string for the union of all the
|
/* SHORT_OPTS is the getopt short options string for the union of all the
|
groups of options. */
|
groups of options. */
|
char *short_opts;
|
char *short_opts;
|
/* LONG_OPTS is the array of getop long option structures for the union of
|
/* LONG_OPTS is the array of getop long option structures for the union of
|
all the groups of options. */
|
all the groups of options. */
|
struct option *long_opts;
|
struct option *long_opts;
|
|
|
/* States of the various parsing groups. */
|
/* States of the various parsing groups. */
|
struct group *groups;
|
struct group *groups;
|
/* The end of the GROUPS array. */
|
/* The end of the GROUPS array. */
|
struct group *egroup;
|
struct group *egroup;
|
/* An vector containing storage for the CHILD_INPUTS field in all groups. */
|
/* An vector containing storage for the CHILD_INPUTS field in all groups. */
|
void **child_inputs;
|
void **child_inputs;
|
|
|
/* True if we think using getopt is still useful; if false, then
|
/* True if we think using getopt is still useful; if false, then
|
remaining arguments are just passed verbatim with ARGP_KEY_ARG. This is
|
remaining arguments are just passed verbatim with ARGP_KEY_ARG. This is
|
cleared whenever getopt returns KEY_END, but may be set again if the user
|
cleared whenever getopt returns KEY_END, but may be set again if the user
|
moves the next argument pointer backwards. */
|
moves the next argument pointer backwards. */
|
int try_getopt;
|
int try_getopt;
|
|
|
/* State block supplied to parsing routines. */
|
/* State block supplied to parsing routines. */
|
struct argp_state state;
|
struct argp_state state;
|
|
|
/* Memory used by this parser. */
|
/* Memory used by this parser. */
|
void *storage;
|
void *storage;
|
};
|
};
|
|
|
/* The next usable entries in the various parser tables being filled in by
|
/* The next usable entries in the various parser tables being filled in by
|
convert_options. */
|
convert_options. */
|
struct parser_convert_state
|
struct parser_convert_state
|
{
|
{
|
struct parser *parser;
|
struct parser *parser;
|
char *short_end;
|
char *short_end;
|
struct option *long_end;
|
struct option *long_end;
|
void **child_inputs_end;
|
void **child_inputs_end;
|
};
|
};
|
|
|
/* Converts all options in ARGP (which is put in GROUP) and ancestors
|
/* 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
|
into getopt options stored in SHORT_OPTS and LONG_OPTS; SHORT_END and
|
CVT->LONG_END are the points at which new options are added. Returns the
|
CVT->LONG_END are the points at which new options are added. Returns the
|
next unused group entry. CVT holds state used during the conversion. */
|
next unused group entry. CVT holds state used during the conversion. */
|
static struct group *
|
static struct group *
|
convert_options (const struct argp *argp,
|
convert_options (const struct argp *argp,
|
struct group *parent, unsigned parent_index,
|
struct group *parent, unsigned parent_index,
|
struct group *group, struct parser_convert_state *cvt)
|
struct group *group, struct parser_convert_state *cvt)
|
{
|
{
|
/* REAL is the most recent non-alias value of OPT. */
|
/* REAL is the most recent non-alias value of OPT. */
|
const struct argp_option *real = argp->options;
|
const struct argp_option *real = argp->options;
|
const struct argp_child *children = argp->children;
|
const struct argp_child *children = argp->children;
|
|
|
if (real || argp->parser)
|
if (real || argp->parser)
|
{
|
{
|
const struct argp_option *opt;
|
const struct argp_option *opt;
|
|
|
if (real)
|
if (real)
|
for (opt = real; !__option_is_end (opt); opt++)
|
for (opt = real; !__option_is_end (opt); opt++)
|
{
|
{
|
if (! (opt->flags & OPTION_ALIAS))
|
if (! (opt->flags & OPTION_ALIAS))
|
/* OPT isn't an alias, so we can use values from it. */
|
/* OPT isn't an alias, so we can use values from it. */
|
real = opt;
|
real = opt;
|
|
|
if (! (real->flags & OPTION_DOC))
|
if (! (real->flags & OPTION_DOC))
|
/* A real option (not just documentation). */
|
/* A real option (not just documentation). */
|
{
|
{
|
if (__option_is_short (opt))
|
if (__option_is_short (opt))
|
/* OPT can be used as a short option. */
|
/* OPT can be used as a short option. */
|
{
|
{
|
*cvt->short_end++ = opt->key;
|
*cvt->short_end++ = opt->key;
|
if (real->arg)
|
if (real->arg)
|
{
|
{
|
*cvt->short_end++ = ':';
|
*cvt->short_end++ = ':';
|
if (real->flags & OPTION_ARG_OPTIONAL)
|
if (real->flags & OPTION_ARG_OPTIONAL)
|
*cvt->short_end++ = ':';
|
*cvt->short_end++ = ':';
|
}
|
}
|
*cvt->short_end = '\0'; /* keep 0 terminated */
|
*cvt->short_end = '\0'; /* keep 0 terminated */
|
}
|
}
|
|
|
if (opt->name
|
if (opt->name
|
&& find_long_option (cvt->parser->long_opts, opt->name) < 0)
|
&& find_long_option (cvt->parser->long_opts, opt->name) < 0)
|
/* OPT can be used as a long option. */
|
/* OPT can be used as a long option. */
|
{
|
{
|
cvt->long_end->name = opt->name;
|
cvt->long_end->name = opt->name;
|
cvt->long_end->has_arg =
|
cvt->long_end->has_arg =
|
(real->arg
|
(real->arg
|
? (real->flags & OPTION_ARG_OPTIONAL
|
? (real->flags & OPTION_ARG_OPTIONAL
|
? optional_argument
|
? optional_argument
|
: required_argument)
|
: required_argument)
|
: no_argument);
|
: no_argument);
|
cvt->long_end->flag = 0;
|
cvt->long_end->flag = 0;
|
/* we add a disambiguating code to all the user's
|
/* we add a disambiguating code to all the user's
|
values (which is removed before we actually call
|
values (which is removed before we actually call
|
the function to parse the value); this means that
|
the function to parse the value); this means that
|
the user loses use of the high 8 bits in all his
|
the user loses use of the high 8 bits in all his
|
values (the sign of the lower bits is preserved
|
values (the sign of the lower bits is preserved
|
however)... */
|
however)... */
|
cvt->long_end->val =
|
cvt->long_end->val =
|
((opt->key | real->key) & USER_MASK)
|
((opt->key | real->key) & USER_MASK)
|
+ (((group - cvt->parser->groups) + 1) << USER_BITS);
|
+ (((group - cvt->parser->groups) + 1) << USER_BITS);
|
|
|
/* Keep the LONG_OPTS list terminated. */
|
/* Keep the LONG_OPTS list terminated. */
|
(++cvt->long_end)->name = NULL;
|
(++cvt->long_end)->name = NULL;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
group->parser = argp->parser;
|
group->parser = argp->parser;
|
group->argp = argp;
|
group->argp = argp;
|
group->short_end = cvt->short_end;
|
group->short_end = cvt->short_end;
|
group->args_processed = 0;
|
group->args_processed = 0;
|
group->parent = parent;
|
group->parent = parent;
|
group->parent_index = parent_index;
|
group->parent_index = parent_index;
|
group->input = 0;
|
group->input = 0;
|
group->hook = 0;
|
group->hook = 0;
|
group->child_inputs = 0;
|
group->child_inputs = 0;
|
|
|
if (children)
|
if (children)
|
/* Assign GROUP's CHILD_INPUTS field some space from
|
/* Assign GROUP's CHILD_INPUTS field some space from
|
CVT->child_inputs_end.*/
|
CVT->child_inputs_end.*/
|
{
|
{
|
unsigned num_children = 0;
|
unsigned num_children = 0;
|
while (children[num_children].argp)
|
while (children[num_children].argp)
|
num_children++;
|
num_children++;
|
group->child_inputs = cvt->child_inputs_end;
|
group->child_inputs = cvt->child_inputs_end;
|
cvt->child_inputs_end += num_children;
|
cvt->child_inputs_end += num_children;
|
}
|
}
|
|
|
parent = group++;
|
parent = group++;
|
}
|
}
|
else
|
else
|
parent = 0;
|
parent = 0;
|
|
|
if (children)
|
if (children)
|
{
|
{
|
unsigned index = 0;
|
unsigned index = 0;
|
while (children->argp)
|
while (children->argp)
|
group =
|
group =
|
convert_options (children++->argp, parent, index++, group, cvt);
|
convert_options (children++->argp, parent, index++, group, cvt);
|
}
|
}
|
|
|
return group;
|
return group;
|
}
|
}
|
|
|
/* Find the merged set of getopt options, with keys appropiately prefixed. */
|
/* Find the merged set of getopt options, with keys appropiately prefixed. */
|
static void
|
static void
|
parser_convert (struct parser *parser, const struct argp *argp, int flags)
|
parser_convert (struct parser *parser, const struct argp *argp, int flags)
|
{
|
{
|
struct parser_convert_state cvt;
|
struct parser_convert_state cvt;
|
|
|
cvt.parser = parser;
|
cvt.parser = parser;
|
cvt.short_end = parser->short_opts;
|
cvt.short_end = parser->short_opts;
|
cvt.long_end = parser->long_opts;
|
cvt.long_end = parser->long_opts;
|
cvt.child_inputs_end = parser->child_inputs;
|
cvt.child_inputs_end = parser->child_inputs;
|
|
|
if (flags & ARGP_IN_ORDER)
|
if (flags & ARGP_IN_ORDER)
|
*cvt.short_end++ = '-';
|
*cvt.short_end++ = '-';
|
else if (flags & ARGP_NO_ARGS)
|
else if (flags & ARGP_NO_ARGS)
|
*cvt.short_end++ = '+';
|
*cvt.short_end++ = '+';
|
*cvt.short_end = '\0';
|
*cvt.short_end = '\0';
|
|
|
cvt.long_end->name = NULL;
|
cvt.long_end->name = NULL;
|
|
|
parser->argp = argp;
|
parser->argp = argp;
|
|
|
if (argp)
|
if (argp)
|
parser->egroup = convert_options (argp, 0, 0, parser->groups, &cvt);
|
parser->egroup = convert_options (argp, 0, 0, parser->groups, &cvt);
|
else
|
else
|
parser->egroup = parser->groups; /* No parsers at all! */
|
parser->egroup = parser->groups; /* No parsers at all! */
|
}
|
}
|
|
|
/* Lengths of various parser fields which we will allocated. */
|
/* Lengths of various parser fields which we will allocated. */
|
struct parser_sizes
|
struct parser_sizes
|
{
|
{
|
size_t short_len; /* Getopt short options string. */
|
size_t short_len; /* Getopt short options string. */
|
size_t long_len; /* Getopt long options vector. */
|
size_t long_len; /* Getopt long options vector. */
|
size_t num_groups; /* Group structures we allocate. */
|
size_t num_groups; /* Group structures we allocate. */
|
size_t num_child_inputs; /* Child input slots. */
|
size_t num_child_inputs; /* Child input slots. */
|
};
|
};
|
|
|
/* For ARGP, increments the NUM_GROUPS field in SZS by the total number of
|
/* For ARGP, increments the NUM_GROUPS field in SZS by the total number of
|
argp structures descended from it, and the SHORT_LEN & LONG_LEN fields by
|
argp structures descended from it, and the SHORT_LEN & LONG_LEN fields by
|
the maximum lengths of the resulting merged getopt short options string and
|
the maximum lengths of the resulting merged getopt short options string and
|
long-options array, respectively. */
|
long-options array, respectively. */
|
static void
|
static void
|
calc_sizes (const struct argp *argp, struct parser_sizes *szs)
|
calc_sizes (const struct argp *argp, struct parser_sizes *szs)
|
{
|
{
|
const struct argp_child *child = argp->children;
|
const struct argp_child *child = argp->children;
|
const struct argp_option *opt = argp->options;
|
const struct argp_option *opt = argp->options;
|
|
|
if (opt || argp->parser)
|
if (opt || argp->parser)
|
{
|
{
|
szs->num_groups++;
|
szs->num_groups++;
|
if (opt)
|
if (opt)
|
{
|
{
|
int num_opts = 0;
|
int num_opts = 0;
|
while (!__option_is_end (opt++))
|
while (!__option_is_end (opt++))
|
num_opts++;
|
num_opts++;
|
szs->short_len += num_opts * 3; /* opt + up to 2 `:'s */
|
szs->short_len += num_opts * 3; /* opt + up to 2 `:'s */
|
szs->long_len += num_opts;
|
szs->long_len += num_opts;
|
}
|
}
|
}
|
}
|
|
|
if (child)
|
if (child)
|
while (child->argp)
|
while (child->argp)
|
{
|
{
|
calc_sizes ((child++)->argp, szs);
|
calc_sizes ((child++)->argp, szs);
|
szs->num_child_inputs++;
|
szs->num_child_inputs++;
|
}
|
}
|
}
|
}
|
|
|
/* Initializes PARSER to parse ARGP in a manner described by FLAGS. */
|
/* Initializes PARSER to parse ARGP in a manner described by FLAGS. */
|
static error_t
|
static error_t
|
parser_init (struct parser *parser, const struct argp *argp,
|
parser_init (struct parser *parser, const struct argp *argp,
|
int argc, char **argv, int flags, void *input)
|
int argc, char **argv, int flags, void *input)
|
{
|
{
|
error_t err = 0;
|
error_t err = 0;
|
struct group *group;
|
struct group *group;
|
struct parser_sizes szs;
|
struct parser_sizes szs;
|
|
|
szs.short_len = (flags & ARGP_NO_ARGS) ? 0 : 1;
|
szs.short_len = (flags & ARGP_NO_ARGS) ? 0 : 1;
|
szs.long_len = 0;
|
szs.long_len = 0;
|
szs.num_groups = 0;
|
szs.num_groups = 0;
|
szs.num_child_inputs = 0;
|
szs.num_child_inputs = 0;
|
|
|
if (argp)
|
if (argp)
|
calc_sizes (argp, &szs);
|
calc_sizes (argp, &szs);
|
|
|
/* Lengths of the various bits of storage used by PARSER. */
|
/* Lengths of the various bits of storage used by PARSER. */
|
#define GLEN (szs.num_groups + 1) * sizeof (struct group)
|
#define GLEN (szs.num_groups + 1) * sizeof (struct group)
|
#define CLEN (szs.num_child_inputs * sizeof (void *))
|
#define CLEN (szs.num_child_inputs * sizeof (void *))
|
#define LLEN ((szs.long_len + 1) * sizeof (struct option))
|
#define LLEN ((szs.long_len + 1) * sizeof (struct option))
|
#define SLEN (szs.short_len + 1)
|
#define SLEN (szs.short_len + 1)
|
|
|
parser->storage = malloc (GLEN + CLEN + LLEN + SLEN);
|
parser->storage = malloc (GLEN + CLEN + LLEN + SLEN);
|
if (! parser->storage)
|
if (! parser->storage)
|
return ENOMEM;
|
return ENOMEM;
|
|
|
parser->groups = parser->storage;
|
parser->groups = parser->storage;
|
parser->child_inputs = parser->storage + GLEN;
|
parser->child_inputs = parser->storage + GLEN;
|
parser->long_opts = parser->storage + GLEN + CLEN;
|
parser->long_opts = parser->storage + GLEN + CLEN;
|
parser->short_opts = parser->storage + GLEN + CLEN + LLEN;
|
parser->short_opts = parser->storage + GLEN + CLEN + LLEN;
|
|
|
memset (parser->child_inputs, 0, szs.num_child_inputs * sizeof (void *));
|
memset (parser->child_inputs, 0, szs.num_child_inputs * sizeof (void *));
|
parser_convert (parser, argp, flags);
|
parser_convert (parser, argp, flags);
|
|
|
memset (&parser->state, 0, sizeof (struct argp_state));
|
memset (&parser->state, 0, sizeof (struct argp_state));
|
parser->state.root_argp = parser->argp;
|
parser->state.root_argp = parser->argp;
|
parser->state.argc = argc;
|
parser->state.argc = argc;
|
parser->state.argv = argv;
|
parser->state.argv = argv;
|
parser->state.flags = flags;
|
parser->state.flags = flags;
|
parser->state.err_stream = stderr;
|
parser->state.err_stream = stderr;
|
parser->state.out_stream = stdout;
|
parser->state.out_stream = stdout;
|
parser->state.next = 0; /* Tell getopt to initialize. */
|
parser->state.next = 0; /* Tell getopt to initialize. */
|
parser->state.pstate = parser;
|
parser->state.pstate = parser;
|
|
|
parser->try_getopt = 1;
|
parser->try_getopt = 1;
|
|
|
/* Call each parser for the first time, giving it a chance to propagate
|
/* Call each parser for the first time, giving it a chance to propagate
|
values to child parsers. */
|
values to child parsers. */
|
if (parser->groups < parser->egroup)
|
if (parser->groups < parser->egroup)
|
parser->groups->input = input;
|
parser->groups->input = input;
|
for (group = parser->groups;
|
for (group = parser->groups;
|
group < parser->egroup && (!err || err == EBADKEY);
|
group < parser->egroup && (!err || err == EBADKEY);
|
group++)
|
group++)
|
{
|
{
|
if (group->parent)
|
if (group->parent)
|
/* If a child parser, get the initial input value from the parent. */
|
/* If a child parser, get the initial input value from the parent. */
|
group->input = group->parent->child_inputs[group->parent_index];
|
group->input = group->parent->child_inputs[group->parent_index];
|
|
|
if (!group->parser
|
if (!group->parser
|
&& group->argp->children && group->argp->children->argp)
|
&& group->argp->children && group->argp->children->argp)
|
/* For the special case where no parsing function is supplied for an
|
/* For the special case where no parsing function is supplied for an
|
argp, propagate its input to its first child, if any (this just
|
argp, propagate its input to its first child, if any (this just
|
makes very simple wrapper argps more convenient). */
|
makes very simple wrapper argps more convenient). */
|
group->child_inputs[0] = group->input;
|
group->child_inputs[0] = group->input;
|
|
|
err = group_parse (group, &parser->state, ARGP_KEY_INIT, 0);
|
err = group_parse (group, &parser->state, ARGP_KEY_INIT, 0);
|
}
|
}
|
if (err == EBADKEY)
|
if (err == EBADKEY)
|
err = 0; /* Some parser didn't understand. */
|
err = 0; /* Some parser didn't understand. */
|
|
|
if (err)
|
if (err)
|
return err;
|
return err;
|
|
|
/* Getopt is (currently) non-reentrant. */
|
/* Getopt is (currently) non-reentrant. */
|
LOCK_GETOPT;
|
LOCK_GETOPT;
|
|
|
if (parser->state.flags & ARGP_NO_ERRS)
|
if (parser->state.flags & ARGP_NO_ERRS)
|
{
|
{
|
opterr = 0;
|
opterr = 0;
|
if (parser->state.flags & ARGP_PARSE_ARGV0)
|
if (parser->state.flags & ARGP_PARSE_ARGV0)
|
/* getopt always skips ARGV[0], so we have to fake it out. As long
|
/* 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. */
|
as OPTERR is 0, then it shouldn't actually try to access it. */
|
parser->state.argv--, parser->state.argc++;
|
parser->state.argv--, parser->state.argc++;
|
}
|
}
|
else
|
else
|
opterr = 1; /* Print error messages. */
|
opterr = 1; /* Print error messages. */
|
|
|
if (parser->state.argv == argv && argv[0])
|
if (parser->state.argv == argv && argv[0])
|
/* There's an argv[0]; use it for messages. */
|
/* There's an argv[0]; use it for messages. */
|
{
|
{
|
char *short_name = strrchr (argv[0], '/');
|
char *short_name = strrchr (argv[0], '/');
|
parser->state.name = short_name ? short_name + 1 : argv[0];
|
parser->state.name = short_name ? short_name + 1 : argv[0];
|
}
|
}
|
else
|
else
|
parser->state.name = program_invocation_short_name;
|
parser->state.name = program_invocation_short_name;
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Free any storage consumed by PARSER (but not PARSER itself). */
|
/* Free any storage consumed by PARSER (but not PARSER itself). */
|
static error_t
|
static error_t
|
parser_finalize (struct parser *parser,
|
parser_finalize (struct parser *parser,
|
error_t err, int arg_ebadkey, int *end_index)
|
error_t err, int arg_ebadkey, int *end_index)
|
{
|
{
|
struct group *group;
|
struct group *group;
|
|
|
UNLOCK_GETOPT;
|
UNLOCK_GETOPT;
|
|
|
if (err == EBADKEY && arg_ebadkey)
|
if (err == EBADKEY && arg_ebadkey)
|
/* Suppress errors generated by unparsed arguments. */
|
/* Suppress errors generated by unparsed arguments. */
|
err = 0;
|
err = 0;
|
|
|
if (! err)
|
if (! err)
|
{
|
{
|
if (parser->state.next == parser->state.argc)
|
if (parser->state.next == parser->state.argc)
|
/* We successfully parsed all arguments! Call all the parsers again,
|
/* We successfully parsed all arguments! Call all the parsers again,
|
just a few more times... */
|
just a few more times... */
|
{
|
{
|
for (group = parser->groups;
|
for (group = parser->groups;
|
group < parser->egroup && (!err || err==EBADKEY);
|
group < parser->egroup && (!err || err==EBADKEY);
|
group++)
|
group++)
|
if (group->args_processed == 0)
|
if (group->args_processed == 0)
|
err = group_parse (group, &parser->state, ARGP_KEY_NO_ARGS, 0);
|
err = group_parse (group, &parser->state, ARGP_KEY_NO_ARGS, 0);
|
for (group = parser->egroup - 1;
|
for (group = parser->egroup - 1;
|
group >= parser->groups && (!err || err==EBADKEY);
|
group >= parser->groups && (!err || err==EBADKEY);
|
group--)
|
group--)
|
err = group_parse (group, &parser->state, ARGP_KEY_END, 0);
|
err = group_parse (group, &parser->state, ARGP_KEY_END, 0);
|
|
|
if (err == EBADKEY)
|
if (err == EBADKEY)
|
err = 0; /* Some parser didn't understand. */
|
err = 0; /* Some parser didn't understand. */
|
|
|
/* Tell the user that all arguments are parsed. */
|
/* Tell the user that all arguments are parsed. */
|
if (end_index)
|
if (end_index)
|
*end_index = parser->state.next;
|
*end_index = parser->state.next;
|
}
|
}
|
else if (end_index)
|
else if (end_index)
|
/* Return any remaining arguments to the user. */
|
/* Return any remaining arguments to the user. */
|
*end_index = parser->state.next;
|
*end_index = parser->state.next;
|
else
|
else
|
/* No way to return the remaining arguments, they must be bogus. */
|
/* No way to return the remaining arguments, they must be bogus. */
|
{
|
{
|
if (!(parser->state.flags & ARGP_NO_ERRS)
|
if (!(parser->state.flags & ARGP_NO_ERRS)
|
&& parser->state.err_stream)
|
&& parser->state.err_stream)
|
fprintf (parser->state.err_stream,
|
fprintf (parser->state.err_stream,
|
dgettext (parser->argp->argp_domain,
|
dgettext (parser->argp->argp_domain,
|
"%s: Too many arguments\n"),
|
"%s: Too many arguments\n"),
|
parser->state.name);
|
parser->state.name);
|
err = EBADKEY;
|
err = EBADKEY;
|
}
|
}
|
}
|
}
|
|
|
/* Okay, we're all done, with either an error or success; call the parsers
|
/* Okay, we're all done, with either an error or success; call the parsers
|
to indicate which one. */
|
to indicate which one. */
|
|
|
if (err)
|
if (err)
|
{
|
{
|
/* Maybe print an error message. */
|
/* Maybe print an error message. */
|
if (err == EBADKEY)
|
if (err == EBADKEY)
|
/* An appropriate message describing what the error was should have
|
/* An appropriate message describing what the error was should have
|
been printed earlier. */
|
been printed earlier. */
|
__argp_state_help (&parser->state, parser->state.err_stream,
|
__argp_state_help (&parser->state, parser->state.err_stream,
|
ARGP_HELP_STD_ERR);
|
ARGP_HELP_STD_ERR);
|
|
|
/* Since we didn't exit, give each parser an error indication. */
|
/* Since we didn't exit, give each parser an error indication. */
|
for (group = parser->groups; group < parser->egroup; group++)
|
for (group = parser->groups; group < parser->egroup; group++)
|
group_parse (group, &parser->state, ARGP_KEY_ERROR, 0);
|
group_parse (group, &parser->state, ARGP_KEY_ERROR, 0);
|
}
|
}
|
else
|
else
|
/* Notify parsers of success, and propagate back values from parsers. */
|
/* Notify parsers of success, and propagate back values from parsers. */
|
{
|
{
|
/* We pass over the groups in reverse order so that child groups are
|
/* We pass over the groups in reverse order so that child groups are
|
given a chance to do there processing before passing back a value to
|
given a chance to do there processing before passing back a value to
|
the parent. */
|
the parent. */
|
for (group = parser->egroup - 1
|
for (group = parser->egroup - 1
|
; group >= parser->groups && (!err || err == EBADKEY)
|
; group >= parser->groups && (!err || err == EBADKEY)
|
; group--)
|
; group--)
|
err = group_parse (group, &parser->state, ARGP_KEY_SUCCESS, 0);
|
err = group_parse (group, &parser->state, ARGP_KEY_SUCCESS, 0);
|
if (err == EBADKEY)
|
if (err == EBADKEY)
|
err = 0; /* Some parser didn't understand. */
|
err = 0; /* Some parser didn't understand. */
|
}
|
}
|
|
|
/* Call parsers once more, to do any final cleanup. Errors are ignored. */
|
/* Call parsers once more, to do any final cleanup. Errors are ignored. */
|
for (group = parser->egroup - 1; group >= parser->groups; group--)
|
for (group = parser->egroup - 1; group >= parser->groups; group--)
|
group_parse (group, &parser->state, ARGP_KEY_FINI, 0);
|
group_parse (group, &parser->state, ARGP_KEY_FINI, 0);
|
|
|
if (err == EBADKEY)
|
if (err == EBADKEY)
|
err = EINVAL;
|
err = EINVAL;
|
|
|
free (parser->storage);
|
free (parser->storage);
|
|
|
return err;
|
return err;
|
}
|
}
|
|
|
/* Call the user parsers to parse the non-option argument VAL, at the current
|
/* Call the user parsers to parse the non-option argument VAL, at the current
|
position, returning any error. The state NEXT pointer is assumed to have
|
position, returning any error. The state NEXT pointer is assumed to have
|
been adjusted (by getopt) to point after this argument; this function will
|
been adjusted (by getopt) to point after this argument; this function will
|
adjust it correctly to reflect however many args actually end up being
|
adjust it correctly to reflect however many args actually end up being
|
consumed. */
|
consumed. */
|
static error_t
|
static error_t
|
parser_parse_arg (struct parser *parser, char *val)
|
parser_parse_arg (struct parser *parser, char *val)
|
{
|
{
|
/* Save the starting value of NEXT, first adjusting it so that the arg
|
/* Save the starting value of NEXT, first adjusting it so that the arg
|
we're parsing is again the front of the arg vector. */
|
we're parsing is again the front of the arg vector. */
|
int index = --parser->state.next;
|
int index = --parser->state.next;
|
error_t err = EBADKEY;
|
error_t err = EBADKEY;
|
struct group *group;
|
struct group *group;
|
int key = 0; /* Which of ARGP_KEY_ARG[S] we used. */
|
int key = 0; /* Which of ARGP_KEY_ARG[S] we used. */
|
|
|
/* Try to parse the argument in each parser. */
|
/* Try to parse the argument in each parser. */
|
for (group = parser->groups
|
for (group = parser->groups
|
; group < parser->egroup && err == EBADKEY
|
; group < parser->egroup && err == EBADKEY
|
; group++)
|
; group++)
|
{
|
{
|
parser->state.next++; /* For ARGP_KEY_ARG, consume the arg. */
|
parser->state.next++; /* For ARGP_KEY_ARG, consume the arg. */
|
key = ARGP_KEY_ARG;
|
key = ARGP_KEY_ARG;
|
err = group_parse (group, &parser->state, key, val);
|
err = group_parse (group, &parser->state, key, val);
|
|
|
if (err == EBADKEY)
|
if (err == EBADKEY)
|
/* This parser doesn't like ARGP_KEY_ARG; try ARGP_KEY_ARGS instead. */
|
/* This parser doesn't like ARGP_KEY_ARG; try ARGP_KEY_ARGS instead. */
|
{
|
{
|
parser->state.next--; /* For ARGP_KEY_ARGS, put back the arg. */
|
parser->state.next--; /* For ARGP_KEY_ARGS, put back the arg. */
|
key = ARGP_KEY_ARGS;
|
key = ARGP_KEY_ARGS;
|
err = group_parse (group, &parser->state, key, 0);
|
err = group_parse (group, &parser->state, key, 0);
|
}
|
}
|
}
|
}
|
|
|
if (! err)
|
if (! err)
|
{
|
{
|
if (key == ARGP_KEY_ARGS)
|
if (key == ARGP_KEY_ARGS)
|
/* The default for ARGP_KEY_ARGS is to assume that if NEXT isn't
|
/* The default for ARGP_KEY_ARGS is to assume that if NEXT isn't
|
changed by the user, *all* arguments should be considered
|
changed by the user, *all* arguments should be considered
|
consumed. */
|
consumed. */
|
parser->state.next = parser->state.argc;
|
parser->state.next = parser->state.argc;
|
|
|
if (parser->state.next > index)
|
if (parser->state.next > index)
|
/* Remember that we successfully processed a non-option
|
/* Remember that we successfully processed a non-option
|
argument -- but only if the user hasn't gotten tricky and set
|
argument -- but only if the user hasn't gotten tricky and set
|
the clock back. */
|
the clock back. */
|
(--group)->args_processed += (parser->state.next - index);
|
(--group)->args_processed += (parser->state.next - index);
|
else
|
else
|
/* The user wants to reparse some args, give getopt another try. */
|
/* The user wants to reparse some args, give getopt another try. */
|
parser->try_getopt = 1;
|
parser->try_getopt = 1;
|
}
|
}
|
|
|
return err;
|
return err;
|
}
|
}
|
|
|
/* Call the user parsers to parse the option OPT, with argument VAL, at the
|
/* Call the user parsers to parse the option OPT, with argument VAL, at the
|
current position, returning any error. */
|
current position, returning any error. */
|
static error_t
|
static error_t
|
parser_parse_opt (struct parser *parser, int opt, char *val)
|
parser_parse_opt (struct parser *parser, int opt, char *val)
|
{
|
{
|
/* The group key encoded in the high bits; 0 for short opts or
|
/* The group key encoded in the high bits; 0 for short opts or
|
group_number + 1 for long opts. */
|
group_number + 1 for long opts. */
|
int group_key = opt >> USER_BITS;
|
int group_key = opt >> USER_BITS;
|
error_t err = EBADKEY;
|
error_t err = EBADKEY;
|
|
|
if (group_key == 0)
|
if (group_key == 0)
|
/* A short option. By comparing OPT's position in SHORT_OPTS to the
|
/* A short option. By comparing OPT's position in SHORT_OPTS to the
|
various starting positions in each group's SHORT_END field, we can
|
various starting positions in each group's SHORT_END field, we can
|
determine which group OPT came from. */
|
determine which group OPT came from. */
|
{
|
{
|
struct group *group;
|
struct group *group;
|
char *short_index = strchr (parser->short_opts, opt);
|
char *short_index = strchr (parser->short_opts, opt);
|
|
|
if (short_index)
|
if (short_index)
|
for (group = parser->groups; group < parser->egroup; group++)
|
for (group = parser->groups; group < parser->egroup; group++)
|
if (group->short_end > short_index)
|
if (group->short_end > short_index)
|
{
|
{
|
err = group_parse (group, &parser->state, opt, optarg);
|
err = group_parse (group, &parser->state, opt, optarg);
|
break;
|
break;
|
}
|
}
|
}
|
}
|
else
|
else
|
/* A long option. We use shifts instead of masking for extracting
|
/* A long option. We use shifts instead of masking for extracting
|
the user value in order to preserve the sign. */
|
the user value in order to preserve the sign. */
|
err =
|
err =
|
group_parse (&parser->groups[group_key - 1], &parser->state,
|
group_parse (&parser->groups[group_key - 1], &parser->state,
|
(opt << GROUP_BITS) >> GROUP_BITS, optarg);
|
(opt << GROUP_BITS) >> GROUP_BITS, optarg);
|
|
|
if (err == EBADKEY)
|
if (err == EBADKEY)
|
/* At least currently, an option not recognized is an error in the
|
/* At least currently, an option not recognized is an error in the
|
parser, because we pre-compute which parser is supposed to deal
|
parser, because we pre-compute which parser is supposed to deal
|
with each option. */
|
with each option. */
|
{
|
{
|
static const char bad_key_err[] =
|
static const char bad_key_err[] =
|
N_("(PROGRAM ERROR) Option should have been recognized!?");
|
N_("(PROGRAM ERROR) Option should have been recognized!?");
|
if (group_key == 0)
|
if (group_key == 0)
|
__argp_error (&parser->state, "-%c: %s", opt,
|
__argp_error (&parser->state, "-%c: %s", opt,
|
dgettext (parser->argp->argp_domain, bad_key_err));
|
dgettext (parser->argp->argp_domain, bad_key_err));
|
else
|
else
|
{
|
{
|
struct option *long_opt = parser->long_opts;
|
struct option *long_opt = parser->long_opts;
|
while (long_opt->val != opt && long_opt->name)
|
while (long_opt->val != opt && long_opt->name)
|
long_opt++;
|
long_opt++;
|
__argp_error (&parser->state, "--%s: %s",
|
__argp_error (&parser->state, "--%s: %s",
|
long_opt->name ? long_opt->name : "???",
|
long_opt->name ? long_opt->name : "???",
|
dgettext (parser->argp->argp_domain, bad_key_err));
|
dgettext (parser->argp->argp_domain, bad_key_err));
|
}
|
}
|
}
|
}
|
|
|
return err;
|
return err;
|
}
|
}
|
|
|
/* Parse the next argument in PARSER (as indicated by PARSER->state.next).
|
/* Parse the next argument in PARSER (as indicated by PARSER->state.next).
|
Any error from the parsers is returned, and *ARGP_EBADKEY indicates
|
Any error from the parsers is returned, and *ARGP_EBADKEY indicates
|
whether a value of EBADKEY is due to an unrecognized argument (which is
|
whether a value of EBADKEY is due to an unrecognized argument (which is
|
generally not fatal). */
|
generally not fatal). */
|
static error_t
|
static error_t
|
parser_parse_next (struct parser *parser, int *arg_ebadkey)
|
parser_parse_next (struct parser *parser, int *arg_ebadkey)
|
{
|
{
|
int opt;
|
int opt;
|
error_t err = 0;
|
error_t err = 0;
|
|
|
if (parser->state.quoted && parser->state.next < parser->state.quoted)
|
if (parser->state.quoted && parser->state.next < parser->state.quoted)
|
/* The next argument pointer has been moved to before the quoted
|
/* The next argument pointer has been moved to before the quoted
|
region, so pretend we never saw the quoting `--', and give getopt
|
region, so pretend we never saw the quoting `--', and give getopt
|
another chance. If the user hasn't removed it, getopt will just
|
another chance. If the user hasn't removed it, getopt will just
|
process it again. */
|
process it again. */
|
parser->state.quoted = 0;
|
parser->state.quoted = 0;
|
|
|
if (parser->try_getopt && !parser->state.quoted)
|
if (parser->try_getopt && !parser->state.quoted)
|
/* Give getopt a chance to parse this. */
|
/* Give getopt a chance to parse this. */
|
{
|
{
|
optind = parser->state.next; /* Put it back in OPTIND for getopt. */
|
optind = parser->state.next; /* Put it back in OPTIND for getopt. */
|
optopt = KEY_END; /* Distinguish KEY_ERR from a real option. */
|
optopt = KEY_END; /* Distinguish KEY_ERR from a real option. */
|
if (parser->state.flags & ARGP_LONG_ONLY)
|
if (parser->state.flags & ARGP_LONG_ONLY)
|
opt = getopt_long_only (parser->state.argc, parser->state.argv,
|
opt = getopt_long_only (parser->state.argc, parser->state.argv,
|
parser->short_opts, parser->long_opts, 0);
|
parser->short_opts, parser->long_opts, 0);
|
else
|
else
|
opt = getopt_long (parser->state.argc, parser->state.argv,
|
opt = getopt_long (parser->state.argc, parser->state.argv,
|
parser->short_opts, parser->long_opts, 0);
|
parser->short_opts, parser->long_opts, 0);
|
parser->state.next = optind; /* And see what getopt did. */
|
parser->state.next = optind; /* And see what getopt did. */
|
|
|
if (opt == KEY_END)
|
if (opt == KEY_END)
|
/* Getopt says there are no more options, so stop using
|
/* Getopt says there are no more options, so stop using
|
getopt; we'll continue if necessary on our own. */
|
getopt; we'll continue if necessary on our own. */
|
{
|
{
|
parser->try_getopt = 0;
|
parser->try_getopt = 0;
|
if (parser->state.next > 1
|
if (parser->state.next > 1
|
&& strcmp (parser->state.argv[parser->state.next - 1], QUOTE)
|
&& strcmp (parser->state.argv[parser->state.next - 1], QUOTE)
|
== 0)
|
== 0)
|
/* Not only is this the end of the options, but it's a
|
/* Not only is this the end of the options, but it's a
|
`quoted' region, which may have args that *look* like
|
`quoted' region, which may have args that *look* like
|
options, so we definitely shouldn't try to use getopt past
|
options, so we definitely shouldn't try to use getopt past
|
here, whatever happens. */
|
here, whatever happens. */
|
parser->state.quoted = parser->state.next;
|
parser->state.quoted = parser->state.next;
|
}
|
}
|
else if (opt == KEY_ERR && optopt != KEY_END)
|
else if (opt == KEY_ERR && optopt != KEY_END)
|
/* KEY_ERR can have the same value as a valid user short
|
/* KEY_ERR can have the same value as a valid user short
|
option, but in the case of a real error, getopt sets OPTOPT
|
option, but in the case of a real error, getopt sets OPTOPT
|
to the offending character, which can never be KEY_END. */
|
to the offending character, which can never be KEY_END. */
|
{
|
{
|
*arg_ebadkey = 0;
|
*arg_ebadkey = 0;
|
return EBADKEY;
|
return EBADKEY;
|
}
|
}
|
}
|
}
|
else
|
else
|
opt = KEY_END;
|
opt = KEY_END;
|
|
|
if (opt == KEY_END)
|
if (opt == KEY_END)
|
{
|
{
|
/* We're past what getopt considers the options. */
|
/* We're past what getopt considers the options. */
|
if (parser->state.next >= parser->state.argc
|
if (parser->state.next >= parser->state.argc
|
|| (parser->state.flags & ARGP_NO_ARGS))
|
|| (parser->state.flags & ARGP_NO_ARGS))
|
/* Indicate that we're done. */
|
/* Indicate that we're done. */
|
{
|
{
|
*arg_ebadkey = 1;
|
*arg_ebadkey = 1;
|
return EBADKEY;
|
return EBADKEY;
|
}
|
}
|
else
|
else
|
/* A non-option arg; simulate what getopt might have done. */
|
/* A non-option arg; simulate what getopt might have done. */
|
{
|
{
|
opt = KEY_ARG;
|
opt = KEY_ARG;
|
optarg = parser->state.argv[parser->state.next++];
|
optarg = parser->state.argv[parser->state.next++];
|
}
|
}
|
}
|
}
|
|
|
if (opt == KEY_ARG)
|
if (opt == KEY_ARG)
|
/* A non-option argument; try each parser in turn. */
|
/* A non-option argument; try each parser in turn. */
|
err = parser_parse_arg (parser, optarg);
|
err = parser_parse_arg (parser, optarg);
|
else
|
else
|
err = parser_parse_opt (parser, opt, optarg);
|
err = parser_parse_opt (parser, opt, optarg);
|
|
|
if (err == EBADKEY)
|
if (err == EBADKEY)
|
*arg_ebadkey = (opt == KEY_END || opt == KEY_ARG);
|
*arg_ebadkey = (opt == KEY_END || opt == KEY_ARG);
|
|
|
return err;
|
return err;
|
}
|
}
|
|
|
/* Parse the options strings in ARGC & ARGV according to the argp in ARGP.
|
/* Parse the options strings in ARGC & ARGV according to the argp in ARGP.
|
FLAGS is one of the ARGP_ flags above. If END_INDEX is non-NULL, the
|
FLAGS is one of the ARGP_ flags above. If END_INDEX is non-NULL, the
|
index in ARGV of the first unparsed option is returned in it. If an
|
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
|
unknown option is present, EINVAL is returned; if some parser routine
|
returned a non-zero value, it is returned; otherwise 0 is returned. */
|
returned a non-zero value, it is returned; otherwise 0 is returned. */
|
error_t
|
error_t
|
__argp_parse (const struct argp *argp, int argc, char **argv, unsigned flags,
|
__argp_parse (const struct argp *argp, int argc, char **argv, unsigned flags,
|
int *end_index, void *input)
|
int *end_index, void *input)
|
{
|
{
|
error_t err;
|
error_t err;
|
struct parser parser;
|
struct parser parser;
|
|
|
/* If true, then err == EBADKEY is a result of a non-option argument failing
|
/* If true, then err == EBADKEY is a result of a non-option argument failing
|
to be parsed (which in some cases isn't actually an error). */
|
to be parsed (which in some cases isn't actually an error). */
|
int arg_ebadkey = 0;
|
int arg_ebadkey = 0;
|
|
|
if (! (flags & ARGP_NO_HELP))
|
if (! (flags & ARGP_NO_HELP))
|
/* Add our own options. */
|
/* Add our own options. */
|
{
|
{
|
struct argp_child *child = alloca (4 * sizeof (struct argp_child));
|
struct argp_child *child = alloca (4 * sizeof (struct argp_child));
|
struct argp *top_argp = alloca (sizeof (struct argp));
|
struct argp *top_argp = alloca (sizeof (struct argp));
|
|
|
/* TOP_ARGP has no options, it just serves to group the user & default
|
/* TOP_ARGP has no options, it just serves to group the user & default
|
argps. */
|
argps. */
|
memset (top_argp, 0, sizeof (*top_argp));
|
memset (top_argp, 0, sizeof (*top_argp));
|
top_argp->children = child;
|
top_argp->children = child;
|
|
|
memset (child, 0, 4 * sizeof (struct argp_child));
|
memset (child, 0, 4 * sizeof (struct argp_child));
|
|
|
if (argp)
|
if (argp)
|
(child++)->argp = argp;
|
(child++)->argp = argp;
|
(child++)->argp = &argp_default_argp;
|
(child++)->argp = &argp_default_argp;
|
if (argp_program_version || argp_program_version_hook)
|
if (argp_program_version || argp_program_version_hook)
|
(child++)->argp = &argp_version_argp;
|
(child++)->argp = &argp_version_argp;
|
child->argp = 0;
|
child->argp = 0;
|
|
|
argp = top_argp;
|
argp = top_argp;
|
}
|
}
|
|
|
/* Construct a parser for these arguments. */
|
/* Construct a parser for these arguments. */
|
err = parser_init (&parser, argp, argc, argv, flags, input);
|
err = parser_init (&parser, argp, argc, argv, flags, input);
|
|
|
if (! err)
|
if (! err)
|
/* Parse! */
|
/* Parse! */
|
{
|
{
|
while (! err)
|
while (! err)
|
err = parser_parse_next (&parser, &arg_ebadkey);
|
err = parser_parse_next (&parser, &arg_ebadkey);
|
err = parser_finalize (&parser, err, arg_ebadkey, end_index);
|
err = parser_finalize (&parser, err, arg_ebadkey, end_index);
|
}
|
}
|
|
|
return err;
|
return err;
|
}
|
}
|
#ifdef weak_alias
|
#ifdef weak_alias
|
weak_alias (__argp_parse, argp_parse)
|
weak_alias (__argp_parse, argp_parse)
|
#endif
|
#endif
|
|
|
/* Return the input field for ARGP in the parser corresponding to STATE; used
|
/* Return the input field for ARGP in the parser corresponding to STATE; used
|
by the help routines. */
|
by the help routines. */
|
void *
|
void *
|
__argp_input (const struct argp *argp, const struct argp_state *state)
|
__argp_input (const struct argp *argp, const struct argp_state *state)
|
{
|
{
|
if (state)
|
if (state)
|
{
|
{
|
struct group *group;
|
struct group *group;
|
struct parser *parser = state->pstate;
|
struct parser *parser = state->pstate;
|
|
|
for (group = parser->groups; group < parser->egroup; group++)
|
for (group = parser->groups; group < parser->egroup; group++)
|
if (group->argp == argp)
|
if (group->argp == argp)
|
return group->input;
|
return group->input;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
#ifdef weak_alias
|
#ifdef weak_alias
|
weak_alias (__argp_input, _argp_input)
|
weak_alias (__argp_input, _argp_input)
|
#endif
|
#endif
|
|
|
