Changeset 3213 in kBuild

Timestamp:

Mar 30, 2018 9:03:28 PM (7 years ago)

Author:

bird

Message:

kmk: Forked getopt and created a reentrant variant getopt_r.

Location:

trunk/src/kmk/kmkbuiltin

Files:

• getopt1_r.c (copied) (copied from trunk/src/kmk/getopt1.c ) (11 diffs)
• getopt_r.c (copied) (copied from trunk/src/kmk/getopt.c ) (46 diffs)
• getopt_r.h (copied) (copied from trunk/src/kmk/getopt.h ) (6 diffs)
• mscfakes.h (modified) (1 diff)
• solfakes.h (modified) (2 diffs)

trunk/src/kmk/kmkbuiltin/getopt1_r.c

@@ -1 @@
-/* getopt_long and getopt_long_only entry points for GNU getopt.
+/*  Reentrant version of getopt_long and getopt_long_only.
+
+Based on ../getopt*.*:
+
+   getopt_long and getopt_long_only entry points for GNU getopt.
 Copyright (C) 1987-1994, 1996-2016 Free Software Foundation, Inc.
 
@@ -15 +19 @@
 
 You should have received a copy of the GNU General Public License along with
-this program.  If not, see <http://www.gnu.org/licenses/>.  */
+this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Modifications:
+  Copyright (c) 2018 knut st. osmundsen <[email protected]>
+*/
 
 
+#define FAKES_NO_GETOPT_H /* bird */
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 
-#include "getopt.h"
+#include "getopt_r.h"
 
 #if !defined __STDC__ || !__STDC__
@@ -34 +43 @@
 #include <stdio.h>
 
+#if 0
 /* 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
@@ -49 +59 @@
 #endif
 #endif
+#endif
 
-#ifndef ELIDE_CODE
+#if 1 //ndef ELIDE_CODE
 
 
@@ -64 +75 @@
 
 int
-getopt_long (int argc, char *const *argv, const char *options,
-             const struct option *long_options, int *opt_index)
+getopt_long_r (struct getopt_state_r *gos, int *opt_index)
 {
-  return _getopt_internal (argc, argv, options, long_options, opt_index, 0);
+  return _getopt_internal_r (gos, gos->long_options, opt_index, 0);
 }
 
@@ -76 +86 @@
 
 int
-getopt_long_only (int argc, char *const *argv, const char *options,
-                  const struct option *long_options, int *opt_index)
+getopt_long_only_r (struct getopt_state_r *gos, int *opt_index)
 {
-  return _getopt_internal (argc, argv, options, long_options, opt_index, 1);
+  return _getopt_internal_r (gos, gos->long_options, opt_index, 0);
 }
 
 
-#endif  /* Not ELIDE_CODE.  */
+#endif /* #if 1 */ /* Not ELIDE_CODE.  */
 
 
@@ -100 +109 @@
       int this_option_optind = optind ? optind : 1;
       int option_index = 0;
+      struct getopt_state_r gos;
       static struct option long_options[] =
       {
@@ -111 +121 @@
       };
 
-      c = getopt_long (argc, argv, "abc:d:0123456789",
-                       long_options, &option_index);
+      getopt_initialize_r (&gos, argc, argv, "abc:d:0123456789", long_options, NULL, NULL);
+      c = getopt_long_r (&geo, &option_index);
       if (c == -1)
         break;
@@ -120 +130 @@
         case 0:
           printf ("option %s", long_options[option_index].name);
-          if (optarg)
-            printf (" with arg %s", optarg);
+          if (geo.optarg)
+            printf (" with arg %s", geo.optarg);
           printf ("\n");
           break;
@@ -150 +160 @@
 
         case 'c':
-          printf ("option c with value '%s'\n", optarg);
+          printf ("option c with value '%s'\n", geo.optarg);
           break;
 
         case 'd':
-          printf ("option d with value '%s'\n", optarg);
+          printf ("option d with value '%s'\n", geo.optarg);
           break;
 
@@ -165 +175 @@
     }
 
-  if (optind < argc)
+  if (geo.optind < argc)
     {
       printf ("non-option ARGV-elements: ");
       while (optind < argc)
-        printf ("%s ", argv[optind++]);
+        printf ("%s ", argv[geo.optind++]);
       printf ("\n");
     }

trunk/src/kmk/kmkbuiltin/getopt_r.c

