1 files changed, 576 insertions, 563 deletions

diff --git a/src/main/getopt.c b/src/main/getopt.c
index b64fdf5..890aa9b 100644
--- a/src/main/getopt.c
+++ b/src/main/getopt.c
@@ -4,7 +4,7 @@
    before changing it!
 
    Copyright Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97
-        Free Software Foundation, Inc.
+    Free Software Foundation, Inc.
 
 NOTE: The canonical source of this file is maintained with the GNU C Library.
 Bugs can be reported to bug-glibc@prep.ai.mit.edu.
@@ -32,7 +32,7 @@ USA.  */
 
 #include "config.h"
 
-#if !defined (__STDC__) || !__STDC__
+#if ! defined (__STDC__) || ! __STDC__
 /* This is a separate conditional since some stdc systems
    reject `defined (const)'.  */
 #ifndef const
@@ -51,7 +51,7 @@ USA.  */
    it is simpler to just do this in the source for each such file.  */
 
 #define GETOPT_INTERFACE_VERSION 2
-#if !defined (_LIBC) && defined (__GLIBC__) && __GLIBC__ >= 2
+#if ! defined (_LIBC) && defined (__GLIBC__) && __GLIBC__ >= 2
 #include <gnu-versions.h>
 #if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
 #define ELIDE_CODE
@@ -63,7 +63,7 @@ USA.  */
 
 /* This needs to come after some library #include
    to get __GNU_LIBRARY__ defined.  */
-#ifdef  __GNU_LIBRARY__
+#ifdef  __GNU_LIBRARY__
 /* Don't include stdlib.h for non-GNU C libraries because some of them
    contain conflicting prototypes for getopt.  */
 #include <stdlib.h>
@@ -77,10 +77,10 @@ USA.  */
 #include <string.h>
 #endif
 
-#if defined (WIN32) && !defined (__CYGWIN32__)
+#if defined (WIN32) && ! defined (__CYGWIN32__)
 /* It's not Unix, really.  See?  Capital letters.  */
 #include <windows.h>
-#define getpid() GetCurrentProcessId()
+#define getpid() GetCurrentProcessId ()
 #endif
 
 #ifndef _
@@ -88,9 +88,9 @@ USA.  */
    When compiling libc, the _ macro is predefined.  */
 #ifdef NEVER_HAVE_LIBINTL_H
 # include <libintl.h>
-# define _(msgid)       gettext (msgid)
+# define _(msgid) gettext (msgid)
 #else
-# define _(msgid)       (msgid)
+# define _(msgid) (msgid)
 #endif
 #endif
 
@@ -195,14 +195,14 @@ static enum
 
 /* Value of POSIXLY_CORRECT environment variable.  */
 static char *posixly_correct;
-
-#ifdef  __GNU_LIBRARY__
+
+#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_index  strchr
 #else
 
 /* Avoid depending on library functions or files
@@ -212,15 +212,16 @@ char *getenv ();
 
 static char *
 my_index (str, chr)
-     const char *str;
-     int chr;
+const char *str;
+
+int chr;
 {
   while (*str)
-    {
-      if (*str == chr)
-        return (char *) str;
-      str++;
-    }
+  {
+    if (*str == chr)
+      return (char *) str;
+    str++;
+  }
   return 0;
 }
 
@@ -229,18 +230,20 @@ my_index (str, chr)
 #ifdef __GNUC__
 /* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
    That was relevant to code that was here before.  */
-#if !defined (__STDC__) || !__STDC__
+#if ! defined (__STDC__) || ! __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__ */
 #if defined(__APPLE__)
 extern size_t strlen (const char *);
+
 #endif
 #endif /* __GNUC__ */
 
 #endif /* not __GNU_LIBRARY__ */
-
+
 /* Handle permutation of arguments.  */
 
 /* Describe the part of ARGV that contains non-options that have
@@ -269,7 +272,8 @@ extern pid_t __libc_pid;
    is valid for the getopt call we must make sure that the ARGV passed
    to getopt is that one passed to the process.  */
 static void
-  __attribute__ ((unused)) store_args_and_env (int argc, char *const *argv)
+__attribute__ ((unused))
+store_args_and_env (int argc, char *const *argv)
 {
   /* XXX This is no good solution.  We should rather copy the args so
      that we can compare them later.  But we must not use malloc(3).  */
@@ -277,15 +281,16 @@ static void
   original_argv = argv;
 }
 
