entered into RCS
authorroland <roland>
Tue, 12 Jul 1994 09:28:11 +0000 (09:28 +0000)
committerroland <roland>
Tue, 12 Jul 1994 09:28:11 +0000 (09:28 +0000)
posix/getopt.c

index c957763..7e7fdc7 100644 (file)
@@ -3,64 +3,73 @@
    "Keep this file name-space clean" means, talk to roland@gnu.ai.mit.edu
    before changing it!
 
-   Copyright (C) 1987, 88, 89, 90, 91, 1992 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
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   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, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+   Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94
+       Free Software Foundation, Inc.
+
+This file is part of the GNU C Library.  Its master source is NOT part of
+the C library, however.  The master source lives in /gd/gnu/lib.
+
+The GNU C Library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public License as
+published by the Free Software Foundation; either version 2 of the
+License, or (at your option) any later version.
+
+The GNU C Library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with the GNU C Library; see the file COPYING.LIB.  If
+not, write to the Free Software Foundation, Inc., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
 \f
-/* AIX requires this to be the first thing in the file. */
-#ifdef __GNUC__
-#define alloca __builtin_alloca
-#else /* not __GNUC__ */
-#if defined(sparc) && !defined(USG) && !defined(SVR4) && !defined(__svr4__)
-#include <alloca.h>
-#else
-#ifdef _AIX
- #pragma alloca
+/* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.
+   Ditto for AIX 3.2 and <stdlib.h>.  */
+#ifndef _NO_PROTO
+#define _NO_PROTO
+#endif
+
+#ifdef HAVE_CONFIG_H
+#if defined (emacs) || defined (CONFIG_BROKETS)
+/* We use <config.h> instead of "config.h" so that a compilation
+   using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h
+   (which it would do because it found this file in $srcdir).  */
+#include <config.h>
 #else
-char *alloca ();
+#include "config.h"
+#endif
 #endif
-#endif /* sparc */
-#endif /* not __GNUC__ */
 
-#ifdef LIBC
-/* For when compiled as part of the GNU C library.  */
-#include <ansidecl.h>
+#ifndef __STDC__
+/* This is a separate conditional since some stdc systems
+   reject `defined (const)'.  */
+#ifndef const
+#define const
+#endif
 #endif
 
 #include <stdio.h>
 
+/* Comment out all this code if we are using the GNU C Library, and are not
+   actually compiling the library itself.  This code is part of the GNU C
+   Library, but also included in many other GNU distributions.  Compiling
+   and linking in this code is a waste when using the GNU C library
+   (especially if it is a shared library).  Rather than having every GNU
+   program understand `configure --with-gnu-libc' and omit the object files,
+   it is simpler to just do this in the source for each such file.  */
+
+#if defined (_LIBC) || !defined (__GNU_LIBRARY__)
+
+
 /* This needs to come after some library #include
    to get __GNU_LIBRARY__ defined.  */
 #ifdef __GNU_LIBRARY__
-#undef alloca
+/* Don't include stdlib.h for non-GNU C libraries because some of them
+   contain conflicting prototypes for getopt.  */
 #include <stdlib.h>
-#include <string.h>
-#else  /* Not GNU C library.  */
-#define        __alloca        alloca
 #endif /* GNU C library.  */
 
-
-#ifndef __STDC__
-#define const
-#endif
-
-/* If GETOPT_COMPAT is defined, `+' as well as `--' can introduce a
-   long-named option.  Because this is not POSIX.2 compliant, it is
-   being phased out. */
-#define GETOPT_COMPAT
-
 /* This version of `getopt' appears to the caller like standard Unix `getopt'
    but it behaves differently for the user, since it allows the user
    to intersperse the options with the other arguments.
@@ -83,7 +92,7 @@ char *alloca ();
    Also, when `ordering' is RETURN_IN_ORDER,
    each non-option ARGV-element is returned here.  */
 
-char *optarg = 0;
+char *optarg = NULL;
 
 /* Index in ARGV of the next element to be scanned.
    This is used for communication to and from the caller
@@ -97,6 +106,7 @@ char *optarg = 0;
    Otherwise, `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 optind = 0;
 
 /* The next char to be scanned in the option-element
@@ -113,6 +123,12 @@ static char *nextchar;
 
 int 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 optopt = '?';
+
 /* Describe how to deal with options that follow non-option ARGV-elements.
 
    If the caller did not specify anything,
@@ -146,11 +162,17 @@ static enum
 {
   REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
 } ordering;
+
+/* Value of POSIXLY_CORRECT environment variable.  */
+static char *posixly_correct;
 \f
 #ifdef __GNU_LIBRARY__