@@ -1 @@
-/* Getopt for GNU.
+/* Reentrant version of getopt.
+
+Based on ../getopt*.*:
+
+   Getopt for GNU.
 NOTE: getopt is now part of the C library, so if you don't know what
 "Keep this file name-space clean" means, talk to [email protected]
@@ -19 +23 @@
 
 You should have received a copy of the GNU General Public License along with
-this program.  If not, see <http://www.gnu.org/licenses/>.  */
+this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Modifications:
+  Copyright (c) 2018 knut st. osmundsen <[email protected]>
+*/
 
 /* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.
@@ -27 +35 @@
 #endif
 
+#define FAKES_NO_GETOPT_H /* bird */
 #ifdef HAVE_CONFIG_H
 # include <config.h>
@@ -41 +50 @@
 #include <stdio.h>
 
+#if 0
 /* 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
@@ -56 +66 @@
 # endif
 #endif
-
-#ifndef ELIDE_CODE
+#endif
+
+#if 1 //ndef ELIDE_CODE
 
 
@@ -96 +107 @@
    they can distinguish the relative order of options and other arguments.  */
 
-#include "getopt.h"
-
+#include "getopt_r.h"
+#include "err.h"
+#include <assert.h>
+
+#if 0 /* Moved to state_getopt_r in getopt_r.h. */
 /* For communication from `getopt' to the caller.
    When `getopt' finds an option that takes an argument,
@@ -146 +160 @@
 
 int optopt = '?';
+#endif /* Moved to state_getopt_r in getopt_r.h. */
 
 /* Describe how to deal with options that follow non-option ARGV-elements.
@@ -176 +191 @@
    `--' can cause `getopt' to return -1 with `optind' != ARGC.  */
 
-static enum
+/*static*/ enum
 {
   REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
-} ordering;
-
+} /*ordering*/;
+
+#if 0 /* Moved to state_getopt_r in getopt_r.h. */
 /* Value of POSIXLY_CORRECT environment variable.  */
 static char *posixly_correct;
-
-
-#ifdef  __GNU_LIBRARY__
+#endif
+
+
+
+#if 1 //def     __GNU_LIBRARY__
 /* We want to avoid inclusion of string.h with non-GNU libraries
    because there are many ways it can cause trouble.
@@ -191 +209 @@
    in GCC.  */
 # include <string.h>
-# define my_index       strchr
+//# define my_index     strchr
 #else
 
@@ -200 +218 @@
 # endif
 
-#ifndef KMK
+#if 0 //def
 /* Avoid depending on library functions or files
    whose names are inconsistent.  */
@@ -206 +224 @@
 extern char *getenv ();
 #endif
-#endif /* !KMK */
+#endif
 
 static char *
@@ -237 +255 @@
 /* Handle permutation of arguments.  */
 
+#if 0 /* Moved to state_getopt_r in getopt_r.h. */
 /* Describe the part of ARGV that contains non-options that have
    been skipped.  `first_nonopt' is the index in ARGV of the first of them;
@@ -243 +262 @@
 static int first_nonopt;
 static int last_nonopt;
-
-#ifdef _LIBC
+#endif
+
+#if 0 //def _LIBC
 /* Bash 2.0 gives us an environment variable containing flags
    indicating ARGV elements that should not be considered arguments.  */
@@ -280 +300 @@
     }
 #else   /* !_LIBC */
-# define SWAP_FLAGS(ch1, ch2)
+# define SWAP_FLAGS(ch1, ch2) do { } while (0)
 #endif  /* _LIBC */
 
@@ -292 +312 @@
    the new indices of the non-options in ARGV after they are moved.  */
 
-#if defined __STDC__ && __STDC__
-static void exchange (char **);
-#endif
-
 static void
-exchange (char **argv)
+exchange (struct getopt_state_r *gos, char **argv)
 {
-  int bottom = first_nonopt;
-  int middle = last_nonopt;
-  int top = optind;
+  int bottom = gos->first_nonopt;
+  int middle = gos->last_nonopt;
+  int top = gos->optind;
   char *tem;
 
@@ -309 +325 @@
      but it consists of two parts that need to be swapped next.  */
 
-#ifdef _LIBC
+#if 0 //def _LIBC
   /* First make sure the handling of the `__getopt_nonoption_flags'
      string can work normally.  Our top argument must be in the range
@@ -371 +387 @@
   /* Update records for the slots the non-options now occupy.  */
 
-  first_nonopt += (optind - last_nonopt);
-  last_nonopt = optind;
+  gos->first_nonopt += (gos->optind - gos->last_nonopt);
+  gos->last_nonopt = gos->optind;
 }
 
