Annotation of OpenXM_contrib/gmp/demos/calc/calc.c, Revision 1.1.1.1
1.1 ohara 1: /* A Bison parser, made from calc.y
2: by GNU bison 1.34. */
3:
4: #define YYBISON 1 /* Identify Bison output. */
5:
6: # define EOS 257
7: # define BAD 258
8: # define HELP 259
9: # define HEX 260
10: # define DECIMAL 261
11: # define QUIT 262
12: # define ABS 263
13: # define BIN 264
14: # define FIB 265
15: # define GCD 266
16: # define KRON 267
17: # define LCM 268
18: # define LUCNUM 269
19: # define NEXTPRIME 270
20: # define POWM 271
21: # define ROOT 272
22: # define SQRT 273
23: # define NUMBER 274
24: # define VARIABLE 275
25: # define LOR 276
26: # define LAND 277
27: # define EQ 278
28: # define NE 279
29: # define LE 280
30: # define GE 281
31: # define LSHIFT 282
32: # define RSHIFT 283
33: # define UMINUS 284
34:
35: #line 1 "calc.y"
36:
37: /* A simple integer desk calculator using yacc and gmp.
38:
39: Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
40:
41: This file is part of the GNU MP Library.
42:
43: This program is free software; you can redistribute it and/or modify it under
44: the terms of the GNU General Public License as published by the Free Software
45: Foundation; either version 2 of the License, or (at your option) any later
46: version.
47:
48: This program is distributed in the hope that it will be useful, but WITHOUT ANY
49: WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
50: PARTICULAR PURPOSE. See the GNU General Public License for more details.
51:
52: You should have received a copy of the GNU General Public License along with
53: this program; if not, write to the Free Software Foundation, Inc., 59 Temple
54: Place - Suite 330, Boston, MA 02111-1307, USA. */
55:
56:
57: /* This is a simple program, meant only to show one way to use GMP for this
58: sort of thing. There's few features, and error checking is minimal.
59: Standard input is read, calc_help() below shows the inputs accepted.
60:
61: Expressions are evaluated as they're read. If user defined functions
62: were wanted it'd be necessary to build a parse tree like pexpr.c does, or
63: a list of operations for a stack based evaluator. That would also make
64: it possible to detect and optimize evaluations "mod m" like pexpr.c does.
65:
66: A stack is used for intermediate values in the expression evaluation,
67: separate from the yacc parser stack. This is simple, makes error
68: recovery easy, minimizes the junk around mpz calls in the rules, and
69: saves initializing or clearing "mpz_t"s during a calculation. A
70: disadvantage though is that variables must be copied to the stack to be
71: worked on. A more sophisticated calculator or language system might be
72: able to avoid that when executing a compiled or semi-compiled form.
73:
74: Avoiding repeated initializing and clearing of "mpz_t"s is important. In
75: this program the time spent parsing is obviously much greater than any
76: possible saving from this, but a proper calculator or language should
77: take some trouble over it. Don't be surprised if an init/clear takes 3
78: or more times as long as a 10 limb addition, depending on the system (see
79: the mpz_init_realloc_clear example in tune/README). */
80:
81:
82: #include <stdio.h>
83: #include <stdlib.h>
84: #include <string.h>
85: #include "gmp.h"
86: #define NO_CALC_H /* because it conflicts with normal calc.c stuff */
87: #include "calc-common.h"
88:
89:
90: #define numberof(x) (sizeof (x) / sizeof ((x)[0]))
91:
92:
93: void
94: calc_help (void)
95: {
96: printf ("Examples:\n");
97: printf (" 2+3*4 expressions are evaluated\n");
98: printf (" x=5^6 variables a to z can be set and used\n");
99: printf ("Operators:\n");
100: printf (" + - * arithmetic\n");
101: printf (" / %% division and remainder (rounding towards negative infinity)\n");
102: printf (" ^ exponentiation\n");
103: printf (" ! factorial\n");
104: printf (" << >> left and right shifts\n");
105: printf (" <= >= > \\ comparisons, giving 1 if true, 0 if false\n");
106: printf (" == != < /\n");
107: printf (" && || logical and/or, giving 1 if true, 0 if false\n");
108: printf ("Functions:\n");
109: printf (" abs(n) absolute value\n");
110: printf (" bin(n,m) binomial coefficient\n");
111: printf (" fib(n) fibonacci number\n");
112: printf (" gcd(a,b,..) greatest common divisor\n");
113: printf (" kron(a,b) kronecker symbol\n");
114: printf (" lcm(a,b,..) least common multiple\n");
115: printf (" lucnum(n) lucas number\n");
116: printf (" nextprime(n) next prime after n\n");
117: printf (" powm(b,e,m) modulo powering, b^e%%m\n");
118: printf (" root(n,r) r-th root\n");
119: printf (" sqrt(n) square root\n");
120: printf ("Other:\n");
121: printf (" hex \\ set hex or decimal for input and output\n");
122: printf (" decimal / (\"0x\" can be used for hex too)\n");
123: printf (" quit exit program (EOF works too)\n");
124: printf (" ; statements are separated with a ; or newline\n");
125: printf (" \\ continue expressions with \\ before newline\n");
126: printf (" # xxx comments are # though to newline\n");
127: printf ("Hex numbers must be entered in upper case, to distinguish them from the\n");
128: printf ("variables a to f (like in bc).\n");
129: }
130:
131:
132: int ibase = 0;
133: int obase = 10;
134:
135:
136: /* The stack is a fixed size, which means there's a limit on the nesting
137: allowed in expressions. A more sophisticated program could let it grow
138: dynamically. */
139:
140: mpz_t stack[100];
141: mpz_ptr sp = stack[0];
142:
143: #define CHECK_OVERFLOW() \
144: if (sp >= stack[numberof(stack)]) \
145: { \
146: fprintf (stderr, \
147: "Value stack overflow, too much nesting in expression\n"); \
148: YYERROR; \
149: }
150:
151: #define CHECK_EMPTY() \
152: if (sp != stack[0]) \
153: { \
154: fprintf (stderr, "Oops, expected the value stack to be empty\n"); \
155: sp = stack[0]; \
156: }
157:
158:
159: mpz_t variable[26];
160:
161: #define CHECK_VARIABLE(var) \
162: if ((var) < 0 || (var) >= numberof (variable)) \
163: { \
164: fprintf (stderr, "Oops, bad variable somehow: %d\n", var); \
165: YYERROR; \
166: }
167:
168:
169: #define CHECK_UI(name,z) \
170: if (! mpz_fits_ulong_p (z)) \
171: { \
172: fprintf (stderr, "%s too big\n", name); \
173: YYERROR; \
174: }
175:
176:
177: #line 143 "calc.y"
178: #ifndef YYSTYPE
179: typedef union {
180: char *str;
181: int var;
182: } yystype;
183: # define YYSTYPE yystype
184: #endif
185: #ifndef YYDEBUG
186: # define YYDEBUG 0
187: #endif
188:
189:
190:
191: #define YYFINAL 118
192: #define YYFLAG -32768
193: #define YYNTBASE 44
194:
195: /* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */
196: #define YYTRANSLATE(x) ((unsigned)(x) <= 284 ? yytranslate[x] : 50)
197:
198: /* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */
199: static const char yytranslate[] =
200: {
201: 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
202: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
203: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
204: 2, 2, 2, 39, 2, 2, 2, 36, 2, 2,
205: 41, 42, 34, 32, 43, 33, 2, 35, 2, 2,
206: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
207: 24, 40, 25, 2, 2, 2, 2, 2, 2, 2,
208: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
209: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
210: 2, 2, 2, 2, 38, 2, 2, 2, 2, 2,
211: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
212: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
213: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
214: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
215: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
216: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
217: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
218: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
219: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
220: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
221: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
222: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
223: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
224: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
225: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
226: 2, 2, 2, 2, 2, 2, 1, 3, 4, 5,
227: 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
228: 16, 17, 18, 19, 20, 21, 22, 23, 26, 27,
229: 28, 29, 30, 31, 37
230: };
231:
232: #if YYDEBUG
233: static const short yyprhs[] =
234: {
235: 0, 0, 2, 5, 8, 12, 15, 16, 18, 22,
236: 24, 26, 28, 30, 34, 38, 42, 46, 50, 54,
237: 58, 62, 66, 69, 72, 76, 80, 84, 88, 92,
238: 96, 100, 104, 109, 116, 121, 126, 133, 138, 143,
239: 148, 157, 164, 169, 171, 173, 175, 179, 181
240: };
241: static const short yyrhs[] =
242: {
243: 46, 0, 45, 46, 0, 46, 3, 0, 45, 46,
244: 3, 0, 1, 3, 0, 0, 47, 0, 21, 40,
245: 47, 0, 5, 0, 6, 0, 7, 0, 8, 0,
246: 41, 47, 42, 0, 47, 32, 47, 0, 47, 33,
247: 47, 0, 47, 34, 47, 0, 47, 35, 47, 0,
248: 47, 36, 47, 0, 47, 38, 47, 0, 47, 30,
249: 47, 0, 47, 31, 47, 0, 47, 39, 0, 33,
250: 47, 0, 47, 24, 47, 0, 47, 28, 47, 0,
251: 47, 26, 47, 0, 47, 27, 47, 0, 47, 29,
252: 47, 0, 47, 25, 47, 0, 47, 23, 47, 0,
253: 47, 22, 47, 0, 9, 41, 47, 42, 0, 10,
254: 41, 47, 43, 47, 42, 0, 11, 41, 47, 42,
255: 0, 12, 41, 48, 42, 0, 13, 41, 47, 43,
256: 47, 42, 0, 14, 41, 49, 42, 0, 15, 41,
257: 47, 42, 0, 16, 41, 47, 42, 0, 17, 41,
258: 47, 43, 47, 43, 47, 42, 0, 18, 41, 47,
259: 43, 47, 42, 0, 19, 41, 47, 42, 0, 21,
260: 0, 20, 0, 47, 0, 48, 43, 47, 0, 47,
261: 0, 49, 43, 47, 0
262: };
263:
264: #endif
265:
266: #if YYDEBUG
267: /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
268: static const short yyrline[] =
269: {
270: 0, 167, 169, 171, 173, 174, 176, 178, 183, 189,
271: 190, 191, 192, 197, 199, 200, 201, 202, 203, 204,
272: 206, 208, 210, 212, 214, 215, 216, 217, 218, 219,
273: 221, 222, 224, 225, 227, 229, 230, 232, 233, 235,
274: 236, 237, 239, 241, 247, 257, 259, 261, 263
275: };
276: #endif
277:
278:
279: #if (YYDEBUG) || defined YYERROR_VERBOSE
280:
281: /* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */
282: static const char *const yytname[] =
283: {
284: "$", "error", "$undefined.", "EOS", "BAD", "HELP", "HEX", "DECIMAL",
285: "QUIT", "ABS", "BIN", "FIB", "GCD", "KRON", "LCM", "LUCNUM",
286: "NEXTPRIME", "POWM", "ROOT", "SQRT", "NUMBER", "VARIABLE", "LOR",
287: "LAND", "'<'", "'>'", "EQ", "NE", "LE", "GE", "LSHIFT", "RSHIFT", "'+'",
288: "'-'", "'*'", "'/'", "'%'", "UMINUS", "'^'", "'!'", "'='", "'('", "')'",
289: "','", "top", "statements", "statement", "e", "gcdlist", "lcmlist", 0
290: };
291: #endif
292:
293: /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
294: static const short yyr1[] =
295: {
296: 0, 44, 44, 45, 45, 45, 46, 46, 46, 46,
297: 46, 46, 46, 47, 47, 47, 47, 47, 47, 47,
298: 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
299: 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
300: 47, 47, 47, 47, 47, 48, 48, 49, 49
301: };
302:
303: /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
304: static const short yyr2[] =
305: {
306: 0, 1, 2, 2, 3, 2, 0, 1, 3, 1,
307: 1, 1, 1, 3, 3, 3, 3, 3, 3, 3,
308: 3, 3, 2, 2, 3, 3, 3, 3, 3, 3,
309: 3, 3, 4, 6, 4, 4, 6, 4, 4, 4,
310: 8, 6, 4, 1, 1, 1, 3, 1, 3
311: };
312:
313: /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
314: doesn't specify something else to do. Zero means the default is an
315: error. */
316: static const short yydefact[] =
317: {
318: 0, 0, 9, 10, 11, 12, 0, 0, 0, 0,
319: 0, 0, 0, 0, 0, 0, 0, 44, 43, 0,
320: 0, 6, 1, 7, 5, 0, 0, 0, 0, 0,
321: 0, 0, 0, 0, 0, 0, 0, 43, 23, 0,
322: 2, 3, 0, 0, 0, 0, 0, 0, 0, 0,
323: 0, 0, 0, 0, 0, 0, 0, 0, 22, 0,
324: 0, 0, 45, 0, 0, 47, 0, 0, 0, 0,
325: 0, 0, 8, 13, 4, 31, 30, 24, 29, 26,
326: 27, 25, 28, 20, 21, 14, 15, 16, 17, 18,
327: 19, 32, 0, 34, 35, 0, 0, 37, 0, 38,
328: 39, 0, 0, 42, 0, 46, 0, 48, 0, 0,
329: 33, 36, 0, 41, 0, 40, 0, 0, 0
330: };
331:
332: static const short yydefgoto[] =
333: {
334: 116, 21, 22, 23, 63, 66
335: };
336:
337: static const short yypact[] =
338: {
339: 39, 17,-32768,-32768,-32768,-32768, -20, 0, 2, 25,
340: 28, 30, 33, 34, 37, 40, 46,-32768, -18, 122,
341: 122, 89, 67, 462,-32768, 122, 122, 122, 122, 122,
342: 122, 122, 122, 122, 122, 122, 122,-32768, -36, 252,
343: 87,-32768, 122, 122, 122, 122, 122, 122, 122, 122,
344: 122, 122, 122, 122, 122, 122, 122, 122,-32768, 273,
345: 142, 294, 462, -38, 164, 462, -24, 315, 336, 186,
346: 208, 357, 462,-32768,-32768, 479, 495, 511, 511, 511,
347: 511, 511, 511, 29, 29, 50, 50, -36, -36, -36,
348: -36,-32768, 122,-32768,-32768, 122, 122,-32768, 122,-32768,
349: -32768, 122, 122,-32768, 378, 462, 399, 462, 230, 420,
350: -32768,-32768, 122,-32768, 441,-32768, 91, 92,-32768
351: };
352:
353: static const short yypgoto[] =
354: {
355: -32768,-32768, 90, -19,-32768,-32768
356: };
357:
358:
359: #define YYLAST 550
360:
361:
362: static const short yytable[] =
363: {
364: 38, 39, 57, 58, 94, 95, 59, 60, 61, 62,
365: 64, 65, 67, 68, 69, 70, 71, 72, 97, 98,
366: 24, 25, 36, 75, 76, 77, 78, 79, 80, 81,
367: 82, 83, 84, 85, 86, 87, 88, 89, 90, -6,
368: 1, 26, -6, 27, 2, 3, 4, 5, 6, 7,
369: 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
370: 18, 52, 53, 54, 55, 56, 28, 57, 58, 29,
371: 41, 30, 19, 104, 31, 32, 105, 106, 33, 107,
372: 20, 34, 108, 109, 54, 55, 56, 35, 57, 58,
373: 74, 117, 118, 114, 2, 3, 4, 5, 6, 7,
374: 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
375: 18, 40, 0, 0, 0, 0, 0, 0, 0, 0,
376: 0, 0, 19, 0, 0, 0, 0, 0, 0, 0,
377: 20, 6, 7, 8, 9, 10, 11, 12, 13, 14,
378: 15, 16, 17, 37, 0, 0, 0, 0, 0, 0,
379: 0, 0, 0, 0, 0, 19, 0, 0, 0, 0,
380: 0, 0, 0, 20, 42, 43, 44, 45, 46, 47,
381: 48, 49, 50, 51, 52, 53, 54, 55, 56, 0,
382: 57, 58, 0, 0, 0, 92, 42, 43, 44, 45,
383: 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
384: 56, 0, 57, 58, 0, 0, 0, 96, 42, 43,
385: 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
386: 54, 55, 56, 0, 57, 58, 0, 0, 0, 101,
387: 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
388: 52, 53, 54, 55, 56, 0, 57, 58, 0, 0,
389: 0, 102, 42, 43, 44, 45, 46, 47, 48, 49,
390: 50, 51, 52, 53, 54, 55, 56, 0, 57, 58,
391: 0, 0, 0, 112, 42, 43, 44, 45, 46, 47,
392: 48, 49, 50, 51, 52, 53, 54, 55, 56, 0,
393: 57, 58, 0, 0, 73, 42, 43, 44, 45, 46,
394: 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
395: 0, 57, 58, 0, 0, 91, 42, 43, 44, 45,
396: 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
397: 56, 0, 57, 58, 0, 0, 93, 42, 43, 44,
398: 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
399: 55, 56, 0, 57, 58, 0, 0, 99, 42, 43,
400: 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
401: 54, 55, 56, 0, 57, 58, 0, 0, 100, 42,
402: 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
403: 53, 54, 55, 56, 0, 57, 58, 0, 0, 103,
404: 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
405: 52, 53, 54, 55, 56, 0, 57, 58, 0, 0,
406: 110, 42, 43, 44, 45, 46, 47, 48, 49, 50,
407: 51, 52, 53, 54, 55, 56, 0, 57, 58, 0,
408: 0, 111, 42, 43, 44, 45, 46, 47, 48, 49,
409: 50, 51, 52, 53, 54, 55, 56, 0, 57, 58,
410: 0, 0, 113, 42, 43, 44, 45, 46, 47, 48,
411: 49, 50, 51, 52, 53, 54, 55, 56, 0, 57,
412: 58, 0, 0, 115, 42, 43, 44, 45, 46, 47,
413: 48, 49, 50, 51, 52, 53, 54, 55, 56, 0,
414: 57, 58, 43, 44, 45, 46, 47, 48, 49, 50,
415: 51, 52, 53, 54, 55, 56, 0, 57, 58, 44,
416: 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
417: 55, 56, 0, 57, 58,-32768,-32768,-32768,-32768,-32768,
418: -32768, 50, 51, 52, 53, 54, 55, 56, 0, 57,
419: 58
420: };
421:
422: static const short yycheck[] =
423: {
424: 19, 20, 38, 39, 42, 43, 25, 26, 27, 28,
425: 29, 30, 31, 32, 33, 34, 35, 36, 42, 43,
426: 3, 41, 40, 42, 43, 44, 45, 46, 47, 48,
427: 49, 50, 51, 52, 53, 54, 55, 56, 57, 0,
428: 1, 41, 3, 41, 5, 6, 7, 8, 9, 10,
429: 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
430: 21, 32, 33, 34, 35, 36, 41, 38, 39, 41,
431: 3, 41, 33, 92, 41, 41, 95, 96, 41, 98,
432: 41, 41, 101, 102, 34, 35, 36, 41, 38, 39,
433: 3, 0, 0, 112, 5, 6, 7, 8, 9, 10,
434: 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
435: 21, 21, -1, -1, -1, -1, -1, -1, -1, -1,
436: -1, -1, 33, -1, -1, -1, -1, -1, -1, -1,
437: 41, 9, 10, 11, 12, 13, 14, 15, 16, 17,
438: 18, 19, 20, 21, -1, -1, -1, -1, -1, -1,
439: -1, -1, -1, -1, -1, 33, -1, -1, -1, -1,
440: -1, -1, -1, 41, 22, 23, 24, 25, 26, 27,
441: 28, 29, 30, 31, 32, 33, 34, 35, 36, -1,
442: 38, 39, -1, -1, -1, 43, 22, 23, 24, 25,
443: 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
444: 36, -1, 38, 39, -1, -1, -1, 43, 22, 23,
445: 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
446: 34, 35, 36, -1, 38, 39, -1, -1, -1, 43,
447: 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
448: 32, 33, 34, 35, 36, -1, 38, 39, -1, -1,
449: -1, 43, 22, 23, 24, 25, 26, 27, 28, 29,
450: 30, 31, 32, 33, 34, 35, 36, -1, 38, 39,
451: -1, -1, -1, 43, 22, 23, 24, 25, 26, 27,
452: 28, 29, 30, 31, 32, 33, 34, 35, 36, -1,
453: 38, 39, -1, -1, 42, 22, 23, 24, 25, 26,
454: 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
455: -1, 38, 39, -1, -1, 42, 22, 23, 24, 25,
456: 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
457: 36, -1, 38, 39, -1, -1, 42, 22, 23, 24,
458: 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
459: 35, 36, -1, 38, 39, -1, -1, 42, 22, 23,
460: 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
461: 34, 35, 36, -1, 38, 39, -1, -1, 42, 22,
462: 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
463: 33, 34, 35, 36, -1, 38, 39, -1, -1, 42,
464: 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
465: 32, 33, 34, 35, 36, -1, 38, 39, -1, -1,
466: 42, 22, 23, 24, 25, 26, 27, 28, 29, 30,
467: 31, 32, 33, 34, 35, 36, -1, 38, 39, -1,
468: -1, 42, 22, 23, 24, 25, 26, 27, 28, 29,
469: 30, 31, 32, 33, 34, 35, 36, -1, 38, 39,
470: -1, -1, 42, 22, 23, 24, 25, 26, 27, 28,
471: 29, 30, 31, 32, 33, 34, 35, 36, -1, 38,
472: 39, -1, -1, 42, 22, 23, 24, 25, 26, 27,
473: 28, 29, 30, 31, 32, 33, 34, 35, 36, -1,
474: 38, 39, 23, 24, 25, 26, 27, 28, 29, 30,
475: 31, 32, 33, 34, 35, 36, -1, 38, 39, 24,
476: 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
477: 35, 36, -1, 38, 39, 24, 25, 26, 27, 28,
478: 29, 30, 31, 32, 33, 34, 35, 36, -1, 38,
479: 39
480: };
481: /* -*-C-*- Note some compilers choke on comments on `#line' lines. */
482: #line 3 "/usr/share/bison/bison.simple"
483:
484: /* Skeleton output parser for bison,
485:
486: Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software
487: Foundation, Inc.
488:
489: This program is free software; you can redistribute it and/or modify
490: it under the terms of the GNU General Public License as published by
491: the Free Software Foundation; either version 2, or (at your option)
492: any later version.
493:
494: This program is distributed in the hope that it will be useful,
495: but WITHOUT ANY WARRANTY; without even the implied warranty of
496: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
497: GNU General Public License for more details.
498:
499: You should have received a copy of the GNU General Public License
500: along with this program; if not, write to the Free Software
501: Foundation, Inc., 59 Temple Place - Suite 330,
502: Boston, MA 02111-1307, USA. */
503:
504: /* As a special exception, when this file is copied by Bison into a
505: Bison output file, you may use that output file without restriction.
506: This special exception was added by the Free Software Foundation
507: in version 1.24 of Bison. */
508:
509: /* This is the parser code that is written into each bison parser when
510: the %semantic_parser declaration is not specified in the grammar.
511: It was written by Richard Stallman by simplifying the hairy parser
512: used when %semantic_parser is specified. */
513:
514: /* All symbols defined below should begin with yy or YY, to avoid
515: infringing on user name space. This should be done even for local
516: variables, as they might otherwise be expanded by user macros.
517: There are some unavoidable exceptions within include files to
518: define necessary library symbols; they are noted "INFRINGES ON
519: USER NAME SPACE" below. */
520:
521: #if ! defined (yyoverflow) || defined (YYERROR_VERBOSE)
522:
523: /* The parser invokes alloca or malloc; define the necessary symbols. */
524:
525: # if YYSTACK_USE_ALLOCA
526: # define YYSTACK_ALLOC alloca
527: # else
528: # ifndef YYSTACK_USE_ALLOCA
529: # if defined (alloca) || defined (_ALLOCA_H)
530: # define YYSTACK_ALLOC alloca
531: # else
532: # ifdef __GNUC__
533: # define YYSTACK_ALLOC __builtin_alloca
534: # endif
535: # endif
536: # endif
537: # endif
538:
539: # ifdef YYSTACK_ALLOC
540: /* Pacify GCC's `empty if-body' warning. */
541: # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
542: # else
543: # if defined (__STDC__) || defined (__cplusplus)
544: # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
545: # define YYSIZE_T size_t
546: # endif
547: # define YYSTACK_ALLOC malloc
548: # define YYSTACK_FREE free
549: # endif
550:
551: /* A type that is properly aligned for any stack member. */
552: union yyalloc
553: {
554: short yyss;
555: YYSTYPE yyvs;
556: # if YYLSP_NEEDED
557: YYLTYPE yyls;
558: # endif
559: };
560:
561: /* The size of the maximum gap between one aligned stack and the next. */
562: # define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
563:
564: /* The size of an array large to enough to hold all stacks, each with
565: N elements. */
566: # if YYLSP_NEEDED
567: # define YYSTACK_BYTES(N) \
568: ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
569: + 2 * YYSTACK_GAP_MAX)
570: # else
571: # define YYSTACK_BYTES(N) \
572: ((N) * (sizeof (short) + sizeof (YYSTYPE)) \
573: + YYSTACK_GAP_MAX)
574: # endif
575:
576: /* Relocate the TYPE STACK from its old location to the new one. The
577: local variables YYSIZE and YYSTACKSIZE give the old and new number of
578: elements in the stack, and YYPTR gives the new location of the
579: stack. Advance YYPTR to a properly aligned location for the next
580: stack. */
581: # define YYSTACK_RELOCATE(Type, Stack) \
582: do \
583: { \
584: YYSIZE_T yynewbytes; \
585: yymemcpy ((char *) yyptr, (char *) (Stack), \
586: yysize * (YYSIZE_T) sizeof (Type)); \
587: Stack = &yyptr->Stack; \
588: yynewbytes = yystacksize * sizeof (Type) + YYSTACK_GAP_MAX; \
589: yyptr += yynewbytes / sizeof (*yyptr); \
590: } \
591: while (0)
592:
593: #endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */
594:
595:
596: #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
597: # define YYSIZE_T __SIZE_TYPE__
598: #endif
599: #if ! defined (YYSIZE_T) && defined (size_t)
600: # define YYSIZE_T size_t
601: #endif
602: #if ! defined (YYSIZE_T)
603: # if defined (__STDC__) || defined (__cplusplus)
604: # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
605: # define YYSIZE_T size_t
606: # endif
607: #endif
608: #if ! defined (YYSIZE_T)
609: # define YYSIZE_T unsigned int
610: #endif
611:
612: #define yyerrok (yyerrstatus = 0)
613: #define yyclearin (yychar = YYEMPTY)
614: #define YYEMPTY -2
615: #define YYEOF 0
616: #define YYACCEPT goto yyacceptlab
617: #define YYABORT goto yyabortlab
618: #define YYERROR goto yyerrlab1
619: /* Like YYERROR except do call yyerror. This remains here temporarily
620: to ease the transition to the new meaning of YYERROR, for GCC.
621: Once GCC version 2 has supplanted version 1, this can go. */
622: #define YYFAIL goto yyerrlab
623: #define YYRECOVERING() (!!yyerrstatus)
624: #define YYBACKUP(Token, Value) \
625: do \
626: if (yychar == YYEMPTY && yylen == 1) \
627: { \
628: yychar = (Token); \
629: yylval = (Value); \
630: yychar1 = YYTRANSLATE (yychar); \
631: YYPOPSTACK; \
632: goto yybackup; \
633: } \
634: else \
635: { \
636: yyerror ("syntax error: cannot back up"); \
637: YYERROR; \
638: } \
639: while (0)
640:
641: #define YYTERROR 1
642: #define YYERRCODE 256
643:
644:
645: /* YYLLOC_DEFAULT -- Compute the default location (before the actions
646: are run).
647:
648: When YYLLOC_DEFAULT is run, CURRENT is set the location of the
649: first token. By default, to implement support for ranges, extend
650: its range to the last symbol. */
651:
652: #ifndef YYLLOC_DEFAULT
653: # define YYLLOC_DEFAULT(Current, Rhs, N) \
654: Current.last_line = Rhs[N].last_line; \
655: Current.last_column = Rhs[N].last_column;
656: #endif
657:
658:
659: /* YYLEX -- calling `yylex' with the right arguments. */
660:
661: #if YYPURE
662: # if YYLSP_NEEDED
663: # ifdef YYLEX_PARAM
664: # define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM)
665: # else
666: # define YYLEX yylex (&yylval, &yylloc)
667: # endif
668: # else /* !YYLSP_NEEDED */
669: # ifdef YYLEX_PARAM
670: # define YYLEX yylex (&yylval, YYLEX_PARAM)
671: # else
672: # define YYLEX yylex (&yylval)
673: # endif
674: # endif /* !YYLSP_NEEDED */
675: #else /* !YYPURE */
676: # define YYLEX yylex ()
677: #endif /* !YYPURE */
678:
679:
680: /* Enable debugging if requested. */
681: #if YYDEBUG
682:
683: # ifndef YYFPRINTF
684: # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
685: # define YYFPRINTF fprintf
686: # endif
687:
688: # define YYDPRINTF(Args) \
689: do { \
690: if (yydebug) \
691: YYFPRINTF Args; \
692: } while (0)
693: /* Nonzero means print parse trace. It is left uninitialized so that
694: multiple parsers can coexist. */
695: int yydebug;
696: #else /* !YYDEBUG */
697: # define YYDPRINTF(Args)
698: #endif /* !YYDEBUG */
699:
700: /* YYINITDEPTH -- initial size of the parser's stacks. */
701: #ifndef YYINITDEPTH
702: # define YYINITDEPTH 200
703: #endif
704:
705: /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
706: if the built-in stack extension method is used).
707:
708: Do not make this value too large; the results are undefined if
709: SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
710: evaluated with infinite-precision integer arithmetic. */
711:
712: #if YYMAXDEPTH == 0
713: # undef YYMAXDEPTH
714: #endif
715:
716: #ifndef YYMAXDEPTH
717: # define YYMAXDEPTH 10000
718: #endif
719:
720: #if ! defined (yyoverflow) && ! defined (yymemcpy)
721: # if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
722: # define yymemcpy __builtin_memcpy
723: # else /* not GNU C or C++ */
724:
725: /* This is the most reliable way to avoid incompatibilities
726: in available built-in functions on various systems. */
727: static void
728: # if defined (__STDC__) || defined (__cplusplus)
729: yymemcpy (char *yyto, const char *yyfrom, YYSIZE_T yycount)
730: # else
731: yymemcpy (yyto, yyfrom, yycount)
732: char *yyto;
733: const char *yyfrom;
734: YYSIZE_T yycount;
735: # endif
736: {
737: register const char *yyf = yyfrom;
738: register char *yyt = yyto;
739: register YYSIZE_T yyi = yycount;
740:
741: while (yyi-- != 0)
742: *yyt++ = *yyf++;
743: }
744: # endif
745: #endif
746:
747: #ifdef YYERROR_VERBOSE
748:
749: # ifndef yystrlen
750: # if defined (__GLIBC__) && defined (_STRING_H)
751: # define yystrlen strlen
752: # else
753: /* Return the length of YYSTR. */
754: static YYSIZE_T
755: # if defined (__STDC__) || defined (__cplusplus)
756: yystrlen (const char *yystr)
757: # else
758: yystrlen (yystr)
759: const char *yystr;
760: # endif
761: {
762: register const char *yys = yystr;
763:
764: while (*yys++ != '\0')
765: continue;
766:
767: return yys - yystr - 1;
768: }
769: # endif
770: # endif
771:
772: # ifndef yystpcpy
773: # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
774: # define yystpcpy stpcpy
775: # else
776: /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
777: YYDEST. */
778: static char *
779: # if defined (__STDC__) || defined (__cplusplus)
780: yystpcpy (char *yydest, const char *yysrc)
781: # else
782: yystpcpy (yydest, yysrc)
783: char *yydest;
784: const char *yysrc;
785: # endif
786: {
787: register char *yyd = yydest;
788: register const char *yys = yysrc;
789:
790: while ((*yyd++ = *yys++) != '\0')
791: continue;
792:
793: return yyd - 1;
794: }
795: # endif
796: # endif
797: #endif
798:
799: #line 319 "/usr/share/bison/bison.simple"
800:
801:
802: /* The user can define YYPARSE_PARAM as the name of an argument to be passed
803: into yyparse. The argument should have type void *.
804: It should actually point to an object.
805: Grammar actions can access the variable by casting it
806: to the proper pointer type. */
807:
808: #ifdef YYPARSE_PARAM
809: # if defined (__STDC__) || defined (__cplusplus)
810: # define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
811: # define YYPARSE_PARAM_DECL
812: # else
813: # define YYPARSE_PARAM_ARG YYPARSE_PARAM
814: # define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
815: # endif
816: #else /* !YYPARSE_PARAM */
817: # define YYPARSE_PARAM_ARG
818: # define YYPARSE_PARAM_DECL
819: #endif /* !YYPARSE_PARAM */
820:
821: /* Prevent warning if -Wstrict-prototypes. */
822: #ifdef __GNUC__
823: # ifdef YYPARSE_PARAM
824: int yyparse (void *);
825: # else
826: int yyparse (void);
827: # endif
828: #endif
829:
830: /* YY_DECL_VARIABLES -- depending whether we use a pure parser,
831: variables are global, or local to YYPARSE. */
832:
833: #define YY_DECL_NON_LSP_VARIABLES \
834: /* The lookahead symbol. */ \
835: int yychar; \
836: \
837: /* The semantic value of the lookahead symbol. */ \
838: YYSTYPE yylval; \
839: \
840: /* Number of parse errors so far. */ \
841: int yynerrs;
842:
843: #if YYLSP_NEEDED
844: # define YY_DECL_VARIABLES \
845: YY_DECL_NON_LSP_VARIABLES \
846: \
847: /* Location data for the lookahead symbol. */ \
848: YYLTYPE yylloc;
849: #else
850: # define YY_DECL_VARIABLES \
851: YY_DECL_NON_LSP_VARIABLES
852: #endif
853:
854:
855: /* If nonreentrant, generate the variables here. */
856:
857: #if !YYPURE
858: YY_DECL_VARIABLES
859: #endif /* !YYPURE */
860:
861: int
862: yyparse (YYPARSE_PARAM_ARG)
863: YYPARSE_PARAM_DECL
864: {
865: /* If reentrant, generate the variables here. */
866: #if YYPURE
867: YY_DECL_VARIABLES
868: #endif /* !YYPURE */
869:
870: register int yystate;
871: register int yyn;
872: int yyresult;
873: /* Number of tokens to shift before error messages enabled. */
874: int yyerrstatus;
875: /* Lookahead token as an internal (translated) token number. */
876: int yychar1 = 0;
877:
878: /* Three stacks and their tools:
879: `yyss': related to states,
880: `yyvs': related to semantic values,
881: `yyls': related to locations.
882:
883: Refer to the stacks thru separate pointers, to allow yyoverflow
884: to reallocate them elsewhere. */
885:
886: /* The state stack. */
887: short yyssa[YYINITDEPTH];
888: short *yyss = yyssa;
889: register short *yyssp;
890:
891: /* The semantic value stack. */
892: YYSTYPE yyvsa[YYINITDEPTH];
893: YYSTYPE *yyvs = yyvsa;
894: register YYSTYPE *yyvsp;
895:
896: #if YYLSP_NEEDED
897: /* The location stack. */
898: YYLTYPE yylsa[YYINITDEPTH];
899: YYLTYPE *yyls = yylsa;
900: YYLTYPE *yylsp;
901: #endif
902:
903: #if YYLSP_NEEDED
904: # define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
905: #else
906: # define YYPOPSTACK (yyvsp--, yyssp--)
907: #endif
908:
909: YYSIZE_T yystacksize = YYINITDEPTH;
910:
911:
912: /* The variables used to return semantic value and location from the
913: action routines. */
914: YYSTYPE yyval;
915: #if YYLSP_NEEDED
916: YYLTYPE yyloc;
917: #endif
918:
919: /* When reducing, the number of symbols on the RHS of the reduced
920: rule. */
921: int yylen;
922:
923: YYDPRINTF ((stderr, "Starting parse\n"));
924:
925: yystate = 0;
926: yyerrstatus = 0;
927: yynerrs = 0;
928: yychar = YYEMPTY; /* Cause a token to be read. */
929:
930: /* Initialize stack pointers.
931: Waste one element of value and location stack
932: so that they stay on the same level as the state stack.
933: The wasted elements are never initialized. */
934:
935: yyssp = yyss;
936: yyvsp = yyvs;
937: #if YYLSP_NEEDED
938: yylsp = yyls;
939: #endif
940: goto yysetstate;
941:
942: /*------------------------------------------------------------.
943: | yynewstate -- Push a new state, which is found in yystate. |
944: `------------------------------------------------------------*/
945: yynewstate:
946: /* In all cases, when you get here, the value and location stacks
947: have just been pushed. so pushing a state here evens the stacks.
948: */
949: yyssp++;
950:
951: yysetstate:
952: *yyssp = yystate;
953:
954: if (yyssp >= yyss + yystacksize - 1)
955: {
956: /* Get the current used size of the three stacks, in elements. */
957: YYSIZE_T yysize = yyssp - yyss + 1;
958:
959: #ifdef yyoverflow
960: {
961: /* Give user a chance to reallocate the stack. Use copies of
962: these so that the &'s don't force the real ones into
963: memory. */
964: YYSTYPE *yyvs1 = yyvs;
965: short *yyss1 = yyss;
966:
967: /* Each stack pointer address is followed by the size of the
968: data in use in that stack, in bytes. */
969: # if YYLSP_NEEDED
970: YYLTYPE *yyls1 = yyls;
971: /* This used to be a conditional around just the two extra args,
972: but that might be undefined if yyoverflow is a macro. */
973: yyoverflow ("parser stack overflow",
974: &yyss1, yysize * sizeof (*yyssp),
975: &yyvs1, yysize * sizeof (*yyvsp),
976: &yyls1, yysize * sizeof (*yylsp),
977: &yystacksize);
978: yyls = yyls1;
979: # else
980: yyoverflow ("parser stack overflow",
981: &yyss1, yysize * sizeof (*yyssp),
982: &yyvs1, yysize * sizeof (*yyvsp),
983: &yystacksize);
984: # endif
985: yyss = yyss1;
986: yyvs = yyvs1;
987: }
988: #else /* no yyoverflow */
989: /* Extend the stack our own way. */
990: if (yystacksize >= YYMAXDEPTH)
991: goto yyoverflowlab;
992: yystacksize *= 2;
993: if (yystacksize > YYMAXDEPTH)
994: yystacksize = YYMAXDEPTH;
995:
996: {
997: short *yyss1 = yyss;
998: union yyalloc *yyptr =
999: (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1000: if (! yyptr)
1001: goto yyoverflowlab;
1002: YYSTACK_RELOCATE (short, yyss);
1003: YYSTACK_RELOCATE (YYSTYPE, yyvs);
1004: # if YYLSP_NEEDED
1005: YYSTACK_RELOCATE (YYLTYPE, yyls);
1006: # endif
1007: # undef YYSTACK_RELOCATE
1008: if (yyss1 != yyssa)
1009: YYSTACK_FREE (yyss1);
1010: }
1011: #endif /* no yyoverflow */
1012:
1013: yyssp = yyss + yysize - 1;
1014: yyvsp = yyvs + yysize - 1;
1015: #if YYLSP_NEEDED
1016: yylsp = yyls + yysize - 1;
1017: #endif
1018:
1019: YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1020: (unsigned long int) yystacksize));
1021:
1022: if (yyssp >= yyss + yystacksize - 1)
1023: YYABORT;
1024: }
1025:
1026: YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1027:
1028: goto yybackup;
1029:
1030:
1031: /*-----------.
1032: | yybackup. |
1033: `-----------*/
1034: yybackup:
1035:
1036: /* Do appropriate processing given the current state. */
1037: /* Read a lookahead token if we need one and don't already have one. */
1038: /* yyresume: */
1039:
1040: /* First try to decide what to do without reference to lookahead token. */
1041:
1042: yyn = yypact[yystate];
1043: if (yyn == YYFLAG)
1044: goto yydefault;
1045:
1046: /* Not known => get a lookahead token if don't already have one. */
1047:
1048: /* yychar is either YYEMPTY or YYEOF
1049: or a valid token in external form. */
1050:
1051: if (yychar == YYEMPTY)
1052: {
1053: YYDPRINTF ((stderr, "Reading a token: "));
1054: yychar = YYLEX;
1055: }
1056:
1057: /* Convert token to internal form (in yychar1) for indexing tables with */
1058:
1059: if (yychar <= 0) /* This means end of input. */
1060: {
1061: yychar1 = 0;
1062: yychar = YYEOF; /* Don't call YYLEX any more */
1063:
1064: YYDPRINTF ((stderr, "Now at end of input.\n"));
1065: }
1066: else
1067: {
1068: yychar1 = YYTRANSLATE (yychar);
1069:
1070: #if YYDEBUG
1071: /* We have to keep this `#if YYDEBUG', since we use variables
1072: which are defined only if `YYDEBUG' is set. */
1073: if (yydebug)
1074: {
1075: YYFPRINTF (stderr, "Next token is %d (%s",
1076: yychar, yytname[yychar1]);
1077: /* Give the individual parser a way to print the precise
1078: meaning of a token, for further debugging info. */
1079: # ifdef YYPRINT
1080: YYPRINT (stderr, yychar, yylval);
1081: # endif
1082: YYFPRINTF (stderr, ")\n");
1083: }
1084: #endif
1085: }
1086:
1087: yyn += yychar1;
1088: if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
1089: goto yydefault;
1090:
1091: yyn = yytable[yyn];
1092:
1093: /* yyn is what to do for this token type in this state.
1094: Negative => reduce, -yyn is rule number.
1095: Positive => shift, yyn is new state.
1096: New state is final state => don't bother to shift,
1097: just return success.
1098: 0, or most negative number => error. */
1099:
1100: if (yyn < 0)
1101: {
1102: if (yyn == YYFLAG)
1103: goto yyerrlab;
1104: yyn = -yyn;
1105: goto yyreduce;
1106: }
1107: else if (yyn == 0)
1108: goto yyerrlab;
1109:
1110: if (yyn == YYFINAL)
1111: YYACCEPT;
1112:
1113: /* Shift the lookahead token. */
1114: YYDPRINTF ((stderr, "Shifting token %d (%s), ",
1115: yychar, yytname[yychar1]));
1116:
1117: /* Discard the token being shifted unless it is eof. */
1118: if (yychar != YYEOF)
1119: yychar = YYEMPTY;
1120:
1121: *++yyvsp = yylval;
1122: #if YYLSP_NEEDED
1123: *++yylsp = yylloc;
1124: #endif
1125:
1126: /* Count tokens shifted since error; after three, turn off error
1127: status. */
1128: if (yyerrstatus)
1129: yyerrstatus--;
1130:
1131: yystate = yyn;
1132: goto yynewstate;
1133:
1134:
1135: /*-----------------------------------------------------------.
1136: | yydefault -- do the default action for the current state. |
1137: `-----------------------------------------------------------*/
1138: yydefault:
1139: yyn = yydefact[yystate];
1140: if (yyn == 0)
1141: goto yyerrlab;
1142: goto yyreduce;
1143:
1144:
1145: /*-----------------------------.
1146: | yyreduce -- Do a reduction. |
1147: `-----------------------------*/
1148: yyreduce:
1149: /* yyn is the number of a rule to reduce with. */
1150: yylen = yyr2[yyn];
1151:
1152: /* If YYLEN is nonzero, implement the default value of the action:
1153: `$$ = $1'.
1154:
1155: Otherwise, the following line sets YYVAL to the semantic value of
1156: the lookahead token. This behavior is undocumented and Bison
1157: users should not rely upon it. Assigning to YYVAL
1158: unconditionally makes the parser a bit smaller, and it avoids a
1159: GCC warning that YYVAL may be used uninitialized. */
1160: yyval = yyvsp[1-yylen];
1161:
1162: #if YYLSP_NEEDED
1163: /* Similarly for the default location. Let the user run additional
1164: commands if for instance locations are ranges. */
1165: yyloc = yylsp[1-yylen];
1166: YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
1167: #endif
1168:
1169: #if YYDEBUG
1170: /* We have to keep this `#if YYDEBUG', since we use variables which
1171: are defined only if `YYDEBUG' is set. */
1172: if (yydebug)
1173: {
1174: int yyi;
1175:
1176: YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
1177: yyn, yyrline[yyn]);
1178:
1179: /* Print the symbols being reduced, and their result. */
1180: for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++)
1181: YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
1182: YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
1183: }
1184: #endif
1185:
1186: switch (yyn) {
1187:
1188: case 5:
1189: #line 174 "calc.y"
1190: { sp = stack[0]; yyerrok; }
1191: break;
1192: case 7:
1193: #line 178 "calc.y"
1194: {
1195: mpz_out_str (stdout, obase, sp); putchar ('\n');
1196: sp--;
1197: CHECK_EMPTY ();
1198: }
1199: break;
1200: case 8:
1201: #line 183 "calc.y"
1202: {
1203: CHECK_VARIABLE (yyvsp[-2].var);
1204: mpz_swap (variable[yyvsp[-2].var], sp);
1205: sp--;
1206: CHECK_EMPTY ();
1207: }
1208: break;
1209: case 9:
1210: #line 189 "calc.y"
1211: { calc_help (); }
1212: break;
1213: case 10:
1214: #line 190 "calc.y"
1215: { ibase = 16; obase = -16; }
1216: break;
1217: case 11:
1218: #line 191 "calc.y"
1219: { ibase = 0; obase = 10; }
1220: break;
1221: case 12:
1222: #line 192 "calc.y"
1223: { exit (0); }
1224: break;
1225: case 14:
1226: #line 199 "calc.y"
1227: { sp--; mpz_add (sp, sp, sp+1); }
1228: break;
1229: case 15:
1230: #line 200 "calc.y"
1231: { sp--; mpz_sub (sp, sp, sp+1); }
1232: break;
1233: case 16:
1234: #line 201 "calc.y"
1235: { sp--; mpz_mul (sp, sp, sp+1); }
1236: break;
1237: case 17:
1238: #line 202 "calc.y"
1239: { sp--; mpz_fdiv_q (sp, sp, sp+1); }
1240: break;
1241: case 18:
1242: #line 203 "calc.y"
1243: { sp--; mpz_fdiv_r (sp, sp, sp+1); }
1244: break;
1245: case 19:
1246: #line 204 "calc.y"
1247: { CHECK_UI ("Exponent", sp);
1248: sp--; mpz_pow_ui (sp, sp, mpz_get_ui (sp+1)); }
1249: break;
1250: case 20:
1251: #line 206 "calc.y"
1252: { CHECK_UI ("Shift count", sp);
1253: sp--; mpz_mul_2exp (sp, sp, mpz_get_ui (sp+1)); }
1254: break;
1255: case 21:
1256: #line 208 "calc.y"
1257: { CHECK_UI ("Shift count", sp);
1258: sp--; mpz_fdiv_q_2exp (sp, sp, mpz_get_ui (sp+1)); }
1259: break;
1260: case 22:
1261: #line 210 "calc.y"
1262: { CHECK_UI ("Factorial", sp);
1263: mpz_fac_ui (sp, mpz_get_ui (sp)); }
1264: break;
1265: case 23:
1266: #line 212 "calc.y"
1267: { mpz_neg (sp, sp); }
1268: break;
1269: case 24:
1270: #line 214 "calc.y"
1271: { sp--; mpz_set_ui (sp, mpz_cmp (sp, sp+1) < 0); }
1272: break;
1273: case 25:
1274: #line 215 "calc.y"
1275: { sp--; mpz_set_ui (sp, mpz_cmp (sp, sp+1) <= 0); }
1276: break;
1277: case 26:
1278: #line 216 "calc.y"
1279: { sp--; mpz_set_ui (sp, mpz_cmp (sp, sp+1) == 0); }
1280: break;
1281: case 27:
1282: #line 217 "calc.y"
1283: { sp--; mpz_set_ui (sp, mpz_cmp (sp, sp+1) != 0); }
1284: break;
1285: case 28:
1286: #line 218 "calc.y"
1287: { sp--; mpz_set_ui (sp, mpz_cmp (sp, sp+1) >= 0); }
1288: break;
1289: case 29:
1290: #line 219 "calc.y"
1291: { sp--; mpz_set_ui (sp, mpz_cmp (sp, sp+1) > 0); }
1292: break;
1293: case 30:
1294: #line 221 "calc.y"
1295: { sp--; mpz_set_ui (sp, mpz_sgn (sp) && mpz_sgn (sp+1)); }
1296: break;
1297: case 31:
1298: #line 222 "calc.y"
1299: { sp--; mpz_set_ui (sp, mpz_sgn (sp) || mpz_sgn (sp+1)); }
1300: break;
1301: case 32:
1302: #line 224 "calc.y"
1303: { mpz_abs (sp, sp); }
1304: break;
1305: case 33:
1306: #line 225 "calc.y"
1307: { sp--; CHECK_UI ("Binomial base", sp+1);
1308: mpz_bin_ui (sp, sp, mpz_get_ui (sp+1)); }
1309: break;
1310: case 34:
1311: #line 227 "calc.y"
1312: { CHECK_UI ("Fibonacci", sp);
1313: mpz_fib_ui (sp, mpz_get_ui (sp)); }
1314: break;
1315: case 36:
1316: #line 230 "calc.y"
1317: { sp--; mpz_set_si (sp,
1318: mpz_kronecker (sp, sp+1)); }
1319: break;
1320: case 38:
1321: #line 233 "calc.y"
1322: { CHECK_UI ("Lucas number", sp);
1323: mpz_lucnum_ui (sp, mpz_get_ui (sp)); }
1324: break;
1325: case 39:
1326: #line 235 "calc.y"
1327: { mpz_nextprime (sp, sp); }
1328: break;
1329: case 40:
1330: #line 236 "calc.y"
1331: { sp -= 2; mpz_powm (sp, sp, sp+1, sp+2); }
1332: break;
1333: case 41:
1334: #line 237 "calc.y"
1335: { sp--; CHECK_UI ("Nth-root", sp+1);
1336: mpz_root (sp, sp, mpz_get_ui (sp+1)); }
1337: break;
1338: case 42:
1339: #line 239 "calc.y"
1340: { mpz_sqrt (sp, sp); }
1341: break;
1342: case 43:
1343: #line 241 "calc.y"
1344: {
1345: sp++;
1346: CHECK_OVERFLOW ();
1347: CHECK_VARIABLE (yyvsp[0].var);
1348: mpz_set (sp, variable[yyvsp[0].var]);
1349: }
1350: break;
1351: case 44:
1352: #line 247 "calc.y"
1353: {
1354: sp++;
1355: CHECK_OVERFLOW ();
1356: if (mpz_set_str (sp, yyvsp[0].str, ibase) != 0)
1357: {
1358: fprintf (stderr, "Invalid number: %s\n", yyvsp[0].str);
1359: YYERROR;
1360: }
1361: }
1362: break;
1363: case 46:
1364: #line 259 "calc.y"
1365: { sp--; mpz_gcd (sp, sp, sp+1); }
1366: break;
1367: case 48:
1368: #line 263 "calc.y"
1369: { sp--; mpz_lcm (sp, sp, sp+1); }
1370: break;
1371: }
1372:
1373: #line 705 "/usr/share/bison/bison.simple"
1374:
1375:
1376: yyvsp -= yylen;
1377: yyssp -= yylen;
1378: #if YYLSP_NEEDED
1379: yylsp -= yylen;
1380: #endif
1381:
1382: #if YYDEBUG
1383: if (yydebug)
1384: {
1385: short *yyssp1 = yyss - 1;
1386: YYFPRINTF (stderr, "state stack now");
1387: while (yyssp1 != yyssp)
1388: YYFPRINTF (stderr, " %d", *++yyssp1);
1389: YYFPRINTF (stderr, "\n");
1390: }
1391: #endif
1392:
1393: *++yyvsp = yyval;
1394: #if YYLSP_NEEDED
1395: *++yylsp = yyloc;
1396: #endif
1397:
1398: /* Now `shift' the result of the reduction. Determine what state
1399: that goes to, based on the state we popped back to and the rule
1400: number reduced by. */
1401:
1402: yyn = yyr1[yyn];
1403:
1404: yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
1405: if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1406: yystate = yytable[yystate];
1407: else
1408: yystate = yydefgoto[yyn - YYNTBASE];
1409:
1410: goto yynewstate;
1411:
1412:
1413: /*------------------------------------.
1414: | yyerrlab -- here on detecting error |
1415: `------------------------------------*/
1416: yyerrlab:
1417: /* If not already recovering from an error, report this error. */
1418: if (!yyerrstatus)
1419: {
1420: ++yynerrs;
1421:
1422: #ifdef YYERROR_VERBOSE
1423: yyn = yypact[yystate];
1424:
1425: if (yyn > YYFLAG && yyn < YYLAST)
1426: {
1427: YYSIZE_T yysize = 0;
1428: char *yymsg;
1429: int yyx, yycount;
1430:
1431: yycount = 0;
1432: /* Start YYX at -YYN if negative to avoid negative indexes in
1433: YYCHECK. */
1434: for (yyx = yyn < 0 ? -yyn : 0;
1435: yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
1436: if (yycheck[yyx + yyn] == yyx)
1437: yysize += yystrlen (yytname[yyx]) + 15, yycount++;
1438: yysize += yystrlen ("parse error, unexpected ") + 1;
1439: yysize += yystrlen (yytname[YYTRANSLATE (yychar)]);
1440: yymsg = (char *) YYSTACK_ALLOC (yysize);
1441: if (yymsg != 0)
1442: {
1443: char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
1444: yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);
1445:
1446: if (yycount < 5)
1447: {
1448: yycount = 0;
1449: for (yyx = yyn < 0 ? -yyn : 0;
1450: yyx < (int) (sizeof (yytname) / sizeof (char *));
1451: yyx++)
1452: if (yycheck[yyx + yyn] == yyx)
1453: {
1454: const char *yyq = ! yycount ? ", expecting " : " or ";
1455: yyp = yystpcpy (yyp, yyq);
1456: yyp = yystpcpy (yyp, yytname[yyx]);
1457: yycount++;
1458: }
1459: }
1460: yyerror (yymsg);
1461: YYSTACK_FREE (yymsg);
1462: }
1463: else
1464: yyerror ("parse error; also virtual memory exhausted");
1465: }
1466: else
1467: #endif /* defined (YYERROR_VERBOSE) */
1468: yyerror ("parse error");
1469: }
1470: goto yyerrlab1;
1471:
1472:
1473: /*--------------------------------------------------.
1474: | yyerrlab1 -- error raised explicitly by an action |
1475: `--------------------------------------------------*/
1476: yyerrlab1:
1477: if (yyerrstatus == 3)
1478: {
1479: /* If just tried and failed to reuse lookahead token after an
1480: error, discard it. */
1481:
1482: /* return failure if at end of input */
1483: if (yychar == YYEOF)
1484: YYABORT;
1485: YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
1486: yychar, yytname[yychar1]));
1487: yychar = YYEMPTY;
1488: }
1489:
1490: /* Else will try to reuse lookahead token after shifting the error
1491: token. */
1492:
1493: yyerrstatus = 3; /* Each real token shifted decrements this */
1494:
1495: goto yyerrhandle;
1496:
1497:
1498: /*-------------------------------------------------------------------.
1499: | yyerrdefault -- current state does not do anything special for the |
1500: | error token. |
1501: `-------------------------------------------------------------------*/
1502: yyerrdefault:
1503: #if 0
1504: /* This is wrong; only states that explicitly want error tokens
1505: should shift them. */
1506:
1507: /* If its default is to accept any token, ok. Otherwise pop it. */
1508: yyn = yydefact[yystate];
1509: if (yyn)
1510: goto yydefault;
1511: #endif
1512:
1513:
1514: /*---------------------------------------------------------------.
1515: | yyerrpop -- pop the current state because it cannot handle the |
1516: | error token |
1517: `---------------------------------------------------------------*/
1518: yyerrpop:
1519: if (yyssp == yyss)
1520: YYABORT;
1521: yyvsp--;
1522: yystate = *--yyssp;
1523: #if YYLSP_NEEDED
1524: yylsp--;
1525: #endif
1526:
1527: #if YYDEBUG
1528: if (yydebug)
1529: {
1530: short *yyssp1 = yyss - 1;
1531: YYFPRINTF (stderr, "Error: state stack now");
1532: while (yyssp1 != yyssp)
1533: YYFPRINTF (stderr, " %d", *++yyssp1);
1534: YYFPRINTF (stderr, "\n");
1535: }
1536: #endif
1537:
1538: /*--------------.
1539: | yyerrhandle. |
1540: `--------------*/
1541: yyerrhandle:
1542: yyn = yypact[yystate];
1543: if (yyn == YYFLAG)
1544: goto yyerrdefault;
1545:
1546: yyn += YYTERROR;
1547: if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
1548: goto yyerrdefault;
1549:
1550: yyn = yytable[yyn];
1551: if (yyn < 0)
1552: {
1553: if (yyn == YYFLAG)
1554: goto yyerrpop;
1555: yyn = -yyn;
1556: goto yyreduce;
1557: }
1558: else if (yyn == 0)
1559: goto yyerrpop;
1560:
1561: if (yyn == YYFINAL)
1562: YYACCEPT;
1563:
1564: YYDPRINTF ((stderr, "Shifting error token, "));
1565:
1566: *++yyvsp = yylval;
1567: #if YYLSP_NEEDED
1568: *++yylsp = yylloc;
1569: #endif
1570:
1571: yystate = yyn;
1572: goto yynewstate;
1573:
1574:
1575: /*-------------------------------------.
1576: | yyacceptlab -- YYACCEPT comes here. |
1577: `-------------------------------------*/
1578: yyacceptlab:
1579: yyresult = 0;
1580: goto yyreturn;
1581:
1582: /*-----------------------------------.
1583: | yyabortlab -- YYABORT comes here. |
1584: `-----------------------------------*/
1585: yyabortlab:
1586: yyresult = 1;
1587: goto yyreturn;
1588:
1589: /*---------------------------------------------.
1590: | yyoverflowab -- parser overflow comes here. |
1591: `---------------------------------------------*/
1592: yyoverflowlab:
1593: yyerror ("parser stack overflow");
1594: yyresult = 2;
1595: /* Fall through. */
1596:
1597: yyreturn:
1598: #ifndef yyoverflow
1599: if (yyss != yyssa)
1600: YYSTACK_FREE (yyss);
1601: #endif
1602: return yyresult;
1603: }
1604: #line 265 "calc.y"
1605:
1606:
1607: yyerror (char *s)
1608: {
1609: fprintf (stderr, "%s\n", s);
1610: }
1611:
1612: int calc_option_readline = -1;
1613:
1614: int
1615: main (int argc, char *argv[])
1616: {
1617: int i;
1618:
1619: for (i = 1; i < argc; i++)
1620: {
1621: if (strcmp (argv[i], "--readline") == 0)
1622: calc_option_readline = 1;
1623: else if (strcmp (argv[i], "--noreadline") == 0)
1624: calc_option_readline = 0;
1625: else if (strcmp (argv[i], "--help") == 0)
1626: {
1627: printf ("Usage: calc [--option]...\n");
1628: printf (" --readline use readline\n");
1629: printf (" --noreadline don't use readline\n");
1630: printf (" --help this message\n");
1631: printf ("Readline is only available when compiled in,\n");
1632: printf ("and in that case it's the default on a tty.\n");
1633: exit (0);
1634: }
1635: else
1636: {
1637: fprintf (stderr, "Unrecognised option: %s\n", argv[i]);
1638: exit (1);
1639: }
1640: }
1641:
1642: #if WITH_READLINE
1643: calc_init_readline ();
1644: #else
1645: if (calc_option_readline == 1)
1646: {
1647: fprintf (stderr, "Readline support not available\n");
1648: exit (1);
1649: }
1650: #endif
1651:
1652: for (i = 0; i < numberof (variable); i++)
1653: mpz_init (variable[i]);
1654:
1655: for (i = 0; i < numberof (stack); i++)
1656: mpz_init (stack[i]);
1657:
1658: return yyparse ();
1659: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to calc.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gmp / demos / calc