xref: /netbsd-src/external/lgpl3/gmp/dist/demos/expr/run-expr.c (revision ce54336801cf28877c3414aa2fcb251dddd543a2)
1 /* Demo program to run expression evaluation.
2 
3 Copyright 2000-2002, 2004 Free Software Foundation, Inc.
4 
5 This file is part of the GNU MP Library.
6 
7 The GNU MP Library is free software; you can redistribute it and/or modify
8 it under the terms of either:
9 
10   * the GNU Lesser General Public License as published by the Free
11     Software Foundation; either version 3 of the License, or (at your
12     option) any later version.
13 
14 or
15 
16   * the GNU General Public License as published by the Free Software
17     Foundation; either version 2 of the License, or (at your option) any
18     later version.
19 
20 or both in parallel, as here.
21 
22 The GNU MP Library is distributed in the hope that it will be useful, but
23 WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
24 or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
25 for more details.
26 
27 You should have received copies of the GNU General Public License and the
28 GNU Lesser General Public License along with the GNU MP Library.  If not,
29 see https://www.gnu.org/licenses/.  */
30 
31 
32 /* Usage: ./run-expr [-z] [-q] [-f] [-p prec] [-b base] expression...
33 
34    Evaluate each argument as a simple expression.  By default this is in mpz
35    integers, but -q selects mpq or -f selects mpf.  For mpf the float
36    precision can be set with -p.  In all cases the input base can be set
37    with -b, or the default is "0" meaning decimal with "0x" allowed.
38 
39    This is a pretty trivial program, it's just an easy way to experiment
40    with the evaluation functions.  */
41 
42 
43 #include <stdio.h>
44 #include <stdlib.h>
45 
46 #include "gmp.h"
47 #include "expr.h"
48 
49 
50 void
run_expr(int type,int base,unsigned long prec,char * str)51 run_expr (int type, int base, unsigned long prec, char *str)
52 {
53   int  outbase = (base == 0 ? 10 : base);
54   int  ret;
55 
56   switch (type) {
57   case 'z':
58   default:
59     {
60       mpz_t  res, var_a, var_b;
61 
62       mpz_init (res);
63       mpz_init_set_ui (var_a, 55L);
64       mpz_init_set_ui (var_b, 99L);
65 
66       ret = mpz_expr (res, base, str, var_a, var_b, NULL);
67       printf ("\"%s\" base %d: ", str, base);
68       if (ret == MPEXPR_RESULT_OK)
69         {
70           printf ("result ");
71           mpz_out_str (stdout, outbase, res);
72           printf ("\n");
73         }
74       else
75         printf ("invalid (return code %d)\n", ret);
76 
77       mpz_clear (res);
78       mpz_clear (var_a);
79       mpz_clear (var_b);
80     }
81     break;
82 
83   case 'q':
84     {
85       mpq_t  res, var_a, var_b;
86 
87       mpq_init (res);
88       mpq_init (var_a);
89       mpq_init (var_b);
90 
91       mpq_set_ui (var_a, 55L, 1);
92       mpq_set_ui (var_b, 99L, 1);
93 
94       ret = mpq_expr (res, base, str, var_a, var_b, NULL);
95       printf ("\"%s\" base %d: ", str, base);
96       if (ret == MPEXPR_RESULT_OK)
97         {
98           printf ("result ");
99           mpq_out_str (stdout, outbase, res);
100           printf ("\n");
101         }
102       else
103         printf ("invalid (return code %d)\n", ret);
104 
105       mpq_clear (res);
106       mpq_clear (var_a);
107       mpq_clear (var_b);
108     }
109     break;
110 
111   case 'f':
112     {
113       mpf_t  res, var_a, var_b;
114 
115       mpf_init2 (res, prec);
116       mpf_init_set_ui (var_a, 55L);
117       mpf_init_set_ui (var_b, 99L);
118 
119       ret = mpf_expr (res, base, str, var_a, var_b, NULL);
120       printf ("\"%s\" base %d: ", str, base);
121       if (ret == MPEXPR_RESULT_OK)
122         {
123           printf ("result ");
124           mpf_out_str (stdout, outbase, (size_t) 0, res);
125           printf ("\n");
126         }
127       else
128         printf ("invalid (return code %d)\n", ret);
129 
130       mpf_clear (res);
131       mpf_clear (var_a);
132       mpf_clear (var_b);
133     }
134     break;
135   }
136 }
137 
138 int
main(int argc,char * argv[])139 main (int argc, char *argv[])
140 {
141   int            type = 'z';
142   int            base = 0;
143   unsigned long  prec = 64;
144   int            seen_expr = 0;
145   int            opt;
146   char           *arg;
147 
148   for (;;)
149     {
150       argv++;
151       arg = argv[0];
152       if (arg == NULL)
153         break;
154 
155       if (arg[0] == '-')
156         {
157           for (;;)
158             {
159               arg++;
160               opt = arg[0];
161 
162               switch (opt) {
163               case '\0':
164                 goto end_opt;
165 
166               case 'f':
167               case 'q':
168               case 'z':
169                 type = opt;
170                 break;
171 
172               case 'b':
173                 arg++;
174                 if (arg[0] == '\0')
175                   {
176                     argv++;
177                     arg = argv[0];
178                     if (arg == NULL)
179                       {
180                       need_arg:
181                         fprintf (stderr, "Need argument for -%c\n", opt);
182                         exit (1);
183                       }
184                   }
185                 base = atoi (arg);
186                 goto end_opt;
187 
188               case 'p':
189                 arg++;
190                 if (arg[0] == '\0')
191                   {
192                     argv++;
193                     arg = argv[0];
194                     if (arg == NULL)
195                       goto need_arg;
196                   }
197                 prec = atoi (arg);
198                 goto end_opt;
199 
200               case '-':
201                 arg++;
202                 if (arg[0] != '\0')
203                   {
204                     /* no "--foo" options */
205                     fprintf (stderr, "Unrecognised option --%s\n", arg);
206                     exit (1);
207                   }
208                 /* stop option interpretation at "--" */
209                 for (;;)
210                   {
211                     argv++;
212                     arg = argv[0];
213                     if (arg == NULL)
214                       goto done;
215                     run_expr (type, base, prec, arg);
216                     seen_expr = 1;
217                   }
218 
219               default:
220                 fprintf (stderr, "Unrecognised option -%c\n", opt);
221                 exit (1);
222               }
223             }
224         end_opt:
225           ;
226         }
227       else
228         {
229           run_expr (type, base, prec, arg);
230           seen_expr = 1;
231         }
232     }
233 
234  done:
235   if (! seen_expr)
236     {
237       printf ("Usage: %s [-z] [-q] [-f] [-p prec] [-b base] expression...\n", argv[0]);
238       exit (1);
239     }
240 
241   return 0;
242 }
243