+/* We want to avoid inclusion of string.h with non-GNU libraries
+   because there are many ways it can cause trouble.
+   On some systems, it contains special magic macros that don't work
+   in GCC.  */
 #include <string.h>
 #define        my_index        strchr
-#define        my_bcopy(src, dst, n)   memcpy ((dst), (src), (n))
 #else
 
 /* Avoid depending on library functions or files
@@ -159,29 +181,32 @@ static enum
 char *getenv ();
 
 static char *
-my_index (string, chr)
-     char *string;
+my_index (str, chr)
+     const char *str;
      int chr;
 {
-  while (*string)
+  while (*str)
     {
-      if (*string == chr)
-       return string;
-      string++;
+      if (*str == chr)
+       return (char *) str;
+      str++;
     }
   return 0;
 }
 
-static void
-my_bcopy (from, to, size)
-     char *from, *to;
-     int size;
-{
-  int i;
-  for (i = 0; i < size; i++)
-    to[i] = from[i];
-}
-#endif                         /* GNU C library.  */
+/* If using GCC, we can safely declare strlen this way.
+   If not using GCC, it is ok not to declare it.  */
+#ifdef __GNUC__
+/* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
+   That was relevant to code that was here before.  */
+#ifndef __STDC__
+/* gcc with -traditional declares the built-in strlen to return int,
+   and has done so at least since version 2.4.5. -- rms.  */
+extern int strlen (const char *);
+#endif /* not __STDC__ */
+#endif /* __GNUC__ */
+
+#endif /* not __GNU_LIBRARY__ */
 \f
 /* Handle permutation of arguments.  */
 
@@ -205,21 +230,93 @@ static void
 exchange (argv)
      char **argv;
 {
-  int nonopts_size = (last_nonopt - first_nonopt) * sizeof (char *);
-  char **temp = (char **) __alloca (nonopts_size);
+  int bottom = first_nonopt;
+  int middle = last_nonopt;
+  int top = optind;
+  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.  */
 
-  /* Interchange the two blocks of data in ARGV.  */
+  while (top > middle && middle > bottom)
+    {
+      if (top - middle > middle - bottom)
+       {
+         /* Bottom segment is the short one.  */
+         int len = middle - bottom;
+         register int i;
 
-  my_bcopy (&argv[first_nonopt], temp, nonopts_size);
-  my_bcopy (&argv[last_nonopt], &argv[first_nonopt],
-           (optind - last_nonopt) * sizeof (char *));
-  my_bcopy (temp, &argv[first_nonopt + optind - last_nonopt], nonopts_size);
+         /* 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;
+           }
+         /* 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;
+           }
+         /* Exclude the moved top segment from further swapping.  */
+         bottom += len;
+       }
+    }
 
   /* Update records for the slots the non-options now occupy.  */
 
   first_nonopt += (optind - last_nonopt);
   last_nonopt = optind;
 }
+
+/* Initialize the internal data when the first call is made.  */
+
+static const char *
+_getopt_initialize (optstring)
+     const char *optstring;
+{
+  /* 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 = optind = 1;
+
+  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;
+}
 \f
 /* Scan elements of ARGV (whose length is ARGC) for option characters
    given in OPTSTRING.
@@ -286,41 +383,15 @@ _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
      int *longind;
      int long_only;
 {
-  int option_index;
-
-  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.  */
+  optarg = NULL;
 
   if (optind == 0)
-    {
-      first_nonopt = last_nonopt = 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;
-    }
+    optstring = _getopt_initialize (optstring);
 
   if (nextchar == NULL || *nextchar == '\0')
     {
+      /* Advance to the next ARGV-element.  */
+
       if (ordering == PERMUTE)
        {
          /* If we have just processed some options following some non-options,
@@ -331,21 +402,16 @@ _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
          else if (last_nonopt != optind)
            first_nonopt = optind;
 
-         /* Now skip any additional non-options
+         /* Skip any additional non-options
             and extend the range of non-options previously skipped.  */
 
          while (optind < argc
-                && (argv[optind][0] != '-' || argv[optind][1] == '\0')
-#ifdef GETOPT_COMPAT
-                && (longopts == NULL
-                    || argv[optind][0] != '+' || argv[optind][1] == '\0')
-#endif                         /* GETOPT_COMPAT */
-                )
+                && (argv[optind][0] != '-' || argv[optind][1] == '\0'))
            optind++;
          last_nonopt = optind;
        }
 
-      /* Special ARGV-element `--' means premature end of options.
+      /* 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.  */
@@ -378,12 +444,7 @@ _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
       /* 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[optind][0] != '-' || argv[optind][1] == '\0')
-#ifdef GETOPT_COMPAT
-         && (longopts == NULL
-             || argv[optind][0] != '+' || argv[optind][1] == '\0')
-#endif                         /* GETOPT_COMPAT */
-         )
+      if ((argv[optind][0] != '-' || argv[optind][1] == '\0'))
        {
          if (ordering == REQUIRE_ORDER)
            return EOF;
@@ -392,36 +453,48 @@ _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
        }
 
       /* We have found another option-ARGV-element.
-        Start decoding its characters.  */
+        Skip the initial punctuation.  */
 
       nextchar = (argv[optind] + 1
                  + (longopts != NULL && argv[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[optind][0] == '-'
-          && (argv[optind][1] == '-' || long_only))
-#ifdef GETOPT_COMPAT
-         || argv[optind][0] == '+'
-#endif                         /* GETOPT_COMPAT */
-         ))
+      && (argv[optind][1] == '-'
+         || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
     {
+      char *nameend;
       const struct option *p;
-      char *s = nextchar;
+      const struct option *pfound = NULL;
       int exact = 0;
       int ambig = 0;
-      const struct option *pfound = NULL;
       int indfound;
+      int option_index;
 
-      while (*s && *s != '=')
-       s++;
+      for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
+       /* Do nothing.  */ ;
 
-      /* 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))
+      /* 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 (s - nextchar == strlen (p->name))
+           if (nameend - nextchar == strlen (p->name))
              {
                /* Exact match found.  */
                pfound = p;
@@ -436,7 +509,7 @@ _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
                indfound = option_index;
              }
            else
-             /* Second nonexact match found.  */
+             /* Second or later nonexact match found.  */
              ambig = 1;
          }
 
