fegetopt.h File Reference

Go to the source code of this file.

Data Structures
struct	fe_option

Macros
#define	no_argument   0
#define	required_argument   1
#define	optional_argument   2

Enumerations
enum	feOptType { feOptUntyped , feOptBool , feOptInt , feOptString }

Functions
int	fe_getopt (int argc, char *const *argv, const char *shortopts)
int	fe_getopt_long (int argc, char *const *argv, const char *shortopts, const struct fe_option *longopts, int *longind)
int	fe_getopt_long_only (int argc, char *const *argv, const char *shortopts, const struct fe_option *longopts, int *longind)
int	_fe_getopt_internal (int argc, char *const *argv, const char *shortopts, const struct fe_option *longopts, int *longind, int long_only)

Variables
char *	fe_optarg
int	fe_optind
int	fe_opterr
int	fe_optopt

---

Data Structure Documentation

fe_option

struct fe_option

Definition at line 78 of file fegetopt.h.

Data Fields
const char *	arg_name
int	has_arg
const char *	help
char *	name
int	set
feOptType	type
int	val
void *	value

Macro Definition Documentation

no_argument

#define no_argument   0

Definition at line 99 of file fegetopt.h.

optional_argument

#define optional_argument   2

Definition at line 101 of file fegetopt.h.

required_argument

#define required_argument   1

Definition at line 100 of file fegetopt.h.

Enumeration Type Documentation

feOptType

enum feOptType

Enumerator
feOptUntyped
feOptBool
feOptInt
feOptString

Definition at line 77 of file fegetopt.h.

{feOptUntyped, feOptBool, feOptInt, feOptString} feOptType;

Function Documentation

_fe_getopt_internal()

int _fe_getopt_internal	(	int	argc,
		char *const *	argv,
		const char *	shortopts,
		const struct fe_option *	longopts,
		int *	longind,
		int	long_only
	)

Definition at line 325 of file fegetopt.c.

