cobgetopt.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	option

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

Functions
COB_EXPIMP int	cob_getopt_long_long (const int, char *const *, const char *, const struct option *, int *, const int)

Variables
COB_EXPIMP char *	cob_optarg
COB_EXPIMP int	cob_optind
COB_EXPIMP int	cob_opterr
COB_EXPIMP int	cob_optopt

Macro Definition Documentation

#define no_argument   0

Definition at line 92 of file cobgetopt.h.

#define optional_argument   2

Definition at line 94 of file cobgetopt.h.

#define required_argument   1

Definition at line 93 of file cobgetopt.h.

Function Documentation

COB_EXPIMP int cob_getopt_long_long	(	const int	,
		char *const *	,
		const char *	,
		const struct option *	,
		int *	,
		const int
	)

Definition at line 321 of file cobgetopt.c.

References _, _getopt_initialize(), cob_fast_malloc(), cob_free(), cob_getopt_initialized, cob_optarg, cob_opterr, cob_optind, cob_optopt, exchange(), first_nonopt, option::flag, option::has_arg, last_nonopt, option::name, nextchar, NONOPTION_P, NULL, ordering, PERMUTE, REQUIRE_ORDER, seen_short, and option::val.

Referenced by cob_sys_getopt_long_long(), and process_command_line().

