getopt.c File Reference

GNU style option parsing. More...

#include "platform.h"
#include "gnunet_util_lib.h"

Include dependency graph for getopt.c:

Go to the source code of this file.

Data Structures
struct	GNoption

Macros
#define	LOG(kind, ...)   GNUNET_log_from (kind, "util-getopt", __VA_ARGS__)
#define	LOG_STRERROR(kind, syscall)    GNUNET_log_from_strerror (kind, "util-getopt", syscall)
#define	_(msgid)   (msgid)
#define	SWAP_FLAGS(ch1, ch2)
#define	NONOPTION_P   (argv[GNoptind][0] != '-' || argv[GNoptind][1] == '\0')

Enumerations
enum	{ REQUIRE_ORDER , PERMUTE , RETURN_IN_ORDER }

Functions
char *	getenv ()
static char *	my_index (const char *str, int chr)
static void	exchange (char **argv)
static const char *	_getopt_initialize (int argc, char *const *argv, const char *optstring)
static int	GN_getopt_internal (int argc, char *const *argv, const char *optstring, const struct GNoption *longopts, int *longind, int long_only)
static int	GNgetopt_long (int argc, char *const *argv, const char *options, const struct GNoption *long_options, int *opt_index)
int	GNUNET_GETOPT_run (const char *binaryOptions, const struct GNUNET_GETOPT_CommandLineOption *allOptions, unsigned int argc, char *const *argv)
	Parse the command line. More...

Variables
static char *	GNoptarg = NULL
static int	GNoptind = 1
static char *	nextchar
static enum { ... }	ordering
static char *	posixly_correct
static int	first_nonopt
static int	last_nonopt

Detailed Description

GNU style option parsing.

TODO: get rid of statics (make reentrant) and replace main GNU getopt parser with one that actually fits our API.

Definition in file getopt.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, "util-getopt", __VA_ARGS__)

Definition at line 51 of file getopt.c.

LOG_STRERROR

#define LOG_STRERROR	(		kind,
			syscall
	)		GNUNET_log_from_strerror (kind, "util-getopt", syscall)

Definition at line 53 of file getopt.c.

_

#define _

(

msgid

)

(msgid)

Definition at line 63 of file getopt.c.

SWAP_FLAGS

#define SWAP_FLAGS	(		ch1,
			ch2
	)

Definition at line 233 of file getopt.c.

NONOPTION_P

#define NONOPTION_P   (argv[GNoptind][0] != '-' || argv[GNoptind][1] == '\0')

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
REQUIRE_ORDER
PERMUTE
RETURN_IN_ORDER

Definition at line 175 of file getopt.c.

{ REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER } ordering;

Function Documentation

getenv()

char* getenv

(

)

Referenced by _getopt_initialize(), expand_dollar(), gen_rsh_args(), gen_rsh_suffix_args(), get_homedir(), get_path_from_GNUNET_PREFIX(), get_path_from_PATH(), GNUNET_CONFIGURATION_config_tool_run(), GNUNET_CONFIGURATION_default(), GNUNET_CONFIGURATION_default_filename(), GNUNET_log_setup(), GNUNET_OS_install_parent_control_handler(), GNUNET_PLUGIN_unload(), GNUNET_SERVICE_run_(), GNUNET_STRINGS_filename_expand(), GNUNET_TESTBED_barrier_wait(), GNUNET_TESTBED_test_run(), GNUNET_TESTING_system_create_with_portrange(), handle_union_p2p_strata_estimator(), LEGACY_SERVICE_run(), main(), mktemp_name(), my_timegm(), parent_control_handler(), parse_definitions(), plugin_fini(), set_cont(), setup_service(), share_tree_trim(), tokenizer_cb(), and write_benchmark_data().

Here is the caller graph for this function:

my_index()

static char* my_index ( const char *  str, int  chr  )

static

Definition at line 196 of file getopt.c.

{
  while (*str)
  {
    if (*str == chr)
      return (char *) str;
    str++;
  }
  return 0;
}

Referenced by GN_getopt_internal().

Here is the caller graph for this function:

exchange()

static void exchange ( char **  argv )

static

Definition at line 251 of file getopt.c.

