Back to index

glibc  2.9
Classes | Defines | Functions | Variables
argp-help.c File Reference
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <stdarg.h>
#include <ctype.h>
#include <limits.h>
#include "argp.h"
#include "argp-fmtstream.h"
#include "argp-namefrob.h"

Go to the source code of this file.

Classes

struct  uparams
struct  uparam_name
struct  hol_entry
struct  hol_cluster
struct  hol
struct  hol_help_state
struct  pentry_state

Defines

#define _GNU_SOURCE   1
#define dgettext(domain, msgid)   (msgid)
#define SIZE_MAX   ((size_t) -1)
#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 */
#define nuparam_names   (sizeof (uparam_names) / sizeof (uparam_names[0]))
#define SKIPWS(p)   do { while (isspace (*p)) p++; } while (0);
#define ovisible(opt)   (! ((opt)->flags & OPTION_HIDDEN))
#define oalias(opt)   ((opt)->flags & OPTION_ALIAS)
#define odoc(opt)   ((opt)->flags & OPTION_DOC)
#define oend(opt)   __option_is_end (opt)
#define oshort(opt)   __option_is_short (opt)

Functions

char * alloca ()
char * strerror (int errnum)
static void fill_in_uparams (const struct argp_state *state)
static int find_char (char ch, char *beg, char *end)
static struct holmake_hol (const struct argp *argp, struct hol_cluster *cluster)
static struct hol_clusterhol_add_cluster (struct hol *hol, int group, const char *header, int index, struct hol_cluster *parent, const struct argp *argp)
static void hol_free (struct hol *hol)
static 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)
static int __attribute__ ((always_inline))
static int until_short (const struct argp_option *opt, const struct argp_option *real, const char *domain, void *cookie)
static char hol_entry_first_short (const struct hol_entry *entry)
static const char * hol_entry_first_long (const struct hol_entry *entry)
static struct hol_entryhol_find_entry (struct hol *hol, const char *name)
static void hol_set_group (struct hol *hol, const char *name, int group)
static int group_cmp (int group1, int group2, int eq)
static int hol_cluster_cmp (const struct hol_cluster *cl1, const struct hol_cluster *cl2)
static struct hol_clusterhol_cluster_base (struct hol_cluster *cl)
static int hol_cluster_is_child (const struct hol_cluster *cl1, const struct hol_cluster *cl2)
static int canon_doc_option (const char **name)
static int hol_entry_cmp (const struct hol_entry *entry1, const struct hol_entry *entry2)
static int hol_entry_qcmp (const void *entry1_v, const void *entry2_v)
static void hol_sort (struct hol *hol)
static void hol_append (struct hol *hol, struct hol *more)
static void indent_to (argp_fmtstream_t stream, unsigned col)
static void space (argp_fmtstream_t stream, size_t ensure)
static void arg (const struct argp_option *real, const char *req_fmt, const char *opt_fmt, const char *domain, argp_fmtstream_t stream)
static const char * filter_doc (const char *doc, int key, const struct argp *argp, const struct argp_state *state)
static void print_header (const char *str, const struct argp *argp, struct pentry_state *pest)
static void comma (unsigned col, struct pentry_state *pest)
static void hol_entry_help (struct hol_entry *entry, const struct argp_state *state, argp_fmtstream_t stream, struct hol_help_state *hhstate)
static void hol_help (struct hol *hol, const struct argp_state *state, argp_fmtstream_t stream)
static int add_argless_short_opt (const struct argp_option *opt, const struct argp_option *real, const char *domain, void *cookie)
static int usage_argful_short_opt (const struct argp_option *opt, const struct argp_option *real, const char *domain, void *cookie)
static int usage_long_opt (const struct argp_option *opt, const struct argp_option *real, const char *domain, void *cookie)
static void hol_usage (struct hol *hol, argp_fmtstream_t stream)
static struct holargp_hol (const struct argp *argp, struct hol_cluster *cluster)
static size_t argp_args_levels (const struct argp *argp)
static int argp_args_usage (const struct argp *argp, const struct argp_state *state, char **levels, int advance, argp_fmtstream_t stream)
static int argp_doc (const struct argp *argp, const struct argp_state *state, int post, int pre_blank, int first_only, argp_fmtstream_t stream)
static void _help (const struct argp *argp, const struct argp_state *state, FILE *stream, unsigned flags, char *name)
void __argp_help (const struct argp *argp, FILE *stream, unsigned flags, char *name)
char * __argp_basename (char *name)
char * __argp_short_program_name (void)
void __argp_state_help (const struct argp_state *state, FILE *stream, unsigned flags)
void __argp_error (const struct argp_state *state, const char *fmt,...)
void __argp_failure (const struct argp_state *state, int status, int errnum, const char *fmt,...)

Variables

static struct uparams
static struct uparam_name []

Class Documentation

struct uparams

Definition at line 111 of file argp-help.c.

Class Members
int doc_opt_col
int dup_args
int dup_args_note
int header_col
int long_opt_col
int opt_doc_col
int rmargin
int short_opt_col
int usage_indent
struct uparam_name

Definition at line 142 of file argp-help.c.

Class Members
bool is_bool
const char name
uint8_t uparams_offs
struct hol_entry

Definition at line 351 of file argp-help.c.

Collaboration diagram for hol_entry:
Class Members
struct argp * argp
struct hol_cluster * cluster
int group
unsigned num
struct argp_option * opt
char * short_options
struct hol_cluster

Definition at line 379 of file argp-help.c.

Collaboration diagram for hol_cluster:
Class Members
struct argp * argp
int depth
int group
const char * header
int index
struct hol_cluster * next
struct hol_cluster * parent
struct hol

Definition at line 409 of file argp-help.c.

Collaboration diagram for hol:
Class Members
struct hol_cluster * clusters
struct hol_entry * entries
unsigned num_entries
char * short_options
struct hol_help_state

Definition at line 956 of file argp-help.c.