+
 text_set_element (__libc_subinit, store_args_and_env);
 
 # define SWAP_FLAGS(ch1, ch2) \
-  if (nonoption_flags_len > 0)                                                \
-    {                                                                         \
-      char __tmp = __getopt_nonoption_flags[ch1];                             \
-      __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2];          \
-      __getopt_nonoption_flags[ch2] = __tmp;                                  \
-    }
+  if (nonoption_flags_len > 0)                  \
+  {                       \
+    char __tmp = __getopt_nonoption_flags[ch1];           \
+    __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2];        \
+    __getopt_nonoption_flags[ch2] = __tmp;              \
+  }
 #else /* !_LIBC */
 # define SWAP_FLAGS(ch1, ch2)
 #endif /* _LIBC */
@@ -301,11 +306,13 @@ text_set_element (__libc_subinit, store_args_and_env);
 
 #if defined (__STDC__) && __STDC__
 static void exchange (char **);
+
 #endif
 
 static void
 exchange (argv)
-     char **argv;
+char **argv;
+
 {
   int bottom = first_nonopt;
   int middle = last_nonopt;
@@ -321,61 +328,61 @@ exchange (argv)
   /* First make sure the handling of the `__getopt_nonoption_flags'
      string can work normally.  Our top argument must be in the range
      of the string.  */
-  if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len)
+  if ((nonoption_flags_len > 0) && (top >= nonoption_flags_max_len))
+  {
+    /* We must extend the array.  The user plays games with us and
+       presents new arguments.  */
+    char *new_str = malloc (top + 1);
+    if (new_str == NULL)
+      nonoption_flags_len = nonoption_flags_max_len = 0;
+    else
     {
-      /* We must extend the array.  The user plays games with us and
-         presents new arguments.  */
-      char *new_str = malloc (top + 1);
-      if (new_str == NULL)
-        nonoption_flags_len = nonoption_flags_max_len = 0;
-      else
-        {
-          memcpy (new_str, __getopt_nonoption_flags, nonoption_flags_max_len);
-          memset (&new_str[nonoption_flags_max_len], '\0',
-                  top + 1 - nonoption_flags_max_len);
-          nonoption_flags_max_len = top + 1;
-          __getopt_nonoption_flags = new_str;
-        }
+      memcpy (new_str, __getopt_nonoption_flags, nonoption_flags_max_len);
+      memset (&new_str[nonoption_flags_max_len], '\0',
+              top + 1 - nonoption_flags_max_len);
+      nonoption_flags_max_len = top + 1;
+      __getopt_nonoption_flags = new_str;
     }
+  }
 #endif
 
   while (top > middle && middle > bottom)