-/* Initialize the internal data when the first call is made.  */
-
-#if defined __STDC__ && __STDC__
-static const char *_getopt_initialize (int, char *const *, const char *);
-#endif
-static const char *
-_getopt_initialize (int argc, char *const *argv, const char *optstring)
+/* Initialize the internal data   */
+
+void
+getopt_initialize_r (struct getopt_state_r *gos, int argc,
+                     char * const *argv, const char *shortopts,
+                     const struct option *long_options,
+                     char **envp, struct KMKBUILTINCTX *pCtx)
 {
+  assert (shortopts != NULL);
+
+  /* General initialization. */
+  gos->optarg = NULL;
+  gos->optind = 1;
+  gos->__getopt_initialized = (void *)(uintptr_t)&exchange;
+  gos->opterr = 1;
+  gos->optopt = '?';
+  gos->argc = argc;
+  gos->argv = argv;
+  gos->optstring = shortopts;
+  gos->len_optstring = strlen (shortopts);
+  gos->long_options = long_options;
+  gos->pCtx = pCtx;
+
   /* 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;
-
-  nextchar = NULL;
-
-  posixly_correct = getenv ("POSIXLY_CORRECT");
+  gos->first_nonopt = gos->last_nonopt = gos->optind;
+
+  gos->nextchar = NULL;
+
+  if (!envp)
+    gos->posixly_correct = getenv("POSIXLY_CORRECT");
+  else
+    {
+      const char *psz;
+      size_t i = 0;
+      gos->posixly_correct = NULL;
+      while ((psz = envp[i]) != NULL)
+        {
+          if (   psz[0] == 'P'
+              && strncmp (psz, "POSIXLY_CORRECT=", sizeof("POSIXLY_CORRECT=") - 1) == 0)
+            {
+              gos->posixly_correct = psz + sizeof("POSIXLY_CORRECT=") - 1;
+              break;
+            }
+          i++;
+        }
+    }
 
   /* 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;
+  if (shortopts[0] == '-')
+    {
+      gos->ordering = RETURN_IN_ORDER;
+      gos->optstring++;
+      gos->len_optstring--;
+    }
+  else if (shortopts[0] == '+')
+    {
+      gos->ordering = REQUIRE_ORDER;
+      gos->optstring++;
+      gos->len_optstring--;
+    }
+  else if (gos->posixly_correct != NULL)
+    gos->ordering = REQUIRE_ORDER;
   else
-    ordering = PERMUTE;
-
-#ifdef _LIBC
+    gos->ordering = PERMUTE;
+
+#if 0 //def _LIBC
   if (posixly_correct == NULL
       && argc == original_argc && argv == original_argv)
@@ -440 +490 @@
 #endif
 
-  return optstring;
+  //return optstring;
 }
 
@@ -501 +551 @@
 
 int
-_getopt_internal (int argc, char *const *argv, const char *optstring,
-                  const struct option *longopts, int *longind, int long_only)
+_getopt_internal_r (struct getopt_state_r *gos, 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;
-    }
+  assert (gos->__getopt_initialized == (void *)(uintptr_t)&exchange);
+  gos->optarg = NULL;
+
+#if 0 /* requires explicit call now */
+  if (gos->optind == 0 || !gos->__getopt_initialized)
+    {
+      if (gos->optind == 0)
+        gos->optind = 1;        /* Don't scan ARGV[0], the program name.  */
+      optstring = _getopt_initialize_r (gos, gos->argc, gos->argv, optstring);
+      gos->__getopt_initialized = 1;
+    }
+#else
+  assert (gos->__getopt_initialized == (void *)(uintptr_t)&exchange);
+#endif
 
   /* Test whether ARGV[optind] points to a non-option argument.
@@ -518 +573 @@
      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'))
+#if 0 //def _LIBC
+# define NONOPTION_P (gos->argv[gos->optind][0] != '-' || gos->argv[gos->optind][1] == '\0'           \
+                      || (gos->optind < gos->nonoption_flags_len                              \
+                          && gos->__getopt_nonoption_flags[gos->optind] == '1'))
 #else
-# define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')
-#endif
-
-  if (nextchar == NULL || *nextchar == '\0')
+# define NONOPTION_P (gos->argv[gos->optind][0] != '-' || gos->argv[gos->optind][1] == '\0')
+#endif
+
+  if (gos->nextchar == NULL || *gos->nextchar == '\0')
     {
       /* Advance to the next ARGV-element.  */
@@ -532 +587 @@
       /* 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 (gos->last_nonopt > gos->optind)
+        gos->last_nonopt = gos->optind;
+      if (gos->first_nonopt > gos->optind)
+        gos->first_nonopt = gos->optind;
+
+      if (gos->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;
+          if (gos->first_nonopt != gos->last_nonopt && gos->last_nonopt != gos->optind)
+            exchange (gos, (char **) gos->argv);
+          else if (gos->last_nonopt != gos->optind)
+            gos->first_nonopt = gos->optind;
 
           /* Skip any additional non-options
              and extend the range of non-options previously skipped.  */
 
-          while (optind < argc && NONOPTION_P)
-            optind++;
-          last_nonopt = optind;
+          while (gos->optind < gos->argc && NONOPTION_P)
+            gos->optind++;
+          gos->last_nonopt = gos->optind;
         }
 
