Subversion Repositories openrisc

/* Hierarchial argument parsing help output

   Copyright (C) 1995-2000, 2001 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 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

   Lesser General Public License for more details.

   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.  */

#ifndef _GNU_SOURCE

# define _GNU_SOURCE    1

#endif

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#ifndef alloca

# ifdef __GNUC__

#  define alloca __builtin_alloca

#  define HAVE_ALLOCA 1

# else

#  if defined HAVE_ALLOCA_H || defined _LIBC

#   include <alloca.h>

#  else

#   ifdef _AIX

 #pragma alloca

#   else

#    ifndef alloca

char *alloca ();

#    endif

#   endif

#  endif

# endif

#endif

#include <stddef.h>

#include <stdlib.h>

#include <string.h>

#include <assert.h>

#include <stdarg.h>

#include <malloc.h>

#include <ctype.h>

#ifdef USE_IN_LIBIO

# include <wchar.h>

#endif

#ifndef _

/* This is for other GNU distributions with internationalized messages.  */

# 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)

# endif

#endif

#include <argp.h>

#include "argp-fmtstream.h"

#include "argp-namefrob.h"

/* User-selectable (using an environment variable) formatting parameters.

   These may be specified in an environment variable called `ARGP_HELP_FMT',

   with a contents like:  VAR1=VAL1,VAR2=VAL2,BOOLVAR2,no-BOOLVAR2

   Where VALn must be a positive integer.  The list of variables is in the

   UPARAM_NAMES vector, below.  */

/* Default parameters.  */

#define DUP_ARGS      0         /* True if option argument can be duplicated. */

#define DUP_ARGS_NOTE 1         /* True to print a note about duplicate args. */

#define SHORT_OPT_COL 2         /* column in which short options start */

#define LONG_OPT_COL  6         /* column in which long options start */

#define DOC_OPT_COL   2         /* column in which doc options start */

#define OPT_DOC_COL  29         /* column in which option text starts */

#define HEADER_COL    1         /* column in which group headers are printed */

#define USAGE_INDENT 12         /* indentation of wrapped usage lines */

#define RMARGIN      79         /* right margin used for wrapping */

/* User-selectable (using an environment variable) formatting parameters.

   They must all be of type `int' for the parsing code to work.  */

struct uparams

{

  /* If true, arguments for an option are shown with both short and long

     options, even when a given option has both, e.g. `-x ARG, --longx=ARG'.

     If false, then if an option has both, the argument is only shown with

     the long one, e.g., `-x, --longx=ARG', and a message indicating that

     this really means both is printed below the options.  */

  int dup_args;

  /* This is true if when DUP_ARGS is false, and some duplicate arguments have

     been suppressed, an explanatory message should be printed.  */

  int dup_args_note;

  /* Various output columns.  */

  int short_opt_col;

  int long_opt_col;

  int doc_opt_col;

  int opt_doc_col;

  int header_col;

  int usage_indent;

  int rmargin;

  int valid;                    /* True when the values in here are valid.  */

};

/* This is a global variable, as user options are only ever read once.  */

static struct uparams uparams = {

  DUP_ARGS, DUP_ARGS_NOTE,

  SHORT_OPT_COL, LONG_OPT_COL, DOC_OPT_COL, OPT_DOC_COL, HEADER_COL,

  USAGE_INDENT, RMARGIN,

};

/* A particular uparam, and what the user name is.  */

struct uparam_name

{

  const char *name;             /* User name.  */

  int is_bool;                  /* Whether it's `boolean'.  */

  size_t uparams_offs;          /* Location of the (int) field in UPARAMS.  */

};

/* The name-field mappings we know about.  */

static const struct uparam_name uparam_names[] =

{

  { "dup-args",       1, offsetof (struct uparams, dup_args) },

  { "dup-args-note",  1, offsetof (struct uparams, dup_args_note) },

  { "short-opt-col",  0, offsetof (struct uparams, short_opt_col) },

  { "long-opt-col",   0, offsetof (struct uparams, long_opt_col) },

  { "doc-opt-col",    0, offsetof (struct uparams, doc_opt_col) },

  { "opt-doc-col",    0, offsetof (struct uparams, opt_doc_col) },

  { "header-col",     0, offsetof (struct uparams, header_col) },

  { "usage-indent",   0, offsetof (struct uparams, usage_indent) },

  { "rmargin",        0, offsetof (struct uparams, rmargin) },

  { 0 }

};