Collaboration diagram for hol_help_state:
Class Members
struct hol_entry * prev_entry
int sep_groups
int suppressed_dup_arg
struct pentry_state

Definition at line 973 of file argp-help.c.

Collaboration diagram for pentry_state:
Class Members
struct hol_entry * entry
int first
struct hol_help_state * hhstate
struct argp_state * state
argp_fmtstream_t stream

Define Documentation

#define _GNU_SOURCE   1

Definition at line 23 of file argp-help.c.

#define dgettext (   domain,
  msgid 
)    (msgid)

Definition at line 67 of file argp-help.c.

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

Definition at line 103 of file argp-help.c.

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

Definition at line 99 of file argp-help.c.

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

Definition at line 100 of file argp-help.c.

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

Definition at line 105 of file argp-help.c.

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

Definition at line 102 of file argp-help.c.

#define nuparam_names   (sizeof (uparam_names) / sizeof (uparam_names[0]))

Definition at line 162 of file argp-help.c.

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

Definition at line 262 of file argp-help.c.

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

Definition at line 265 of file argp-help.c.

#define oend (   opt)    __option_is_end (opt)

Definition at line 268 of file argp-help.c.

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

Definition at line 104 of file argp-help.c.

#define oshort (   opt)    __option_is_short (opt)

Definition at line 271 of file argp-help.c.

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

Definition at line 259 of file argp-help.c.

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

Definition at line 107 of file argp-help.c.

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

Definition at line 101 of file argp-help.c.

#define SIZE_MAX   ((size_t) -1)

Definition at line 88 of file argp-help.c.

#define SKIPWS (   p)    do { while (isspace (*p)) p++; } while (0);
#define USAGE_INDENT   12 /* indentation of wrapped usage lines */

Definition at line 106 of file argp-help.c.


Function Documentation

char* __argp_basename ( char *  name)

Definition at line 1699 of file argp-help.c.

