"SfR Fresh" - the SfR Freeware/Shareware Archive 
Member "bc-1.06.95/bc/bc.c" of archive bc-1.06.95.tar.gz:
As a special service "SfR Fresh" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting with prefixed line numbers.
Alternatively you can here view or download the uninterpreted source code file.
That can be also achieved for any archive member file by clicking within an archive contents listing on the first character of the file(path) respectively on the according byte size field.
1 /* A Bison parser, made by GNU Bison 2.1. */
2
3 /* Skeleton parser for Yacc-like parsing with Bison,
4 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street, Fifth Floor,
19 Boston, MA 02110-1301, USA. */
20
21 /* As a special exception, when this file is copied by Bison into a
22 Bison output file, you may use that output file without restriction.
23 This special exception was added by the Free Software Foundation
24 in version 1.24 of Bison. */
25
26 /* Written by Richard Stallman by simplifying the original so called
27 ``semantic'' parser. */
28
29 /* All symbols defined below should begin with yy or YY, to avoid
30 infringing on user name space. This should be done even for local
31 variables, as they might otherwise be expanded by user macros.
32 There are some unavoidable exceptions within include files to
33 define necessary library symbols; they are noted "INFRINGES ON
34 USER NAME SPACE" below. */
35
36 /* Identify Bison output. */
37 #define YYBISON 1
38
39 /* Bison version. */
40 #define YYBISON_VERSION "2.1"
41
42 /* Skeleton name. */
43 #define YYSKELETON_NAME "yacc.c"
44
45 /* Pure parsers. */
46 #define YYPURE 0
47
48 /* Using locations. */
49 #define YYLSP_NEEDED 0
50
51
52
53 /* Tokens. */
54 #ifndef YYTOKENTYPE
55 # define YYTOKENTYPE
56 /* Put the tokens into the symbol table, so that GDB and other debuggers
57 know about them. */
58 enum yytokentype {
59 ENDOFLINE = 258,
60 AND = 259,
61 OR = 260,
62 NOT = 261,
63 STRING = 262,
64 NAME = 263,
65 NUMBER = 264,
66 ASSIGN_OP = 265,
67 REL_OP = 266,
68 INCR_DECR = 267,
69 Define = 268,
70 Break = 269,
71 Quit = 270,
72 Length = 271,
73 Return = 272,
74 For = 273,
75 If = 274,
76 While = 275,
77 Sqrt = 276,
78 Else = 277,
79 Scale = 278,
80 Ibase = 279,
81 Obase = 280,
82 Auto = 281,
83 Read = 282,
84 Random = 283,
85 Warranty = 284,
86 Halt = 285,
87 Last = 286,
88 Continue = 287,
89 Print = 288,
90 Limits = 289,
91 UNARY_MINUS = 290,
92 HistoryVar = 291,
93 Void = 292
94 };
95 #endif
96 /* Tokens. */
97 #define ENDOFLINE 258
98 #define AND 259
99 #define OR 260
100 #define NOT 261
101 #define STRING 262
102 #define NAME 263
103 #define NUMBER 264
104 #define ASSIGN_OP 265
105 #define REL_OP 266
106 #define INCR_DECR 267
107 #define Define 268
108 #define Break 269
109 #define Quit 270
110 #define Length 271
111 #define Return 272
112 #define For 273
113 #define If 274
114 #define While 275
115 #define Sqrt 276
116 #define Else 277
117 #define Scale 278
118 #define Ibase 279
119 #define Obase 280
120 #define Auto 281
121 #define Read 282
122 #define Random 283
123 #define Warranty 284
124 #define Halt 285
125 #define Last 286
126 #define Continue 287
127 #define Print 288
128 #define Limits 289
129 #define UNARY_MINUS 290
130 #define HistoryVar 291
131 #define Void 292
132
133
134
135
136 /* Copy the first part of user declarations. */
137 #line 33 "bc.y"
138
139
140 #include "bcdefs.h"
141 #include "global.h"
142 #include "proto.h"
143
144 /* current function number. */
145 int cur_func = -1;
146
147 /* Expression encoded information -- See comment at expression rules. */
148 #define EX_ASSGN 0
149 #define EX_REG 1
150 #define EX_COMP 2
151 #define EX_PAREN 4
152 #define EX_VOID 8
153 #define EX_EMPTY 16
154
155
156
157 /* Enabling traces. */
158 #ifndef YYDEBUG
159 # define YYDEBUG 0
160 #endif
161
162 /* Enabling verbose error messages. */
163 #ifdef YYERROR_VERBOSE
164 # undef YYERROR_VERBOSE
165 # define YYERROR_VERBOSE 1
166 #else
167 # define YYERROR_VERBOSE 0
168 #endif
169
170 /* Enabling the token table. */
171 #ifndef YYTOKEN_TABLE
172 # define YYTOKEN_TABLE 0
173 #endif
174
175 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
176 #line 54 "bc.y"
177 typedef union YYSTYPE {
178 char *s_value;
179 char c_value;
180 int i_value;
181 arg_list *a_value;
182 } YYSTYPE;
183 /* Line 196 of yacc.c. */
184 #line 185 "bc.c"
185 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
186 # define YYSTYPE_IS_DECLARED 1
187 # define YYSTYPE_IS_TRIVIAL 1
188 #endif
189
190
191
192 /* Copy the second part of user declarations. */
193
194
195 /* Line 219 of yacc.c. */
196 #line 197 "bc.c"
197
198 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
199 # define YYSIZE_T __SIZE_TYPE__
200 #endif
201 #if ! defined (YYSIZE_T) && defined (size_t)
202 # define YYSIZE_T size_t
203 #endif
204 #if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus))
205 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
206 # define YYSIZE_T size_t
207 #endif
208 #if ! defined (YYSIZE_T)
209 # define YYSIZE_T unsigned int
210 #endif
211
212 #ifndef YY_
213 # if YYENABLE_NLS
214 # if ENABLE_NLS
215 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
216 # define YY_(msgid) dgettext ("bison-runtime", msgid)
217 # endif
218 # endif
219 # ifndef YY_
220 # define YY_(msgid) msgid
221 # endif
222 #endif
223
224 #if ! defined (yyoverflow) || YYERROR_VERBOSE
225
226 /* The parser invokes alloca or malloc; define the necessary symbols. */
227
228 # ifdef YYSTACK_USE_ALLOCA
229 # if YYSTACK_USE_ALLOCA
230 # ifdef __GNUC__
231 # define YYSTACK_ALLOC __builtin_alloca
232 # else
233 # define YYSTACK_ALLOC alloca
234 # if defined (__STDC__) || defined (__cplusplus)
235 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
236 # define YYINCLUDED_STDLIB_H
237 # endif
238 # endif
239 # endif
240 # endif
241
242 # ifdef YYSTACK_ALLOC
243 /* Pacify GCC's `empty if-body' warning. */
244 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
245 # ifndef YYSTACK_ALLOC_MAXIMUM
246 /* The OS might guarantee only one guard page at the bottom of the stack,
247 and a page size can be as small as 4096 bytes. So we cannot safely
248 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
249 to allow for a few compiler-allocated temporary stack slots. */
250 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
251 # endif
252 # else
253 # define YYSTACK_ALLOC YYMALLOC
254 # define YYSTACK_FREE YYFREE
255 # ifndef YYSTACK_ALLOC_MAXIMUM
256 # define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
257 # endif
258 # ifdef __cplusplus
259 extern "C" {
260 # endif
261 # ifndef YYMALLOC
262 # define YYMALLOC malloc
263 # if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \
264 && (defined (__STDC__) || defined (__cplusplus)))
265 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
266 # endif
267 # endif
268 # ifndef YYFREE
269 # define YYFREE free
270 # if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \
271 && (defined (__STDC__) || defined (__cplusplus)))
272 void free (void *); /* INFRINGES ON USER NAME SPACE */
273 # endif
274 # endif
275 # ifdef __cplusplus
276 }
277 # endif
278 # endif
279 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
280
281
282 #if (! defined (yyoverflow) \
283 && (! defined (__cplusplus) \
284 || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
285
286 /* A type that is properly aligned for any stack member. */
287 union yyalloc
288 {
289 short int yyss;
290 YYSTYPE yyvs;
291 };
292
293 /* The size of the maximum gap between one aligned stack and the next. */
294 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
295
296 /* The size of an array large to enough to hold all stacks, each with
297 N elements. */
298 # define YYSTACK_BYTES(N) \
299 ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \
300 + YYSTACK_GAP_MAXIMUM)
301
302 /* Copy COUNT objects from FROM to TO. The source and destination do
303 not overlap. */
304 # ifndef YYCOPY
305 # if defined (__GNUC__) && 1 < __GNUC__
306 # define YYCOPY(To, From, Count) \
307 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
308 # else
309 # define YYCOPY(To, From, Count) \
310 do \
311 { \
312 YYSIZE_T yyi; \
313 for (yyi = 0; yyi < (Count); yyi++) \
314 (To)[yyi] = (From)[yyi]; \
315 } \
316 while (0)
317 # endif
318 # endif
319
320 /* Relocate STACK from its old location to the new one. The
321 local variables YYSIZE and YYSTACKSIZE give the old and new number of
322 elements in the stack, and YYPTR gives the new location of the
323 stack. Advance YYPTR to a properly aligned location for the next
324 stack. */
325 # define YYSTACK_RELOCATE(Stack) \
326 do \
327 { \
328 YYSIZE_T yynewbytes; \
329 YYCOPY (&yyptr->Stack, Stack, yysize); \
330 Stack = &yyptr->Stack; \
331 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
332 yyptr += yynewbytes / sizeof (*yyptr); \
333 } \
334 while (0)
335
336 #endif
337
338 #if defined (__STDC__) || defined (__cplusplus)
339 typedef signed char yysigned_char;
340 #else
341 typedef short int yysigned_char;
342 #endif
343
344 /* YYFINAL -- State number of the termination state. */
345 #define YYFINAL 2
346 /* YYLAST -- Last index in YYTABLE. */
347 #define YYLAST 719
348
349 /* YYNTOKENS -- Number of terminals. */
350 #define YYNTOKENS 53
351 /* YYNNTS -- Number of nonterminals. */
352 #define YYNNTS 36
353 /* YYNRULES -- Number of rules. */
354 #define YYNRULES 112
355 /* YYNRULES -- Number of states. */
356 #define YYNSTATES 198
357
358 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
359 #define YYUNDEFTOK 2
360 #define YYMAXUTOK 292
361
362 #define YYTRANSLATE(YYX) \
363 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
364
365 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
366 static const unsigned char yytranslate[] =
367 {
368 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
369 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
370 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
371 2, 2, 2, 2, 2, 2, 2, 42, 52, 2,
372 45, 46, 40, 38, 49, 39, 2, 41, 2, 2,
373 2, 2, 2, 2, 2, 2, 2, 2, 2, 44,
374 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
375 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
376 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
377 2, 50, 2, 51, 43, 2, 2, 2, 2, 2,
378 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
379 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
380 2, 2, 2, 47, 2, 48, 2, 2, 2, 2,
381 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
382 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
383 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
384 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
385 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
386 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
387 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
388 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
389 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
390 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
391 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
392 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
393 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
394 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
395 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
396 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
397 35, 36, 37
398 };
399
400 #if YYDEBUG
401 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
402 YYRHS. */
403 static const unsigned short int yyprhs[] =
404 {
405 0, 0, 3, 4, 7, 10, 12, 15, 16, 18,
406 19, 21, 25, 28, 29, 31, 34, 38, 41, 45,
407 47, 50, 52, 54, 56, 58, 60, 62, 64, 66,
408 69, 70, 71, 72, 73, 88, 89, 98, 99, 100,
409 109, 113, 114, 118, 120, 124, 126, 128, 129, 130,
410 135, 136, 150, 151, 153, 154, 156, 157, 161, 165,
411 167, 171, 176, 181, 185, 191, 198, 205, 206, 208,
412 210, 214, 218, 224, 225, 227, 228, 230, 231, 236,
413 237, 242, 243, 248, 251, 255, 259, 263, 267, 271,
414 275, 279, 282, 284, 286, 290, 295, 298, 301, 306,
415 311, 316, 320, 324, 326, 331, 333, 335, 337, 339,
416 341, 342, 344
417 };
418
419 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
420 static const yysigned_char yyrhs[] =
421 {
422 54, 0, -1, -1, 54, 55, -1, 57, 3, -1,
423 73, -1, 1, 3, -1, -1, 3, -1, -1, 59,
424 -1, 57, 44, 59, -1, 57, 44, -1, -1, 59,
425 -1, 58, 3, -1, 58, 3, 59, -1, 58, 44,
426 -1, 58, 44, 60, -1, 60, -1, 1, 60, -1,
427 29, -1, 34, -1, 83, -1, 7, -1, 14, -1,
428 32, -1, 15, -1, 30, -1, 17, 82, -1, -1,
429 -1, -1, -1, 18, 61, 45, 81, 44, 62, 81,
430 44, 63, 81, 46, 64, 56, 60, -1, -1, 19,
431 45, 83, 46, 65, 56, 60, 71, -1, -1, -1,
432 20, 66, 45, 83, 67, 46, 56, 60, -1, 47,
433 58, 48, -1, -1, 33, 68, 69, -1, 70, -1,
434 70, 49, 69, -1, 7, -1, 83, -1, -1, -1,
435 22, 72, 56, 60, -1, -1, 13, 75, 8, 45,
436 76, 46, 56, 47, 88, 77, 74, 58, 48, -1,
437 -1, 37, -1, -1, 78, -1, -1, 26, 78, 3,
438 -1, 26, 78, 44, -1, 8, -1, 8, 50, 51,
439 -1, 40, 8, 50, 51, -1, 52, 8, 50, 51,
440 -1, 78, 49, 8, -1, 78, 49, 8, 50, 51,
441 -1, 78, 49, 40, 8, 50, 51, -1, 78, 49,
442 52, 8, 50, 51, -1, -1, 80, -1, 83, -1,
443 8, 50, 51, -1, 80, 49, 83, -1, 80, 49,
444 8, 50, 51, -1, -1, 83, -1, -1, 83, -1,
445 -1, 87, 10, 84, 83, -1, -1, 83, 4, 85,
446 83, -1, -1, 83, 5, 86, 83, -1, 6, 83,
447 -1, 83, 11, 83, -1, 83, 38, 83, -1, 83,
448 39, 83, -1, 83, 40, 83, -1, 83, 41, 83,
449 -1, 83, 42, 83, -1, 83, 43, 83, -1, 39,
450 83, -1, 87, -1, 9, -1, 45, 83, 46, -1,
451 8, 45, 79, 46, -1, 12, 87, -1, 87, 12,
452 -1, 16, 45, 83, 46, -1, 21, 45, 83, 46,
453 -1, 23, 45, 83, 46, -1, 27, 45, 46, -1,
454 28, 45, 46, -1, 8, -1, 8, 50, 83, 51,
455 -1, 24, -1, 25, -1, 23, -1, 36, -1, 31,
456 -1, -1, 3, -1, 88, 3, -1
457 };
458
459 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
460 static const unsigned short int yyrline[] =
461 {
462 0, 124, 124, 132, 134, 136, 138, 144, 145, 149,
463 150, 151, 152, 155, 156, 157, 158, 159, 160, 162,
464 163, 166, 168, 170, 179, 186, 196, 207, 209, 211,
465 214, 219, 231, 244, 213, 264, 263, 279, 285, 278,
466 299, 302, 301, 305, 306, 308, 314, 321, 323, 322,
467 334, 332, 359, 360, 367, 368, 371, 372, 374, 377,
468 379, 381, 385, 389, 391, 393, 397, 403, 404, 406,
469 414, 420, 428, 446, 450, 453, 459, 474, 473, 503,
470 502, 518, 517, 535, 543, 573, 580, 587, 594, 601,
471 608, 615, 622, 631, 647, 653, 672, 691, 714, 721,
472 728, 735, 741, 748, 750, 758, 760, 762, 764, 768,
473 775, 776, 777
474 };
475 #endif
476
477 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
478 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
479 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
480 static const char *const yytname[] =
481 {
482 "$end", "error", "$undefined", "ENDOFLINE", "AND", "OR", "NOT",
483 "STRING", "NAME", "NUMBER", "ASSIGN_OP", "REL_OP", "INCR_DECR", "Define",
484 "Break", "Quit", "Length", "Return", "For", "If", "While", "Sqrt",
485 "Else", "Scale", "Ibase", "Obase", "Auto", "Read", "Random", "Warranty",
486 "Halt", "Last", "Continue", "Print", "Limits", "UNARY_MINUS",
487 "HistoryVar", "Void", "'+'", "'-'", "'*'", "'/'", "'%'", "'^'", "';'",
488 "'('", "')'", "'{'", "'}'", "','", "'['", "']'", "'&'", "$accept",
489 "program", "input_item", "opt_newline", "semicolon_list",
490 "statement_list", "statement_or_error", "statement", "@1", "@2", "@3",
491 "@4", "@5", "@6", "@7", "@8", "print_list", "print_element", "opt_else",
492 "@9", "function", "@10", "opt_void", "opt_parameter_list",
493 "opt_auto_define_list", "define_list", "opt_argument_list",
494 "argument_list", "opt_expression", "return_expression", "expression",
495 "@11", "@12", "@13", "named_expression", "required_eol", 0
496 };
497 #endif
498
499 # ifdef YYPRINT
500 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
501 token YYLEX-NUM. */
502 static const unsigned short int yytoknum[] =
503 {
504 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
505 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
506 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
507 285, 286, 287, 288, 289, 290, 291, 292, 43, 45,
508 42, 47, 37, 94, 59, 40, 41, 123, 125, 44,
509 91, 93, 38
510 };
511 # endif
512
513 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
514 static const unsigned char yyr1[] =
515 {
516 0, 53, 54, 54, 55, 55, 55, 56, 56, 57,
517 57, 57, 57, 58, 58, 58, 58, 58, 58, 59,
518 59, 60, 60, 60, 60, 60, 60, 60, 60, 60,
519 61, 62, 63, 64, 60, 65, 60, 66, 67, 60,
520 60, 68, 60, 69, 69, 70, 70, 71, 72, 71,
521 74, 73, 75, 75, 76, 76, 77, 77, 77, 78,
522 78, 78, 78, 78, 78, 78, 78, 79, 79, 80,
523 80, 80, 80, 81, 81, 82, 82, 84, 83, 85,
524 83, 86, 83, 83, 83, 83, 83, 83, 83, 83,
525 83, 83, 83, 83, 83, 83, 83, 83, 83, 83,
526 83, 83, 83, 87, 87, 87, 87, 87, 87, 87,
527 88, 88, 88
528 };
529
530 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
531 static const unsigned char yyr2[] =
532 {
533 0, 2, 0, 2, 2, 1, 2, 0, 1, 0,
534 1, 3, 2, 0, 1, 2, 3, 2, 3, 1,
535 2, 1, 1, 1, 1, 1, 1, 1, 1, 2,
536 0, 0, 0, 0, 14, 0, 8, 0, 0, 8,
537 3, 0, 3, 1, 3, 1, 1, 0, 0, 4,
538 0, 13, 0, 1, 0, 1, 0, 3, 3, 1,
539 3, 4, 4, 3, 5, 6, 6, 0, 1, 1,
540 3, 3, 5, 0, 1, 0, 1, 0, 4, 0,
541 4, 0, 4, 2, 3, 3, 3, 3, 3, 3,
542 3, 2, 1, 1, 3, 4, 2, 2, 4, 4,
543 4, 3, 3, 1, 4, 1, 1, 1, 1, 1,
544 0, 1, 2
545 };
546
547 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
548 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
549 means the default is an error. */
550 static const unsigned char yydefact[] =
551 {
552 2, 0, 1, 0, 0, 24, 103, 93, 0, 52,
553 25, 27, 0, 75, 30, 0, 37, 0, 107, 105,
554 106, 0, 0, 21, 28, 109, 26, 41, 22, 108,
555 0, 0, 0, 3, 0, 10, 19, 5, 23, 92,
556 6, 20, 83, 67, 0, 103, 107, 96, 53, 0,
557 0, 29, 76, 0, 0, 0, 0, 0, 0, 0,
558 0, 91, 0, 0, 0, 14, 4, 0, 79, 81,
559 0, 0, 0, 0, 0, 0, 0, 77, 97, 103,
560 0, 68, 69, 0, 0, 0, 73, 0, 0, 0,
561 0, 101, 102, 45, 42, 43, 46, 94, 0, 17,
562 40, 11, 0, 0, 84, 85, 86, 87, 88, 89,
563 90, 0, 0, 95, 0, 104, 54, 98, 0, 74,
564 35, 38, 99, 100, 0, 16, 18, 80, 82, 78,
565 70, 103, 71, 59, 0, 0, 0, 55, 31, 7,
566 0, 44, 0, 0, 0, 0, 7, 0, 73, 8,
567 0, 7, 72, 60, 0, 0, 0, 63, 0, 0,
568 0, 47, 0, 61, 62, 110, 0, 0, 0, 32,
569 48, 36, 39, 111, 56, 64, 0, 0, 73, 7,
570 112, 0, 50, 65, 66, 0, 0, 0, 0, 33,
571 49, 57, 58, 0, 7, 51, 0, 34
572 };
573
574 /* YYDEFGOTO[NTERM-NUM]. */
575 static const short int yydefgoto[] =
576 {
577 -1, 1, 33, 150, 34, 64, 65, 36, 53, 148,
578 178, 194, 139, 55, 140, 60, 94, 95, 171, 179,
579 37, 188, 49, 136, 182, 137, 80, 81, 118, 51,
580 38, 111, 102, 103, 39, 174
581 };
582
583 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
584 STATE-NUM. */
585 #define YYPACT_NINF -144
586 static const short int yypact[] =
587 {
588 -144, 188, -144, 392, 595, -144, -36, -144, 484, -31,
589 -144, -144, -32, 595, -144, -11, -144, -10, -7, -144,
590 -144, -6, -5, -144, -144, -144, -144, -144, -144, -144,
591 595, 595, 222, -144, 2, -144, -144, -144, 676, 14,
592 -144, -144, 131, 621, 595, -27, -144, -144, -144, 54,
593 595, -144, 676, 20, 595, 21, 595, 595, 13, 37,
594 569, -144, 425, 535, 1, -144, -144, 318, -144, -144,
595 595, 595, 595, 595, 595, 595, 595, -144, -144, -23,
596 41, 36, 676, 39, 43, 436, 595, 445, 595, 485,
597 494, -144, -144, -144, -144, 40, 676, -144, 270, 535,
598 -144, -144, 595, 595, -22, 51, 51, 4, 4, 4,
599 4, 595, 105, -144, 647, -144, 23, -144, 53, 676,
600 -144, 676, -144, -144, 569, -144, -144, 131, 123, -22,
601 -144, -20, 676, 45, 91, 94, 57, 55, -144, 102,
602 60, -144, 352, 56, 58, 65, 102, 24, 595, -144,
603 535, 102, -144, -144, 67, 68, 69, 70, 115, 116,
604 81, 109, 535, -144, -144, 132, 86, 88, 89, -144,
605 -144, -144, -144, -144, 7, -144, 92, 97, 595, 102,
606 -144, 23, -144, -144, -144, 99, 535, 12, 222, -144,
607 -144, -144, -144, 9, 102, -144, 535, -144
608 };
609
610 /* YYPGOTO[NTERM-NUM]. */
611 static const short int yypgoto[] =
612 {
613 -144, -144, -144, -143, -144, -39, 0, -3, -144, -144,
614 -144, -144, -144, -144, -144, -144, 27, -144, -144, -144,
615 -144, -144, -144, -144, -144, -29, -144, -144, -141, -144,
616 -2, -144, -144, -144, 145, -144
617 };
618
619 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
620 positive, shift that token. If negative, reduce the rule which
621 number is the opposite. If zero, do what YYDEFACT says.
622 If YYTABLE_NINF, syntax error. */
623 #define YYTABLE_NINF -16
624 static const short int yytable[] =
625 {
626 41, 35, 42, 156, 98, 66, 48, 160, 162, 43,
627 180, 52, 98, 50, 44, 191, 71, 72, 73, 74,
628 75, 76, 43, 44, 77, 43, 78, 112, 61, 62,
629 142, 133, 157, 181, 54, 56, 186, 185, 57, 58,
630 59, 82, 83, 68, 69, 99, 67, 76, 85, 100,
631 70, 196, 87, 99, 89, 90, 192, 195, 96, 91,
632 41, 147, 84, 134, 158, 86, 88, 101, 104, 105,
633 106, 107, 108, 109, 110, 135, 159, 71, 72, 73,
634 74, 75, 76, 92, 119, 114, 121, 113, 116, 124,
635 115, 73, 74, 75, 76, 143, 126, 138, 125, 144,
636 127, 128, 145, 146, 147, 149, 151, 153, 154, 129,
637 83, 4, 132, 6, 7, 155, 165, 8, 163, 164,
638 166, 12, 96, 167, 168, 169, 17, 68, 18, 19,
639 20, 170, 21, 22, 70, 173, 25, 175, 176, 177,
640 83, 29, 70, 183, 30, 189, 119, 161, 184, 193,
641 31, 141, 187, 47, 0, 0, 130, 0, 0, 172,
642 0, 71, 72, 73, 74, 75, 76, 0, 0, 71,
643 72, 73, 74, 75, 76, 0, 119, 0, 0, 0,
644 0, 0, 0, 190, 0, 0, 0, 0, 2, 3,
645 0, -9, 0, 197, 4, 5, 6, 7, 0, 0,
646 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
647 0, 18, 19, 20, 0, 21, 22, 23, 24, 25,
648 26, 27, 28, 63, 29, -13, 0, 30, 4, 5,
649 6, 7, -9, 31, 8, 32, 10, 11, 12, 13,
650 14, 15, 16, 17, 0, 18, 19, 20, 0, 21,
651 22, 23, 24, 25, 26, 27, 28, 0, 29, 0,
652 0, 30, 0, 0, 0, 0, -13, 31, 0, 32,
653 -13, 63, 0, -15, 0, 0, 4, 5, 6, 7,
654 0, 0, 8, 0, 10, 11, 12, 13, 14, 15,
655 16, 17, 0, 18, 19, 20, 0, 21, 22, 23,
656 24, 25, 26, 27, 28, 0, 29, 0, 0, 30,
657 0, 0, 0, 0, -15, 31, 0, 32, -15, 63,
658 0, -12, 0, 0, 4, 5, 6, 7, 0, 0,
659 8, 0, 10, 11, 12, 13, 14, 15, 16, 17,
660 0, 18, 19, 20, 0, 21, 22, 23, 24, 25,
661 26, 27, 28, 0, 29, 0, 0, 30, 4, 0,
662 6, 7, -12, 31, 8, 32, 0, 0, 12, 0,
663 0, 0, 0, 17, 0, 18, 19, 20, 0, 21,
664 22, 0, 0, 25, 0, 0, 0, 0, 29, 0,
665 0, 30, 0, 0, 0, 40, 0, 31, 4, 5,
666 6, 7, 0, 152, 8, 0, 10, 11, 12, 13,
667 14, 15, 16, 17, 0, 18, 19, 20, 0, 21,
668 22, 23, 24, 25, 26, 27, 28, 0, 29, 68,
669 69, 30, 0, 0, 0, 0, 70, 31, 0, 32,
670 68, 69, 0, 0, 0, 0, 0, 70, 0, 68,
671 69, 0, 0, 0, 0, 0, 70, 0, 0, 0,
672 0, 0, 0, 71, 72, 73, 74, 75, 76, 0,
673 0, 97, 0, 0, 71, 72, 73, 74, 75, 76,
674 0, 0, 117, 71, 72, 73, 74, 75, 76, 68,
675 69, 120, 45, 0, 0, 0, 70, 0, 68, 69,
676 0, 0, 0, 0, 0, 70, 0, 46, 19, 20,
677 0, 0, 0, 0, 0, 25, 0, 0, 0, 0,
678 29, 0, 0, 71, 72, 73, 74, 75, 76, 0,
679 0, 122, 71, 72, 73, 74, 75, 76, 0, 0,
680 123, 4, 5, 6, 7, 0, 0, 8, 0, 10,
681 11, 12, 13, 14, 15, 16, 17, 0, 18, 19,
682 20, 0, 21, 22, 23, 24, 25, 26, 27, 28,
683 0, 29, 0, 0, 30, 4, 93, 6, 7, 0,
684 31, 8, 32, 0, 0, 12, 0, 0, 0, 0,
685 17, 0, 18, 19, 20, 0, 21, 22, 0, 0,
686 25, 4, 0, 6, 7, 29, 0, 8, 30, 0,
687 0, 12, 0, 0, 31, 0, 17, 0, 18, 19,
688 20, 0, 21, 22, 0, 0, 25, 4, 0, 79,
689 7, 29, 0, 8, 30, 0, 0, 12, 0, 0,
690 31, 0, 17, 0, 18, 19, 20, 0, 21, 22,
691 0, 0, 25, 4, 0, 131, 7, 29, 0, 8,
692 30, 0, 0, 12, 0, 0, 31, 0, 17, 0,
693 18, 19, 20, 0, 21, 22, 0, 0, 25, 0,
694 68, 69, 0, 29, 0, 0, 30, 70, 0, 0,
695 0, 0, 31, 0, 0, 0, 0, 0, 0, 0,
696 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
697 0, 0, 0, 0, 71, 72, 73, 74, 75, 76
698 };
699
700 static const short int yycheck[] =
701 {
702 3, 1, 4, 146, 3, 3, 37, 148, 151, 45,
703 3, 13, 3, 45, 50, 3, 38, 39, 40, 41,
704 42, 43, 45, 50, 10, 45, 12, 50, 30, 31,
705 50, 8, 8, 26, 45, 45, 179, 178, 45, 45,
706 45, 43, 44, 4, 5, 44, 44, 43, 50, 48,
707 11, 194, 54, 44, 56, 57, 44, 48, 60, 46,
708 63, 49, 8, 40, 40, 45, 45, 67, 70, 71,
709 72, 73, 74, 75, 76, 52, 52, 38, 39, 40,
710 41, 42, 43, 46, 86, 49, 88, 46, 45, 49,
711 51, 40, 41, 42, 43, 50, 99, 44, 98, 8,
712 102, 103, 8, 46, 49, 3, 46, 51, 50, 111,
713 112, 6, 114, 8, 9, 50, 47, 12, 51, 51,
714 50, 16, 124, 8, 8, 44, 21, 4, 23, 24,
715 25, 22, 27, 28, 11, 3, 31, 51, 50, 50,
716 142, 36, 11, 51, 39, 46, 148, 150, 51, 188,
717 45, 124, 181, 8, -1, -1, 51, -1, -1, 162,
718 -1, 38, 39, 40, 41, 42, 43, -1, -1, 38,
719 39, 40, 41, 42, 43, -1, 178, -1, -1, -1,
720 -1, -1, -1, 186, -1, -1, -1, -1, 0, 1,
721 -1, 3, -1, 196, 6, 7, 8, 9, -1, -1,
722 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
723 -1, 23, 24, 25, -1, 27, 28, 29, 30, 31,
724 32, 33, 34, 1, 36, 3, -1, 39, 6, 7,
725 8, 9, 44, 45, 12, 47, 14, 15, 16, 17,
726 18, 19, 20, 21, -1, 23, 24, 25, -1, 27,
727 28, 29, 30, 31, 32, 33, 34, -1, 36, -1,
728 -1, 39, -1, -1, -1, -1, 44, 45, -1, 47,
729 48, 1, -1, 3, -1, -1, 6, 7, 8, 9,
730 -1, -1, 12, -1, 14, 15, 16, 17, 18, 19,
731 20, 21, -1, 23, 24, 25, -1, 27, 28, 29,
732 30, 31, 32, 33, 34, -1, 36, -1, -1, 39,
733 -1, -1, -1, -1, 44, 45, -1, 47, 48, 1,
734 -1, 3, -1, -1, 6, 7, 8, 9, -1, -1,
735 12, -1, 14, 15, 16, 17, 18, 19, 20, 21,
736 -1, 23, 24, 25, -1, 27, 28, 29, 30, 31,
737 32, 33, 34, -1, 36, -1, -1, 39, 6, -1,
738 8, 9, 44, 45, 12, 47, -1, -1, 16, -1,
739 -1, -1, -1, 21, -1, 23, 24, 25, -1, 27,
740 28, -1, -1, 31, -1, -1, -1, -1, 36, -1,
741 -1, 39, -1, -1, -1, 3, -1, 45, 6, 7,
742 8, 9, -1, 51, 12, -1, 14, 15, 16, 17,
743 18, 19, 20, 21, -1, 23, 24, 25, -1, 27,
744 28, 29, 30, 31, 32, 33, 34, -1, 36, 4,
745 5, 39, -1, -1, -1, -1, 11, 45, -1, 47,
746 4, 5, -1, -1, -1, -1, -1, 11, -1, 4,
747 5, -1, -1, -1, -1, -1, 11, -1, -1, -1,
748 -1, -1, -1, 38, 39, 40, 41, 42, 43, -1,
749 -1, 46, -1, -1, 38, 39, 40, 41, 42, 43,
750 -1, -1, 46, 38, 39, 40, 41, 42, 43, 4,
751 5, 46, 8, -1, -1, -1, 11, -1, 4, 5,
752 -1, -1, -1, -1, -1, 11, -1, 23, 24, 25,
753 -1, -1, -1, -1, -1, 31, -1, -1, -1, -1,
754 36, -1, -1, 38, 39, 40, 41, 42, 43, -1,
755 -1, 46, 38, 39, 40, 41, 42, 43, -1, -1,
756 46, 6, 7, 8, 9, -1, -1, 12, -1, 14,
757 15, 16, 17, 18, 19, 20, 21, -1, 23, 24,
758 25, -1, 27, 28, 29, 30, 31, 32, 33, 34,
759 -1, 36, -1, -1, 39, 6, 7, 8, 9, -1,
760 45, 12, 47, -1, -1, 16, -1, -1, -1, -1,
761 21, -1, 23, 24, 25, -1, 27, 28, -1, -1,
762 31, 6, -1, 8, 9, 36, -1, 12, 39, -1,
763 -1, 16, -1, -1, 45, -1, 21, -1, 23, 24,
764 25, -1, 27, 28, -1, -1, 31, 6, -1, 8,
765 9, 36, -1, 12, 39, -1, -1, 16, -1, -1,
766 45, -1, 21, -1, 23, 24, 25, -1, 27, 28,
767 -1, -1, 31, 6, -1, 8, 9, 36, -1, 12,
768 39, -1, -1, 16, -1, -1, 45, -1, 21, -1,
769 23, 24, 25, -1, 27, 28, -1, -1, 31, -1,
770 4, 5, -1, 36, -1, -1, 39, 11, -1, -1,
771 -1, -1, 45, -1, -1, -1, -1, -1, -1, -1,
772 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
773 -1, -1, -1, -1, 38, 39, 40, 41, 42, 43
774 };
775
776 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
777 symbol of state STATE-NUM. */
778 static const unsigned char yystos[] =
779 {
780 0, 54, 0, 1, 6, 7, 8, 9, 12, 13,
781 14, 15, 16, 17, 18, 19, 20, 21, 23, 24,
782 25, 27, 28, 29, 30, 31, 32, 33, 34, 36,
783 39, 45, 47, 55, 57, 59, 60, 73, 83, 87,
784 3, 60, 83, 45, 50, 8, 23, 87, 37, 75,
785 45, 82, 83, 61, 45, 66, 45, 45, 45, 45,
786 68, 83, 83, 1, 58, 59, 3, 44, 4, 5,
787 11, 38, 39, 40, 41, 42, 43, 10, 12, 8,
788 79, 80, 83, 83, 8, 83, 45, 83, 45, 83,
789 83, 46, 46, 7, 69, 70, 83, 46, 3, 44,
790 48, 59, 85, 86, 83, 83, 83, 83, 83, 83,
791 83, 84, 50, 46, 49, 51, 45, 46, 81, 83,
792 46, 83, 46, 46, 49, 59, 60, 83, 83, 83,
793 51, 8, 83, 8, 40, 52, 76, 78, 44, 65,
794 67, 69, 50, 50, 8, 8, 46, 49, 62, 3,
795 56, 46, 51, 51, 50, 50, 56, 8, 40, 52,
796 81, 60, 56, 51, 51, 47, 50, 8, 8, 44,
797 22, 71, 60, 3, 88, 51, 50, 50, 63, 72,
798 3, 26, 77, 51, 51, 81, 56, 78, 74, 46,
799 60, 3, 44, 58, 64, 48, 56, 60
800 };
801
802 #define yyerrok (yyerrstatus = 0)
803 #define yyclearin (yychar = YYEMPTY)
804 #define YYEMPTY (-2)
805 #define YYEOF 0
806
807 #define YYACCEPT goto yyacceptlab
808 #define YYABORT goto yyabortlab
809 #define YYERROR goto yyerrorlab
810
811
812 /* Like YYERROR except do call yyerror. This remains here temporarily
813 to ease the transition to the new meaning of YYERROR, for GCC.
814 Once GCC version 2 has supplanted version 1, this can go. */
815
816 #define YYFAIL goto yyerrlab
817
818 #define YYRECOVERING() (!!yyerrstatus)
819
820 #define YYBACKUP(Token, Value) \
821 do \
822 if (yychar == YYEMPTY && yylen == 1) \
823 { \
824 yychar = (Token); \
825 yylval = (Value); \
826 yytoken = YYTRANSLATE (yychar); \
827 YYPOPSTACK; \
828 goto yybackup; \
829 } \
830 else \
831 { \
832 yyerror (YY_("syntax error: cannot back up")); \
833 YYERROR; \
834 } \
835 while (0)
836
837
838 #define YYTERROR 1
839 #define YYERRCODE 256
840
841
842 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
843 If N is 0, then set CURRENT to the empty location which ends
844 the previous symbol: RHS[0] (always defined). */
845
846 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
847 #ifndef YYLLOC_DEFAULT
848 # define YYLLOC_DEFAULT(Current, Rhs, N) \
849 do \
850 if (N) \
851 { \
852 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
853 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
854 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
855 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
856 } \
857 else \
858 { \
859 (Current).first_line = (Current).last_line = \
860 YYRHSLOC (Rhs, 0).last_line; \
861 (Current).first_column = (Current).last_column = \
862 YYRHSLOC (Rhs, 0).last_column; \
863 } \
864 while (0)
865 #endif
866
867
868 /* YY_LOCATION_PRINT -- Print the location on the stream.
869 This macro was not mandated originally: define only if we know
870 we won't break user code: when these are the locations we know. */
871
872 #ifndef YY_LOCATION_PRINT
873 # if YYLTYPE_IS_TRIVIAL
874 # define YY_LOCATION_PRINT(File, Loc) \
875 fprintf (File, "%d.%d-%d.%d", \
876 (Loc).first_line, (Loc).first_column, \
877 (Loc).last_line, (Loc).last_column)
878 # else
879 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
880 # endif
881 #endif
882
883
884 /* YYLEX -- calling `yylex' with the right arguments. */
885
886 #ifdef YYLEX_PARAM
887 # define YYLEX yylex (YYLEX_PARAM)
888 #else
889 # define YYLEX yylex ()
890 #endif
891
892 /* Enable debugging if requested. */
893 #if YYDEBUG
894
895 # ifndef YYFPRINTF
896 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
897 # define YYFPRINTF fprintf
898 # endif
899
900 # define YYDPRINTF(Args) \
901 do { \
902 if (yydebug) \
903 YYFPRINTF Args; \
904 } while (0)
905
906 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
907 do { \
908 if (yydebug) \
909 { \
910 YYFPRINTF (stderr, "%s ", Title); \
911 yysymprint (stderr, \
912 Type, Value); \
913 YYFPRINTF (stderr, "\n"); \
914 } \
915 } while (0)
916
917 /*------------------------------------------------------------------.
918 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
919 | TOP (included). |
920 `------------------------------------------------------------------*/
921
922 #if defined (__STDC__) || defined (__cplusplus)
923 static void
924 yy_stack_print (short int *bottom, short int *top)
925 #else
926 static void
927 yy_stack_print (bottom, top)
928 short int *bottom;
929 short int *top;
930 #endif
931 {
932 YYFPRINTF (stderr, "Stack now");
933 for (/* Nothing. */; bottom <= top; ++bottom)
934 YYFPRINTF (stderr, " %d", *bottom);
935 YYFPRINTF (stderr, "\n");
936 }
937
938 # define YY_STACK_PRINT(Bottom, Top) \
939 do { \
940 if (yydebug) \
941 yy_stack_print ((Bottom), (Top)); \
942 } while (0)
943
944
945 /*------------------------------------------------.
946 | Report that the YYRULE is going to be reduced. |
947 `------------------------------------------------*/
948
949 #if defined (__STDC__) || defined (__cplusplus)
950 static void
951 yy_reduce_print (int yyrule)
952 #else
953 static void
954 yy_reduce_print (yyrule)
955 int yyrule;
956 #endif
957 {
958 int yyi;
959 unsigned long int yylno = yyrline[yyrule];
960 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
961 yyrule - 1, yylno);
962 /* Print the symbols being reduced, and their result. */
963 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
964 YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
965 YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);
966 }
967
968 # define YY_REDUCE_PRINT(Rule) \
969 do { \
970 if (yydebug) \
971 yy_reduce_print (Rule); \
972 } while (0)
973
974 /* Nonzero means print parse trace. It is left uninitialized so that
975 multiple parsers can coexist. */
976 int yydebug;
977 #else /* !YYDEBUG */
978 # define YYDPRINTF(Args)
979 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
980 # define YY_STACK_PRINT(Bottom, Top)
981 # define YY_REDUCE_PRINT(Rule)
982 #endif /* !YYDEBUG */
983
984
985 /* YYINITDEPTH -- initial size of the parser's stacks. */
986 #ifndef YYINITDEPTH
987 # define YYINITDEPTH 200
988 #endif
989
990 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
991 if the built-in stack extension method is used).
992
993 Do not make this value too large; the results are undefined if
994 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
995 evaluated with infinite-precision integer arithmetic. */
996
997 #ifndef YYMAXDEPTH
998 # define YYMAXDEPTH 10000
999 #endif
1000
1001
1002
1003 #if YYERROR_VERBOSE
1004
1005 # ifndef yystrlen
1006 # if defined (__GLIBC__) && defined (_STRING_H)
1007 # define yystrlen strlen
1008 # else
1009 /* Return the length of YYSTR. */
1010 static YYSIZE_T
1011 # if defined (__STDC__) || defined (__cplusplus)
1012 yystrlen (const char *yystr)
1013 # else
1014 yystrlen (yystr)
1015 const char *yystr;
1016 # endif
1017 {
1018 const char *yys = yystr;
1019
1020 while (*yys++ != '\0')
1021 continue;
1022
1023 return yys - yystr - 1;
1024 }
1025 # endif
1026 # endif
1027
1028 # ifndef yystpcpy
1029 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
1030 # define yystpcpy stpcpy
1031 # else
1032 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1033 YYDEST. */
1034 static char *
1035 # if defined (__STDC__) || defined (__cplusplus)
1036 yystpcpy (char *yydest, const char *yysrc)
1037 # else
1038 yystpcpy (yydest, yysrc)
1039 char *yydest;
1040 const char *yysrc;
1041 # endif
1042 {
1043 char *yyd = yydest;
1044 const char *yys = yysrc;
1045
1046 while ((*yyd++ = *yys++) != '\0')
1047 continue;
1048
1049 return yyd - 1;
1050 }
1051 # endif
1052 # endif
1053
1054 # ifndef yytnamerr
1055 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1056 quotes and backslashes, so that it's suitable for yyerror. The
1057 heuristic is that double-quoting is unnecessary unless the string
1058 contains an apostrophe, a comma, or backslash (other than
1059 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1060 null, do not copy; instead, return the length of what the result
1061 would have been. */
1062 static YYSIZE_T
1063 yytnamerr (char *yyres, const char *yystr)
1064 {
1065 if (*yystr == '"')
1066 {
1067 size_t yyn = 0;
1068 char const *yyp = yystr;
1069
1070 for (;;)
1071 switch (*++yyp)
1072 {
1073 case '\'':
1074 case ',':
1075 goto do_not_strip_quotes;
1076
1077 case '\\':
1078 if (*++yyp != '\\')
1079 goto do_not_strip_quotes;
1080 /* Fall through. */
1081 default:
1082 if (yyres)
1083 yyres[yyn] = *yyp;
1084 yyn++;
1085 break;
1086
1087 case '"':
1088 if (yyres)
1089 yyres[yyn] = '\0';
1090 return yyn;
1091 }
1092 do_not_strip_quotes: ;
1093 }
1094
1095 if (! yyres)
1096 return yystrlen (yystr);
1097
1098 return yystpcpy (yyres, yystr) - yyres;
1099 }
1100 # endif
1101
1102 #endif /* YYERROR_VERBOSE */
1103
1104
1105
1106 #if YYDEBUG
1107 /*--------------------------------.
1108 | Print this symbol on YYOUTPUT. |
1109 `--------------------------------*/
1110
1111 #if defined (__STDC__) || defined (__cplusplus)
1112 static void
1113 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
1114 #else
1115 static void
1116 yysymprint (yyoutput, yytype, yyvaluep)
1117 FILE *yyoutput;
1118 int yytype;
1119 YYSTYPE *yyvaluep;
1120 #endif
1121 {
1122 /* Pacify ``unused variable'' warnings. */
1123 (void) yyvaluep;
1124
1125 if (yytype < YYNTOKENS)
1126 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1127 else
1128 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1129
1130
1131 # ifdef YYPRINT
1132 if (yytype < YYNTOKENS)
1133 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1134 # endif
1135 switch (yytype)
1136 {
1137 default:
1138 break;
1139 }
1140 YYFPRINTF (yyoutput, ")");
1141 }
1142
1143 #endif /* ! YYDEBUG */
1144 /*-----------------------------------------------.
1145 | Release the memory associated to this symbol. |
1146 `-----------------------------------------------*/
1147
1148 #if defined (__STDC__) || defined (__cplusplus)
1149 static void
1150 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1151 #else
1152 static void
1153 yydestruct (yymsg, yytype, yyvaluep)
1154 const char *yymsg;
1155 int yytype;
1156 YYSTYPE *yyvaluep;
1157 #endif
1158 {
1159 /* Pacify ``unused variable'' warnings. */
1160 (void) yyvaluep;
1161
1162 if (!yymsg)
1163 yymsg = "Deleting";
1164 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1165
1166 switch (yytype)
1167 {
1168
1169 default:
1170 break;
1171 }
1172 }
1173
1174
1175 /* Prevent warnings from -Wmissing-prototypes. */
1176
1177 #ifdef YYPARSE_PARAM
1178 # if defined (__STDC__) || defined (__cplusplus)
1179 int yyparse (void *YYPARSE_PARAM);
1180 # else
1181 int yyparse ();
1182 # endif
1183 #else /* ! YYPARSE_PARAM */
1184 #if defined (__STDC__) || defined (__cplusplus)
1185 int yyparse (void);
1186 #else
1187 int yyparse ();
1188 #endif
1189 #endif /* ! YYPARSE_PARAM */
1190
1191
1192
1193 /* The look-ahead symbol. */
1194 int yychar;
1195
1196 /* The semantic value of the look-ahead symbol. */
1197 YYSTYPE yylval;
1198
1199 /* Number of syntax errors so far. */
1200 int yynerrs;
1201
1202
1203
1204 /*----------.
1205 | yyparse. |
1206 `----------*/
1207
1208 #ifdef YYPARSE_PARAM
1209 # if defined (__STDC__) || defined (__cplusplus)
1210 int yyparse (void *YYPARSE_PARAM)
1211 # else
1212 int yyparse (YYPARSE_PARAM)
1213 void *YYPARSE_PARAM;
1214 # endif
1215 #else /* ! YYPARSE_PARAM */
1216 #if defined (__STDC__) || defined (__cplusplus)
1217 int
1218 yyparse (void)
1219 #else
1220 int
1221 yyparse ()
1222 ;
1223 #endif
1224 #endif
1225 {
1226
1227 int yystate;
1228 int yyn;
1229 int yyresult;
1230 /* Number of tokens to shift before error messages enabled. */
1231 int yyerrstatus;
1232 /* Look-ahead token as an internal (translated) token number. */
1233 int yytoken = 0;
1234
1235 /* Three stacks and their tools:
1236 `yyss': related to states,
1237 `yyvs': related to semantic values,
1238 `yyls': related to locations.
1239
1240 Refer to the stacks thru separate pointers, to allow yyoverflow
1241 to reallocate them elsewhere. */
1242
1243 /* The state stack. */
1244 short int yyssa[YYINITDEPTH];
1245 short int *yyss = yyssa;
1246 short int *yyssp;
1247
1248 /* The semantic value stack. */
1249 YYSTYPE yyvsa[YYINITDEPTH];
1250 YYSTYPE *yyvs = yyvsa;
1251 YYSTYPE *yyvsp;
1252
1253
1254
1255 #define YYPOPSTACK (yyvsp--, yyssp--)
1256
1257 YYSIZE_T yystacksize = YYINITDEPTH;
1258
1259 /* The variables used to return semantic value and location from the
1260 action routines. */
1261 YYSTYPE yyval;
1262
1263
1264 /* When reducing, the number of symbols on the RHS of the reduced
1265 rule. */
1266 int yylen;
1267
1268 YYDPRINTF ((stderr, "Starting parse\n"));
1269
1270 yystate = 0;
1271 yyerrstatus = 0;
1272 yynerrs = 0;
1273 yychar = YYEMPTY; /* Cause a token to be read. */
1274
1275 /* Initialize stack pointers.
1276 Waste one element of value and location stack
1277 so that they stay on the same level as the state stack.
1278 The wasted elements are never initialized. */
1279
1280 yyssp = yyss;
1281 yyvsp = yyvs;
1282
1283 goto yysetstate;
1284
1285 /*------------------------------------------------------------.
1286 | yynewstate -- Push a new state, which is found in yystate. |
1287 `------------------------------------------------------------*/
1288 yynewstate:
1289 /* In all cases, when you get here, the value and location stacks
1290 have just been pushed. so pushing a state here evens the stacks.
1291 */
1292 yyssp++;
1293
1294 yysetstate:
1295 *yyssp = yystate;
1296
1297 if (yyss + yystacksize - 1 <= yyssp)
1298 {
1299 /* Get the current used size of the three stacks, in elements. */
1300 YYSIZE_T yysize = yyssp - yyss + 1;
1301
1302 #ifdef yyoverflow
1303 {
1304 /* Give user a chance to reallocate the stack. Use copies of
1305 these so that the &'s don't force the real ones into
1306 memory. */
1307 YYSTYPE *yyvs1 = yyvs;
1308 short int *yyss1 = yyss;
1309
1310
1311 /* Each stack pointer address is followed by the size of the
1312 data in use in that stack, in bytes. This used to be a
1313 conditional around just the two extra args, but that might
1314 be undefined if yyoverflow is a macro. */
1315 yyoverflow (YY_("memory exhausted"),
1316 &yyss1, yysize * sizeof (*yyssp),
1317 &yyvs1, yysize * sizeof (*yyvsp),
1318
1319 &yystacksize);
1320
1321 yyss = yyss1;
1322 yyvs = yyvs1;
1323 }
1324 #else /* no yyoverflow */
1325 # ifndef YYSTACK_RELOCATE
1326 goto yyexhaustedlab;
1327 # else
1328 /* Extend the stack our own way. */
1329 if (YYMAXDEPTH <= yystacksize)
1330 goto yyexhaustedlab;
1331 yystacksize *= 2;
1332 if (YYMAXDEPTH < yystacksize)
1333 yystacksize = YYMAXDEPTH;
1334
1335 {
1336 short int *yyss1 = yyss;
1337 union yyalloc *yyptr =
1338 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1339 if (! yyptr)
1340 goto yyexhaustedlab;
1341 YYSTACK_RELOCATE (yyss);
1342 YYSTACK_RELOCATE (yyvs);
1343
1344 # undef YYSTACK_RELOCATE
1345 if (yyss1 != yyssa)
1346 YYSTACK_FREE (yyss1);
1347 }
1348 # endif
1349 #endif /* no yyoverflow */
1350
1351 yyssp = yyss + yysize - 1;
1352 yyvsp = yyvs + yysize - 1;
1353
1354
1355 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1356 (unsigned long int) yystacksize));
1357
1358 if (yyss + yystacksize - 1 <= yyssp)
1359 YYABORT;
1360 }
1361
1362 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1363
1364 goto yybackup;
1365
1366 /*-----------.
1367 | yybackup. |
1368 `-----------*/
1369 yybackup:
1370
1371 /* Do appropriate processing given the current state. */
1372 /* Read a look-ahead token if we need one and don't already have one. */
1373 /* yyresume: */
1374
1375 /* First try to decide what to do without reference to look-ahead token. */
1376
1377 yyn = yypact[yystate];
1378 if (yyn == YYPACT_NINF)
1379 goto yydefault;
1380
1381 /* Not known => get a look-ahead token if don't already have one. */
1382
1383 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
1384 if (yychar == YYEMPTY)
1385 {
1386 YYDPRINTF ((stderr, "Reading a token: "));
1387 yychar = YYLEX;
1388 }
1389
1390 if (yychar <= YYEOF)
1391 {
1392 yychar = yytoken = YYEOF;
1393 YYDPRINTF ((stderr, "Now at end of input.\n"));
1394 }
1395 else
1396 {
1397 yytoken = YYTRANSLATE (yychar);
1398 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1399 }
1400
1401 /* If the proper action on seeing token YYTOKEN is to reduce or to
1402 detect an error, take that action. */
1403 yyn += yytoken;
1404 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1405 goto yydefault;
1406 yyn = yytable[yyn];
1407 if (yyn <= 0)
1408 {
1409 if (yyn == 0 || yyn == YYTABLE_NINF)
1410 goto yyerrlab;
1411 yyn = -yyn;
1412 goto yyreduce;
1413 }
1414
1415 if (yyn == YYFINAL)
1416 YYACCEPT;
1417
1418 /* Shift the look-ahead token. */
1419 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1420
1421 /* Discard the token being shifted unless it is eof. */
1422 if (yychar != YYEOF)
1423 yychar = YYEMPTY;
1424
1425 *++yyvsp = yylval;
1426
1427
1428 /* Count tokens shifted since error; after three, turn off error
1429 status. */
1430 if (yyerrstatus)
1431 yyerrstatus--;
1432
1433 yystate = yyn;
1434 goto yynewstate;
1435
1436
1437 /*-----------------------------------------------------------.
1438 | yydefault -- do the default action for the current state. |
1439 `-----------------------------------------------------------*/
1440 yydefault:
1441 yyn = yydefact[yystate];
1442 if (yyn == 0)
1443 goto yyerrlab;
1444 goto yyreduce;
1445
1446
1447 /*-----------------------------.
1448 | yyreduce -- Do a reduction. |
1449 `-----------------------------*/
1450 yyreduce:
1451 /* yyn is the number of a rule to reduce with. */
1452 yylen = yyr2[yyn];
1453
1454 /* If YYLEN is nonzero, implement the default value of the action:
1455 `$$ = $1'.
1456
1457 Otherwise, the following line sets YYVAL to garbage.
1458 This behavior is undocumented and Bison
1459 users should not rely upon it. Assigning to YYVAL
1460 unconditionally makes the parser a bit smaller, and it avoids a
1461 GCC warning that YYVAL may be used uninitialized. */
1462 yyval = yyvsp[1-yylen];
1463
1464
1465 YY_REDUCE_PRINT (yyn);
1466 switch (yyn)
1467 {
1468 case 2:
1469 #line 124 "bc.y"
1470 {
1471 (yyval.i_value) = 0;
1472 if (interactive && !quiet)
1473 {
1474 show_bc_version ();
1475 welcome ();
1476 }
1477 }
1478 break;
1479
1480 case 4:
1481 #line 135 "bc.y"
1482 { run_code (); }
1483 break;
1484
1485 case 5:
1486 #line 137 "bc.y"
1487 { run_code (); }
1488 break;
1489
1490 case 6:
1491 #line 139 "bc.y"
1492 {
1493 yyerrok;
1494 init_gen ();
1495 }
1496 break;
1497
1498 case 8:
1499 #line 146 "bc.y"
1500 { warn ("newline not allowed"); }
1501 break;
1502
1503 case 9:
1504 #line 149 "bc.y"
1505 { (yyval.i_value) = 0; }
1506 break;
1507
1508 case 13:
1509 #line 155 "bc.y"
1510 { (yyval.i_value) = 0; }
1511 break;
1512
1513 case 20:
1514 #line 164 "bc.y"
1515 { (yyval.i_value) = (yyvsp[0].i_value); }
1516 break;
1517
1518 case 21:
1519 #line 167 "bc.y"
1520 { warranty (""); }
1521 break;
1522
1523 case 22:
1524 #line 169 "bc.y"
1525 { limits (); }
1526 break;
1527
1528 case 23:
1529 #line 171 "bc.y"
1530 {
1531 if ((yyvsp[0].i_value) & EX_COMP)
1532 warn ("comparison in expression");
1533 if ((yyvsp[0].i_value) & EX_REG)
1534 generate ("W");
1535 else
1536 generate ("p");
1537 }
1538 break;
1539
1540 case 24:
1541 #line 180 "bc.y"
1542 {
1543 (yyval.i_value) = 0;
1544 generate ("w");
1545 generate ((yyvsp[0].s_value));
1546 free ((yyvsp[0].s_value));
1547 }
1548 break;
1549
1550 case 25:
1551 #line 187 "bc.y"
1552 {
1553 if (break_label == 0)
1554 yyerror ("Break outside a for/while");
1555 else
1556 {
1557 sprintf (genstr, "J%1d:", break_label);
1558 generate (genstr);
1559 }
1560 }
1561 break;
1562
1563 case 26:
1564 #line 197 "bc.y"
1565 {
1566 warn ("Continue statement");
1567 if (continue_label == 0)
1568 yyerror ("Continue outside a for");
1569 else
1570 {
1571 sprintf (genstr, "J%1d:", continue_label);
1572 generate (genstr);
1573 }
1574 }
1575 break;
1576
1577 case 27:
1578 #line 208 "bc.y"
1579 { exit (0); }
1580 break;
1581
1582 case 28:
1583 #line 210 "bc.y"
1584 { generate ("h"); }
1585 break;
1586
1587 case 29:
1588 #line 212 "bc.y"
1589 { generate ("R"); }
1590 break;
1591
1592 case 30:
1593 #line 214 "bc.y"
1594 {
1595 (yyvsp[0].i_value) = break_label;
1596 break_label = next_label++;
1597 }
1598 break;
1599
1600 case 31:
1601 #line 219 "bc.y"
1602 {
1603 if ((yyvsp[-1].i_value) & EX_COMP)
1604 warn ("Comparison in first for expression");
1605 if ((yyvsp[-1].i_value) & EX_VOID)
1606 yyerror ("first expression is void");
1607 if (!((yyvsp[-1].i_value) & EX_EMPTY))
1608 generate ("p");
1609 (yyvsp[-1].i_value) = next_label++;
1610 sprintf (genstr, "N%1d:", (yyvsp[-1].i_value));
1611 generate (genstr);
1612 }
1613 break;
1614
1615 case 32:
1616 #line 231 "bc.y"
1617 {
1618 if ((yyvsp[-1].i_value) & EX_VOID)
1619 yyerror ("second expression is void");
1620 if ((yyvsp[-1].i_value) & EX_EMPTY ) generate ("1");
1621 (yyvsp[-1].i_value) = next_label++;
1622 sprintf (genstr, "B%1d:J%1d:", (yyvsp[-1].i_value), break_label);
1623 generate (genstr);
1624 (yyval.i_value) = continue_label;
1625 continue_label = next_label++;
1626 sprintf (genstr, "N%1d:", continue_label);
1627 generate (genstr);
1628 }
1629 break;
1630
1631 case 33:
1632 #line 244 "bc.y"
1633 {
1634 if ((yyvsp[-1].i_value) & EX_COMP)
1635 warn ("Comparison in third for expression");
1636 if ((yyvsp[-1].i_value) & EX_VOID)
1637 yyerror ("third expression is void");
1638 if ((yyvsp[-1].i_value) & EX_EMPTY)
1639 sprintf (genstr, "J%1d:N%1d:", (yyvsp[-7].i_value), (yyvsp[-4].i_value));
1640 else
1641 sprintf (genstr, "pJ%1d:N%1d:", (yyvsp[-7].i_value), (yyvsp[-4].i_value));
1642 generate (genstr);
1643 }
1644 break;
1645
1646 case 34:
1647 #line 256 "bc.y"
1648 {
1649 sprintf (genstr, "J%1d:N%1d:",
1650 continue_label, break_label);
1651 generate (genstr);
1652 break_label = (yyvsp[-13].i_value);
1653 continue_label = (yyvsp[-5].i_value);
1654 }
1655 break;
1656
1657 case 35:
1658 #line 264 "bc.y"
1659 {
1660 if ((yyvsp[-1].i_value) & EX_VOID)
1661 yyerror ("void expression");
1662 (yyvsp[-1].i_value) = if_label;
1663 if_label = next_label++;
1664 sprintf (genstr, "Z%1d:", if_label);
1665 generate (genstr);
1666 }
1667 break;
1668
1669 case 36:
1670 #line 273 "bc.y"
1671 {
1672 sprintf (genstr, "N%1d:", if_label);
1673 generate (genstr);
1674 if_label = (yyvsp[-5].i_value);
1675 }
1676 break;
1677
1678 case 37:
1679 #line 279 "bc.y"
1680 {
1681 (yyvsp[0].i_value) = next_label++;
1682 sprintf (genstr, "N%1d:", (yyvsp[0].i_value));
1683 generate (genstr);
1684 }
1685 break;
1686
1687 case 38:
1688 #line 285 "bc.y"
1689 {
1690 if ((yyvsp[0].i_value) & EX_VOID)
1691 yyerror ("void expression");
1692 (yyvsp[0].i_value) = break_label;
1693 break_label = next_label++;
1694 sprintf (genstr, "Z%1d:", break_label);
1695 generate (genstr);
1696 }
1697 break;
1698
1699 case 39:
1700 #line 294 "bc.y"
1701 {
1702 sprintf (genstr, "J%1d:N%1d:", (yyvsp[-7].i_value), break_label);
1703 generate (genstr);
1704 break_label = (yyvsp[-4].i_value);
1705 }
1706 break;
1707
1708 case 40:
1709 #line 300 "bc.y"
1710 { (yyval.i_value) = 0; }
1711 break;
1712
1713 case 41:
1714 #line 302 "bc.y"
1715 { warn ("print statement"); }
1716 break;
1717
1718 case 45:
1719 #line 309 "bc.y"
1720 {
1721 generate ("O");
1722 generate ((yyvsp[0].s_value));
1723 free ((yyvsp[0].s_value));
1724 }
1725 break;
1726
1727 case 46:
1728 #line 315 "bc.y"
1729 {
1730 if ((yyvsp[0].i_value) & EX_VOID)
1731 yyerror ("void expression in print");
1732 generate ("P");
1733 }
1734 break;
1735
1736 case 48:
1737 #line 323 "bc.y"
1738 {
1739 warn ("else clause in if statement");
1740 (yyvsp[0].i_value) = next_label++;
1741 sprintf (genstr, "J%d:N%1d:", (yyvsp[0].i_value), if_label);
1742 generate (genstr);
1743 if_label = (yyvsp[0].i_value);
1744 }
1745 break;
1746
1747 case 50:
1748 #line 334 "bc.y"
1749 { char *params, *autos;
1750 /* Check auto list against parameter list? */
1751 check_params ((yyvsp[-5].a_value),(yyvsp[0].a_value));
1752 params = arg_str ((yyvsp[-5].a_value));
1753 autos = arg_str ((yyvsp[0].a_value));
1754 set_genstr_size (30 + strlen (params)
1755 + strlen (autos));
1756 cur_func = lookup((yyvsp[-7].s_value),FUNCTDEF);
1757 sprintf (genstr, "F%d,%s.%s[", cur_func, params,
1758 autos);
1759 generate (genstr);
1760 functions[cur_func].f_void = (yyvsp[-8].i_value);
1761 free_args ((yyvsp[-5].a_value));
1762 free_args ((yyvsp[0].a_value));
1763 (yyvsp[-9].i_value) = next_label;
1764 next_label = 1;
1765 }
1766 break;
1767
1768 case 51:
1769 #line 352 "bc.y"
1770 {
1771 generate ("0R]");
1772 next_label = (yyvsp[-12].i_value);
1773 cur_func = -1;
1774 }
1775 break;
1776
1777 case 52:
1778 #line 359 "bc.y"
1779 { (yyval.i_value) = 0; }
1780 break;
1781
1782 case 53:
1783 #line 361 "bc.y"
1784 {
1785 (yyval.i_value) = 1;
1786 warn ("void functions");
1787 }
1788 break;
1789
1790 case 54:
1791 #line 367 "bc.y"
1792 { (yyval.a_value) = NULL; }
1793 break;
1794
1795 case 56:
1796 #line 371 "bc.y"
1797 { (yyval.a_value) = NULL; }
1798 break;
1799
1800 case 57:
1801 #line 373 "bc.y"
1802 { (yyval.a_value) = (yyvsp[-1].a_value); }
1803 break;
1804
1805 case 58:
1806 #line 375 "bc.y"
1807 { (yyval.a_value) = (yyvsp[-1].a_value); }
1808 break;
1809
1810 case 59:
1811 #line 378 "bc.y"
1812 { (yyval.a_value) = nextarg (NULL, lookup ((yyvsp[0].s_value),SIMPLE), FALSE);}
1813 break;
1814
1815 case 60:
1816 #line 380 "bc.y"
1817 { (yyval.a_value) = nextarg (NULL, lookup ((yyvsp[-2].s_value),ARRAY), FALSE); }
1818 break;
1819
1820 case 61:
1821 #line 382 "bc.y"
1822 { (yyval.a_value) = nextarg (NULL, lookup ((yyvsp[-2].s_value),ARRAY), TRUE);
1823 warn ("Call by variable arrays");
1824 }
1825 break;
1826
1827 case 62:
1828 #line 386 "bc.y"
1829 { (yyval.a_value) = nextarg (NULL, lookup ((yyvsp[-2].s_value),ARRAY), TRUE);
1830 warn ("Call by variable arrays");
1831 }
1832 break;
1833
1834 case 63:
1835 #line 390 "bc.y"
1836 { (yyval.a_value) = nextarg ((yyvsp[-2].a_value), lookup ((yyvsp[0].s_value),SIMPLE), FALSE); }
1837 break;
1838
1839 case 64:
1840 #line 392 "bc.y"
1841 { (yyval.a_value) = nextarg ((yyvsp[-4].a_value), lookup ((yyvsp[-2].s_value),ARRAY), FALSE); }
1842 break;
1843
1844 case 65:
1845 #line 394 "bc.y"
1846 { (yyval.a_value) = nextarg ((yyvsp[-5].a_value), lookup ((yyvsp[-2].s_value),ARRAY), TRUE);
1847 warn ("Call by variable arrays");
1848 }
1849 break;
1850
1851 case 66:
1852 #line 398 "bc.y"
1853 { (yyval.a_value) = nextarg ((yyvsp[-5].a_value), lookup ((yyvsp[-2].s_value),ARRAY), TRUE);
1854 warn ("Call by variable arrays");
1855 }
1856 break;
1857
1858 case 67:
1859 #line 403 "bc.y"
1860 { (yyval.a_value) = NULL; }
1861 break;
1862
1863 case 69:
1864 #line 407 "bc.y"
1865 {
1866 if ((yyvsp[0].i_value) & EX_COMP)
1867 warn ("comparison in argument");
1868 if ((yyvsp[0].i_value) & EX_VOID)
1869 yyerror ("void argument");
1870 (yyval.a_value) = nextarg (NULL,0,FALSE);
1871 }
1872 break;
1873
1874 case 70:
1875 #line 415 "bc.y"
1876 {
1877 sprintf (genstr, "K%d:", -lookup ((yyvsp[-2].s_value),ARRAY));
1878 generate (genstr);
1879 (yyval.a_value) = nextarg (NULL,1,FALSE);
1880 }
1881 break;
1882
1883 case 71:
1884 #line 421 "bc.y"
1885 {
1886 if ((yyvsp[0].i_value) & EX_COMP)
1887 warn ("comparison in argument");
1888 if ((yyvsp[0].i_value) & EX_VOID)
1889 yyerror ("void argument");
1890 (yyval.a_value) = nextarg ((yyvsp[-2].a_value),0,FALSE);
1891 }
1892 break;
1893
1894 case 72:
1895 #line 429 "bc.y"
1896 {
1897 sprintf (genstr, "K%d:", -lookup ((yyvsp[-2].s_value),ARRAY));
1898 generate (genstr);
1899 (yyval.a_value) = nextarg ((yyvsp[-4].a_value),1,FALSE);
1900 }
1901 break;
1902
1903 case 73:
1904 #line 446 "bc.y"
1905 {
1906 (yyval.i_value) = EX_EMPTY;
1907 warn ("Missing expression in for statement");
1908 }
1909 break;
1910
1911 case 75:
1912 #line 453 "bc.y"
1913 {
1914 (yyval.i_value) = 0;
1915 generate ("0");
1916 if (cur_func == -1)
1917 yyerror("Return outside of a function.");
1918 }
1919 break;
1920
1921 case 76:
1922 #line 460 "bc.y"
1923 {
1924 if ((yyvsp[0].i_value) & EX_COMP)
1925 warn ("comparison in return expresion");
1926 if (!((yyvsp[0].i_value) & EX_PAREN))
1927 warn ("return expression requires parenthesis");
1928 if ((yyvsp[0].i_value) & EX_VOID)
1929 yyerror("return requires non-void expression");
1930 if (cur_func == -1)
1931 yyerror("Return outside of a function.");
1932 else if (functions[cur_func].f_void)
1933 yyerror("Return expression in a void function.");
1934 }
1935 break;
1936
1937 case 77:
1938 #line 474 "bc.y"
1939 {
1940 if ((yyvsp[0].c_value) != '=')
1941 {
1942 if ((yyvsp[-1].i_value) < 0)
1943 sprintf (genstr, "DL%d:", -(yyvsp[-1].i_value));
1944 else
1945 sprintf (genstr, "l%d:", (yyvsp[-1].i_value));
1946 generate (genstr);
1947 }
1948 }
1949 break;
1950
1951 case 78:
1952 #line 485 "bc.y"
1953 {
1954 if ((yyvsp[0].i_value) & EX_ASSGN)
1955 warn("comparison in assignment");
1956 if ((yyvsp[0].i_value) & EX_VOID)
1957 yyerror("Assignment of a void expression");
1958 if ((yyvsp[-2].c_value) != '=')
1959 {
1960 sprintf (genstr, "%c", (yyvsp[-2].c_value));
1961 generate (genstr);
1962 }
1963 if ((yyvsp[-3].i_value) < 0)
1964 sprintf (genstr, "S%d:", -(yyvsp[-3].i_value));
1965 else
1966 sprintf (genstr, "s%d:", (yyvsp[-3].i_value));
1967 generate (genstr);
1968 (yyval.i_value) = EX_ASSGN;
1969 }
1970 break;
1971
1972 case 79:
1973 #line 503 "bc.y"
1974 {
1975 warn("&& operator");
1976 (yyvsp[0].i_value) = next_label++;
1977 sprintf (genstr, "DZ%d:p", (yyvsp[0].i_value));
1978 generate (genstr);
1979 }
1980 break;
1981
1982 case 80:
1983 #line 510 "bc.y"
1984 {
1985 if (((yyvsp[-3].i_value) & EX_VOID) || ((yyvsp[0].i_value) & EX_VOID))
1986 yyerror ("void expression with &&");
1987 sprintf (genstr, "DZ%d:p1N%d:", (yyvsp[-2].i_value), (yyvsp[-2].i_value));
1988 generate (genstr);
1989 (yyval.i_value) = ((yyvsp[-3].i_value) | (yyvsp[0].i_value)) & ~EX_PAREN;
1990 }
1991 break;
1992
1993 case 81:
1994 #line 518 "bc.y"
1995 {
1996 warn("|| operator");
1997 (yyvsp[0].i_value) = next_label++;
1998 sprintf (genstr, "B%d:", (yyvsp[0].i_value));
1999 generate (genstr);
2000 }
2001 break;
2002
2003 case 82:
2004 #line 525 "bc.y"
2005 {
2006 int tmplab;
2007 if (((yyvsp[-3].i_value) & EX_VOID) || ((yyvsp[0].i_value) & EX_VOID))
2008 yyerror ("void expression with ||");
2009 tmplab = next_label++;
2010 sprintf (genstr, "B%d:0J%d:N%d:1N%d:",
2011 (yyvsp[-2].i_value), tmplab, (yyvsp[-2].i_value), tmplab);
2012 generate (genstr);
2013 (yyval.i_value) = ((yyvsp[-3].i_value) | (yyvsp[0].i_value)) & ~EX_PAREN;
2014 }
2015 break;
2016
2017 case 83:
2018 #line 536 "bc.y"
2019 {
2020 if ((yyvsp[0].i_value) & EX_VOID)
2021 yyerror ("void expression with !");
2022 (yyval.i_value) = (yyvsp[0].i_value) & ~EX_PAREN;
2023 warn("! operator");
2024 generate ("!");
2025 }
2026 break;
2027
2028 case 84:
2029 #line 544 "bc.y"
2030 {
2031 if (((yyvsp[-2].i_value) & EX_VOID) || ((yyvsp[0].i_value) & EX_VOID))
2032 yyerror ("void expression with comparison");
2033 (yyval.i_value) = EX_REG | EX_COMP;
2034 switch (*((yyvsp[-1].s_value)))
2035 {
2036 case '=':
2037 generate ("=");
2038 break;
2039
2040 case '!':
2041 generate ("#");
2042 break;
2043
2044 case '<':
2045 if ((yyvsp[-1].s_value)[1] == '=')
2046 generate ("{");
2047 else
2048 generate ("<");
2049 break;
2050
2051 case '>':
2052 if ((yyvsp[-1].s_value)[1] == '=')
2053 generate ("}");
2054 else
2055 generate (">");
2056 break;
2057 }
2058 }
2059 break;
2060
2061 case 85:
2062 #line 574 "bc.y"
2063 {
2064 if (((yyvsp[-2].i_value) & EX_VOID) || ((yyvsp[0].i_value) & EX_VOID))
2065 yyerror ("void expression with +");
2066 generate ("+");
2067 (yyval.i_value) = ((yyvsp[-2].i_value) | (yyvsp[0].i_value)) & ~EX_PAREN;
2068 }
2069 break;
2070
2071 case 86:
2072 #line 581 "bc.y"
2073 {
2074 if (((yyvsp[-2].i_value) & EX_VOID) || ((yyvsp[0].i_value) & EX_VOID))
2075 yyerror ("void expression with -");
2076 generate ("-");
2077 (yyval.i_value) = ((yyvsp[-2].i_value) | (yyvsp[0].i_value)) & ~EX_PAREN;
2078 }
2079 break;
2080
2081 case 87:
2082 #line 588 "bc.y"
2083 {
2084 if (((yyvsp[-2].i_value) & EX_VOID) || ((yyvsp[0].i_value) & EX_VOID))
2085 yyerror ("void expression with *");
2086 generate ("*");
2087 (yyval.i_value) = ((yyvsp[-2].i_value) | (yyvsp[0].i_value)) & ~EX_PAREN;
2088 }
2089 break;
2090
2091 case 88:
2092 #line 595 "bc.y"
2093 {
2094 if (((yyvsp[-2].i_value) & EX_VOID) || ((yyvsp[0].i_value) & EX_VOID))
2095 yyerror ("void expression with /");
2096 generate ("/");
2097 (yyval.i_value) = ((yyvsp[-2].i_value) | (yyvsp[0].i_value)) & ~EX_PAREN;
2098 }
2099 break;
2100
2101 case 89:
2102 #line 602 "bc.y"
2103 {
2104 if (((yyvsp[-2].i_value) & EX_VOID) || ((yyvsp[0].i_value) & EX_VOID))
2105 yyerror ("void expression with %");
2106 generate ("%");
2107 (yyval.i_value) = ((yyvsp[-2].i_value) | (yyvsp[0].i_value)) & ~EX_PAREN;
2108 }
2109 break;
2110
2111 case 90:
2112 #line 609 "bc.y"
2113 {
2114 if (((yyvsp[-2].i_value) & EX_VOID) || ((yyvsp[0].i_value) & EX_VOID))
2115 yyerror ("void expression with ^");
2116 generate ("^");
2117 (yyval.i_value) = ((yyvsp[-2].i_value) | (yyvsp[0].i_value)) & ~EX_PAREN;
2118 }
2119 break;
2120
2121 case 91:
2122 #line 616 "bc.y"
2123 {
2124 if ((yyvsp[0].i_value) & EX_VOID)
2125 yyerror ("void expression with unary -");
2126 generate ("n");
2127 (yyval.i_value) = (yyvsp[0].i_value) & ~EX_PAREN;
2128 }
2129 break;
2130
2131 case 92:
2132 #line 623 "bc.y"
2133 {
2134 (yyval.i_value) = EX_REG;
2135 if ((yyvsp[0].i_value) < 0)
2136 sprintf (genstr, "L%d:", -(yyvsp[0].i_value));
2137 else
2138 sprintf (genstr, "l%d:", (yyvsp[0].i_value));
2139 generate (genstr);
2140 }
2141 break;
2142
2143 case 93:
2144 #line 632 "bc.y"
2145 {
2146 int len = strlen((yyvsp[0].s_value));
2147 (yyval.i_value) = EX_REG;
2148 if (len == 1 && *(yyvsp[0].s_value) == '0')
2149 generate ("0");
2150 else if (len == 1 && *(yyvsp[0].s_value) == '1')
2151 generate ("1");
2152 else
2153 {
2154 generate ("K");
2155 generate ((yyvsp[0].s_value));
2156 generate (":");
2157 }
2158 free ((yyvsp[0].s_value));
2159 }
2160 break;
2161
2162 case 94:
2163 #line 648 "bc.y"
2164 {
2165 if ((yyvsp[-1].i_value) & EX_VOID)
2166 yyerror ("void expression in parenthesis");
2167 (yyval.i_value) = (yyvsp[-1].i_value) | EX_REG | EX_PAREN;
2168 }
2169 break;
2170
2171 case 95:
2172 #line 654 "bc.y"
2173 { int fn;
2174 fn = lookup ((yyvsp[-3].s_value),FUNCT);
2175 if (functions[fn].f_void)
2176 (yyval.i_value) = EX_VOID;
2177 else
2178 (yyval.i_value) = EX_REG;
2179 if ((yyvsp[-1].a_value) != NULL)
2180 { char *params = call_str ((yyvsp[-1].a_value));
2181 set_genstr_size (20 + strlen (params));
2182 sprintf (genstr, "C%d,%s:", fn, params);
2183 free_args ((yyvsp[-1].a_value));
2184 }
2185 else
2186 {
2187 sprintf (genstr, "C%d:", fn);
2188 }
2189 generate (genstr);
2190 }
2191 break;
2192
2193 case 96:
2194 #line 673 "bc.y"
2195 {
2196 (yyval.i_value) = EX_REG;
2197 if ((yyvsp[0].i_value) < 0)
2198 {
2199 if ((yyvsp[-1].c_value) == '+')
2200 sprintf (genstr, "DA%d:L%d:", -(yyvsp[0].i_value), -(yyvsp[0].i_value));
2201 else
2202 sprintf (genstr, "DM%d:L%d:", -(yyvsp[0].i_value), -(yyvsp[0].i_value));
2203 }
2204 else
2205 {
2206 if ((yyvsp[-1].c_value) == '+')
2207 sprintf (genstr, "i%d:l%d:", (yyvsp[0].i_value), (yyvsp[0].i_value));
2208 else
2209 sprintf (genstr, "d%d:l%d:", (yyvsp[0].i_value), (yyvsp[0].i_value));
2210 }
2211 generate (genstr);
2212 }
2213 break;
2214
2215 case 97:
2216 #line 692 "bc.y"
2217 {
2218 (yyval.i_value) = EX_REG;
2219 if ((yyvsp[-1].i_value) < 0)
2220 {
2221 sprintf (genstr, "DL%d:x", -(yyvsp[-1].i_value));
2222 generate (genstr);
2223 if ((yyvsp[0].c_value) == '+')
2224 sprintf (genstr, "A%d:", -(yyvsp[-1].i_value));
2225 else
2226 sprintf (genstr, "M%d:", -(yyvsp[-1].i_value));
2227 }
2228 else
2229 {
2230 sprintf (genstr, "l%d:", (yyvsp[-1].i_value));
2231 generate (genstr);
2232 if ((yyvsp[0].c_value) == '+')
2233 sprintf (genstr, "i%d:", (yyvsp[-1].i_value));
2234 else
2235 sprintf (genstr, "d%d:", (yyvsp[-1].i_value));
2236 }
2237 generate (genstr);
2238 }
2239 break;
2240
2241 case 98:
2242 #line 715 "bc.y"
2243 {
2244 if ((yyvsp[-1].i_value) & EX_VOID)
2245 yyerror ("void expression in length()");
2246 generate ("cL");
2247 (yyval.i_value) = EX_REG;
2248 }
2249 break;
2250
2251 case 99:
2252 #line 722 "bc.y"
2253 {
2254 if ((yyvsp[-1].i_value) & EX_VOID)
2255 yyerror ("void expression in sqrt()");
2256 generate ("cR");
2257 (yyval.i_value) = EX_REG;
2258 }
2259 break;
2260
2261 case 100:
2262 #line 729 "bc.y"
2263 {
2264 if ((yyvsp[-1].i_value) & EX_VOID)
2265 yyerror ("void expression in scale()");
2266 generate ("cS");
2267 (yyval.i_value) = EX_REG;
2268 }
2269 break;
2270
2271 case 101:
2272 #line 736 "bc.y"
2273 {
2274 warn ("read function");
2275 generate ("cI");
2276 (yyval.i_value) = EX_REG;
2277 }
2278 break;
2279
2280 case 102:
2281 #line 742 "bc.y"
2282 {
2283 warn ("random function");
2284 generate ("cX");
2285 (yyval.i_value) = EX_REG;
2286 }
2287 break;
2288
2289 case 103:
2290 #line 749 "bc.y"
2291 { (yyval.i_value) = lookup((yyvsp[0].s_value),SIMPLE); }
2292 break;
2293
2294 case 104:
2295 #line 751 "bc.y"
2296 {
2297 if ((yyvsp[-1].i_value) & EX_VOID)
2298 yyerror("void expression as subscript");
2299 if ((yyvsp[-1].i_value) & EX_COMP)
2300 warn("comparison in subscript");
2301 (yyval.i_value) = lookup((yyvsp[-3].s_value),ARRAY);
2302 }
2303 break;
2304
2305 case 105:
2306 #line 759 "bc.y"
2307 { (yyval.i_value) = 0; }
2308 break;
2309
2310 case 106:
2311 #line 761 "bc.y"
2312 { (yyval.i_value) = 1; }
2313 break;
2314
2315 case 107:
2316 #line 763 "bc.y"
2317 { (yyval.i_value) = 2; }
2318 break;
2319
2320 case 108:
2321 #line 765 "bc.y"
2322 { (yyval.i_value) = 3;
2323 warn ("History variable");
2324 }
2325 break;
2326
2327 case 109:
2328 #line 769 "bc.y"
2329 { (yyval.i_value) = 4;
2330 warn ("Last variable");
2331 }
2332 break;
2333
2334 case 110:
2335 #line 775 "bc.y"
2336 { warn ("End of line required"); }
2337 break;
2338
2339 case 112:
2340 #line 778 "bc.y"
2341 { warn ("Too many end of lines"); }
2342 break;
2343
2344
2345 default: break;
2346 }
2347
2348 /* Line 1126 of yacc.c. */
2349 #line 2350 "bc.c"
2350
2351 yyvsp -= yylen;
2352 yyssp -= yylen;
2353
2354
2355 YY_STACK_PRINT (yyss, yyssp);
2356
2357 *++yyvsp = yyval;
2358
2359
2360 /* Now `shift' the result of the reduction. Determine what state
2361 that goes to, based on the state we popped back to and the rule
2362 number reduced by. */
2363
2364 yyn = yyr1[yyn];
2365
2366 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
2367 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2368 yystate = yytable[yystate];
2369 else
2370 yystate = yydefgoto[yyn - YYNTOKENS];
2371
2372 goto yynewstate;
2373
2374
2375 /*------------------------------------.
2376 | yyerrlab -- here on detecting error |
2377 `------------------------------------*/
2378 yyerrlab:
2379 /* If not already recovering from an error, report this error. */
2380 if (!yyerrstatus)
2381 {
2382 ++yynerrs;
2383 #if YYERROR_VERBOSE
2384 yyn = yypact[yystate];
2385
2386 if (YYPACT_NINF < yyn && yyn < YYLAST)
2387 {
2388 int yytype = YYTRANSLATE (yychar);
2389 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
2390 YYSIZE_T yysize = yysize0;
2391 YYSIZE_T yysize1;
2392 int yysize_overflow = 0;
2393 char *yymsg = 0;
2394 # define YYERROR_VERBOSE_ARGS_MAXIMUM 5
2395 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
2396 int yyx;
2397
2398 #if 0
2399 /* This is so xgettext sees the translatable formats that are
2400 constructed on the fly. */
2401 YY_("syntax error, unexpected %s");
2402 YY_("syntax error, unexpected %s, expecting %s");
2403 YY_("syntax error, unexpected %s, expecting %s or %s");
2404 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
2405 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
2406 #endif
2407 char *yyfmt;
2408 char const *yyf;
2409 static char const yyunexpected[] = "syntax error, unexpected %s";
2410 static char const yyexpecting[] = ", expecting %s";
2411 static char const yyor[] = " or %s";
2412 char yyformat[sizeof yyunexpected
2413 + sizeof yyexpecting - 1
2414 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
2415 * (sizeof yyor - 1))];
2416 char const *yyprefix = yyexpecting;
2417
2418 /* Start YYX at -YYN if negative to avoid negative indexes in
2419 YYCHECK. */
2420 int yyxbegin = yyn < 0 ? -yyn : 0;
2421
2422 /* Stay within bounds of both yycheck and yytname. */
2423 int yychecklim = YYLAST - yyn;
2424 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
2425 int yycount = 1;
2426
2427 yyarg[0] = yytname[yytype];
2428 yyfmt = yystpcpy (yyformat, yyunexpected);
2429
2430 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
2431 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
2432 {
2433 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
2434 {
2435 yycount = 1;
2436 yysize = yysize0;
2437 yyformat[sizeof yyunexpected - 1] = '\0';
2438 break;
2439 }
2440 yyarg[yycount++] = yytname[yyx];
2441 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
2442 yysize_overflow |= yysize1 < yysize;
2443 yysize = yysize1;
2444 yyfmt = yystpcpy (yyfmt, yyprefix);
2445 yyprefix = yyor;
2446 }
2447
2448 yyf = YY_(yyformat);
2449 yysize1 = yysize + yystrlen (yyf);
2450 yysize_overflow |= yysize1 < yysize;
2451 yysize = yysize1;
2452
2453 if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM)
2454 yymsg = (char *) YYSTACK_ALLOC (yysize);
2455 if (yymsg)
2456 {
2457 /* Avoid sprintf, as that infringes on the user's name space.
2458 Don't have undefined behavior even if the translation
2459 produced a string with the wrong number of "%s"s. */
2460 char *yyp = yymsg;
2461 int yyi = 0;
2462 while ((*yyp = *yyf))
2463 {
2464 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
2465 {
2466 yyp += yytnamerr (yyp, yyarg[yyi++]);
2467 yyf += 2;
2468 }
2469 else
2470 {
2471 yyp++;
2472 yyf++;
2473 }
2474 }
2475 yyerror (yymsg);
2476 YYSTACK_FREE (yymsg);
2477 }
2478 else
2479 {
2480 yyerror (YY_("syntax error"));
2481 goto yyexhaustedlab;
2482 }
2483 }
2484 else
2485 #endif /* YYERROR_VERBOSE */
2486 yyerror (YY_("syntax error"));
2487 }
2488
2489
2490
2491 if (yyerrstatus == 3)
2492 {
2493 /* If just tried and failed to reuse look-ahead token after an
2494 error, discard it. */
2495
2496 if (yychar <= YYEOF)
2497 {
2498 /* Return failure if at end of input. */
2499 if (yychar == YYEOF)
2500 YYABORT;
2501 }
2502 else
2503 {
2504 yydestruct ("Error: discarding", yytoken, &yylval);
2505 yychar = YYEMPTY;
2506 }
2507 }
2508
2509 /* Else will try to reuse look-ahead token after shifting the error
2510 token. */
2511 goto yyerrlab1;
2512
2513
2514 /*---------------------------------------------------.
2515 | yyerrorlab -- error raised explicitly by YYERROR. |
2516 `---------------------------------------------------*/
2517 yyerrorlab:
2518
2519 /* Pacify compilers like GCC when the user code never invokes
2520 YYERROR and the label yyerrorlab therefore never appears in user
2521 code. */
2522 if (0)
2523 goto yyerrorlab;
2524
2525 yyvsp -= yylen;
2526 yyssp -= yylen;
2527 yystate = *yyssp;
2528 goto yyerrlab1;
2529
2530
2531 /*-------------------------------------------------------------.
2532 | yyerrlab1 -- common code for both syntax error and YYERROR. |
2533 `-------------------------------------------------------------*/
2534 yyerrlab1:
2535 yyerrstatus = 3; /* Each real token shifted decrements this. */
2536
2537 for (;;)
2538 {
2539 yyn = yypact[yystate];
2540 if (yyn != YYPACT_NINF)
2541 {
2542 yyn += YYTERROR;
2543 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
2544 {
2545 yyn = yytable[yyn];
2546 if (0 < yyn)
2547 break;
2548 }
2549 }
2550
2551 /* Pop the current state because it cannot handle the error token. */
2552 if (yyssp == yyss)
2553 YYABORT;
2554
2555
2556 yydestruct ("Error: popping", yystos[yystate], yyvsp);
2557 YYPOPSTACK;
2558 yystate = *yyssp;
2559 YY_STACK_PRINT (yyss, yyssp);
2560 }
2561
2562 if (yyn == YYFINAL)
2563 YYACCEPT;
2564
2565 *++yyvsp = yylval;
2566
2567
2568 /* Shift the error token. */
2569 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
2570
2571 yystate = yyn;
2572 goto yynewstate;
2573
2574
2575 /*-------------------------------------.
2576 | yyacceptlab -- YYACCEPT comes here. |
2577 `-------------------------------------*/
2578 yyacceptlab:
2579 yyresult = 0;
2580 goto yyreturn;
2581
2582 /*-----------------------------------.
2583 | yyabortlab -- YYABORT comes here. |
2584 `-----------------------------------*/
2585 yyabortlab:
2586 yyresult = 1;
2587 goto yyreturn;
2588
2589 #ifndef yyoverflow
2590 /*-------------------------------------------------.
2591 | yyexhaustedlab -- memory exhaustion comes here. |
2592 `-------------------------------------------------*/
2593 yyexhaustedlab:
2594 yyerror (YY_("memory exhausted"));
2595 yyresult = 2;
2596 /* Fall through. */
2597 #endif
2598
2599 yyreturn:
2600 if (yychar != YYEOF && yychar != YYEMPTY)
2601 yydestruct ("Cleanup: discarding lookahead",
2602 yytoken, &yylval);
2603 while (yyssp != yyss)
2604 {
2605 yydestruct ("Cleanup: popping",
2606 yystos[*yyssp], yyvsp);
2607 YYPOPSTACK;
2608 }
2609 #ifndef yyoverflow
2610 if (yyss != yyssa)
2611 YYSTACK_FREE (yyss);
2612 #endif
2613 return yyresult;
2614 }
2615
2616
2617 #line 781 "bc.y"
2618
2619
2620