@@ -560 +615 @@
          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 (gos->optind != gos->argc && !strcmp (gos->argv[gos->optind], "--"))
+        {
+          gos->optind++;
+
+          if (gos->first_nonopt != gos->last_nonopt && gos->last_nonopt != gos->optind)
+            exchange (gos, (char **) gos->argv);
+          else if (gos->first_nonopt == gos->last_nonopt)
+            gos->first_nonopt = gos->optind;
+          gos->last_nonopt = gos->argc;
+
+          gos->optind = gos->argc;
         }
 
@@ -576 +631 @@
          and back over any non-options that we skipped and permuted.  */
 
-      if (optind == argc)
+      if (gos->optind == gos->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;
+          if (gos->first_nonopt != gos->last_nonopt)
+            gos->optind = gos->first_nonopt;
           return -1;
         }
@@ -590 +645 @@
       if (NONOPTION_P)
         {
-          if (ordering == REQUIRE_ORDER)
+          if (gos->ordering == REQUIRE_ORDER)
             return -1;
-          optarg = argv[optind++];
+          gos->optarg = gos->argv[gos->optind++];
           return 1;
         }
@@ -599 +654 @@
          Skip the initial punctuation.  */
 
-      nextchar = (argv[optind] + 1
-                  + (longopts != NULL && argv[optind][1] == '-'));
+      gos->nextchar = (gos->argv[gos->optind] + 1
+                    + (longopts != NULL && gos->argv[gos->optind][1] == '-'));
     }
 
