* demos/expr/run-expr.c: Don't use getopt, to avoid needing configury

	for optarg declaration.  Remove TRY macro, rename foo and bar to var_a
	and var_b, for clarity.

1 files changed, 159 insertions, 82 deletions

diff --git a/demos/expr/run-expr.c b/demos/expr/run-expr.c
index 6024b2dcc..620c9aeaa 100644
--- a/demos/expr/run-expr.c
+++ b/demos/expr/run-expr.c
@@ -33,124 +33,201 @@ MA 02111-1307, USA. */
 
 #include <stdio.h>
 #include <stdlib.h>
-#include <unistd.h>
 
 #include "gmp.h"
 #include "expr.h"
 
-#if ! HAVE_DECL_OPTARG
-extern char *optarg;
-extern int optind, opterr;
-#endif
-
-
-#define TRY(exprfun, outfun, str)                       \
-  {                                                     \
-    ret = exprfun (res, base, str, foo, bar, NULL);     \
-    printf ("\"%s\" base %d: ", str, base);             \
-    if (ret == MPEXPR_RESULT_OK)                        \
-      {                                                 \
-        printf ("result ");                             \
-        outfun;                                         \
-        printf ("\n");                                  \
-      }                                                 \
-    else                                                \
-      printf ("invalid (return code %d)\n", ret);       \
-  }
 