{
  int bottom = first_nonopt;
  int middle = last_nonopt;
  int top = GNoptind;
  char *tem;
 
  /* Exchange the shorter segment with the far end of the longer segment.
   * That puts the shorter segment into the right place.
   * It leaves the longer segment in the right place overall,
   * but it consists of two parts that need to be swapped next.  */
 
  while (top > middle && middle > bottom)
  {
    if (top - middle > middle - bottom)
    {
      /* Bottom segment is the short one.  */
      int len = middle - bottom;
      register int i;
 
      /* Swap it with the top part of the top segment.  */
      for (i = 0; i < len; i++)
      {
        tem = argv[bottom + i];
        argv[bottom + i] = argv[top - (middle - bottom) + i];
        argv[top - (middle - bottom) + i] = tem;
        SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
      }
      /* Exclude the moved bottom segment from further swapping.  */
      top -= len;
    }
    else
    {
      /* Top segment is the short one.  */
      int len = top - middle;
      register int i;
 
      /* Swap it with the bottom part of the bottom segment.  */
      for (i = 0; i < len; i++)
      {
        tem = argv[bottom + i];
        argv[bottom + i] = argv[middle + i];
        argv[middle + i] = tem;
        SWAP_FLAGS (bottom + i, middle + i);
      }
      /* Exclude the moved top segment from further swapping.  */
      bottom += len;
    }
  }
 
  /* Update records for the slots the non-options now occupy.  */
 
  first_nonopt += (GNoptind - last_nonopt);
  last_nonopt = GNoptind;
}

References first_nonopt, GNoptind, last_nonopt, len, and SWAP_FLAGS.

Referenced by GN_getopt_internal().

Here is the caller graph for this function:

_getopt_initialize()

static const char* _getopt_initialize ( int  argc, char *const *  argv, const char *  optstring  )

static

Definition at line 316 of file getopt.c.

{
  /* Start processing options with ARGV-element 1 (since ARGV-element 0
   * is the program name); the sequence of previously skipped
   * non-option ARGV-elements is empty.  */
 
  first_nonopt = last_nonopt = GNoptind;
 
  nextchar = NULL;
 
  posixly_correct = getenv ("POSIXLY_CORRECT");
 
  /* Determine how to handle the ordering of options and nonoptions.  */
 
  if (optstring[0] == '-')
  {
    ordering = RETURN_IN_ORDER;
    ++optstring;
  }
  else if (optstring[0] == '+')
  {
    ordering = REQUIRE_ORDER;
    ++optstring;
  }
  else if (posixly_correct != NULL)
    ordering = REQUIRE_ORDER;
  else
    ordering = PERMUTE;
 
  return optstring;
}

References first_nonopt, getenv(), GNoptind, last_nonopt, nextchar, ordering, PERMUTE, posixly_correct, REQUIRE_ORDER, and RETURN_IN_ORDER.

Referenced by GN_getopt_internal().

Here is the call graph for this function:

Here is the caller graph for this function:

GN_getopt_internal()

static int GN_getopt_internal ( int  argc, char *const *  argv, const char *  optstring, const struct GNoption *  longopts, int *  longind, int  long_only  )

static

Definition at line 406 of file getopt.c.