{
  char *short_name = strrchr (name, '/');
  return short_name ? short_name + 1 : name;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void __argp_error ( const struct argp_state state,
const char *  fmt,
  ... 
)

Definition at line 1754 of file argp-help.c.

{
  if (!state || !(state->flags & ARGP_NO_ERRS))
    {
      FILE *stream = state ? state->err_stream : stderr;

      if (stream)
       {
         va_list ap;

#if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
         __flockfile (stream);
#endif

         va_start (ap, fmt);

#ifdef _LIBC
         char *buf;

         if (_IO_vasprintf (&buf, fmt, ap) < 0)
           buf = NULL;

         __fxprintf (stream, "%s: %s\n",
                    state ? state->name : __argp_short_program_name (), buf);

         free (buf);
#else
         fputs_unlocked (state ? state->name : __argp_short_program_name (),
                       stream);
         putc_unlocked (':', stream);
         putc_unlocked (' ', stream);

         vfprintf (stream, fmt, ap);

         putc_unlocked ('\n', stream);
#endif

         __argp_state_help (state, stream, ARGP_HELP_STD_ERR);

         va_end (ap);

#if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
         __funlockfile (stream);
#endif
       }
    }
}

Here is the call graph for this function:

void __argp_failure ( const struct argp_state state,
int  status,
int  errnum,
const char *  fmt,
  ... 
)

Definition at line 1814 of file argp-help.c.

{
  if (!state || !(state->flags & ARGP_NO_ERRS))
    {
      FILE *stream = state ? state->err_stream : stderr;

      if (stream)
       {
#if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
         __flockfile (stream);
#endif

#ifdef _LIBC
         __fxprintf (stream, "%s",
                    state ? state->name : __argp_short_program_name ());
#else
         fputs_unlocked (state ? state->name : __argp_short_program_name (),
                       stream);
#endif

         if (fmt)
           {
             va_list ap;

             va_start (ap, fmt);
#ifdef _LIBC
             char *buf;

             if (_IO_vasprintf (&buf, fmt, ap) < 0)
              buf = NULL;

             __fxprintf (stream, ": %s", buf);

             free (buf);
#else
             putc_unlocked (':', stream);
             putc_unlocked (' ', stream);

             vfprintf (stream, fmt, ap);
#endif

             va_end (ap);
           }

         if (errnum)
           {
             char buf[200];

#ifdef _LIBC
             __fxprintf (stream, ": %s",
                       __strerror_r (errnum, buf, sizeof (buf)));
#else
             putc_unlocked (':', stream);
             putc_unlocked (' ', stream);
# ifdef HAVE_STRERROR_R
             fputs (__strerror_r (errnum, buf, sizeof (buf)), stream);
# else
             fputs (strerror (errnum), stream);
# endif
#endif
           }

#ifdef USE_IN_LIBIO
         if (_IO_fwide (stream, 0) > 0)
           putwc_unlocked (L'\n', stream);
         else
#endif
           putc_unlocked ('\n', stream);

#if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
         __funlockfile (stream);
#endif

         if (status && (!state || !(state->flags & ARGP_NO_EXIT)))
           exit (status);
       }
    }
}

Here is the call graph for this function:

void __argp_help ( const struct argp argp,
FILE stream,
unsigned  flags,
char *  name 
)

Definition at line 1689 of file argp-help.c.

{
  _help (argp, 0, stream, flags, name);
}

Here is the call graph for this function:

char* __argp_short_program_name ( void  )

Definition at line 1706 of file argp-help.c.

{
# if HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME
  return program_invocation_short_name;
# elif HAVE_DECL_PROGRAM_INVOCATION_NAME
  return __argp_basename (program_invocation_name);
# else
  /* FIXME: What now? Miles suggests that it is better to use NULL,
     but currently the value is passed on directly to fputs_unlocked,
     so that requires more changes. */
# if __GNUC__
#  warning No reasonable value to return
# endif /* __GNUC__ */
  return "";
# endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void __argp_state_help ( const struct argp_state state,
FILE stream,
unsigned  flags 
)

Definition at line 1727 of file argp-help.c.

{
  if ((!state || ! (state->flags & ARGP_NO_ERRS)) && stream)
    {
      if (state && (state->flags & ARGP_LONG_ONLY))
       flags |= ARGP_HELP_LONG_ONLY;

      _help (state ? state->root_argp : 0, state, stream, flags,
            state ? state->name : __argp_short_program_name ());

      if (!state || ! (state->flags & ARGP_NO_EXIT))
       {
         if (flags & ARGP_HELP_EXIT_ERR)
           exit (argp_err_exit_status);
         if (flags & ARGP_HELP_EXIT_OK)
           exit (0);
       }
  }
}

Here is the call graph for this function:

static int __attribute__ ( (always_inline)  ) [inline, static]

Definition at line 570 of file argp-help.c.

{
  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;
}
static void _help ( const struct argp argp,
const struct argp_state state,
FILE stream,
unsigned  flags,
char *  name 
) [static]

Definition at line 1548 of file argp-help.c.

{
  int anything = 0;         /* Whether we've output anything.  */
  struct hol *hol = 0;
  argp_fmtstream_t fs;

  if (! stream)
    return;

#if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
  __flockfile (stream);
#endif

  fill_in_uparams (state);

  fs = __argp_make_fmtstream (stream, 0, uparams.rmargin, 0);
  if (! fs)
    {
#if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
      __funlockfile (stream);
#endif
      return;
    }

  if (flags & (ARGP_HELP_USAGE | ARGP_HELP_SHORT_USAGE | ARGP_HELP_LONG))
    {
      hol = argp_hol (argp, 0);

      /* If present, these options always come last.  */
      hol_set_group (hol, "help", -1);
      hol_set_group (hol, "version", -1);

      hol_sort (hol);
    }

  if (flags & (ARGP_HELP_USAGE | ARGP_HELP_SHORT_USAGE))
    /* Print a short `Usage:' message.  */
    {
      int first_pattern = 1, more_patterns;
      size_t num_pattern_levels = argp_args_levels (argp);
      char *pattern_levels = alloca (num_pattern_levels);

      memset (pattern_levels, 0, num_pattern_levels);

      do
       {
         int old_lm;
         int old_wm = __argp_fmtstream_set_wmargin (fs, uparams.usage_indent);
         char *levels = pattern_levels;

         if (first_pattern)
           __argp_fmtstream_printf (fs, "%s %s",
                                 dgettext (argp->argp_domain, "Usage:"),
                                 name);
         else
           __argp_fmtstream_printf (fs, "%s %s",
                                 dgettext (argp->argp_domain, "  or: "),
                                 name);

         /* We set the lmargin as well as the wmargin, because hol_usage
            manually wraps options with newline to avoid annoying breaks.  */
         old_lm = __argp_fmtstream_set_lmargin (fs, uparams.usage_indent);

         if (flags & ARGP_HELP_SHORT_USAGE)
           /* Just show where the options go.  */
           {
             if (hol->num_entries > 0)
              __argp_fmtstream_puts (fs, dgettext (argp->argp_domain,
                                               " [OPTION...]"));
           }
         else
           /* Actually print the options.  */
           {
             hol_usage (hol, fs);
             flags |= ARGP_HELP_SHORT_USAGE; /* But only do so once.  */
           }

         more_patterns = argp_args_usage (argp, state, &levels, 1, fs);

         __argp_fmtstream_set_wmargin (fs, old_wm);
         __argp_fmtstream_set_lmargin (fs, old_lm);

         __argp_fmtstream_putc (fs, '\n');
         anything = 1;

         first_pattern = 0;
       }
      while (more_patterns);
    }

  if (flags & ARGP_HELP_PRE_DOC)
    anything |= argp_doc (argp, state, 0, 0, 1, fs);

  if (flags & ARGP_HELP_SEE)
    {
      __argp_fmtstream_printf (fs, dgettext (argp->argp_domain, "\
Try `%s --help' or `%s --usage' for more information.\n"),
                            name, name);
      anything = 1;
    }

  if (flags & ARGP_HELP_LONG)
    /* Print a long, detailed help message.  */
    {
      /* Print info about all the options.  */
      if (hol->num_entries > 0)
       {
         if (anything)
           __argp_fmtstream_putc (fs, '\n');
         hol_help (hol, state, fs);
         anything = 1;
       }
    }

  if (flags & ARGP_HELP_POST_DOC)
    /* Print any documentation strings at the end.  */
    anything |= argp_doc (argp, state, 1, anything, 0, fs);

  if ((flags & ARGP_HELP_BUG_ADDR) && argp_program_bug_address)
    {
      if (anything)
       __argp_fmtstream_putc (fs, '\n');
      __argp_fmtstream_printf (fs, dgettext (argp->argp_domain,
                                        "Report bugs to %s.\n"),
                            argp_program_bug_address);
      anything = 1;
    }

#if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
  __funlockfile (stream);
#endif

  if (hol)
    hol_free (hol);

  __argp_fmtstream_free (fs);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int add_argless_short_opt ( const struct argp_option opt,
const struct argp_option real,
const char *  domain,
void *  cookie 
) [static]

Definition at line 1236 of file argp-help.c.

{
  char **snao_end = cookie;
  if (!(opt->arg || real->arg)
      && !((opt->flags | real->flags) & OPTION_NO_USAGE))
    *(*snao_end)++ = opt->key;
  return 0;
}

Here is the caller graph for this function:

char* alloca ( )
static void arg ( const struct argp_option real,
const char *  req_fmt,
const char *  opt_fmt,
const char *  domain,
argp_fmtstream_t  stream 
) [static]

Definition at line 939 of file argp-help.c.

{
  if (real->arg)
    {
      if (real->flags & OPTION_ARG_OPTIONAL)
       __argp_fmtstream_printf (stream, opt_fmt,
                             dgettext (domain, real->arg));
      else
       __argp_fmtstream_printf (stream, req_fmt,
                             dgettext (domain, real->arg));
    }
}
static size_t argp_args_levels ( const struct argp argp) [static]

Definition at line 1375 of file argp-help.c.

{
  size_t levels = 0;
  const struct argp_child *child = argp->children;

  if (argp->args_doc && strchr (argp->args_doc, '\n'))
    levels++;

  if (child)
    while (child->argp)
      levels += argp_args_levels ((child++)->argp);

  return levels;
}

Here is the caller graph for this function:

static int argp_args_usage ( const struct argp argp,
const struct argp_state state,
char **  levels,
int  advance,
argp_fmtstream_t  stream 
) [static]

Definition at line 1396 of file argp-help.c.

{
  char *our_level = *levels;
  int multiple = 0;
  const struct argp_child *child = argp->children;
  const char *tdoc = dgettext (argp->argp_domain, argp->args_doc), *nl = 0;
  const char *fdoc = filter_doc (tdoc, ARGP_KEY_HELP_ARGS_DOC, argp, state);

  if (fdoc)
    {
      const char *cp = fdoc;
      nl = __strchrnul (cp, '\n');
      if (*nl != '\0')
       /* This is a `multi-level' args doc; advance to the correct position
          as determined by our state in LEVELS, and update LEVELS.  */
       {
         int i;
         multiple = 1;
         for (i = 0; i < *our_level; i++)
           cp = nl + 1, nl = __strchrnul (cp, '\n');
         (*levels)++;
       }

      /* Manually do line wrapping so that it (probably) won't get wrapped at
        any embedded spaces.  */
      space (stream, 1 + nl - cp);

      __argp_fmtstream_write (stream, cp, nl - cp);
    }
  if (fdoc && fdoc != tdoc)
    free ((char *)fdoc);    /* Free user's modified doc string.  */

  if (child)
    while (child->argp)
      advance = !argp_args_usage ((child++)->argp, state, levels, advance, stream);

  if (advance && multiple)
    {
      /* Need to increment our level.  */
      if (*nl)
       /* There's more we can do here.  */
       {
         (*our_level)++;
         advance = 0;              /* Our parent shouldn't advance also. */
       }
      else if (*our_level > 0)
       /* We had multiple levels, but used them up; reset to zero.  */
       *our_level = 0;
    }

  return !advance;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int argp_doc ( const struct argp argp,
const struct argp_state state,
int  post,
int  pre_blank,
int  first_only,
argp_fmtstream_t  stream 
) [static]

Definition at line 1458 of file argp-help.c.

{
  const char *text;
  const char *inp_text;
  void *input = 0;
  int anything = 0;
  size_t inp_text_limit = 0;
  const char *doc = dgettext (argp->argp_domain, argp->doc);
  const struct argp_child *child = argp->children;

  if (doc)
    {
      char *vt = strchr (doc, '\v');
      inp_text = post ? (vt ? vt + 1 : 0) : doc;
      inp_text_limit = (!post && vt) ? (vt - doc) : 0;
    }
  else
    inp_text = 0;

  if (argp->help_filter)
    /* We have to filter the doc strings.  */
    {
      if (inp_text_limit)
       /* Copy INP_TEXT so that it's nul-terminated.  */
       inp_text = __strndup (inp_text, inp_text_limit);
      input = __argp_input (argp, state);
      text =
       (*argp->help_filter) (post
                           ? ARGP_KEY_HELP_POST_DOC
                           : ARGP_KEY_HELP_PRE_DOC,
                           inp_text, input);
    }
  else
    text = (const char *) inp_text;

  if (text)
    {
      if (pre_blank)
       __argp_fmtstream_putc (stream, '\n');

      if (text == inp_text && inp_text_limit)
       __argp_fmtstream_write (stream, inp_text, inp_text_limit);
      else
       __argp_fmtstream_puts (stream, text);

      if (__argp_fmtstream_point (stream) > __argp_fmtstream_lmargin (stream))
       __argp_fmtstream_putc (stream, '\n');

      anything = 1;
    }

  if (text && text != inp_text)
    free ((char *) text);   /* Free TEXT returned from the help filter.  */
  if (inp_text && inp_text_limit && argp->help_filter)
    free ((char *) inp_text);      /* We copied INP_TEXT, so free it now.  */

  if (post && argp->help_filter)
    /* Now see if we have to output a ARGP_KEY_HELP_EXTRA text.  */
    {
      text = (*argp->help_filter) (ARGP_KEY_HELP_EXTRA, 0, input);
      if (text)
       {
         if (anything || pre_blank)
           __argp_fmtstream_putc (stream, '\n');
         __argp_fmtstream_puts (stream, text);
         free ((char *) text);
         if (__argp_fmtstream_point (stream)
             > __argp_fmtstream_lmargin (stream))
           __argp_fmtstream_putc (stream, '\n');
         anything = 1;
       }
    }

  if (child)
    while (child->argp && !(first_only && anything))
      anything |=
       argp_doc ((child++)->argp, state,
                post, anything || pre_blank, first_only,
                stream);

  return anything;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct hol* argp_hol ( const struct argp argp,
struct hol_cluster cluster 
) [static, read]

Definition at line 1352 of file argp-help.c.

{
  const struct argp_child *child = argp->children;
  struct hol *hol = make_hol (argp, cluster);
  if (child)
    while (child->argp)
      {
       struct hol_cluster *child_cluster =
         ((child->group || child->header)
          /* Put CHILD->argp within its own cluster.  */
          ? hol_add_cluster (hol, child->group, child->header,
                           child - argp->children, cluster, argp)
          /* Just merge it into the parent's cluster.  */
          : cluster);
       hol_append (hol, argp_hol (child->argp, child_cluster)) ;
       child++;
      }
  return hol;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int canon_doc_option ( const char **  name) [static]

Definition at line 713 of file argp-help.c.

{
  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;
}

Here is the caller graph for this function:

static void comma ( unsigned  col,
struct pentry_state pest 
) [static]

Definition at line 1041 of file argp-help.c.

{
  if (pest->first)
    {
      const struct hol_entry *pe = pest->hhstate->prev_entry;
      const struct hol_cluster *cl = pest->entry->cluster;

      if (pest->hhstate->sep_groups && pe && pest->entry->group != pe->group)
       __argp_fmtstream_putc (pest->stream, '\n');

      if (cl && cl->header && *cl->header
         && (!pe
             || (pe->cluster != cl
                && !hol_cluster_is_child (pe->cluster, cl))))
       /* If we're changing clusters, then this must be the start of the
          ENTRY's cluster unless that is an ancestor of the previous one
          (in which case we had just popped into a sub-cluster for a bit).
          If so, then print the cluster's header line.  */
       {
         int old_wm = __argp_fmtstream_wmargin (pest->stream);
         print_header (cl->header, cl->argp, pest);
         __argp_fmtstream_set_wmargin (pest->stream, old_wm);
       }

      pest->first = 0;
    }
  else
    __argp_fmtstream_puts (pest->stream, ", ");

  indent_to (pest->stream, col);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void fill_in_uparams ( const struct argp_state state) [static]

Definition at line 166 of file argp-help.c.

{
  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);
             }

           un = uparam_names;
           size_t u;
           for (u = 0; u < nuparam_names; ++un, ++u)
             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 == NULL ? NULL
                                         : 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 (u == nuparam_names)
             __argp_failure (state, 0, 0,
                           dgettext (state == NULL ? NULL
                                   : 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 == NULL ? NULL
                                  : state->root_argp->argp_domain,
                                  "Garbage in ARGP_HELP_FMT: %s"), var);
           break;
         }
      }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static const char* filter_doc ( const char *  doc,
int  key,
const struct argp argp,
const struct argp_state state 
) [static]

Definition at line 988 of file argp-help.c.

{
  if (argp && argp->help_filter)
    /* We must apply a user filter to this output.  */
    {
      void *input = __argp_input (argp, state);
      return (*argp->help_filter) (key, doc, input);
    }
  else
    /* No filter.  */
    return doc;
}

Here is the caller graph for this function:

static int find_char ( char  ch,
char *  beg,
char *  end 
) [static]

Definition at line 339 of file argp-help.c.

{
  while (beg < end)
    if (*beg == ch)
      return 1;
    else
      beg++;
  return 0;
}

Here is the caller graph for this function:

static int group_cmp ( int  group1,
int  group2,
int  eq 
) [static]

Definition at line 659 of file argp-help.c.

{
  if (group1 == group2)
    return eq;
  else if ((group1 < 0 && group2 < 0) || (group1 >= 0 && group2 >= 0))
    return group1 - group2;
  else
    return group2 - group1;
}

Here is the caller graph for this function:

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 
) [static, read]

Definition at line 502 of file argp-help.c.

{
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void hol_append ( struct hol hol,
struct hol more 
) [static]

Definition at line 823 of file argp-help.c.

{
  struct hol_cluster **cl_end = &hol->clusters;

  /* Steal MORE's cluster list, and add it to the end of HOL's.  */
  while (*cl_end)
    cl_end = &(*cl_end)->next;
  *cl_end = more->clusters;
  more->clusters = 0;

  /* Merge entries.  */
  if (more->num_entries > 0)
    {
      if (hol->num_entries == 0)
       {
         hol->num_entries = more->num_entries;
         hol->entries = more->entries;
         hol->short_options = more->short_options;
         more->num_entries = 0;    /* Mark MORE's fields as invalid.  */
       }
      else
       /* Append the entries in MORE to those in HOL, taking care to only add
          non-shadowed SHORT_OPTIONS values.  */
       {
         unsigned left;
         char *so, *more_so;
         struct hol_entry *e;
         unsigned num_entries = hol->num_entries + more->num_entries;
         struct hol_entry *entries =
           malloc (num_entries * sizeof (struct hol_entry));
         unsigned hol_so_len = strlen (hol->short_options);
         char *short_options =
           malloc (hol_so_len + strlen (more->short_options) + 1);

         assert (entries && short_options);
#if SIZE_MAX <= UINT_MAX
         assert (num_entries <= SIZE_MAX / sizeof (struct hol_entry));
#endif

         __mempcpy (__mempcpy (entries, hol->entries,
                            hol->num_entries * sizeof (struct hol_entry)),
                   more->entries,
                   more->num_entries * sizeof (struct hol_entry));

         __mempcpy (short_options, hol->short_options, hol_so_len);

         /* Fix up the short options pointers from HOL.  */
         for (e = entries, left = hol->num_entries; left > 0; e++, left--)
           e->short_options += (short_options - hol->short_options);

         /* Now add the short options from MORE, fixing up its entries
            too.  */
         so = short_options + hol_so_len;
         more_so = more->short_options;
         for (left = more->num_entries; left > 0; e++, left--)
           {
             int opts_left;
             const struct argp_option *opt;

             e->short_options = so;

             for (opts_left = e->num, opt = e->opt; opts_left; opt++, opts_left--)
              {
                int ch = *more_so;
                if (oshort (opt) && ch == opt->key)
                  /* The next short option in MORE_SO, CH, is from OPT.  */
                  {
                    if (! find_char (ch, short_options,
                                   short_options + hol_so_len))
                     /* The short option CH isn't shadowed by HOL's options,
                        so add it to the sum.  */
                     *so++ = ch;
                    more_so++;
                  }
              }
           }

         *so = '\0';

         free (hol->entries);
         free (hol->short_options);

         hol->entries = entries;
         hol->num_entries = num_entries;
         hol->short_options = short_options;
       }
    }

  hol_free (more);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct hol_cluster* hol_cluster_base ( struct hol_cluster cl) [static, read]

Definition at line 692 of file argp-help.c.

{
  while (cl->parent)
    cl = cl->parent;
  return cl;
}

Here is the caller graph for this function:

static int hol_cluster_cmp ( const struct hol_cluster cl1,
const struct hol_cluster cl2 
) [static]

Definition at line 672 of file argp-help.c.

{
  /* 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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int hol_cluster_is_child ( const struct hol_cluster cl1,
const struct hol_cluster cl2 
) [static]

Definition at line 701 of file argp-help.c.

{
  while (cl1 && cl1 != cl2)
    cl1 = cl1->parent;
  return cl1 == cl2;
}

Here is the caller graph for this function:

static int hol_entry_cmp ( const struct hol_entry entry1,
const struct hol_entry entry2 
) [static]

Definition at line 730 of file argp-help.c.

{
  /* The group numbers by which the entries should be ordered; if either is
     in a cluster, then this is just the group within the cluster.  */
  int group1 = entry1->group, group2 = entry2->group;

  if (entry1->cluster != entry2->cluster)
    {
      /* The entries are not within the same cluster, so we can't compare them
        directly, we have to use the appropiate clustering level too.  */
      if (! entry1->cluster)
       /* ENTRY1 is at the `base level', not in a cluster, so we have to
          compare it's group number with that of the base cluster in which
          ENTRY2 resides.  Note that if they're in the same group, the
          clustered option always comes laster.  */
       return group_cmp (group1, hol_cluster_base (entry2->cluster)->group, -1);
      else if (! entry2->cluster)
       /* Likewise, but ENTRY2's not in a cluster.  */
       return group_cmp (hol_cluster_base (entry1->cluster)->group, group2, 1);
      else
       /* Both entries are in clusters, we can just compare the clusters.  */
       return hol_cluster_cmp (entry1->cluster, entry2->cluster);
    }
  else if (group1 == group2)
    /* The entries are both in the same cluster and group, so compare them
       alphabetically.  */
    {
      int short1 = hol_entry_first_short (entry1);
      int short2 = hol_entry_first_short (entry2);
      int doc1 = odoc (entry1->opt);
      int doc2 = odoc (entry2->opt);
      const char *long1 = hol_entry_first_long (entry1);
      const char *long2 = hol_entry_first_long (entry2);

      if (doc1)
       doc1 = long1 != NULL && canon_doc_option (&long1);
      if (doc2)
       doc2 = long2 != NULL && canon_doc_option (&long2);

      if (doc1 != doc2)
       /* `documentation' options always follow normal options (or
          documentation options that *look* like normal options).  */
       return doc1 - doc2;
      else if (!short1 && !short2 && long1 && long2)
       /* Only long options.  */
       return __strcasecmp (long1, long2);
      else
       /* Compare short/short, long/short, short/long, using the first
          character of long options.  Entries without *any* valid
          options (such as options with OPTION_HIDDEN set) will be put
          first, but as they're not displayed, it doesn't matter where
          they are.  */
       {
         char first1 = short1 ? short1 : long1 ? *long1 : 0;
         char first2 = short2 ? short2 : long2 ? *long2 : 0;
#ifdef _tolower
         int lower_cmp = _tolower (first1) - _tolower (first2);
#else
         int lower_cmp = tolower (first1) - tolower (first2);
#endif
         /* Compare ignoring case, except when the options are both the
            same letter, in which case lower-case always comes first.  */
         return lower_cmp ? lower_cmp : first2 - first1;
       }
    }
  else
    /* Within the same cluster, but not the same group, so just compare
       groups.  */
    return group_cmp (group1, group2, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static const char* hol_entry_first_long ( const struct hol_entry entry) [static]

Definition at line 611 of file argp-help.c.

{
  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;
}

Here is the caller graph for this function:

static char hol_entry_first_short ( const struct hol_entry entry) [static]

Definition at line 603 of file argp-help.c.

{
  return hol_entry_short_iterate (entry, until_short,
                              entry->argp->argp_domain, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void hol_entry_help ( struct hol_entry entry,
const struct argp_state state,
argp_fmtstream_t  stream,
struct hol_help_state hhstate 
) [static]

Definition at line 1075 of file argp-help.c.

{
  unsigned num;
  const struct argp_option *real = entry->opt, *opt;
  char *so = entry->short_options;
  int have_long_opt = 0;    /* We have any long options.  */
  /* Saved margins.  */
  int old_lm = __argp_fmtstream_set_lmargin (stream, 0);
  int old_wm = __argp_fmtstream_wmargin (stream);
  /* PEST is a state block holding some of our variables that we'd like to
     share with helper functions.  */
  struct pentry_state pest = { entry, stream, hhstate, 1, state };

  if (! odoc (real))
    for (opt = real, num = entry->num; num > 0; opt++, num--)
      if (opt->name && ovisible (opt))
       {
         have_long_opt = 1;
         break;
       }

  /* First emit short options.  */
  __argp_fmtstream_set_wmargin (stream, uparams.short_opt_col); /* For truly bizarre cases. */
  for (opt = real, num = entry->num; num > 0; opt++, num--)
    if (oshort (opt) && opt->key == *so)
      /* OPT has a valid (non shadowed) short option.  */
      {
       if (ovisible (opt))
         {
           comma (uparams.short_opt_col, &pest);
           __argp_fmtstream_putc (stream, '-');
           __argp_fmtstream_putc (stream, *so);
           if (!have_long_opt || uparams.dup_args)
             arg (real, " %s", "[%s]",
                 state == NULL ? NULL : state->root_argp->argp_domain,
                 stream);
           else if (real->arg)
             hhstate->suppressed_dup_arg = 1;
         }
       so++;
      }

  /* Now, long options.  */
  if (odoc (real))
    /* A `documentation' option.  */
    {
      __argp_fmtstream_set_wmargin (stream, uparams.doc_opt_col);
      for (opt = real, num = entry->num; num > 0; opt++, num--)
       if (opt->name && ovisible (opt))
         {
           comma (uparams.doc_opt_col, &pest);
           /* Calling gettext here isn't quite right, since sorting will
              have been done on the original; but documentation options
              should be pretty rare anyway...  */
           __argp_fmtstream_puts (stream,
                               dgettext (state == NULL ? NULL
                                        : state->root_argp->argp_domain,
                                        opt->name));
         }
    }
  else
    /* A real long option.  */
    {
      __argp_fmtstream_set_wmargin (stream, uparams.long_opt_col);
      for (opt = real, num = entry->num; num > 0; opt++, num--)
       if (opt->name && ovisible (opt))
         {
           comma (uparams.long_opt_col, &pest);
           __argp_fmtstream_printf (stream, "--%s", opt->name);
           arg (real, "=%s", "[=%s]",
               state == NULL ? NULL : state->root_argp->argp_domain, stream);
         }
    }

  /* Next, documentation strings.  */
  __argp_fmtstream_set_lmargin (stream, 0);

  if (pest.first)
    {
      /* Didn't print any switches, what's up?  */
      if (!oshort (real) && !real->name)
       /* This is a group header, print it nicely.  */
       print_header (real->doc, entry->argp, &pest);
      else
       /* Just a totally shadowed option or null header; print nothing.  */
       goto cleanup;        /* Just return, after cleaning up.  */
    }
  else
    {
      const char *tstr = real->doc ? dgettext (state == NULL ? NULL
                                          : state->root_argp->argp_domain,
                                          real->doc) : 0;
      const char *fstr = filter_doc (tstr, real->key, entry->argp, state);
      if (fstr && *fstr)
       {
         unsigned int col = __argp_fmtstream_point (stream);

         __argp_fmtstream_set_lmargin (stream, uparams.opt_doc_col);
         __argp_fmtstream_set_wmargin (stream, uparams.opt_doc_col);

         if (col > (unsigned int) (uparams.opt_doc_col + 3))
           __argp_fmtstream_putc (stream, '\n');
         else if (col >= (unsigned int) uparams.opt_doc_col)
           __argp_fmtstream_puts (stream, "   ");
         else
           indent_to (stream, uparams.opt_doc_col);

         __argp_fmtstream_puts (stream, fstr);
       }
      if (fstr && fstr != tstr)
       free ((char *) fstr);

      /* Reset the left margin.  */
      __argp_fmtstream_set_lmargin (stream, 0);
      __argp_fmtstream_putc (stream, '\n');
    }

  hhstate->prev_entry = entry;

cleanup:
  __argp_fmtstream_set_lmargin (stream, old_lm);
  __argp_fmtstream_set_wmargin (stream, old_wm);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int hol_entry_qcmp ( const void *  entry1_v,
const void *  entry2_v 
) [static]

Definition at line 804 of file argp-help.c.

{
  return hol_entry_cmp (entry1_v, entry2_v);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int hol_entry_short_iterate ( const struct hol_entry entry,
int(*)(const struct argp_option *opt, const struct argp_option *real, const char *domain, void *cookie)  func,
const char *  domain,
void *  cookie 
) [static]

Definition at line 545 of file argp-help.c.

{
  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;
}

Here is the caller graph for this function:

static struct hol_entry* hol_find_entry ( struct hol hol,
const char *  name 
) [static, read]

Definition at line 624 of file argp-help.c.

{
  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;
}

Here is the caller graph for this function:

static void hol_free ( struct hol hol) [static]

Definition at line 524 of file argp-help.c.

{
  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);
}

Here is the caller graph for this function:

static void hol_help ( struct hol hol,
const struct argp_state state,
argp_fmtstream_t  stream 
) [static]

Definition at line 1202 of file argp-help.c.

{
  unsigned num;
  struct hol_entry *entry;
  struct hol_help_state hhstate = { 0, 0, 0 };

  for (entry = hol->entries, num = hol->num_entries; num > 0; entry++, num--)
    hol_entry_help (entry, state, stream, &hhstate);

  if (hhstate.suppressed_dup_arg && uparams.dup_args_note)
    {
      const char *tstr = dgettext (state == NULL ? NULL
                               : state->root_argp->argp_domain, "\
Mandatory or optional arguments to long options are also mandatory or \
optional for any corresponding short options.");
      const char *fstr = filter_doc (tstr, ARGP_KEY_HELP_DUP_ARGS_NOTE,
                                 state ? state->root_argp : 0, state);
      if (fstr && *fstr)
       {
         __argp_fmtstream_putc (stream, '\n');
         __argp_fmtstream_puts (stream, fstr);
         __argp_fmtstream_putc (stream, '\n');
       }
      if (fstr && fstr != tstr)
       free ((char *) fstr);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void hol_set_group ( struct hol hol,
const char *  name,
int  group 
) [static]

Definition at line 649 of file argp-help.c.

{
  struct hol_entry *entry = hol_find_entry (hol, name);
  if (entry)
    entry->group = group;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void hol_sort ( struct hol hol) [static]

Definition at line 813 of file argp-help.c.

{
  if (hol->num_entries > 0)
    qsort (hol->entries, hol->num_entries, sizeof (struct hol_entry),
          hol_entry_qcmp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void hol_usage ( struct hol hol,
argp_fmtstream_t  stream 
) [static]

Definition at line 1312 of file argp-help.c.

{
  if (hol->num_entries > 0)
    {
      unsigned nentries;
      struct hol_entry *entry;
      char *short_no_arg_opts = alloca (strlen (hol->short_options) + 1);
      char *snao_end = short_no_arg_opts;

      /* First we put a list of short options without arguments.  */
      for (entry = hol->entries, nentries = hol->num_entries
          ; nentries > 0
          ; entry++, nentries--)
       hol_entry_short_iterate (entry, add_argless_short_opt,
                             entry->argp->argp_domain, &snao_end);
      if (snao_end > short_no_arg_opts)
       {
         *snao_end++ = 0;
         __argp_fmtstream_printf (stream, " [-%s]", short_no_arg_opts);
       }

      /* Now a list of short options *with* arguments.  */
      for (entry = hol->entries, nentries = hol->num_entries
          ; nentries > 0
          ; entry++, nentries--)
       hol_entry_short_iterate (entry, usage_argful_short_opt,
                             entry->argp->argp_domain, stream);

      /* Finally, a list of long options (whew!).  */
      for (entry = hol->entries, nentries = hol->num_entries
          ; nentries > 0
          ; entry++, nentries--)
       hol_entry_long_iterate (entry, usage_long_opt,
                            entry->argp->argp_domain, stream);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void indent_to ( argp_fmtstream_t  stream,
unsigned  col 
) [static]

Definition at line 916 of file argp-help.c.

{
  int needed = col - __argp_fmtstream_point (stream);
  while (needed-- > 0)
    __argp_fmtstream_putc (stream, ' ');
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct hol* make_hol ( const struct argp argp,
struct hol_cluster cluster 
) [static, read]

Definition at line 428 of file argp-help.c.

{
  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);
#if SIZE_MAX <= UINT_MAX
      assert (hol->num_entries <= SIZE_MAX / sizeof (struct hol_entry));
#endif

      /* 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void print_header ( const char *  str,
const struct argp argp,
struct pentry_state pest 
) [static]

Definition at line 1008 of file argp-help.c.

{
  const char *tstr = dgettext (argp->argp_domain, str);
  const char *fstr = filter_doc (tstr, ARGP_KEY_HELP_HEADER, argp, pest->state);

  if (fstr)
    {
      if (*fstr)
       {
         if (pest->hhstate->prev_entry)
           /* Precede with a blank line.  */
           __argp_fmtstream_putc (pest->stream, '\n');
         indent_to (pest->stream, uparams.header_col);
         __argp_fmtstream_set_lmargin (pest->stream, uparams.header_col);
         __argp_fmtstream_set_wmargin (pest->stream, uparams.header_col);
         __argp_fmtstream_puts (pest->stream, fstr);
         __argp_fmtstream_set_lmargin (pest->stream, 0);
         __argp_fmtstream_putc (pest->stream, '\n');
       }

      pest->hhstate->sep_groups = 1; /* Separate subsequent groups. */
    }

  if (fstr != tstr)
    free ((char *) fstr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void space ( argp_fmtstream_t  stream,
size_t  ensure 
) [static]

Definition at line 926 of file argp-help.c.

{
  if (__argp_fmtstream_point (stream) + ensure
      >= __argp_fmtstream_rmargin (stream))
    __argp_fmtstream_putc (stream, '\n');
  else
    __argp_fmtstream_putc (stream, ' ');
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* strerror ( int  errnum)

Definition at line 30 of file strerror.c.

{
  char *ret = __strerror_r (errnum, NULL, 0);
  int saved_errno;

  if (__builtin_expect (ret != NULL, 1))
    return ret;
  saved_errno = errno;
  if (buf == NULL)
    buf = malloc (1024);
  __set_errno (saved_errno);
  if (buf == NULL)
    return _("Unknown error");
  return __strerror_r (errnum, buf, 1024);
}

Here is the caller graph for this function:

static int until_short ( const struct argp_option opt,
const struct argp_option real,
const char *  domain,
void *  cookie 
) [inline, static]

Definition at line 595 of file argp-help.c.

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

Here is the caller graph for this function:

static int usage_argful_short_opt ( const struct argp_option opt,
const struct argp_option real,
const char *  domain,
void *  cookie 
) [static]

Definition at line 1250 of file argp-help.c.

{
  argp_fmtstream_t stream = cookie;
  const char *arg = opt->arg;
  int flags = opt->flags | real->flags;

  if (! arg)
    arg = real->arg;

  if (arg && !(flags & OPTION_NO_USAGE))
    {
      arg = dgettext (domain, arg);

      if (flags & OPTION_ARG_OPTIONAL)
       __argp_fmtstream_printf (stream, " [-%c[%s]]", opt->key, arg);
      else
       {
         /* Manually do line wrapping so that it (probably) won't
            get wrapped at the embedded space.  */
         space (stream, 6 + strlen (arg));
         __argp_fmtstream_printf (stream, "[-%c %s]", opt->key, arg);
       }
    }

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int usage_long_opt ( const struct argp_option opt,
const struct argp_option real,
const char *  domain,
void *  cookie 
) [static]

Definition at line 1282 of file argp-help.c.

{
  argp_fmtstream_t stream = cookie;
  const char *arg = opt->arg;
  int flags = opt->flags | real->flags;

  if (! arg)
    arg = real->arg;

  if (! (flags & OPTION_NO_USAGE))
    {
      if (arg)
       {
         arg = dgettext (domain, arg);
         if (flags & OPTION_ARG_OPTIONAL)
           __argp_fmtstream_printf (stream, " [--%s[=%s]]", opt->name, arg);
         else
           __argp_fmtstream_printf (stream, " [--%s=%s]", opt->name, arg);
       }
      else
       __argp_fmtstream_printf (stream, " [--%s]", opt->name);
    }

  return 0;
}

Here is the caller graph for this function:


Variable Documentation

struct uparam_name[] [static]
Initial value:
{
  { "dup-args",       true, offsetof (struct uparams, dup_args) },
  { "dup-args-note",  true, offsetof (struct uparams, dup_args_note) },
  { "short-opt-col",  false, offsetof (struct uparams, short_opt_col) },
  { "long-opt-col",   false, offsetof (struct uparams, long_opt_col) },
  { "doc-opt-col",    false, offsetof (struct uparams, doc_opt_col) },
  { "opt-doc-col",    false, offsetof (struct uparams, opt_doc_col) },
  { "header-col",     false, offsetof (struct uparams, header_col) },
  { "usage-indent",   false, offsetof (struct uparams, usage_indent) },
  { "rmargin",        false, offsetof (struct uparams, rmargin) }
}

Definition at line 150 of file argp-help.c.

struct uparams [static]