-  
-int
-main (int argc, char *argv[])
+void
+run_expr (int type, int base, unsigned long prec, char *str)
 {
-  int        type = 'z';
-  int        base = 0;
-  mp_size_t  prec = 64;
-  int        obase, opt, i, ret;
-
-  while ((opt = getopt (argc, argv, "b:fp:qz")) != EOF)
-    {
-      switch (opt) {
-      case 'f':
-      case 'q':
-      case 'z':
-        type = opt;
-        break;
-      case 'b':
-        base = atoi (optarg);
-        break;
-      case 'p':
-        prec = atoi (optarg);
-        break;
-      case '?':
-      default:
-        abort ();
-      }
-    }
-
-  obase = (base == 0 ? 10 : base);
-
-  if (optind >= argc)
-    {
-      printf ("Usage: %s [-z] [-q] [-f] [-p prec] [-b base] expression...\n", argv[0]);
-      exit (1);
-    }
+  int  outbase = (base == 0 ? 10 : base);
+  int  ret;
 
   switch (type) {
   case 'z':
   default:
     {
-      mpz_t  res, foo, bar;
+      mpz_t  res, var_a, var_b;
 
       mpz_init (res);
-      mpz_init_set_ui (foo, 55L);
-      mpz_init_set_ui (bar, 99L);
-
-      for (i = optind; i < argc; i++)
-        TRY (mpz_expr, mpz_out_str (stdout, obase, res), argv[i]);
+      mpz_init_set_ui (var_a, 55L);
+      mpz_init_set_ui (var_b, 99L);
+
+      ret = mpz_expr (res, base, str, var_a, var_b, NULL);
+      printf ("\"%s\" base %d: ", str, base);
+      if (ret == MPEXPR_RESULT_OK)
+        {
+          printf ("result ");
+          mpz_out_str (stdout, outbase, res);
+          printf ("\n");
+        }
+      else
+        printf ("invalid (return code %d)\n", ret);
 
       mpz_clear (res);
-      mpz_clear (foo);
-      mpz_clear (bar);
+      mpz_clear (var_a);
+      mpz_clear (var_b);
     }
     break;
 
   case 'q':
     {
-      mpq_t  res, foo, bar;
+      mpq_t  res, var_a, var_b;
 
       mpq_init (res);
-      mpq_init (foo);
-      mpq_init (bar);
-
-      mpq_set_ui (foo, 55L, 1);
-      mpq_set_ui (bar, 99L, 1);
-
-      for (i = optind; i < argc; i++)
-        TRY (mpq_expr, mpq_out_str (stdout, obase, res), argv[i]);
+      mpq_init (var_a);
+      mpq_init (var_b);
+
+      mpq_set_ui (var_a, 55L, 1);
+      mpq_set_ui (var_b, 99L, 1);
+
+      ret = mpq_expr (res, base, str, var_a, var_b, NULL);
+      printf ("\"%s\" base %d: ", str, base);
+      if (ret == MPEXPR_RESULT_OK)
+        {
+          printf ("result ");
+          mpq_out_str (stdout, outbase, res);
+          printf ("\n");
+        }
+      else
+        printf ("invalid (return code %d)\n", ret);
 
       mpq_clear (res);
-      mpq_clear (foo);
-      mpq_clear (bar);
+      mpq_clear (var_a);
+      mpq_clear (var_b);
     }
     break;
 
   case 'f':
     {
-      mpf_t  res, foo, bar;
+      mpf_t  res, var_a, var_b;
 
       mpf_init2 (res, prec);
-      mpf_init_set_ui (foo, 55L);
-      mpf_init_set_ui (bar, 99L);
-
-      for (i = optind; i < argc; i++)
-        TRY (mpf_expr, mpf_out_str (stdout, obase, 0, res), argv[i]);
+      mpf_init_set_ui (var_a, 55L);
+      mpf_init_set_ui (var_b, 99L);
+
+      ret = mpf_expr (res, base, str, var_a, var_b, NULL);
+      printf ("\"%s\" base %d: ", str, base);
+      if (ret == MPEXPR_RESULT_OK)
+        {
+          printf ("result ");
+          mpf_out_str (stdout, outbase, (size_t) 0, res);
+          printf ("\n");
+        }
+      else
+        printf ("invalid (return code %d)\n", ret);
 
       mpf_clear (res);
-      mpf_clear (foo);
-      mpf_clear (bar);
+      mpf_clear (var_a);
+      mpf_clear (var_b);
     }
     break;
   }
+}
+
+int
+main (int argc, char *argv[])
+{
+  int            type = 'z';
+  int            base = 0;
+  unsigned long  prec = 64;
+  int            seen_expr = 0;
+  int            opt;
+  char           *arg;
+
+  for (;;)
+    {
+      argv++;
+      arg = argv[0];
+      if (arg == NULL)
+        break;
+
+      if (arg[0] == '-')
+        {
+          for (;;)
+            {
+              arg++;
+              opt = arg[0];
+
+              switch (opt) {
+              case '\0':
+                goto end_opt;
+
+              case 'f':
+              case 'q':
+              case 'z':
+                type = opt;
+                break;
+
+              case 'b':
+                arg++;
+                if (arg[0] == '\0')
+                  {
+                    argv++;
+                    arg = argv[0];
+                    if (arg == NULL)
+                      {
+                      need_arg:
+                        fprintf (stderr, "Need argument for -%c\n", opt);
+                        exit (1);
+                      }
+                  }
+                base = atoi (arg);
+                goto end_opt;
+
+              case 'p':
+                arg++;
+                if (arg[0] == '\0')
+                  {
+                    argv++;
+                    arg = argv[0];
+                    if (arg == NULL)
+                      goto need_arg;
+                  }
+                prec = atoi (arg);
+                goto end_opt;
+
+              case '-':
+                arg++;
+                if (arg[0] != '\0')
+                  {
+                    /* no "--foo" options */
+                    fprintf (stderr, "Unrecognised option --%s\n", arg);
+                    exit (1);
+                  }
+                /* stop option interpretation at "--" */
+                for (;;)
+                  {
+                    argv++;
+                    arg = argv[0];
+                    if (arg == NULL)
+                      goto done;
+                    run_expr (type, base, prec, arg);
+                    seen_expr = 1;
+                  }
+
+              default:
+                fprintf (stderr, "Unrecognised option -%c\n", opt);
+                exit (1);
+              }
+            }
+        end_opt:
+          ;
+        }
+      else
+        {
+          run_expr (type, base, prec, arg);
+          seen_expr = 1;
+        }
+    }
+
+ done:
+  if (! seen_expr)
+    {
+      printf ("Usage: %s [-z] [-q] [-f] [-p prec] [-b base] expression...\n", argv[0]);
+      exit (1);
+    }
 
   return 0;
 }