{
  static int __getopt_initialized = 0;
  static int GNopterr = 1;
 
  GNoptarg = NULL;
 
  if ((GNoptind == 0) || ! __getopt_initialized)
  {
    if (GNoptind == 0)
      GNoptind = 1;   /* Don't scan ARGV[0], the program name.  */
    optstring = _getopt_initialize (argc, argv, optstring);
    __getopt_initialized = 1;
  }
 
  /* Test whether ARGV[GNoptind] points to a non-option argument.
   * Either it does not have option syntax, or there is an environment flag
   * from the shell indicating it is not an option.  The later information
   * is only used when the used in the GNU libc.  */
#define NONOPTION_P (argv[GNoptind][0] != '-' || argv[GNoptind][1] == '\0')
 
  if ((nextchar == NULL) || (*nextchar == '\0'))
  {
    /* Advance to the next ARGV-element.  */
 
    /* Give FIRST_NONOPT & LAST_NONOPT rational values if GNoptind has been
    * moved back by the user (who may also have changed the arguments).  */
    if (last_nonopt > GNoptind)
      last_nonopt = GNoptind;
    if (first_nonopt > GNoptind)
      first_nonopt = GNoptind;
 
    if (ordering == PERMUTE)
    {
      /* If we have just processed some options following some non-options,
       * exchange them so that the options come first.  */
 
      if ((first_nonopt != last_nonopt) && (last_nonopt != GNoptind) )
        exchange ((char **) argv);
      else if (last_nonopt != GNoptind)
        first_nonopt = GNoptind;
 
      /* Skip any additional non-options
       * and extend the range of non-options previously skipped.  */
 
      while (GNoptind < argc && NONOPTION_P)
        GNoptind++;
      last_nonopt = GNoptind;
    }
 
    /* The special ARGV-element `--' means premature end of options.
     * Skip it like a null option,
     * then exchange with previous non-options as if it were an option,
     * then skip everything else like a non-option.  */
    if ((GNoptind != argc) && ! strcmp (argv[GNoptind], "--"))
    {
      GNoptind++;
 
      if ((first_nonopt != last_nonopt) && (last_nonopt != GNoptind) )
        exchange ((char **) argv);
      else if (first_nonopt == last_nonopt)
        first_nonopt = GNoptind;
      last_nonopt = argc;
 
      GNoptind = argc;
    }
 
    /* If we have done all the ARGV-elements, stop the scan
     * and back over any non-options that we skipped and permuted.  */
 
    if (GNoptind == argc)
    {
      /* Set the next-arg-index to point at the non-options
       * that we previously skipped, so the caller will digest them.  */
      if (first_nonopt != last_nonopt)
        GNoptind = first_nonopt;
      return -1;
    }
 
    /* If we have come to a non-option and did not permute it,
     * either stop the scan or describe it to the caller and pass it by.  */
 
    if (NONOPTION_P)
    {
      if (ordering == REQUIRE_ORDER)
        return -1;
      GNoptarg = argv[GNoptind++];
      return 1;
    }
 
    /* We have found another option-ARGV-element.
     * Skip the initial punctuation.  */
 
    nextchar =
      (argv[GNoptind] + 1 + (longopts != NULL && argv[GNoptind][1] == '-'));
  }
 
  /* Decode the current option-ARGV-element.  */
 
  /* Check whether the ARGV-element is a long option.
   *
   * If long_only and the ARGV-element has the form "-f", where f is
   * a valid short option, don't consider it an abbreviated form of
   * a long option that starts with f.  Otherwise there would be no
   * way to give the -f short option.
   *
   * On the other hand, if there's a long option "fubar" and
   * the ARGV-element is "-fu", do consider that an abbreviation of
   * the long option, just like "--fu", and not "-f" with arg "u".
   *
   * This distinction seems to be the most useful approach.  */if ((longopts != NULL) &&
      ((argv[GNoptind][1] == '-') ||
       (long_only &&
        (argv[GNoptind][2] || ! my_index (optstring, argv[GNoptind][1])))))
  {
    char *nameend;
    const struct GNoption *p;
    const struct GNoption *pfound = NULL;
    int exact = 0;
    int ambig = 0;
    int indfound = -1;
    int option_index;
 
    for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
      /* Do nothing.  */;
 
    /* Test all long options for either exact match
     * or abbreviated matches.  */
    for (p = longopts, option_index = 0; p->name; p++, option_index++)
      if (! strncmp (p->name, nextchar, nameend - nextchar))
      {
        if ((unsigned int) (nameend - nextchar) ==
            (unsigned int) strlen (p->name))
        {
          /* Exact match found.  */
          pfound = p;
          indfound = option_index;
          exact = 1;
          break;
        }
        else if (pfound == NULL)
        {
          /* First nonexact match found.  */
          pfound = p;
          indfound = option_index;
        }
        else
          /* Second or later nonexact match found.  */
          ambig = 1;
      }
 
    if (ambig && ! exact)
    {
      if (GNopterr)
        fprintf (stderr,
                 _ ("%s: option `%s' is ambiguous\n"),
                 argv[0],
                 argv[GNoptind]);
      nextchar += strlen (nextchar);
      GNoptind++;
      return '?';
    }
 
    if (pfound != NULL)
    {
      option_index = indfound;
      GNoptind++;
      if (*nameend)
      {
        /* Don't test has_arg with >, because some C compilers don't
         * allow it to be used on enums.  */
        if (pfound->has_arg)
          GNoptarg = nameend + 1;
        else
        {
          if (GNopterr)
          {
            if (argv[GNoptind - 1][1] == '-')
              /* --option */
              fprintf (stderr,
                       _ ("%s: option `--%s' does not allow an argument\n"),
                       argv[0],
                       pfound->name);
            else
              /* +option or -option */
              fprintf (stderr,
                       _ ("%s: option `%c%s' does not allow an argument\n"),
                       argv[0],
                       argv[GNoptind - 1][0],
                       pfound->name);
          }
          nextchar += strlen (nextchar);
          return '?';
        }
      }
      else if (pfound->has_arg == 1)
      {
        if (GNoptind < argc)
        {
          GNoptarg = argv[GNoptind++];
        }
        else
        {
          if (GNopterr)
          {
            fprintf (stderr,
                     _ ("%s: option `%s' requires an argument\n"),
                     argv[0],
                     argv[GNoptind - 1]);
          }
          nextchar += strlen (nextchar);
          return (optstring[0] == ':') ? ':' : '?';
        }
      }
      nextchar += strlen (nextchar);
      if (longind != NULL)
        *longind = option_index;
      if (pfound->flag)
      {
        *(pfound->flag) = pfound->val;
        return 0;
      }
      return pfound->val;
    }
 
    /* Can't find it as a long option.  If this is not getopt_long_only,
     * or the option starts with '--' or is not a valid short
     * option, then it's an error.
     * Otherwise interpret it as a short option.  */
    if (! long_only || (argv[GNoptind][1] == '-') ||
        (my_index (optstring, *nextchar) == NULL) )
    {
      if (GNopterr)
      {
        if (argv[GNoptind][1] == '-')
          /* --option */
          fprintf (stderr,
                   _ ("%s: unrecognized option `--%s'\n"),
                   argv[0],
                   nextchar);
        else
          /* +option or -option */
          fprintf (stderr,
                   _ ("%s: unrecognized option `%c%s'\n"),
                   argv[0],
                   argv[GNoptind][0],
                   nextchar);
      }
      nextchar = (char *) "";
      GNoptind++;
      return '?';
    }
  }
 
  /* Look at and handle the next short option-character.  */
 
  {
    char c = *nextchar++;
    char *temp = my_index (optstring, c);
 
    /* Increment `GNoptind' when we start to process its last character.  */
    if (*nextchar == '\0')
      ++GNoptind;
 
    if ((temp == NULL) || (c == ':'))
    {
      if (GNopterr)
      {
        if (posixly_correct)
          /* 1003.2 specifies the format of this message.  */
          fprintf (stderr, _ ("%s: illegal option -- %c\n"), argv[0], c);
        else
          fprintf (stderr, _ ("%s: invalid option -- %c\n"), argv[0], c);
      }
      return '?';
    }
    /* Convenience. Treat POSIX -W foo same as long option --foo */
    if ((temp[0] == 'W') && (temp[1] == ';'))
    {
      char *nameend;
      const struct GNoption *p;
      const struct GNoption *pfound = NULL;
      int exact = 0;
      int ambig = 0;
      int indfound = 0;
      int option_index;
 
      /* This is an option that requires an argument.  */
      if (*nextchar != '\0')
      {
        GNoptarg = nextchar;
        /* If we end this ARGV-element by taking the rest as an arg,
         * we must advance to the next element now.  */
        GNoptind++;
      }
      else if (GNoptind == argc)
      {
        if (GNopterr)
        {
          /* 1003.2 specifies the format of this message.  */
          fprintf (stderr,
                   _ ("%s: option requires an argument -- %c\n"),
                   argv[0],
                   c);
        }
        if (optstring[0] == ':')
          c = ':';
        else
          c = '?';
        return c;
      }
      else
        /* We already incremented `GNoptind' once;
         * increment it again when taking next ARGV-elt as argument.  */
        GNoptarg = argv[GNoptind++];
 
      /* GNoptarg is now the argument, see if it's in the
       * table of longopts.  */
 
      for (nextchar = nameend = GNoptarg; *nameend && *nameend != '=';
           nameend++)
        /* Do nothing.  */;
 
      /* Test all long options for either exact match
       * or abbreviated matches.  */
      if (longopts != NULL)
        for (p = longopts, option_index = 0; p->name; p++, option_index++)
          if (! strncmp (p->name, nextchar, nameend - nextchar))
          {
            if ((unsigned int) (nameend - nextchar) == strlen (p->name))
            {
              /* Exact match found.  */
              pfound = p;
              indfound = option_index;
              exact = 1;
              break;
            }
            else if (pfound == NULL)
            {
              /* First nonexact match found.  */
              pfound = p;
              indfound = option_index;
            }
            else
              /* Second or later nonexact match found.  */
              ambig = 1;
          }
      if (ambig && ! exact)
      {
        if (GNopterr)
          fprintf (stderr,
                   _ ("%s: option `-W %s' is ambiguous\n"),
                   argv[0],
                   argv[GNoptind]);
        nextchar += strlen (nextchar);
        GNoptind++;
        return '?';
      }
      if (pfound != NULL)
      {
        option_index = indfound;
        if (*nameend)
        {
          /* Don't test has_arg with >, because some C compilers don't
           * allow it to be used on enums.  */
          if (pfound->has_arg)
            GNoptarg = nameend + 1;
          else
          {
            if (GNopterr)
              fprintf (stderr,
                       _ ("%s: option `-W %s' does not allow an argument\n"),
                       argv[0],
                       pfound->name);
 
            nextchar += strlen (nextchar);
            return '?';
          }
        }
        else if (pfound->has_arg == 1)
        {
          if (GNoptind < argc)
            GNoptarg = argv[GNoptind++];
          else
          {
            if (GNopterr)
              fprintf (stderr,
                       _ ("%s: option `%s' requires an argument\n"),
                       argv[0],
                       argv[GNoptind - 1]);
            nextchar += strlen (nextchar);
            return optstring[0] == ':' ? ':' : '?';
          }
        }
        nextchar += strlen (nextchar);
        if (longind != NULL)
          *longind = option_index;
        if (pfound->flag)
        {
          *(pfound->flag) = pfound->val;
          return 0;
        }
        return pfound->val;
      }
      nextchar = NULL;
      return 'W';   /* Let the application handle it.   */
    }
    if (temp[1] == ':')
    {
      if (temp[2] == ':')
      {
        /* This is an option that accepts an argument optionally.  */
        if (*nextchar != '\0')
        {
          GNoptarg = nextchar;
          GNoptind++;
        }
        else
          GNoptarg = NULL;
        nextchar = NULL;
      }
      else
      {
        /* This is an option that requires an argument.  */
        if (*nextchar != '\0')
        {
          GNoptarg = nextchar;
          /* If we end this ARGV-element by taking the rest as an arg,
           * we must advance to the next element now.  */
          GNoptind++;
        }
        else if (GNoptind == argc)
        {
          if (GNopterr)
          {
            /* 1003.2 specifies the format of this message.  */
            fprintf (stderr,
                     _ ("%s: option requires an argument -- %c\n"),
                     argv[0],
                     c);
          }
          if (optstring[0] == ':')
            c = ':';
          else
            c = '?';
        }
        else
          /* We already incremented `GNoptind' once;
           * increment it again when taking next ARGV-elt as argument.  */
          GNoptarg = argv[GNoptind++];
        nextchar = NULL;
      }
    }
    return c;
  }
}