{
  int option_index;
 
  fe_optarg = 0;
 
  /* Initialize the internal data when the first call is made.
     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.  */
 
  if (fe_optind == 0)
    {
      first_nonopt = last_nonopt = fe_optind = 1;
 
      nextchar = NULL;
 
      /* 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 (getenv ("POSIXLY_CORRECT") != NULL)
        ordering = REQUIRE_ORDER;
      else
        ordering = PERMUTE;
    }
 
  if (nextchar == NULL || *nextchar == '\0')
    {
      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 != fe_optind)
            exchange ((char **) argv);
          else if (last_nonopt != fe_optind)
            first_nonopt = fe_optind;
 
          /* Now skip any additional non-options
             and extend the range of non-options previously skipped.  */
 
          while (fe_optind < argc
                 && (argv[fe_optind][0] != '-' || argv[fe_optind][1] == '\0')
#ifdef GETOPT_COMPAT
                 && (longopts == NULL
                     || argv[fe_optind][0] != '+' || argv[fe_optind][1] == '\0')
#endif                          /* GETOPT_COMPAT */
                 )
            fe_optind++;
          last_nonopt = fe_optind;
        }
 
      /* 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 (fe_optind != argc && !strcmp (argv[fe_optind], "--"))
        {
          fe_optind++;
 
          if (first_nonopt != last_nonopt && last_nonopt != fe_optind)
            exchange ((char **) argv);
          else if (first_nonopt == last_nonopt)
            first_nonopt = fe_optind;
          last_nonopt = argc;
 
          fe_optind = argc;
        }
 
      /* If we have done all the ARGV-elements, stop the scan
         and back over any non-options that we skipped and permuted.  */
 
      if (fe_optind == 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)
            fe_optind = first_nonopt;
          return EOF;
        }
 
      /* 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 ((argv[fe_optind][0] != '-' || argv[fe_optind][1] == '\0')
#ifdef GETOPT_COMPAT
          && (longopts == NULL
              || argv[fe_optind][0] != '+' || argv[fe_optind][1] == '\0')
#endif                          /* GETOPT_COMPAT */
          )
        {
          if (ordering == REQUIRE_ORDER)
            return EOF;
          fe_optarg = argv[fe_optind++];
          return 1;
        }
 
      /* We have found another option-ARGV-element.
         Start decoding its characters.  */
 
      nextchar = (argv[fe_optind] + 1
                  + (longopts != NULL && argv[fe_optind][1] == '-'));
    }
 
  if (longopts != NULL
      && ((argv[fe_optind][0] == '-'
           && (argv[fe_optind][1] == '-' || long_only))
#ifdef GETOPT_COMPAT
          || argv[fe_optind][0] == '+'
#endif                          /* GETOPT_COMPAT */
          ))
    {
      const struct fe_option *p;
      char *s = nextchar;
      int exact = 0;
      int ambig = 0;
      const struct fe_option *pfound = NULL;
      int indfound = 0;
 
      while (*s && *s != '=')
        s++;
 
      /* Test all options for either exact match or abbreviated matches.  */
      for (p = longopts, option_index = 0; p->name;
           p++, option_index++)
        if (!strncmp (p->name, nextchar, s - nextchar))
          {
            if (s - nextchar == (long)my_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 nonexact match found.  */
              ambig = 1;
          }
 
      if (ambig && !exact)
        {
          if (fe_opterr)
            fprintf (stderr, "%s: option `%s' is ambiguous\n",
                     argv[0], argv[fe_optind]);
          nextchar += my_strlen (nextchar);
          fe_optind++;
          return BAD_OPTION;
        }
 
      if (pfound != NULL)
        {
          option_index = indfound;
          fe_optind++;
          if (*s)
            {
              /* Don't test has_arg with >, because some C compilers don't
                 allow it to be used on enums.  */
              if (pfound->has_arg)
                fe_optarg = s + 1;
              else
                {
                  if (fe_opterr)
                    {
                      if (argv[fe_optind - 1][1] == '-')
                        /* --option */
                        fprintf (stderr,
                                 "%s: option `--%s' doesn't allow an argument\n",
                                 argv[0], pfound->name);
                      else
                        /* +option or -option */
                        fprintf (stderr,
                             "%s: option `%c%s' doesn't allow an argument\n",
                             argv[0], argv[fe_optind - 1][0], pfound->name);
                    }
                  nextchar += my_strlen (nextchar);
                  return BAD_OPTION;
                }
            }
          else if (pfound->has_arg == 1)
            {
              if (fe_optind < argc)
                fe_optarg = argv[fe_optind++];
              else
                {
                  if (fe_opterr)
                    fprintf (stderr, "%s: option `%s' requires an argument\n",
                             argv[0], argv[fe_optind - 1]);
                  nextchar += my_strlen (nextchar);
                  return optstring[0] == ':' ? ':' : BAD_OPTION;
                }
            }
          nextchar += my_strlen (nextchar);
          if (longind != NULL)
            *longind = option_index;
          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[fe_optind][1] == '-'
#ifdef GETOPT_COMPAT
          || argv[fe_optind][0] == '+'
#endif                          /* GETOPT_COMPAT */
          || my_index (optstring, *nextchar) == NULL)
        {
          if (fe_opterr)
            {
              if (argv[fe_optind][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[fe_optind][0], nextchar);
            }
          nextchar = (char *) "";
          fe_optind++;
          return BAD_OPTION;
        }
    }
 
  /* Look at and handle the next option-character.  */
 
  {
    char c = *nextchar++;
    const char *temp = my_index (optstring, c);
 
    /* Increment `fe_optind' when we start to process its last character.  */
    if (*nextchar == '\0')
      ++fe_optind;
 
    if (temp == NULL || c == ':')
      {
        if (fe_opterr)
          {
#if 0
            if (c < 040 || c >= 0177)
              fprintf (stderr, "%s: unrecognized option, character code 0%o\n",
                       argv[0], c);
            else
              fprintf (stderr, "%s: unrecognized option `-%c'\n", argv[0], c);
#else
            /* 1003.2 specifies the format of this message.  */
            fprintf (stderr, "%s: illegal option -- %c\n", argv[0], c);
#endif
          }
        fe_optopt = c;
        return BAD_OPTION;
      }
    if (temp[1] == ':')
      {
        if (temp[2] == ':')
          {
            /* This is an option that accepts an argument optionally.  */
            if (*nextchar != '\0')
              {
                fe_optarg = nextchar;
                fe_optind++;
              }
            else
              fe_optarg = 0;
            nextchar = NULL;
          }
        else
          {
            /* This is an option that requires an argument.  */
            if (*nextchar != '\0')
              {
                fe_optarg = nextchar;
                /* If we end this ARGV-element by taking the rest as an arg,
                   we must advance to the next element now.  */
                fe_optind++;
              }
            else if (fe_optind == argc)
              {
                if (fe_opterr)
                  {
#if 0
                    fprintf (stderr, "%s: option `-%c' requires an argument\n",
                             argv[0], c);
#else
                    /* 1003.2 specifies the format of this message.  */
                    fprintf (stderr, "%s: option requires an argument -- %c\n",
                             argv[0], c);
#endif
                  }
                fe_optopt = c;
                if (optstring[0] == ':')
                  c = ':';
                else
                  c = BAD_OPTION;
              }
            else
              /* We already incremented `fe_optind' once;
                 increment it again when taking next ARGV-elt as argument.  */
              fe_optarg = argv[fe_optind++];
            nextchar = NULL;
          }
      }
    return c;
  }
}

fe_getopt()

int fe_getopt	(	int	argc,
		char *const *	argv,
		const char *	shortopts
	)

Definition at line 653 of file fegetopt.c.

{
  return _fe_getopt_internal (argc, argv, optstring,
                           (const struct fe_option *) 0,
                           (int *) 0,
                           0);
}

fe_getopt_long()

int fe_getopt_long	(	int	argc,
		char *const *	argv,
		const char *	shortopts,
		const struct fe_option *	longopts,
		int *	longind
	)

Definition at line 664 of file fegetopt.c.

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

fe_getopt_long_only()

int fe_getopt_long_only	(	int	argc,
		char *const *	argv,
		const char *	shortopts,
		const struct fe_option *	longopts,
		int *	longind
	)

Definition at line 674 of file fegetopt.c.

{
  return _fe_getopt_internal (argc, argv, options, long_options, opt_index, 1);
}

Variable Documentation

fe_optarg

char* fe_optarg

extern

Definition at line 94 of file fegetopt.c.

fe_opterr

int fe_opterr

extern

Definition at line 123 of file fegetopt.c.

fe_optind

int fe_optind

extern

Definition at line 109 of file fegetopt.c.

fe_optopt

int fe_optopt

extern

Definition at line 130 of file fegetopt.c.