Use __asprintf and __fwprintf instead of asprintf and fwprintf.
[kopensolaris-gnu/glibc.git] / argp / argp-parse.c
index f1f4ce9..02dbfac 100644 (file)
@@ -1,22 +1,22 @@
 /* Hierarchial argument parsing, layered over getopt
-   Copyright (C) 1995, 1996, 1997 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.
    Written by Miles Bader <miles@gnu.ai.mit.edu>.
 
    The GNU C Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public License as
-   published by the Free Software Foundation; either version 2 of the
-   License, or (at your option) any later version.
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   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,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
+   Lesser General Public License for more details.
 
-   You should have received a copy of the GNU Library General Public
-   License along with the GNU C Library; see the file COPYING.LIB.  If not,
-   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   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
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #ifndef _
 /* This is for other GNU distributions with internationalized messages.
    When compiling libc, the _ macro is predefined.  */
-#ifdef HAVE_LIBINTL_H
-# include <libintl.h>
-# define _(msgid)       gettext (msgid)
-#else
-# define _(msgid)       (msgid)
-# define gettext(msgid) (msgid)
+# if defined HAVE_LIBINTL_H || defined _LIBC
+#  include <libintl.h>
+#  ifdef _LIBC
+#   undef dgettext
+#   define dgettext(domain, msgid) __dcgettext (domain, msgid, LC_MESSAGES)
+#  endif
+# else
+#  define dgettext(domain, msgid) (msgid)
+#  define gettext(msgid) (msgid)
+# endif
 #endif
+#ifndef N_
+# define N_(msgid) (msgid)
 #endif
 
 #if _LIBC - 0
-#include <libc-lock.h>
+#include <bits/libc-lock.h>
 #else
 #ifdef HAVE_CTHREADS_H
 #include <cthreads.h>
@@ -76,7 +82,7 @@
    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
    it to 0 yourself.  */
-volatile int _argp_hang = 0;
+volatile int _argp_hang;
 
 #define OPT_PROGNAME   -2
 #define OPT_USAGE      -3
@@ -84,11 +90,11 @@ volatile int _argp_hang = 0;
 
 static const struct argp_option argp_default_options[] =
 {
-  {"help",       '?',          0, 0,  "Give this help list", -1},
-  {"usage",      OPT_USAGE,    0, 0,  "Give a short usage message"},
-  {"program-name",OPT_PROGNAME,"NAME", OPTION_HIDDEN, "Set the program name"},
+  {"help",       '?',          0, 0,  N_("Give this help list"), -1},
+  {"usage",      OPT_USAGE,    0, 0,  N_("Give a short usage message")},
+  {"program-name",OPT_PROGNAME,"NAME", OPTION_HIDDEN, N_("Set the program name")},
   {"HANG",       OPT_HANG,    "SECS", OPTION_ARG_OPTIONAL | OPTION_HIDDEN,
-     "Hang for SECS seconds (default 3600)"},
+     N_("Hang for SECS seconds (default 3600)")},
   {0, 0}
 };
 
@@ -117,9 +123,13 @@ argp_default_parser (int key, char *arg, struct argp_state *state)
       else
        program_invocation_short_name = program_invocation_name;
 
+      /* Update what we use for messages.  */
+      state->name = program_invocation_short_name;
+
       if ((state->flags & (ARGP_PARSE_ARGV0 | ARGP_NO_ERRS))
          == ARGP_PARSE_ARGV0)
-       state->argv[0] = program_invocation_name; /* Update what getopt uses too.  */
+       /* Update what getopt uses too.  */
+       state->argv[0] = program_invocation_name;
 
       break;
 
@@ -136,12 +146,12 @@ argp_default_parser (int key, char *arg, struct argp_state *state)
 }
 
 static const struct argp argp_default_argp =
-  {argp_default_options, &argp_default_parser};
+  {argp_default_options, &argp_default_parser, NULL, NULL, NULL, NULL, "libc"};
 
 \f
 static const struct argp_option argp_version_options[] =
 {
-  {"version",    'V',          0, 0,  "Print program version", -1},
+  {"version",    'V',          0, 0,  N_("Print program version"), -1},
   {0, 0}
 };
 
@@ -156,7 +166,8 @@ argp_version_parser (int key, char *arg, struct argp_state *state)
       else if (argp_program_version)
        fprintf (state->out_stream, "%s\n", argp_program_version);
       else
-       __argp_error (state, _("No version known!?"));
+       __argp_error (state, dgettext (state->root_argp->argp_domain,
+                                      "(PROGRAM ERROR) No version known!?"));
       if (! (state->flags & ARGP_NO_EXIT))
        exit (0);
       break;