References _, _getopt_initialize(), exchange(), first_nonopt, GNoption::flag, GNoptarg, GNoptind, GNoption::has_arg, last_nonopt, my_index(), GNoption::name, nextchar, NONOPTION_P, ordering, p, PERMUTE, posixly_correct, REQUIRE_ORDER, and GNoption::val.

Referenced by GNgetopt_long().

Here is the call graph for this function:

Here is the caller graph for this function:

GNgetopt_long()

static int GNgetopt_long ( int  argc, char *const *  argv, const char *  options, const struct GNoption *  long_options, int *  opt_index  )

static

Definition at line 870 of file getopt.c.

{
  return GN_getopt_internal (argc, argv, options, long_options, opt_index, 0);
}

References GN_getopt_internal(), and options.

Referenced by GNUNET_GETOPT_run().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

GNoptarg

char* GNoptarg = NULL

static

Definition at line 119 of file getopt.c.

Referenced by GN_getopt_internal(), and GNUNET_GETOPT_run().

GNoptind

int GNoptind = 1

static

Definition at line 134 of file getopt.c.

Referenced by _getopt_initialize(), exchange(), GN_getopt_internal(), and GNUNET_GETOPT_run().

nextchar

char* nextchar

static

Definition at line 143 of file getopt.c.

Referenced by _getopt_initialize(), and GN_getopt_internal().

enum { ... } ordering

Referenced by _getopt_initialize(), and GN_getopt_internal().

posixly_correct

char* posixly_correct

static

Definition at line 178 of file getopt.c.

Referenced by _getopt_initialize(), and GN_getopt_internal().

first_nonopt

int first_nonopt

static

Definition at line 230 of file getopt.c.

Referenced by _getopt_initialize(), exchange(), and GN_getopt_internal().

last_nonopt

int last_nonopt

static

Definition at line 231 of file getopt.c.

Referenced by _getopt_initialize(), exchange(), and GN_getopt_internal().