/* Read user options from the environment, and fill in UPARAMS appropiately.  */

static void

fill_in_uparams (const struct argp_state *state)

{

  const char *var = getenv ("ARGP_HELP_FMT");

#define SKIPWS(p) do { while (isspace (*p)) p++; } while (0);

  if (var)

    /* Parse var. */

    while (*var)

      {

        SKIPWS (var);

        if (isalpha (*var))

          {

            size_t var_len;

            const struct uparam_name *un;

            int unspec = 0, val = 0;

            const char *arg = var;

            while (isalnum (*arg) || *arg == '-' || *arg == '_')

              arg++;

            var_len = arg - var;

            SKIPWS (arg);

            if (*arg == '\0' || *arg == ',')

              unspec = 1;

            else if (*arg == '=')

              {

                arg++;

                SKIPWS (arg);

              }

            if (unspec)

              {

                if (var[0] == 'n' && var[1] == 'o' && var[2] == '-')

                  {

                    val = 0;

                    var += 3;

                    var_len -= 3;

                  }

                else

                  val = 1;

              }

            else if (isdigit (*arg))

              {

                val = atoi (arg);

                while (isdigit (*arg))

                  arg++;

                SKIPWS (arg);

              }

            for (un = uparam_names; un->name; un++)

              if (strlen (un->name) == var_len

                  && strncmp (var, un->name, var_len) == 0)

                {

                  if (unspec && !un->is_bool)

                    __argp_failure (state, 0, 0,

                                    dgettext (state->root_argp->argp_domain, "\

%.*s: ARGP_HELP_FMT parameter requires a value"),

                                    (int) var_len, var);

                  else

                    *(int *)((char *)&uparams + un->uparams_offs) = val;

                  break;

                }

            if (! un->name)

              __argp_failure (state, 0, 0,

                              dgettext (state->root_argp->argp_domain, "\

%.*s: Unknown ARGP_HELP_FMT parameter"),

                              (int) var_len, var);

            var = arg;

            if (*var == ',')

              var++;

          }

        else if (*var)

          {

            __argp_failure (state, 0, 0,

                            dgettext (state->root_argp->argp_domain,

                                      "Garbage in ARGP_HELP_FMT: %s"), var);

            break;

          }

      }

}

/* Returns true if OPT hasn't been marked invisible.  Visibility only affects

   whether OPT is displayed or used in sorting, not option shadowing.  */

#define ovisible(opt) (! ((opt)->flags & OPTION_HIDDEN))

/* Returns true if OPT is an alias for an earlier option.  */

#define oalias(opt) ((opt)->flags & OPTION_ALIAS)

/* Returns true if OPT is an documentation-only entry.  */

#define odoc(opt) ((opt)->flags & OPTION_DOC)

/* Returns true if OPT is the end-of-list marker for a list of options.  */

#define oend(opt) __option_is_end (opt)

/* Returns true if OPT has a short option.  */

#define oshort(opt) __option_is_short (opt)

/*

   The help format for a particular option is like:

     -xARG, -yARG, --long1=ARG, --long2=ARG        Documentation...

   Where ARG will be omitted if there's no argument, for this option, or

   will be surrounded by "[" and "]" appropiately if the argument is

   optional.  The documentation string is word-wrapped appropiately, and if

   the list of options is long enough, it will be started on a separate line.

   If there are no short options for a given option, the first long option is

   indented slighly in a way that's supposed to make most long options appear

   to be in a separate column.

   For example, the following output (from ps):

     -p PID, --pid=PID          List the process PID

         --pgrp=PGRP            List processes in the process group PGRP

     -P, -x, --no-parent        Include processes without parents

     -Q, --all-fields           Don't elide unusable fields (normally if there's

                                some reason ps can't print a field for any

                                process, it's removed from the output entirely)

     -r, --reverse, --gratuitously-long-reverse-option

                                Reverse the order of any sort

         --session[=SID]        Add the processes from the session SID (which

                                defaults to the sid of the current process)

    Here are some more options:

     -f ZOT, --foonly=ZOT       Glork a foonly

     -z, --zaza                 Snit a zar

     -?, --help                 Give this help list

         --usage                Give a short usage message

     -V, --version              Print program version

   The struct argp_option array for the above could look like:

   {

     {"pid",       'p',      "PID",  0, "List the process PID"},

     {"pgrp",      OPT_PGRP, "PGRP", 0, "List processes in the process group PGRP"},

     {"no-parent", 'P',       0,     0, "Include processes without parents"},

     {0,           'x',       0,     OPTION_ALIAS},

     {"all-fields",'Q',       0,     0, "Don't elide unusable fields (normally"

                                        " if there's some reason ps can't"

                                        " print a field for any process, it's"

                                        " removed from the output entirely)" },

     {"reverse",   'r',       0,     0, "Reverse the order of any sort"},

     {"gratuitously-long-reverse-option", 0, 0, OPTION_ALIAS},

     {"session",   OPT_SESS,  "SID", OPTION_ARG_OPTIONAL,

                                        "Add the processes from the session"

                                        " SID (which defaults to the sid of"

                                        " the current process)" },

     {0,0,0,0, "Here are some more options:"},

     {"foonly", 'f', "ZOT", 0, "Glork a foonly"},

     {"zaza", 'z', 0, 0, "Snit a zar"},

     {0}

   }

   Note that the last three options are automatically supplied by argp_parse,

   unless you tell it not to with ARGP_NO_HELP.

*/

/* Returns true if CH occurs between BEG and END.  */

static int

find_char (char ch, char *beg, char *end)

{

  while (beg < end)

    if (*beg == ch)

      return 1;

    else

      beg++;

  return 0;

}

struct hol_cluster;             /* fwd decl */

struct hol_entry

{

  /* First option.  */

  const struct argp_option *opt;

  /* Number of options (including aliases).  */

  unsigned num;

  /* A pointers into the HOL's short_options field, to the first short option

     letter for this entry.  The order of the characters following this point

     corresponds to the order of options pointed to by OPT, and there are at

     most NUM.  A short option recorded in a option following OPT is only

     valid if it occurs in the right place in SHORT_OPTIONS (otherwise it's

     probably been shadowed by some other entry).  */

  char *short_options;

  /* Entries are sorted by their group first, in the order:

       1, 2, ..., n, 0, -m, ..., -2, -1

     and then alphabetically within each group.  The default is 0.  */

  int group;

  /* The cluster of options this entry belongs to, or 0 if none.  */

  struct hol_cluster *cluster;

  /* The argp from which this option came.  */

  const struct argp *argp;

};

/* A cluster of entries to reflect the argp tree structure.  */

struct hol_cluster

{

  /* A descriptive header printed before options in this cluster.  */

  const char *header;

  /* Used to order clusters within the same group with the same parent,

     according to the order in which they occurred in the parent argp's child

     list.  */

  int index;

  /* How to sort this cluster with respect to options and other clusters at the

     same depth (clusters always follow options in the same group).  */

  int group;

  /* The cluster to which this cluster belongs, or 0 if it's at the base

     level.  */

  struct hol_cluster *parent;

  /* The argp from which this cluster is (eventually) derived.  */

  const struct argp *argp;

  /* The distance this cluster is from the root.  */

  int depth;

  /* Clusters in a given hol are kept in a linked list, to make freeing them

     possible.  */

  struct hol_cluster *next;

};

/* A list of options for help.  */

struct hol

{

  /* An array of hol_entry's.  */

  struct hol_entry *entries;

  /* The number of entries in this hol.  If this field is zero, the others

     are undefined.  */

  unsigned num_entries;

  /* A string containing all short options in this HOL.  Each entry contains

     pointers into this string, so the order can't be messed with blindly.  */

  char *short_options;

  /* Clusters of entries in this hol.  */

  struct hol_cluster *clusters;

};

/* Create a struct hol from the options in ARGP.  CLUSTER is the

   hol_cluster in which these entries occur, or 0, if at the root.  */

static struct hol *

make_hol (const struct argp *argp, struct hol_cluster *cluster)

{

  char *so;

  const struct argp_option *o;

  const struct argp_option *opts = argp->options;

  struct hol_entry *entry;

  unsigned num_short_options = 0;

  struct hol *hol = malloc (sizeof (struct hol));

  assert (hol);

  hol->num_entries = 0;

  hol->clusters = 0;

  if (opts)

    {

      int cur_group = 0;

      /* The first option must not be an alias.  */

      assert (! oalias (opts));

      /* Calculate the space needed.  */

      for (o = opts; ! oend (o); o++)

        {

          if (! oalias (o))

            hol->num_entries++;

          if (oshort (o))

            num_short_options++;        /* This is an upper bound.  */

        }

      hol->entries = malloc (sizeof (struct hol_entry) * hol->num_entries);

      hol->short_options = malloc (num_short_options + 1);

      assert (hol->entries && hol->short_options);

      /* Fill in the entries.  */

      so = hol->short_options;

      for (o = opts, entry = hol->entries; ! oend (o); entry++)

        {

          entry->opt = o;

          entry->num = 0;

          entry->short_options = so;

          entry->group = cur_group =

            o->group

            ? o->group

            : ((!o->name && !o->key)

               ? cur_group + 1

               : cur_group);

          entry->cluster = cluster;

          entry->argp = argp;

          do

            {

              entry->num++;

              if (oshort (o) && ! find_char (o->key, hol->short_options, so))

                /* O has a valid short option which hasn't already been used.*/

                *so++ = o->key;

              o++;

            }

          while (! oend (o) && oalias (o));

        }

      *so = '\0';               /* null terminated so we can find the length */

    }

  return hol;

}

/* Add a new cluster to HOL, with the given GROUP and HEADER (taken from the

   associated argp child list entry), INDEX, and PARENT, and return a pointer

   to it.  ARGP is the argp that this cluster results from.  */

static struct hol_cluster *

hol_add_cluster (struct hol *hol, int group, const char *header, int index,

                 struct hol_cluster *parent, const struct argp *argp)

{

  struct hol_cluster *cl = malloc (sizeof (struct hol_cluster));

  if (cl)

    {

      cl->group = group;

      cl->header = header;

      cl->index = index;

      cl->parent = parent;

      cl->argp = argp;

      cl->depth = parent ? parent->depth + 1 : 0;

      cl->next = hol->clusters;

      hol->clusters = cl;

    }

  return cl;

}

/* Free HOL and any resources it uses.  */

static void

hol_free (struct hol *hol)

{

  struct hol_cluster *cl = hol->clusters;

  while (cl)

    {

      struct hol_cluster *next = cl->next;

      free (cl);

      cl = next;

    }

  if (hol->num_entries > 0)

    {

      free (hol->entries);

      free (hol->short_options);

    }

  free (hol);

}

static inline int

hol_entry_short_iterate (const struct hol_entry *entry,

                         int (*func)(const struct argp_option *opt,

                                     const struct argp_option *real,

                                     const char *domain, void *cookie),

                         const char *domain, void *cookie)

{

  unsigned nopts;

  int val = 0;

  const struct argp_option *opt, *real = entry->opt;

  char *so = entry->short_options;

  for (opt = real, nopts = entry->num; nopts > 0 && !val; opt++, nopts--)

    if (oshort (opt) && *so == opt->key)

      {

        if (!oalias (opt))

          real = opt;

        if (ovisible (opt))

          val = (*func)(opt, real, domain, cookie);

        so++;

      }

  return val;

}

static inline int

hol_entry_long_iterate (const struct hol_entry *entry,

                        int (*func)(const struct argp_option *opt,

                                    const struct argp_option *real,

                                    const char *domain, void *cookie),

                        const char *domain, void *cookie)

{

  unsigned nopts;

  int val = 0;

  const struct argp_option *opt, *real = entry->opt;

  for (opt = real, nopts = entry->num; nopts > 0 && !val; opt++, nopts--)

    if (opt->name)

      {

        if (!oalias (opt))

          real = opt;

        if (ovisible (opt))

          val = (*func)(opt, real, domain, cookie);

      }

  return val;

}

/* Iterator that returns true for the first short option.  */

static inline int

until_short (const struct argp_option *opt, const struct argp_option *real,

             const char *domain, void *cookie)

{

  return oshort (opt) ? opt->key : 0;

}

/* Returns the first valid short option in ENTRY, or 0 if there is none.  */

static char

hol_entry_first_short (const struct hol_entry *entry)

{

  return hol_entry_short_iterate (entry, until_short,

                                  entry->argp->argp_domain, 0);

}

/* Returns the first valid long option in ENTRY, or 0 if there is none.  */

static const char *

hol_entry_first_long (const struct hol_entry *entry)

{

  const struct argp_option *opt;

  unsigned num;

  for (opt = entry->opt, num = entry->num; num > 0; opt++, num--)

    if (opt->name && ovisible (opt))

      return opt->name;

  return 0;

}

/* Returns the entry in HOL with the long option name NAME, or 0 if there is

   none.  */

static struct hol_entry *

hol_find_entry (struct hol *hol, const char *name)

{

  struct hol_entry *entry = hol->entries;

  unsigned num_entries = hol->num_entries;

  while (num_entries-- > 0)

    {

      const struct argp_option *opt = entry->opt;

      unsigned num_opts = entry->num;

      while (num_opts-- > 0)

        if (opt->name && ovisible (opt) && strcmp (opt->name, name) == 0)

          return entry;

        else

          opt++;

      entry++;

    }

  return 0;

}

/* If an entry with the long option NAME occurs in HOL, set it's special

   sort position to GROUP.  */

static void

hol_set_group (struct hol *hol, const char *name, int group)

{

  struct hol_entry *entry = hol_find_entry (hol, name);

  if (entry)

    entry->group = group;

}

/* Order by group:  0, 1, 2, ..., n, -m, ..., -2, -1.

   EQ is what to return if GROUP1 and GROUP2 are the same.  */

static int

group_cmp (int group1, int group2, int eq)

{

  if (group1 == group2)

    return eq;

  else if ((group1 < 0 && group2 < 0) || (group1 >= 0 && group2 >= 0))

    return group1 - group2;

  else

    return group2 - group1;

}

/* Compare clusters CL1 & CL2 by the order that they should appear in

   output.  */

static int

hol_cluster_cmp (const struct hol_cluster *cl1, const struct hol_cluster *cl2)

{

  /* If one cluster is deeper than the other, use its ancestor at the same

     level, so that finding the common ancestor is straightforward.  */

  while (cl1->depth < cl2->depth)

    cl1 = cl1->parent;

  while (cl2->depth < cl1->depth)

    cl2 = cl2->parent;

  /* Now reduce both clusters to their ancestors at the point where both have

     a common parent; these can be directly compared.  */

  while (cl1->parent != cl2->parent)

    cl1 = cl1->parent, cl2 = cl2->parent;

  return group_cmp (cl1->group, cl2->group, cl2->index - cl1->index);

}

/* Return the ancestor of CL that's just below the root (i.e., has a parent

   of 0).  */

static struct hol_cluster *

hol_cluster_base (struct hol_cluster *cl)

{

  while (cl->parent)

    cl = cl->parent;

  return cl;

}

/* Return true if CL1 is a child of CL2.  */

static int

hol_cluster_is_child (const struct hol_cluster *cl1,

                      const struct hol_cluster *cl2)

{

  while (cl1 && cl1 != cl2)

    cl1 = cl1->parent;

  return cl1 == cl2;

}

/* Given the name of a OPTION_DOC option, modifies NAME to start at the tail

   that should be used for comparisons, and returns true iff it should be

   treated as a non-option.  */

static int

canon_doc_option (const char **name)

{

  int non_opt;

  /* Skip initial whitespace.  */

  while (isspace (**name))

    (*name)++;

  /* Decide whether this looks like an option (leading `-') or not.  */

  non_opt = (**name != '-');

  /* Skip until part of name used for sorting.  */

  while (**name && !isalnum (**name))

    (*name)++;

  return non_opt;

}

/* Order ENTRY1 & ENTRY2 by the order which they should appear in a help

   listing.  */

static int

hol_entry_cmp (const struct hol_entry *entry1,

               const struct hol_entry *entry2)

{