@@ -167,7 +178,7 @@ argp_version_parser (int key, char *arg, struct argp_state *state)
 }
 
 static const struct argp argp_version_argp =
-  {argp_version_options, &argp_version_parser};
+  {argp_version_options, &argp_version_parser, NULL, NULL, NULL, NULL, "libc"};
 \f
 /* 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
@@ -231,6 +242,9 @@ struct group
   /* This group's parsing function.  */
   argp_parser_t parser;
 
+  /* Which argp this group is from.  */
+  const struct argp *argp;
+
   /* 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.  */
@@ -380,6 +394,7 @@ convert_options (const struct argp *argp,
            }
 
       group->parser = argp->parser;
+      group->argp = argp;
       group->short_end = cvt->short_end;
       group->args_processed = 0;
       group->parent = parent;
@@ -517,15 +532,17 @@ parser_init (struct parser *parser, const struct argp *argp,
   memset (parser->child_inputs, 0, szs.num_child_inputs * sizeof (void *));
   parser_convert (parser, argp, flags);
 
-  parser->try_getopt = 1;
-
   memset (&parser->state, 0, sizeof (struct argp_state));
-  parser->state.argp = parser->argp;
+  parser->state.root_argp = parser->argp;
   parser->state.argc = argc;
   parser->state.argv = argv;
+  parser->state.flags = flags;
   parser->state.err_stream = stderr;
   parser->state.out_stream = stdout;
   parser->state.next = 0;      /* Tell getopt to initialize.  */
+  parser->state.pstate = parser;
+
+  parser->try_getopt = 1;
 
   /* Call each parser for the first time, giving it a chance to propagate
      values to child parsers.  */
@@ -538,6 +555,14 @@ parser_init (struct parser *parser, const struct argp *argp,
       if (group->parent)
        /* If a child parser, get the initial input value from the parent. */
        group->input = group->parent->child_inputs[group->parent_index];
+
+      if (!group->parser
+         && group->argp->children && group->argp->children->argp)
+       /* For the special case where no parsing function is supplied for an
+          argp, propagate its input to its first child, if any (this just
+          makes very simple wrapper argps more convenient).  */
+       group->child_inputs[0] = group->input;
+
       err = group_parse (group, &parser->state, ARGP_KEY_INIT, 0);
     }
   if (err == EBADKEY)
@@ -546,12 +571,6 @@ parser_init (struct parser *parser, const struct argp *argp,
   if (err)
     return err;
 
-  if (parser->state.argv == argv && argv[0])
-    /* There's an argv[0]; use it for messages.  */
-    parser->state.name = argv[0];
-  else
-    parser->state.name = program_invocation_name;
-
   /* Getopt is (currently) non-reentrant.  */
   LOCK_GETOPT;
 
@@ -566,6 +585,15 @@ parser_init (struct parser *parser, const struct argp *argp,
   else
     opterr = 1;                /* Print error messages.  */
 
+  if (parser->state.argv == argv && argv[0])
+    /* There's an argv[0]; use it for messages.  */
+    {
+      char *short_name = strrchr (argv[0], '/');
+      parser->state.name = short_name ? short_name + 1 : argv[0];
+    }
+  else
+    parser->state.name = program_invocation_short_name;
+
   return 0;
 }
 \f
@@ -583,37 +611,46 @@ parser_finalize (struct parser *parser,
     err = 0;
 
   if (! err)
-    if (parser->state.next == parser->state.argc)
-      /* We successfully parsed all arguments!  Call all the parsers again,
-        just a few more times... */
-      {
-       for (group = parser->groups;
-            group < parser->egroup && (!err || err==EBADKEY);
-            group++)
-         if (group->args_processed == 0)
-           err = group_parse (group, &parser->state, ARGP_KEY_NO_ARGS, 0);
-       for (group = parser->groups;
-            group < parser->egroup && (!err || err==EBADKEY);
-            group++)
-         err = group_parse (group, &parser->state, ARGP_KEY_END, 0);
-
-       if (err == EBADKEY)
-         err = 0;              /* Some parser didn't understand.  */
-      }
-    else if (end_index)
-      /* Return any remaining arguments to the user.  */
-      *end_index = parser->state.next;
-    else
-      /* No way to return the remaining arguments, they must be bogus. */
-      {
-       if (!(parser->state.flags & ARGP_NO_ERRS) && parser->state.err_stream)
-         fprintf (parser->state.err_stream,
-                  _("%s: Too many arguments\n"), parser->state.name);
-       err = EBADKEY;
-      }
+    {
+      if (parser->state.next == parser->state.argc)
+       /* We successfully parsed all arguments!  Call all the parsers again,
+          just a few more times... */
+       {
+         for (group = parser->groups;
+              group < parser->egroup && (!err || err==EBADKEY);
+              group++)
+           if (group->args_processed == 0)
+             err = group_parse (group, &parser->state, ARGP_KEY_NO_ARGS, 0);
+         for (group = parser->egroup - 1;
+              group >= parser->groups && (!err || err==EBADKEY);
+              group--)
+           err = group_parse (group, &parser->state, ARGP_KEY_END, 0);
+
+         if (err == EBADKEY)
+           err = 0;            /* Some parser didn't understand.  */
+
+         /* Tell the user that all arguments are parsed.  */
+         if (end_index)
+           *end_index = parser->state.next;
+       }
+      else if (end_index)
+       /* Return any remaining arguments to the user.  */
+       *end_index = parser->state.next;
+      else
+       /* No way to return the remaining arguments, they must be bogus. */
+       {
+         if (!(parser->state.flags & ARGP_NO_ERRS)
+             && parser->state.err_stream)
+           fprintf (parser->state.err_stream,
+                    dgettext (parser->argp->argp_domain,
+                              "%s: Too many arguments\n"),
+                    parser->state.name);
+         err = EBADKEY;
+       }
+    }
 
-  /* Okay, we're all done, with either an error or success.  We only call the
-     parsers once more, to indicate which one.  */
+  /* Okay, we're all done, with either an error or success; call the parsers
+     to indicate which one.  */
 
   if (err)
     {
@@ -629,7 +666,7 @@ parser_finalize (struct parser *parser,
        group_parse (group, &parser->state, ARGP_KEY_ERROR, 0);
     }
   else
-    /* Do final cleanup, including propagating 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
         given a chance to do there processing before passing back a value to
@@ -642,6 +679,10 @@ parser_finalize (struct parser *parser,
        err = 0;                /* Some parser didn't understand.  */
     }
 
+  /* Call parsers once more, to do any final cleanup.  Errors are ignored.  */
+  for (group = parser->egroup - 1; group >= parser->groups; group--)
+    group_parse (group, &parser->state, ARGP_KEY_FINI, 0);
+
   if (err == EBADKEY)
     err = EINVAL;
 
@@ -651,28 +692,55 @@ parser_finalize (struct parser *parser,
 }
 \f
 /* Call the user parsers to parse the non-option argument VAL, at the current
-   position, returning any error.  */
+   position, returning any error.  The state NEXT pointer is assumed to have
+   been adjusted (by getopt) to point after this argument; this function will
+   adjust it correctly to reflect however many args actually end up being
+   consumed.  */
 static error_t
 parser_parse_arg (struct parser *parser, char *val)
 {
-  int index = parser->state.next;
+  /* Save the starting value of NEXT, first adjusting it so that the arg
+     we're parsing is again the front of the arg vector.  */
+  int index = --parser->state.next;
   error_t err = EBADKEY;
   struct group *group;
+  int key = 0;                 /* Which of ARGP_KEY_ARG[S] we used.  */
 
+  /* Try to parse the argument in each parser.  */
   for (group = parser->groups
        ; group < parser->egroup && err == EBADKEY
        ; group++)
-    err = group_parse (group, &parser->state, ARGP_KEY_ARG, val);
-
-  if (!err)
-    if (parser->state.next >= index)
-      /* Remember that we successfully processed a non-option
-        argument -- but only if the user hasn't gotten tricky and set
-        the clock back.  */
-      (--group)->args_processed++;
-    else
-      /* The user wants to reparse some args, give getopt another try.  */
-      parser->try_getopt = 1;
+    {
+      parser->state.next++;    /* For ARGP_KEY_ARG, consume the arg.  */
+      key = ARGP_KEY_ARG;
+      err = group_parse (group, &parser->state, key, val);
+
+      if (err == EBADKEY)
+       /* This parser doesn't like ARGP_KEY_ARG; try ARGP_KEY_ARGS instead. */
+       {
+         parser->state.next--; /* For ARGP_KEY_ARGS, put back the arg.  */
+         key = ARGP_KEY_ARGS;
+         err = group_parse (group, &parser->state, key, 0);
+       }
+    }
+
+  if (! err)
+    {
+      if (key == ARGP_KEY_ARGS)
+       /* The default for ARGP_KEY_ARGS is to assume that if NEXT isn't
+          changed by the user, *all* arguments should be considered
+          consumed.  */
+       parser->state.next = parser->state.argc;
+
+      if (parser->state.next > index)
+       /* Remember that we successfully processed a non-option
+          argument -- but only if the user hasn't gotten tricky and set
+          the clock back.  */
+       (--group)->args_processed += (parser->state.next - index);
+      else
+       /* The user wants to reparse some args, give getopt another try.  */
+       parser->try_getopt = 1;
+    }
 
   return err;
 }
@@ -685,6 +753,7 @@ parser_parse_opt (struct parser *parser, int opt, char *val)
   /* 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;
+  error_t err = EBADKEY;
 
   if (group_key == 0)
     /* A short option.  By comparing OPT's position in SHORT_OPTS to the
@@ -697,16 +766,40 @@ parser_parse_opt (struct parser *parser, int opt, char *val)
       if (short_index)
        for (group = parser->groups; group < parser->egroup; group++)
          if (group->short_end > short_index)
-           return group_parse (group, &parser->state, opt, optarg);
-
-      return EBADKEY;          /* until otherwise asserted */
+           {
+             err = group_parse (group, &parser->state, opt, optarg);
+             break;
+           }
     }
   else
     /* A long option.  We use shifts instead of masking for extracting
        the user value in order to preserve the sign.  */
-    return
+    err =
       group_parse (&parser->groups[group_key - 1], &parser->state,
                   (opt << GROUP_BITS) >> GROUP_BITS, optarg);
+
+  if (err == EBADKEY)
+    /* At least currently, an option not recognized is an error in the
+       parser, because we pre-compute which parser is supposed to deal
+       with each option.  */
+    {
+      static const char bad_key_err[] =
+       N_("(PROGRAM ERROR) Option should have been recognized!?");
+      if (group_key == 0)
+       __argp_error (&parser->state, "-%c: %s", opt,
+                     dgettext (parser->argp->argp_domain, bad_key_err));
+      else
+       {
+         struct option *long_opt = parser->long_opts;
+         while (long_opt->val != opt && long_opt->name)
+           long_opt++;
+         __argp_error (&parser->state, "--%s: %s",
+                       long_opt->name ? long_opt->name : "???",
+                       dgettext (parser->argp->argp_domain, bad_key_err));
+       }
+    }
+
+  return err;
 }
 \f
 /* Parse the next argument in PARSER (as indicated by PARSER->state.next).
@@ -766,29 +859,31 @@ parser_parse_next (struct parser *parser, int *arg_ebadkey)
     opt = KEY_END;
 
   if (opt == KEY_END)
-    /* We're past what getopt considers the options.  */
-    if (parser->state.next >= parser->state.argc
-       || (parser->state.flags & ARGP_NO_ARGS))
-      /* Indicate that we're done.  */
-      {
-       *arg_ebadkey = 1;
-       return EBADKEY;
-      }
-    else
-      /* A non-option arg.  */
-      err =
-       parser_parse_arg (parser, parser->state.argv[parser->state.next++]);
-  else if (opt == KEY_ARG)
+    {
+      /* We're past what getopt considers the options.  */
+      if (parser->state.next >= parser->state.argc
+         || (parser->state.flags & ARGP_NO_ARGS))
+       /* Indicate that we're done.  */
+       {
+         *arg_ebadkey = 1;
+         return EBADKEY;
+       }
+      else
+       /* A non-option arg; simulate what getopt might have done.  */
+       {
+         opt = KEY_ARG;
+         optarg = parser->state.argv[parser->state.next++];
+       }
+    }
+
+  if (opt == KEY_ARG)
     /* A non-option argument; try each parser in turn.  */
     err = parser_parse_arg (parser, optarg);
   else
     err = parser_parse_opt (parser, opt, optarg);
 
   if (err == EBADKEY)
-    {
-      *arg_ebadkey = (opt == KEY_END || opt == KEY_ARG);
-      parser->state.next--;    /* Put back the unused argument.  */
-    }
+    *arg_ebadkey = (opt == KEY_END || opt == KEY_ARG);
 
   return err;
 }
@@ -848,3 +943,24 @@ __argp_parse (const struct argp *argp, int argc, char **argv, unsigned flags,
 #ifdef weak_alias
 weak_alias (__argp_parse, argp_parse)
 #endif
+\f
+/* Return the input field for ARGP in the parser corresponding to STATE; used
+   by the help routines.  */
+void *
+__argp_input (const struct argp *argp, const struct argp_state *state)
+{
+  if (state)
+    {
+      struct group *group;
+      struct parser *parser = state->pstate;
+
+      for (group = parser->groups; group < parser->egroup; group++)
+       if (group->argp == argp)
+         return group->input;
+    }
+
+  return 0;
+}
+#ifdef weak_alias
+weak_alias (__argp_input, _argp_input)
+#endif