+  {
+    if (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;
-        }
+      /* 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.  */
 
@@ -387,12 +394,14 @@ exchange (argv)
 
 #if defined (__STDC__) && __STDC__
 static const char *_getopt_initialize (int, char *const *, const char *);
+
 #endif
 static const char *
 _getopt_initialize (argc, argv, optstring)
-     int argc;
-     char *const *argv;
-     const char *optstring;
+int argc;
+
+char *const *argv;
+const char *optstring;
 {
   /* Start processing options with ARGV-element 1 (since ARGV-element 0
      is the program name); the sequence of previously skipped
@@ -407,56 +416,56 @@ _getopt_initialize (argc, argv, optstring)
   /* Determine how to handle the ordering of options and nonoptions.  */
 
   if (optstring[0] == '-')
-    {
-      ordering = RETURN_IN_ORDER;
-      ++optstring;
-    }
+  {
+    ordering = RETURN_IN_ORDER;
+    ++optstring;
+  }
   else if (optstring[0] == '+')
-    {
-      ordering = REQUIRE_ORDER;
-      ++optstring;
-    }
+  {
+    ordering = REQUIRE_ORDER;
+    ++optstring;
+  }
   else if (posixly_correct != NULL)
     ordering = REQUIRE_ORDER;
   else
     ordering = PERMUTE;
 
 #ifdef _LIBC
-  if (posixly_correct == NULL
-      && argc == original_argc && argv == original_argv)
+  if ((posixly_correct == NULL)
+      && (argc == original_argc) && (argv == original_argv))
+  {
+    if (nonoption_flags_max_len == 0)
     {
-      if (nonoption_flags_max_len == 0)
-        {
-          if (__getopt_nonoption_flags == NULL
-              || __getopt_nonoption_flags[0] == '\0')
-            nonoption_flags_max_len = -1;
-          else
-            {
-              const char *orig_str = __getopt_nonoption_flags;
-              int len = nonoption_flags_max_len = strlen (orig_str);
-              if (nonoption_flags_max_len < argc)
-                nonoption_flags_max_len = argc;
-              __getopt_nonoption_flags =
-                (char *) malloc (nonoption_flags_max_len);
-              if (__getopt_nonoption_flags == NULL)
-                nonoption_flags_max_len = -1;
-              else
-                {
-                  memcpy (__getopt_nonoption_flags, orig_str, len);
-                  memset (&__getopt_nonoption_flags[len], '\0',
-                          nonoption_flags_max_len - len);
-                }
-            }
-        }
-      nonoption_flags_len = nonoption_flags_max_len;
+      if ((__getopt_nonoption_flags == NULL)
+          || (__getopt_nonoption_flags[0] == '\0') )
+        nonoption_flags_max_len = -1;
+      else
+      {
+        const char *orig_str = __getopt_nonoption_flags;
+        int len = nonoption_flags_max_len = strlen (orig_str);
+        if (nonoption_flags_max_len < argc)
+          nonoption_flags_max_len = argc;
+        __getopt_nonoption_flags =
+          (char *) malloc (nonoption_flags_max_len);
+        if (__getopt_nonoption_flags == NULL)
+          nonoption_flags_max_len = -1;
+        else
+        {
+          memcpy (__getopt_nonoption_flags, orig_str, len);
+          memset (&__getopt_nonoption_flags[len], '\0',
+                  nonoption_flags_max_len - len);
+        }
+      }
     }
+    nonoption_flags_len = nonoption_flags_max_len;
+  }
   else
     nonoption_flags_len = 0;
 #endif
 
   return optstring;
 }
-
+
 /* Scan elements of ARGV (whose length is ARGC) for option characters
    given in OPTSTRING.
 
@@ -515,112 +524,113 @@ _getopt_initialize (argc, argv, optstring)
 
 int
 _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
-     int argc;
-     char *const *argv;
-     const char *optstring;
-     const struct option *longopts;
-     int *longind;
-     int long_only;
+int argc;
+
+char *const *argv;
+const char *optstring;
+const struct option *longopts;
+int *longind;
+int long_only;
 {
   optarg = NULL;
 
-  if (optind == 0 || !__getopt_initialized)
-    {
-      if (optind == 0)
-        optind = 1;             /* Don't scan ARGV[0], the program name.  */
-      optstring = _getopt_initialize (argc, argv, optstring);
-      __getopt_initialized = 1;
-    }
+  if ((optind == 0) || ! __getopt_initialized)
+  {
+    if (optind == 0)
+      optind = 1; /* Don't scan ARGV[0], the program name.  */
+    optstring = _getopt_initialize (argc, argv, optstring);
+    __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.  */
 #ifdef _LIBC
-#define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0'        \
-                     || (optind < nonoption_flags_len                         \
-                         && __getopt_nonoption_flags[optind] == '1'))
+#define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0'        \
+                     || (optind < nonoption_flags_len           \
+                         && __getopt_nonoption_flags[optind] == '1'))
 #else
 #define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')
 #endif
 
