Logo Search packages:      
Sourcecode: bash version File versions


/* getopt for BASH.

   Copyright (C) 1993, 1994
      Free Software Foundation, Inc.

   This program is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by the
   Free Software Foundation; either version 2, or (at your option) any
   later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA.  */

#include <config.h>

#if defined (HAVE_UNISTD_H)
#  ifdef _MINIX
#    include <sys/types.h>
#  endif
#  include <unistd.h>

#include <stdio.h>
#include "memalloc.h"
#include "../shell.h"
#include "getopt.h"

/* For communication from `sh_getopt' to the caller.
   When `sh_getopt' finds an option that takes an argument,
   the argument value is returned here. */
char *sh_optarg = 0;

/* Index in ARGV of the next element to be scanned.
   This is used for communication to and from the caller
   and for communication between successive calls to `sh_getopt'.

   On entry to `sh_getopt', zero means this is the first call; initialize.

   When `sh_getopt' returns EOF, this is the index of the first of the
   non-option elements that the caller should itself scan.

   Otherwise, `sh_optind' communicates from one call to the next
   how much of ARGV has been scanned so far.  */

/* XXX 1003.2 says this must be 1 before any call.  */
int sh_optind = 0;

/* Index of the current argument. */
static int sh_curopt;

/* The next char to be scanned in the option-element
   in which the last option character we returned was found.
   This allows us to pick up the scan where we left off.

   If this is zero, or a null string, it means resume the scan
   by advancing to the next ARGV-element.  */

static char *nextchar;
static int sh_charindex;

/* Callers store zero here to inhibit the error message
   for unrecognized options.  */

int sh_opterr = 1;

/* Set to an option character which was unrecognized.
   This must be initialized on some systems to avoid linking in the
   system's own getopt implementation.  */

int sh_optopt = '?';

/* Set to 1 when we see an invalid option; public so getopts can reset it. */
int sh_badopt = 0;

/* Scan elements of ARGV (whose length is ARGC) for option characters
   given in OPTSTRING.

   If an element of ARGV starts with '-', and is not exactly "-" or "--",
   then it is an option element.  The characters of this element
   (aside from the initial '-') are option characters.  If `sh_getopt'
   is called repeatedly, it returns successively each of the option characters
   from each of the option elements.

   If `sh_getopt' finds another option character, it returns that character,
   updating `sh_optind' and `nextchar' so that the next call to `sh_getopt' can
   resume the scan with the following option character or ARGV-element.

   If there are no more option characters, `sh_getopt' returns `EOF'.
   Then `sh_optind' is the index in ARGV of the first ARGV-element
   that is not an option.

   OPTSTRING is a string containing the legitimate option characters.
   If an option character is seen that is not listed in OPTSTRING,
   return '?' after printing an error message.  If you set `sh_opterr' to
   zero, the error message is suppressed but we still return '?'.

   If a char in OPTSTRING is followed by a colon, that means it wants an arg,
   so the following text in the same ARGV-element, or the text of the following
   ARGV-element, is returned in `sh_optarg'. */

/* 1003.2 specifies the format of this message.  */
#define BADOPT(x)  fprintf (stderr, "%s: illegal option -- %c\n", argv[0], x)
#define NEEDARG(x) fprintf (stderr, "%s: option requires an argument -- %c\n", argv[0], x)

sh_getopt (argc, argv, optstring)
     int argc;
     char *const *argv;
     const char *optstring;
  char c, *temp;

  sh_optarg = 0;

  if (sh_optind >= argc || sh_optind < 0) /* XXX was sh_optind > argc */
      sh_optind = argc;
      return (EOF);

  /* 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 (sh_optind == 0)
      sh_optind = 1;
      nextchar = (char *)NULL;

  if (nextchar == 0 || *nextchar == '\0')
      /* If we have done all the ARGV-elements, stop the scan. */
      if (sh_optind >= argc)
      return EOF;

      temp = argv[sh_optind];

      /* Special ARGV-element `--' means premature end of options.
       Skip it like a null option, and return EOF. */
      if (temp[0] == '-' && temp[1] == '-' && temp[2] == '\0')
        return EOF;

      /* If we have come to a non-option, either stop the scan or describe
       it to the caller and pass it by.  This makes the pseudo-option
       `-' mean the end of options, but does not skip over it. */
      if (temp[0] != '-' || temp[1] == '\0')
      return EOF;

      /* We have found another option-ARGV-element.
       Start decoding its characters.  */
      nextchar = argv[sh_curopt = sh_optind] + 1;
      sh_charindex = 1;

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

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

  sh_optopt = c;

  /* Increment `sh_optind' when we start to process its last character.  */
  if (nextchar == 0 || *nextchar == '\0')
      nextchar = (char *)NULL;

  if (sh_badopt = (temp == NULL || c == ':'))
      if (sh_opterr)
      BADOPT (c);

      return '?';

  if (temp[1] == ':')
      if (nextchar && *nextchar)
        /* This is an option that requires an argument.  */
        sh_optarg = nextchar;
        /* If we end this ARGV-element by taking the rest as an arg,
           we must advance to the next element now.  */
      else if (sh_optind == argc)
        if (sh_opterr)
          NEEDARG (c);

        sh_optopt = c;
        sh_optarg = ""; /* Needed by getopts. */
        c = (optstring[0] == ':') ? ':' : '?';
      /* We already incremented `sh_optind' once;
         increment it again when taking next ARGV-elt as argument.  */
      sh_optarg = argv[sh_optind++];
      nextchar = (char *)NULL;
  return c;

sh_getopt_restore_state (argv)
     char **argv;
  if (nextchar)
    nextchar = argv[sh_curopt] + sh_charindex;

#if 0
sh_getopt_debug_restore_state (argv)
     char **argv;
  if (nextchar && nextchar != argv[sh_curopt] + sh_charindex)
      itrace("sh_getopt_debug_restore_state: resetting nextchar");
      nextchar = argv[sh_curopt] + sh_charindex;
#ifdef TEST

/* Compile with -DTEST to make an executable for use in testing
   the above definition of `sh_getopt'.  */

main (argc, argv)
     int argc;
     char **argv;
  int c;
  int digit_sh_optind = 0;

  while (1)
      int this_option_sh_optind = sh_optind ? sh_optind : 1;

      c = sh_getopt (argc, argv, "abc:d:0123456789");
      if (c == EOF)

      switch (c)
      case '0':
      case '1':
      case '2':
      case '3':
      case '4':
      case '5':
      case '6':
      case '7':
      case '8':
      case '9':
        if (digit_sh_optind != 0 && digit_sh_optind != this_option_sh_optind)
          printf ("digits occur in two different argv-elements.\n");
        digit_sh_optind = this_option_sh_optind;
        printf ("option %c\n", c);

      case 'a':
        printf ("option a\n");

      case 'b':
        printf ("option b\n");

      case 'c':
        printf ("option c with value `%s'\n", sh_optarg);

      case '?':

        printf ("?? sh_getopt returned character code 0%o ??\n", c);

  if (sh_optind < argc)
      printf ("non-option ARGV-elements: ");
      while (sh_optind < argc)
      printf ("%s ", argv[sh_optind++]);
      printf ("\n");

  exit (0);

#endif /* TEST */

Generated by  Doxygen 1.6.0   Back to index