{
  if (argc < 1)
    return -1;

  cob_optarg = NULL;

  if (cob_optind == 0 || !cob_getopt_initialized)
    {
      if (cob_optind == 0)
    cob_optind = 1; /* Don't scan ARGV[0], the program name.  */
      optstring = _getopt_initialize (optstring);
      cob_getopt_initialized = 1;
    }

  /* Test whether ARGV[optind] 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.  */

  if (nextchar == NULL || *nextchar == '\0')
    {
      /* Advance to the next ARGV-element.  */

      seen_short = 0;
      /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
     moved back by the user (who may also have changed the arguments).  */
      if (last_nonopt > cob_optind)
    last_nonopt = cob_optind;
      if (first_nonopt > cob_optind)
    first_nonopt = cob_optind;

      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 != cob_optind)
        exchange ((char **) argv);
      else if (last_nonopt != cob_optind)
        first_nonopt = cob_optind;

      /* Skip any additional non-options
         and extend the range of non-options previously skipped.  */

      while (cob_optind < argc && NONOPTION_P)
        cob_optind++;
      last_nonopt = cob_optind;
    }

      /* 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 (cob_optind != argc && !strcmp (argv[cob_optind], "--"))
    {
      cob_optind++;

      if (first_nonopt != last_nonopt && last_nonopt != cob_optind)
        exchange ((char **) argv);
      else if (first_nonopt == last_nonopt)
        first_nonopt = cob_optind;
      last_nonopt = argc;

      cob_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 (cob_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)
        cob_optind = 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;
      cob_optarg = argv[cob_optind++];
      return 1;
    }

      /* We have found another option-ARGV-element.
     Skip the initial punctuation.  */

      nextchar = (argv[cob_optind] + 1
          + (longopts != NULL && argv[cob_optind][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[cob_optind][1] == '-'
      || (long_only && !seen_short && (argv[cob_optind][2] || !strchr (optstring, argv[cob_optind][1])))))
    {
      char *nameend;
      unsigned int namelen;
      const struct option *p;
      const struct option *pfound = NULL;
      struct option_list {
        const struct option *p;
        struct option_list *next;
      } *ambig_list = NULL;
      struct option_list *ambig_last = NULL;
      int exact = 0;
      int indfound = -1;
      int option_index;

      for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
    /* Do nothing.  */ ;
      namelen = nameend - nextchar;

      /* 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, namelen)) {
        if (namelen == (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 if (long_only
             || pfound->has_arg != p->has_arg
             || pfound->flag != p->flag
             || pfound->val != p->val) {
            /* Second or later nonexact match found.  */
            struct option_list *newp = cob_fast_malloc (sizeof (*newp));
            newp->p = p;
            newp->next = ambig_list;
            ambig_list = newp;
            ambig_last = ambig_list;
        }
      }

      if (ambig_list != NULL){
       if (!exact) {
        if (cob_opterr) {
          struct option_list first;
          first.p = pfound;
          first.next = ambig_list;
          ambig_list = &first;

          fprintf (stderr, _("%s: option '%s' is ambiguous; possibilities:"),
               argv[0], argv[cob_optind]);

          do {
              fprintf (stderr, " '--%s'", ambig_list->p->name);
              ambig_list = ambig_list->next;
          }
          while (ambig_list != NULL);

          fputc ('\n', stderr);
        }
     }
     while (ambig_last != NULL) {
        ambig_list = ambig_last;
        ambig_last = ambig_last->next;
        cob_free (ambig_list);
     }
     if (!exact) {
      nextchar += strlen (nextchar);
      cob_optind++;
      cob_optopt = 0;
      return '?';
     }
    }

    if (pfound != NULL) {
      option_index = indfound;
      cob_optind++;
      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)
        cob_optarg = nameend + 1;
          else
        {
          if (cob_opterr)
            {
              if (argv[cob_optind - 1][1] == '-')
            {
              /* --option */
              fprintf (stderr, _("%s: option '--%s' doesn't allow an argument"),
                   argv[0], pfound->name);
              fputc ('\n', stderr);
            }
              else
            {
              /* +option or -option */
              fprintf (stderr, _("%s: option '%c%s' doesn't allow an argument"),
                   argv[0], argv[cob_optind - 1][0], pfound->name);
              fputc ('\n', stderr);
            }
            }

          nextchar += strlen (nextchar);

          cob_optopt = pfound->val;
          return '?';
        }
        }
      else if (pfound->has_arg == 1)
        {
          if (cob_optind < argc)
        cob_optarg = argv[cob_optind++];
          else
        {
          if (cob_opterr)
            {
              fprintf (stderr, _("%s: option '--%s' requires an argument"),
                   argv[0], argv[cob_optind - 1]);
              fputc ('\n', stderr);
            }
          nextchar += strlen (nextchar);
          cob_optopt = pfound->val;
          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[cob_optind][1] == '-'
      || strchr (optstring, *nextchar) == NULL)
    {
      if (cob_opterr)
        {
          if (argv[cob_optind][1] == '-')
        {
          /* --option */
          fprintf (stderr, _("%s: unrecognized option '--%s'"),
               argv[0], nextchar);
          fputc ('\n', stderr);
        }
          else
        {
          /* +option or -option */
          fprintf (stderr, _("%s: unrecognized option '%c%s'"),
               argv[0], argv[cob_optind][0], nextchar);
          fputc ('\n', stderr);
        }
        }
      nextchar = (char *) "";
      cob_optind++;
      cob_optopt = 0;
      return '?';
    }
    }

  /* Look at and handle the next short option-character.  */

  {
    char c = *nextchar++;
    char *temp = strchr (optstring, c);

    /* Increment 'cob_optind' when we start to process its last character.  */
    if (*nextchar == '\0')
    {
      ++cob_optind;
      seen_short = 0;
    }

    if (temp == NULL || c == ':')
      {
    if (cob_opterr)
      {
        fprintf (stderr, _("%s: invalid option -- %c"), argv[0], c);
        fputc ('\n', stderr);
      }
    cob_optopt = c;
    seen_short = 0;
    return '?';
      }
    /* Convenience. Treat POSIX -W foo same as long option --foo */
    if (temp[0] == 'W' && temp[1] == ';')
      {
    char *nameend;
    const struct option *p;
    const struct option *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')
      {
        cob_optarg = nextchar;
        /* If we end this ARGV-element by taking the rest as an arg,
           we must advance to the next element now.  */
        cob_optind++;
      }
    else if (cob_optind == argc)
      {
        if (cob_opterr)
          {
        /* 1003.2 specifies the format of this message.  */
        fprintf (stderr, _("%s: option requires an argument -- %c"),
             argv[0], c);
        fputc ('\n', stderr);
          }
        cob_optopt = c;
        if (optstring[0] == ':')
          c = ':';
        else
          c = '?';
        seen_short = 0;
        return c;
      }
    else
      /* We already incremented 'cob_optind' once;
         increment it again when taking next ARGV-elt as argument.  */
      cob_optarg = argv[cob_optind++];

    /* cob_optarg is now the argument, see if it's in the
       table of longopts.  */
    if (!longopts) return '?'; /* silence warning */
    for (nextchar = nameend = cob_optarg; *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, (size_t)(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 (cob_opterr)
          {
        fprintf (stderr, _("%s: option '-W %s' is ambiguous"),
             argv[0], argv[cob_optind]);
        fputc ('\n', stderr);
          }
        nextchar += strlen (nextchar);
        cob_optind++;
        seen_short = 0;
        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)
          cob_optarg = nameend + 1;
        else
          {
            if (cob_opterr)
              {
            fprintf (stderr, _("%s: option '-W %s' doesn't allow an argument"),
                 argv[0], pfound->name);
            fputc ('\n', stderr);
              }

            nextchar += strlen (nextchar);
            seen_short = 0;
            return '?';
          }
          }
        else if (pfound->has_arg == 1)
          {
        if (cob_optind < argc)
          cob_optarg = argv[cob_optind++];
        else
          {
            if (cob_opterr)
              {
            fprintf (stderr, _("%s: option '%s' requires an argument"),
                 argv[0], argv[cob_optind - 1]);
            fputc ('\n', stderr);
              }
            nextchar += strlen (nextchar);
            seen_short = 0;
            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')
          {
        cob_optarg = nextchar;
        cob_optind++;
          }
        else
          cob_optarg = NULL;
        nextchar = NULL;
      }
    else
      {
        /* This is an option that requires an argument.  */
        if (*nextchar != '\0')
          {
        cob_optarg = nextchar;
        /* If we end this ARGV-element by taking the rest as an arg,
           we must advance to the next element now.  */
        cob_optind++;
          }
        else if (cob_optind == argc)
          {
        if (cob_opterr)
          {
            /* 1003.2 specifies the format of this message.  */
            fprintf (stderr, _("%s: option requires an argument -- %c"),
                 argv[0], c);
             fputc ('\n', stderr);
          }
        cob_optopt = c;
        seen_short = 0;
        if (optstring[0] == ':')
          c = ':';
        else
          c = '?';
          }
        else
          /* We already incremented 'cob_optind' once;
         increment it again when taking next ARGV-elt as argument.  */
          cob_optarg = argv[cob_optind++];
        nextchar = NULL;
      }
      }
    seen_short = 1;
    return c;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

COB_EXPIMP char* cob_optarg

Definition at line 34 of file cobgetopt.h.

COB_EXPIMP int cob_opterr

Definition at line 53 of file cobgetopt.h.

COB_EXPIMP int cob_optind

Definition at line 48 of file cobgetopt.h.

COB_EXPIMP int cob_optopt

Definition at line 57 of file cobgetopt.h.