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