-  if (nextchar == NULL || *nextchar == '\0')
+  if ((nextchar == NULL) || (*nextchar == '\0'))
+  {
+    /* Advance to the next ARGV-element.  */
+
+    /* 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 > optind)
+      last_nonopt = optind;
+    if (first_nonopt > optind)
+      first_nonopt = optind;
+
+    if (ordering == PERMUTE)
     {
-      /* Advance to the next ARGV-element.  */
-
-      /* 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 > optind)
-        last_nonopt = optind;
-      if (first_nonopt > optind)
-        first_nonopt = 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 != optind)
-            exchange ((char **) argv);
-          else if (last_nonopt != optind)
-            first_nonopt = optind;
-
-          /* Skip any additional non-options
-             and extend the range of non-options previously skipped.  */
-
-          while (optind < argc && NONOPTION_P)
-            optind++;
-          last_nonopt = 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 (optind != argc && !strcmp (argv[optind], "--"))
-        {
-          optind++;
-
-          if (first_nonopt != last_nonopt && last_nonopt != optind)
-            exchange ((char **) argv);
-          else if (first_nonopt == last_nonopt)
-            first_nonopt = optind;
-          last_nonopt = argc;
-
-          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 (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)
-            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;
-          optarg = argv[optind++];
-          return 1;
-        }
-
-      /* We have found another option-ARGV-element.
-         Skip the initial punctuation.  */
-
-      nextchar = (argv[optind] + 1
-                  + (longopts != NULL && argv[optind][1] == '-'));
+      /* 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 != optind) )
+        exchange ((char **) argv);
+      else if (last_nonopt != optind)
+        first_nonopt = optind;
+
+      /* Skip any additional non-options
+         and extend the range of non-options previously skipped.  */
+
+      while (optind < argc && NONOPTION_P)
+        optind++;
+      last_nonopt = 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 ((optind != argc) && ! strcmp (argv[optind], "--"))
+    {
+      optind++;
+
+      if ((first_nonopt != last_nonopt) && (last_nonopt != optind) )
+        exchange ((char **) argv);
+      else if (first_nonopt == last_nonopt)
+        first_nonopt = optind;
+      last_nonopt = argc;
+
+      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 (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)
+        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;
+      optarg = argv[optind++];
+      return 1;
+    }
+
+    /* We have found another option-ARGV-element.
+       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.
@@ -636,141 +646,141 @@ _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
 
      This distinction seems to be the most useful approach.  */
 
-  if (longopts != NULL
-      && (argv[optind][1] == '-'
-          || (long_only
-              && (argv[optind][2]
-                  || !my_index (optstring, argv[optind][1])))))
-    {
-      char *nameend;
-      const struct option *p;
-      const struct option *pfound = NULL;
-      int exact = 0;
-      int ambig = 0;
-      int indfound = -1;
-      int option_index;
+  if ((longopts != NULL)
+      && ((argv[optind][1] == '-')
+          || (long_only
+              && (argv[optind][2]
+                  || ! my_index (optstring, argv[optind][1])))))
+  {
+    char *nameend;
+    const struct option *p;
+    const struct option *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;
+      }
 
-      for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
-        /* Do nothing.  */ ;
+    if (ambig && ! exact)
+    {
+      if (opterr)
+        fprintf (stderr, _ ("%s: option `%s' is ambiguous\n"),
+                 argv[0], argv[optind]);
+      nextchar += strlen (nextchar);
+      optind++;
+      optopt = 0;
+      return '?';
+    }
 
-      /* 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 (opterr)
-            fprintf (stderr, _("%s: option `%s' is ambiguous\n"),
-                     argv[0], argv[optind]);
-          nextchar += strlen (nextchar);
-          optind++;
-          optopt = 0;
-          return '?';
-        }
+    if (pfound != NULL)
+    {
+      option_index = indfound;
+      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)
+          optarg = nameend + 1;
+        else
+        {
+          if (opterr)
+            if (argv[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[optind - 1][0], pfound->name);
+
+          nextchar += strlen (nextchar);
+
+          optopt = pfound->val;
+          return '?';
+        }
+      }
+      else if (pfound->has_arg == 1)
+      {
+        if (optind < argc)
+          optarg = argv[optind++];
+        else
+        {
+          if (opterr)
+            fprintf (stderr,
+                     _ ("%s: option `%s' requires an argument\n"),
+                     argv[0], argv[optind - 1]);
+          nextchar += strlen (nextchar);
+          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;
+    }
 
-      if (pfound != NULL)
-        {
-          option_index = indfound;
-          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)
-                optarg = nameend + 1;
-              else
-                {
-                  if (opterr)
-                    if (argv[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[optind - 1][0], pfound->name);
-
-                  nextchar += strlen (nextchar);
-
-                  optopt = pfound->val;
-                  return '?';
-                }
-            }
-          else if (pfound->has_arg == 1)
-            {
-              if (optind < argc)
-                optarg = argv[optind++];
-              else
-                {
-                  if (opterr)
-                    fprintf (stderr,
-                             _("%s: option `%s' requires an argument\n"),
-                             argv[0], argv[optind - 1]);
-                  nextchar += strlen (nextchar);
-                  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[optind][1] == '-'
-          || my_index (optstring, *nextchar) == NULL)
-        {
-          if (opterr)
-            {
-              if (argv[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[optind][0], nextchar);
-            }
-          nextchar = (char *) "";
-          optind++;
-          optopt = 0;
-          return '?';
-        }
+    /* 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[optind][1] == '-')
+        || (my_index (optstring, *nextchar) == NULL) )
+    {
+      if (opterr)
+      {
+        if (argv[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[optind][0], nextchar);
+      }
+      nextchar = (char *) "";
+      optind++;
+      optopt = 0;
+      return '?';
     }
+  }
 
   /* Look at and handle the next short option-character.  */
 
@@ -782,205 +792,207 @@ _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
     if (*nextchar == '\0')
       ++optind;
 
-    if (temp == NULL || c == ':')
+    if ((temp == NULL) || (c == ':'))
+    {
+      if (opterr)
       {
-        if (opterr)
-          {
-            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);
-          }
-        optopt = c;
-        return '?';
+        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);
       }
+      optopt = c;
+      return '?';
+    }
     /* Convenience. Treat POSIX -W foo same as long option --foo */