@@ -454,12 +527,12 @@ _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
        {
          option_index = indfound;
          optind++;
-         if (*s)
+         if (*nameend)
            {
              /* Don't test has_arg with >, because some C compilers don't
-                allow it to be used on enums. */
+                allow it to be used on enums.  */
              if (pfound->has_arg)
-               optarg = s + 1;
+               optarg = nameend + 1;
              else
                {
                  if (opterr)
@@ -489,7 +562,7 @@ _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
                    fprintf (stderr, "%s: option `%s' requires an argument\n",
                             argv[0], argv[optind - 1]);
                  nextchar += strlen (nextchar);
-                 return '?';
+                 return optstring[0] == ':' ? ':' : '?';
                }
            }
          nextchar += strlen (nextchar);
@@ -502,14 +575,12 @@ _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
            }
          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. */
+        Otherwise interpret it as a short option.  */
       if (!long_only || argv[optind][1] == '-'
-#ifdef GETOPT_COMPAT
-         || argv[optind][0] == '+'
-#endif                         /* GETOPT_COMPAT */
          || my_index (optstring, *nextchar) == NULL)
        {
          if (opterr)
@@ -523,13 +594,13 @@ _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
                fprintf (stderr, "%s: unrecognized option `%c%s'\n",
                         argv[0], argv[optind][0], nextchar);
            }
-         nextchar = "";
+         nextchar = (char *) "";
          optind++;
          return '?';
        }
     }
 
-  /* Look at and handle the next option-character.  */
+  /* Look at and handle the next short option-character.  */
 
   {
     char c = *nextchar++;
@@ -543,12 +614,13 @@ _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
       {
        if (opterr)
          {
-           if (c < 040 || c >= 0177)
-             fprintf (stderr, "%s: unrecognized option, character code 0%o\n",
-                      argv[0], c);
+           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: unrecognized option `-%c'\n", argv[0], c);
+             fprintf (stderr, "%s: invalid option -- %c\n", argv[0], c);
          }
+       optopt = c;
        return '?';
       }
     if (temp[1] == ':')
@@ -562,7 +634,7 @@ _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
                optind++;
              }
            else
-             optarg = 0;
+             optarg = NULL;
            nextchar = NULL;
          }
        else
@@ -578,9 +650,16 @@ _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
            else if (optind == argc)
              {
                if (opterr)
-                 fprintf (stderr, "%s: option `-%c' requires an argument\n",
-                          argv[0], c);
-               c = '?';
+                 {
+                   /* 1003.2 specifies the format of this message.  */
+                   fprintf (stderr, "%s: option requires an argument -- %c\n",
+                            argv[0], c);
+                 }
+               optopt = c;
+               if (optstring[0] == ':')
+                 c = ':';
+               else
+                 c = '?';
              }
            else
              /* We already incremented `optind' once;
@@ -604,6 +683,8 @@ getopt (argc, argv, optstring)
                           (int *) 0,
                           0);
 }
+
+#endif /* _LIBC or not __GNU_LIBRARY__.  */
 \f
 #ifdef TEST