@@ -619 +674 @@
 
   if (longopts != NULL
-      && (argv[optind][1] == '-'
-          || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
+      && (gos->argv[gos->optind][1] == '-'
+          || (long_only
+              && (  gos->argv[gos->optind][2]
+                  || !memchr (gos->optstring, gos->argv[gos->optind][1], gos->len_optstring) )
+              )
+          )
+      )
     {
       char *nameend;
@@ -630 +690 @@
       int option_index;
 
-      for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
+      for (nameend = gos->nextchar; *nameend && *nameend != '='; nameend++)
         /* Do nothing.  */ ;
 
@@ -636 +696 @@
          or abbreviated matches.  */
       for (p = longopts, option_index = 0; p->name; p++, option_index++)
-        if (!strncmp (p->name, nextchar, nameend - nextchar))
+        if (!strncmp (p->name, gos->nextchar, nameend - gos->nextchar))
           {
-            if ((unsigned int) (nameend - nextchar)
+            if ((unsigned int) (nameend - gos->nextchar)
                 == (unsigned int) strlen (p->name))
               {
@@ -660 +720 @@
       if (ambig && !exact)
         {
-          if (opterr)
-            fprintf (stderr, _("%s: option '%s' is ambiguous\n"),
-                     argv[0], argv[optind]);
-          nextchar += strlen (nextchar);
-          optind++;
-          optopt = 0;
+          if (gos->opterr)
+            errx (gos->pCtx, 2, _("%s: option '%s' is ambiguous"),
+                  gos->argv[0], gos->argv[gos->optind]);
+          gos->nextchar += strlen (gos->nextchar);
+          gos->optind++;
+          gos->optopt = 0;
           return '?';
         }
@@ -672 +732 @@
         {
           option_index = indfound;
-          optind++;
+          gos->optind++;
           if (*nameend)
             {
@@ -678 +738 @@
                  allow it to be used on enums.  */
               if (pfound->has_arg)
-                optarg = nameend + 1;
+                gos->optarg = nameend + 1;
               else
                 {
-                  if (opterr)
+                  if (gos->opterr)
                   { /* bird: disambiguate */
-                   if (argv[optind - 1][1] == '-')
+                   if (gos->argv[gos->optind - 1][1] == '-')
                     /* --option */
-                    fprintf (stderr,
-                     _("%s: option '--%s' doesn't allow an argument\n"),
-                     argv[0], pfound->name);
+                    errx (gos->pCtx, 2,
+                          _("%s: option '--%s' doesn't allow an argument\n"),
+                          gos->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);
+                    errx (gos->pCtx, 2,
+                          _("%s: option '%c%s' doesn't allow an argument\n"),
+                          gos->argv[0], gos->argv[gos->optind - 1][0], pfound->name);
                   }
 
-                  nextchar += strlen (nextchar);
-
-                  optopt = pfound->val;
+                  gos->nextchar += strlen (gos->nextchar);
+
+                  gos->optopt = pfound->val;
                   return '?';
                 }
@@ -703 +763 @@
           else if (pfound->has_arg == 1)
             {
-              if (optind < argc)
-                optarg = argv[optind++];
+              if (gos->optind < gos->argc)
+                gos->optarg = gos->argv[gos->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] == ':' ? ':' : '?';
+                  if (gos->opterr)
+                    errx (gos->pCtx, 2,
+                          _("%s: option '%s' requires an argument\n"),
+                          gos->argv[0], gos->argv[gos->optind - 1]);
+                  gos->nextchar += strlen (gos->nextchar);
+                  gos->optopt = pfound->val;
+                  return gos->optstring[0] == ':' ? ':' : '?';
                 }
             }
-          nextchar += strlen (nextchar);
+          gos->nextchar += strlen (gos->nextchar);
           if (longind != NULL)
             *longind = option_index;
@@ -731 +791 @@
          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 (!long_only || gos->argv[gos->optind][1] == '-'
+          || memchr(gos->optstring, *gos->nextchar, gos->len_optstring) == NULL)
+        {
+          if (gos->opterr)
             {
-              if (argv[optind][1] == '-')
+              if (gos->argv[gos->optind][1] == '-')
                 /* --option */
-                fprintf (stderr, _("%s: unrecognized option '--%s'\n"),
-                         argv[0], nextchar);
+                errx (gos->pCtx, 2, _("%s: unrecognized option '--%s'\n"),
+                      gos->argv[0], gos->nextchar);
               else
                 /* +option or -option */
-                fprintf (stderr, _("%s: unrecognized option '%c%s'\n"),
-                         argv[0], argv[optind][0], nextchar);
+                errx (gos->pCtx, 2, _("%s: unrecognized option '%c%s'\n"),
+                      gos->argv[0], gos->argv[gos->optind][0], gos->nextchar);
             }
-          nextchar = (char *) "";
-          optind++;
-          optopt = 0;
+          gos->nextchar = (char *) "";
+          gos->optind++;
+          gos->optopt = 0;
           return '?';
         }
@@ -755 +815 @@
 
   {
-    char c = *nextchar++;
-    char *temp = my_index (optstring, c);
+    char c = *gos->nextchar++;
+    char *temp = (char *)memchr (gos->optstring, c, gos->len_optstring);
 
     /* Increment `optind' when we start to process its last character.  */
-    if (*nextchar == '\0')
-      ++optind;
+    if (*gos->nextchar == '\0')
+      ++gos->optind;
 
     if (temp == NULL || c == ':')
       {
-        if (opterr)
+        if (gos->opterr)
           {
-            if (posixly_correct)
+            if (gos->posixly_correct)
               /* 1003.2 specifies the format of this message.  */
-              fprintf (stderr, _("%s: illegal option -- %c\n"),
-                       argv[0], c);
+              errx (gos->pCtx, 2, _("%s: illegal option -- %c\n"),
+                    gos->argv[0], c);
             else
-              fprintf (stderr, _("%s: invalid option -- %c\n"),
-                       argv[0], c);
+              errx (gos->pCtx, 2, _("%s: invalid option -- %c\n"),
+                    gos->argv[0], c);
           }
-        optopt = c;
+        gos->optopt = c;
         return '?';
       }
@@ -789 +849 @@
 
         /* This is an option that requires an argument.  */
-        if (*nextchar != '\0')
+        if (*gos->nextchar != '\0')
           {
-            optarg = nextchar;
+            gos->optarg = gos->nextchar;
             /* If we end this ARGV-element by taking the rest as an arg,
                we must advance to the next element now.  */
-            optind++;
+            gos->optind++;
           }
-        else if (optind == argc)
+        else if (gos->optind == gos->argc)
           {
-            if (opterr)
+            if (gos->opterr)
               {
                 /* 1003.2 specifies the format of this message.  */
-                fprintf (stderr, _("%s: option requires an argument -- %c\n"),
-                         argv[0], c);
+                errx (gos->pCtx, 2, _("%s: option requires an argument -- %c\n"),
+                      gos->argv[0], c);
               }
-            optopt = c;
-            if (optstring[0] == ':')
+            gos->optopt = c;
+            if (gos->optstring[0] == ':')
               c = ':';
             else
@@ -814 +874 @@
           /* We already incremented `optind' once;
              increment it again when taking next ARGV-elt as argument.  */
-          optarg = argv[optind++];
+          gos->optarg = gos->argv[gos->optind++];
 
         /* optarg is now the argument, see if it's in the
            table of longopts.  */
 
-        for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++)
+        for (gos->nextchar = nameend = gos->optarg; *nameend && *nameend != '='; nameend++)
           /* Do nothing.  */ ;
 
@@ -825 +885 @@
            or abbreviated matches.  */
         for (p = longopts, option_index = 0; p->name; p++, option_index++)
-          if (!strncmp (p->name, nextchar, nameend - nextchar))
+          if (!strncmp (p->name, gos->nextchar, nameend - gos->nextchar))
             {
-              if ((unsigned int) (nameend - nextchar) == strlen (p->name))
+              if ((unsigned int) (nameend - gos->nextchar) == strlen (p->name))
                 {
                   /* Exact match found.  */
@@ -847 +907 @@
         if (ambig && !exact)
           {
-            if (opterr)
-              fprintf (stderr, _("%s: option '-W %s' is ambiguous\n"),
-                       argv[0], argv[optind]);
-            nextchar += strlen (nextchar);
-            optind++;
+            if (gos->opterr)
+              errx (gos->pCtx, 2, _("%s: option '-W %s' is ambiguous\n"),
+                    gos->argv[0], gos->argv[gos->optind]);
+            gos->nextchar += strlen (gos->nextchar);
+            gos->optind++;
             return '?';
           }
@@ -862 +922 @@
                    allow it to be used on enums.  */
                 if (pfound->has_arg)
-                  optarg = nameend + 1;
+                  gos->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);
+                    if (gos->opterr)
+                      errx (gos->pCtx, 2,
+                            _("%s: option '-W %s' doesn't allow an argument\n"),
+                            gos->argv[0], pfound->name);
+
+                    gos->nextchar += strlen (gos->nextchar);
                     return '?';
                   }
@@ -876 +936 @@
             else if (pfound->has_arg == 1)
               {
-                if (optind < argc)
-                  optarg = argv[optind++];
+                if (gos->optind < gos->argc)
+                  gos->optarg = gos->argv[gos->optind++];
                 else
                   {
-                    if (opterr)
-                      fprintf (stderr,
-                               _("%s: option '%s' requires an argument\n"),
-                               argv[0], argv[optind - 1]);
-                    nextchar += strlen (nextchar);
-                    return optstring[0] == ':' ? ':' : '?';
+                    if (gos->opterr)
+                      errx (gos->pCtx, 2,
+                            _("%s: option '%s' requires an argument\n"),
+                            gos->argv[0], gos->argv[gos->optind - 1]);
+                    gos->nextchar += strlen (gos->nextchar);
+                    return gos->optstring[0] == ':' ? ':' : '?';
                   }
               }
-            nextchar += strlen (nextchar);
+            gos->nextchar += strlen (gos->nextchar);
             if (longind != NULL)
               *longind = option_index;
@@ -898 +958 @@
             return pfound->val;
           }
-          nextchar = NULL;
+          gos->nextchar = NULL;
           return 'W';   /* Let the application handle it.   */
       }
@@ -906 +966 @@
           {
             /* This is an option that accepts an argument optionally.  */
-            if (*nextchar != '\0')
+            if (*gos->nextchar != '\0')
               {
-                optarg = nextchar;
-                optind++;
+                gos->optarg = gos->nextchar;
+                gos->optind++;
               }
             else
-              optarg = NULL;
-            nextchar = NULL;
+              gos->optarg = NULL;
+            gos->nextchar = NULL;
           }
         else
           {
             /* This is an option that requires an argument.  */
-            if (*nextchar != '\0')
+            if (*gos->nextchar != '\0')
               {
-                optarg = nextchar;
+                gos->optarg = gos->nextchar;
                 /* If we end this ARGV-element by taking the rest as an arg,
                    we must advance to the next element now.  */
-                optind++;
+                gos->optind++;
               }
-            else if (optind == argc)
+            else if (gos->optind == gos->argc)
               {
-                if (opterr)
+                if (gos->opterr)
                   {
                     /* 1003.2 specifies the format of this message.  */
-                    fprintf (stderr,
-                           _("%s: option requires an argument -- %c\n"),
-                           argv[0], c);
+                    errx (gos->pCtx, 2,
+                          _("%s: option requires an argument -- %c\n"),
+                          gos->argv[0], c);
                   }
-                optopt = c;
-                if (optstring[0] == ':')
+                gos->optopt = c;
+                if (gos->optstring[0] == ':')
                   c = ':';
                 else
@@ -943 +1003 @@
               /* We already incremented `optind' once;
                  increment it again when taking next ARGV-elt as argument.  */
-              optarg = argv[optind++];
-            nextchar = NULL;
+              gos->optarg = gos->argv[gos->optind++];
+            gos->nextchar = NULL;
           }
       }
@@ -952 +1012 @@
 
 int
-getopt (int argc, char *const *argv, const char *optstring)
+getopt_r (struct getopt_state_r *gos)
 {
-  return _getopt_internal (argc, argv, optstring,
-                           (const struct option *) 0,
-                           (int *) 0,
-                           0);
+  return _getopt_internal_r (gos, NULL, NULL, 0);
 }
 
-#endif  /* Not ELIDE_CODE.  */
+#endif /* #if 1 */ /* Not ELIDE_CODE.  */
 
 
@@ -973 +1030 @@
   int c;
   int digit_optind = 0;
+  struct getopt_state_r = gos;
+
+  getopt_initialize_r (&gos, argc, argv, "abc:d:0123456789", NULL, NULL, NULL);
 
   while (1)
     {
-      int this_option_optind = optind ? optind : 1;
-
-      c = getopt (argc, argv, "abc:d:0123456789");
+      int this_option_optind = gos.optind ? gos.optind : 1;
+
+      c = getopt_r (&gos);
       if (c == -1)
         break;
@@ -1020 +1080 @@
     }
 
-  if (optind < argc)
+  if (gos.optind < argc)
     {
       printf ("non-option ARGV-elements: ");
-      while (optind < argc)
-        printf ("%s ", argv[optind++]);
+      while (gos.optind < argc)
+        printf ("%s ", argv[gos.optind++]);
       printf ("\n");
     }

trunk/src/kmk/kmkbuiltin/getopt_r.h

@@ -1 @@
-/* Declarations for getopt.
+/* Reentrant version of getopt.
+
+Based on ../getopt*.*:
+
+   Declarations for getopt.
 Copyright (C) 1989-2016 Free Software Foundation, Inc.
 
@@ -15 +19 @@
 
 You should have received a copy of the GNU General Public License along with
-this program.  If not, see <http://www.gnu.org/licenses/>.  */
+this program.  If not, see <http://www.gnu.org/licenses/>.
 
-#ifndef _GETOPT_H
-#define _GETOPT_H 1
+Modifications:
+  Copyright (c) 2018 knut st. osmundsen <[email protected]>
+*/
+
+/* Not quite safe to mix when converting code. */
+#ifdef _GETOPT_H
+# define _GETOPT_H "getopt.h was included already"
+# error "getopt.h was included already"
+#endif
+
+#ifndef INCLUDED_GETOPT_R_H
+#define INCLUDED_GETOPT_R_H 1
 
 #ifdef  __cplusplus
 extern "C" {
 #endif
+
+typedef struct getopt_state_r
+{
 
 /* For communication from `getopt' to the caller.
@@ -30 +47 @@
    each non-option ARGV-element is returned here.  */
 
-extern char *optarg;
+/*extern*/ char *optarg;
 
 /* Index in ARGV of the next element to be scanned.
@@ -44 +61 @@
    how much of ARGV has been scanned so far.  */
 
-extern int optind;
+/*extern*/ int optind;
 
 /* Callers store zero here to inhibit the error message `getopt' prints
    for unrecognized options.  */
 
-extern int opterr;
+/*extern*/ int opterr;
 
 /* Set to an option character which was unrecognized.  */
 
-extern int optopt;
+/*extern*/ int optopt;
+
+
+/* Internal state: */
+
+/* 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;
+
+/* REQUIRE_ORDER, PERMUTE or RETURN_IN_ORDER, see getopt_r.c. */
+/*static*/ int ordering;
+
+/* Value of POSIXLY_CORRECT environment variable.  */
+/*static*/ char *posixly_correct;
+
+/* Describe the part of ARGV that contains non-options that have
+   been skipped.  `first_nonopt' is the index in ARGV of the first of them;
+   `last_nonopt' is the index after the last of them.  */
+
+/*static*/ int first_nonopt;
+/*static*/ int last_nonopt;
+
+/* Mainly for asserting usage sanity. */
+/*static*/ void *__getopt_initialized;
+
+/* New internal state (to resubmitting same parameters in each call): */
+  /* new: the argument vector length. */
+  int argc;
+  /* new: the argument vector. */
+  char * const *argv;
+  /* new: the short option string (can be NULL/empty). */
+  const char *optstring;
+  /* new: the short option string length. */
+  size_t len_optstring;
+  /* new: the long options (can be NULL) */
+  const struct option *long_options;
+  /* Output context for err.h. */
+  struct KMKBUILTINCTX *pCtx;
+} getopt_state_r;
+
+
+#ifndef no_argument
 
 /* Describe the long-named options requested by the application.
@@ -96 +159 @@
 #define optional_argument       2
 
-#if defined (__STDC__) && __STDC__
-#ifdef __GNU_LIBRARY__
-/* Many other libraries have conflicting prototypes for getopt, with
-   differences in the consts, in stdlib.h.  To avoid compilation
-   errors, only prototype getopt for the GNU C library.  */
-extern int getopt (int argc, char *const *argv, const char *shortopts);
-#else /* not __GNU_LIBRARY__ */
-extern int getopt ();
-#endif /* __GNU_LIBRARY__ */
-extern int getopt_long (int argc, char *const *argv, const char *shortopts,
-                        const struct option *longopts, int *longind);
-extern int getopt_long_only (int argc, char *const *argv,
-                             const char *shortopts,
-                             const struct option *longopts, int *longind);
+#endif /* Same as ../getopt.h.  Fix later? */
+
+extern void getopt_initialize_r (struct getopt_state_r *gos, int argc,
+                                 char *const *argv, const char *shortopts,
+                                 const struct option *longopts,
+                                 char **envp, struct KMKBUILTINCTX *pCtx);
+extern int getopt_r (struct getopt_state_r *gos);
+extern int getopt_long_r (struct getopt_state_r *gos, int *longind);
+extern int getopt_long_only_r (struct getopt_state_r *gos, int *longind);
 
 /* Internal only.  Users should not call this directly.  */
-extern int _getopt_internal (int argc, char *const *argv,
-                             const char *shortopts,
-                             const struct option *longopts, int *longind,
-                             int long_only);
-#else /* not __STDC__ */
-extern int getopt ();
-extern int getopt_long ();
-extern int getopt_long_only ();
-
-extern int _getopt_internal ();
-#endif /* __STDC__ */
+extern int _getopt_internal_r (struct getopt_state_r *gos,
+                               const struct option *longopts,
+                               int *longind, int long_only);
 
 #ifdef  __cplusplus
@@ -128 +178 @@
 #endif
 
-#endif /* getopt.h */
+#endif /* getopt_r.h */

trunk/src/kmk/kmkbuiltin/mscfakes.h

@@ -38 +38 @@
 #include <stdarg.h>
 #include <malloc.h>
-#include "getopt.h"
+#ifndef FAKES_NO_GETOPT_H
+# include "getopt.h"
+#endif
 #ifndef MSCFAKES_NO_WINDOWS_H
 # include <Windows.h>

trunk/src/kmk/kmkbuiltin/solfakes.h

@@ -30 +30 @@
 #include <stdarg.h>
 #include <sys/types.h>
-#include "getopt.h"
+#ifndef FAKES_NO_GETOPT_H
+# include "getopt.h"
+#endif
+
 #define _PATH_DEVNULL "/dev/null"
 #define ALLPERMS 0000777
@@ -45 +48 @@
 
 #endif /* __sun__ */
-#endif /* ___solfakes_h */
+#endif /* !___solfakes_h */