-    if (temp[0] == 'W' && temp[1] == ';')
+    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')
+      {
+        optarg = nextchar;
+        /* If we end this ARGV-element by taking the rest as an arg,
+           we must advance to the next element now.  */
+        optind++;
+      }
+      else if (optind == argc)
+      {
+        if (opterr)
+        {
+          /* 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 = '?';
+        return c;
+      }
+      else
+        /* We already incremented `optind' once;
+           increment it again when taking next ARGV-elt as argument.  */
+        optarg = argv[optind++];
+
+      /* optarg is now the argument, see if it's in the
+         table of longopts.  */
+
+      for (nextchar = nameend = 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, 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 (opterr)
+          fprintf (stderr, _ ("%s: option `-W %s' is ambiguous\n"),
+                   argv[0], argv[optind]);
+        nextchar += strlen (nextchar);
+        optind++;
+        return '?';
+      }
+      if (pfound != NULL)
       {
-        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')
-          {
-            optarg = nextchar;
-            /* If we end this ARGV-element by taking the rest as an arg,
-               we must advance to the next element now.  */
-            optind++;
-          }
-        else if (optind == argc)
-          {
-            if (opterr)
-              {
-                /* 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 = '?';
-            return c;
-          }
-        else
-          /* We already incremented `optind' once;
-             increment it again when taking next ARGV-elt as argument.  */
-          optarg = argv[optind++];
-
-        /* optarg is now the argument, see if it's in the
-           table of longopts.  */
-
-        for (nextchar = nameend = 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, 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 (opterr)
-              fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),
-                       argv[0], argv[optind]);
-            nextchar += strlen (nextchar);
-            optind++;
-            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)
-                  optarg = nameend + 1;
-                else
-                  {
-                    if (opterr)
-                      fprintf (stderr, _("\
+        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)
+            optarg = nameend + 1;
+          else
+          {
+            if (opterr)
+              fprintf (stderr, _ (
+                         "\
 %s: option `-W %s' doesn't allow an argument\n"), argv[0], pfound->name);
 
-                    nextchar += strlen (nextchar);
-                    return '?';
-                  }
-              }
-            else if (pfound->has_arg == 1)
-              {
-                if (optind < argc)
-                  optarg = argv[optind++];
-                else
-                  {
-                    if (opterr)
-                      fprintf (stderr,
-                               _("%s: option `%s' requires an argument\n"),
-                               argv[0], argv[optind - 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.   */
+            nextchar += strlen (nextchar);
+            return '?';
+          }
+        }
+        else if (pfound->has_arg == 1)
+        {
+          if (optind < argc)
+            optarg = argv[optind++];
+          else
+          {
+            if (opterr)
+              fprintf (stderr,
+                       _ ("%s: option `%s' requires an argument\n"),
+                       argv[0], argv[optind - 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')
+        {
+          optarg = nextchar;
+          optind++;
+        }
+        else
+          optarg = NULL;
+        nextchar = NULL;
+      }
+      else
       {
-        if (temp[2] == ':')
-          {
-            /* This is an option that accepts an argument optionally.  */
-            if (*nextchar != '\0')
-              {
-                optarg = nextchar;
-                optind++;
-              }
-            else
-              optarg = NULL;
-            nextchar = NULL;
-          }
-        else
-          {
-            /* This is an option that requires an argument.  */
-            if (*nextchar != '\0')
-              {
-                optarg = nextchar;
-                /* If we end this ARGV-element by taking the rest as an arg,
-                   we must advance to the next element now.  */
-                optind++;
-              }
-            else if (optind == argc)
-              {
-                if (opterr)
-                  {
-                    /* 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;
-                 increment it again when taking next ARGV-elt as argument.  */
-              optarg = argv[optind++];
-            nextchar = NULL;
-          }
+        /* This is an option that requires an argument.  */
+        if (*nextchar != '\0')
+        {
+          optarg = nextchar;
+          /* If we end this ARGV-element by taking the rest as an arg,
+             we must advance to the next element now.  */
+          optind++;
+        }
+        else if (optind == argc)
+        {
+          if (opterr)
+          {
+            /* 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;
+             increment it again when taking next ARGV-elt as argument.  */
+          optarg = argv[optind++];
+        nextchar = NULL;
       }
+    }
     return c;
   }
 }
 
 int
 getopt (argc, argv, optstring)
-     int argc;
-     char *const *argv;
-     const char *optstring;
+int argc;
+
+char *const *argv;
+const char *optstring;
 {
   return _getopt_internal (argc, argv, optstring,
-                           (const struct option *) 0, (int *) 0, 0);
+                           (const struct option *) 0, (int *) 0, 0);
 }
 
 #endif /* Not ELIDE_CODE.  */
-
+
 #ifdef TEST
 
 /* Compile with -DTEST to make an executable for use in testing
@@ -988,65 +1000,66 @@ getopt (argc, argv, optstring)
 
 int
 main (argc, argv)
-     int argc;
-     char **argv;
+int argc;
+
+char **argv;
 {
   int c;
   int digit_optind = 0;
 
   while (1)
+  {
+    int this_option_optind = optind ? optind : 1;
+
+    c = getopt (argc, argv, "abc:d:0123456789");
+    if (c == -1)
+      break;
+
+    switch (c)
     {
-      int this_option_optind = optind ? optind : 1;
-
-      c = getopt (argc, argv, "abc:d:0123456789");
-      if (c == -1)
-        break;
-
-      switch (c)
-        {
-        case '0':
-        case '1':
-        case '2':
-        case '3':
-        case '4':
-        case '5':
-        case '6':
-        case '7':
-        case '8':
-        case '9':
-          if (digit_optind != 0 && digit_optind != this_option_optind)
-            printf ("digits occur in two different argv-elements.\n");
-          digit_optind = this_option_optind;
-          printf ("option %c\n", c);
-          break;
-
-        case 'a':
-          printf ("option a\n");
-          break;
-
-        case 'b':
-          printf ("option b\n");
-          break;
-
-        case 'c':
-          printf ("option c with value `%s'\n", optarg);
-          break;
-
-        case '?':
-          break;
-
-        default:
-          printf ("?? getopt returned character code 0%o ??\n", c);
-        }
+    case '0':
+    case '1':
+    case '2':
+    case '3':
+    case '4':
+    case '5':
+    case '6':
+    case '7':
+    case '8':
+    case '9':
+      if ((digit_optind != 0) && (digit_optind != this_option_optind) )
+        printf ("digits occur in two different argv-elements.\n");
+      digit_optind = this_option_optind;
+      printf ("option %c\n", c);
+      break;
+
+    case 'a':
+      printf ("option a\n");
+      break;
+
+    case 'b':
+      printf ("option b\n");
+      break;
+
+    case 'c':
+      printf ("option c with value `%s'\n", optarg);
+      break;
+
+    case '?':
+      break;
+
+    default:
+      printf ("?? getopt returned character code 0%o ??\n", c);
     }
+  }
 
   if (optind < argc)
-    {
-      printf ("non-option ARGV-elements: ");
-      while (optind < argc)
-        printf ("%s ", argv[optind++]);
-      printf ("\n");
-    }
+  {
+    printf ("non-option ARGV-elements: ");
+    while (optind < argc)
+      printf ("%s ", argv[optind++]);
+    printf ("\n");
+  }
 
   exit (0);
 }