1 /* A Bison parser, made by GNU Bison 2.0. */
2
3 /* Skeleton parser for Yacc-like parsing with Bison,
4 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 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., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, 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 /* Skeleton name. */
40 #define YYSKELETON_NAME "yacc.c"
41
42 /* Pure parsers. */
43 #define YYPURE 0
44
45 /* Using locations. */
46 #define YYLSP_NEEDED 0
47
48 /* Substitute the variable and function names. */
49 #define yyparse zzparse
50 #define yylex zzlex
51 #define yyerror zzerror
52 #define yylval zzlval
53 #define yychar zzchar
54 #define yydebug zzdebug
55 #define yynerrs zznerrs
56
57
58 /* Tokens. */
59 #ifndef YYTOKENTYPE
60 # define YYTOKENTYPE
61 /* Put the tokens into the symbol table, so that GDB and other debuggers
62 know about them. */
63 enum yytokentype {
64 ARRAY = 258,
65 BEGIN = 259,
66 CASE = 260,
67 CONST = 261,
68 DO = 262,
69 DOTS = 263,
70 ELSE = 264,
71 END = 265,
72 FIL = 266,
73 FAR = 267,
74 FOR = 268,
75 FUNCTION = 269,
76 GOTO = 270,
77 IDENT = 271,
78 ICONST = 272,
79 IF = 273,
80 IMPLEMENTATION = 274,
81 INTERFACE = 275,
82 LABEL = 276,
83 LOOPHOLE = 277,
84 OBJECT = 278,
85 OF = 279,
86 ORIGIN = 280,
87 OTHERWISE = 281,
88 PACKED = 282,
89 PROCEDURE = 283,
90 PROGRAM = 284,
91 RCONST = 285,
92 READ = 286,
93 RECORD = 287,
94 REPEAT = 288,
95 RETURN = 289,
96 SET = 290,
97 SCONST = 291,
98 STRING = 292,
99 THEN = 293,
100 TO = 294,
101 TYPE = 295,
102 UNTIL = 296,
103 UNIT = 297,
104 UNIT_END = 298,
105 VAR = 299,
106 WHILE = 300,
107 WITH = 301,
108 WRITE = 302,
109 SCOPE = 303,
110 LETSHR = 304,
111 LETSHL = 305,
112 LETOR = 306,
113 LETAND = 307,
114 LETMUL = 308,
115 LETDIV = 309,
116 LETSUB = 310,
117 LETADD = 311,
118 LET = 312,
119 IN = 313,
120 GE = 314,
121 GT = 315,
122 LE = 316,
123 LT = 317,
124 NE = 318,
125 EQ = 319,
126 XOR = 320,
127 OR = 321,
128 MINUS = 322,
129 PLUS = 323,
130 SHL = 324,
131 SHR = 325,
132 AND = 326,
133 MUL = 327,
134 DIVR = 328,
135 DIV = 329,
136 MOD = 330,
137 ADDRESS = 331,
138 NOT = 332,
139 UMINUS = 333,
140 UPLUS = 334
141 };
142 #endif
143 #define ARRAY 258
144 #define BEGIN 259
145 #define CASE 260
146 #define CONST 261
147 #define DO 262
148 #define DOTS 263
149 #define ELSE 264
150 #define END 265
151 #define FIL 266
152 #define FAR 267
153 #define FOR 268
154 #define FUNCTION 269
155 #define GOTO 270
156 #define IDENT 271
157 #define ICONST 272
158 #define IF 273
159 #define IMPLEMENTATION 274
160 #define INTERFACE 275
161 #define LABEL 276
162 #define LOOPHOLE 277
163 #define OBJECT 278
164 #define OF 279
165 #define ORIGIN 280
166 #define OTHERWISE 281
167 #define PACKED 282
168 #define PROCEDURE 283
169 #define PROGRAM 284
170 #define RCONST 285
171 #define READ 286
172 #define RECORD 287
173 #define REPEAT 288
174 #define RETURN 289
175 #define SET 290
176 #define SCONST 291
177 #define STRING 292
178 #define THEN 293
179 #define TO 294
180 #define TYPE 295
181 #define UNTIL 296
182 #define UNIT 297
183 #define UNIT_END 298
184 #define VAR 299
185 #define WHILE 300
186 #define WITH 301
187 #define WRITE 302
188 #define SCOPE 303
189 #define LETSHR 304
190 #define LETSHL 305
191 #define LETOR 306
192 #define LETAND 307
193 #define LETMUL 308
194 #define LETDIV 309
195 #define LETSUB 310
196 #define LETADD 311
197 #define LET 312
198 #define IN 313
199 #define GE 314
200 #define GT 315
201 #define LE 316
202 #define LT 317
203 #define NE 318
204 #define EQ 319
205 #define XOR 320
206 #define OR 321
207 #define MINUS 322
208 #define PLUS 323
209 #define SHL 324
210 #define SHR 325
211 #define AND 326
212 #define MUL 327
213 #define DIVR 328
214 #define DIV 329
215 #define MOD 330
216 #define ADDRESS 331
217 #define NOT 332
218 #define UMINUS 333
219 #define UPLUS 334
220
221
222
223
224 /* Copy the first part of user declarations. */
225 #line 1 "parser.y"
226
227
228 #include <stdio.h>
229 #include <stdlib.h>
230 #include <string.h>
231
232 #include "nmtbl.h"
233 #include "token.h"
234 #include "trnod.h"
235 #include "util.h"
236
237 static int zzcnv_table[] = {
238 #define DEF_TOKEN(mnem, cat, cls, yacc) yacc,
239 #include "token.dpp"
240 };
241
242 #define YYINITDEPTH 100000
243
zzerror(char * text)244 void zzerror(char* text)
245 {
246 error(curr_token, "syntax error: %s", text);
247 }
248
249
250
251 /* Enabling traces. */
252 #ifndef YYDEBUG
253 # define YYDEBUG 0
254 #endif
255
256 /* Enabling verbose error messages. */
257 #ifdef YYERROR_VERBOSE
258 # undef YYERROR_VERBOSE
259 # define YYERROR_VERBOSE 1
260 #else
261 # define YYERROR_VERBOSE 0
262 #endif
263
264 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
265 #line 27 "parser.y"
266 typedef union YYSTYPE {
267 token *tok;
268
269 token_list *toks;
270
271 node *n_node;
272 tpd_node *n_tpd;
273 block_node *n_block;
274 stmt_node *n_stmt;
275 decl_node *n_decl;
276 expr_node *n_expr;
277 expr_group_node *n_grp;
278
279 write_param_node *n_wrtp;
280 write_list_node *n_wrls;
281 case_node *n_case;
282 set_item_node *n_item;
283
284 const_def_node *n_cdef;
285 type_def_node *n_tdef;
286 var_decl_node *n_vdcl;
287
288 field_init_node *n_field;
289
290 param_list_node *n_plist;
291 idx_node *n_idx;
292
293 field_list_node *n_fldls;
294 variant_part_node *n_varp;
295 selector_node *n_sel;
296 variant_node *n_vari;
297 compound_node *n_comp;
298
299 import_list_node *n_imp;
300 } YYSTYPE;
301 /* Line 190 of yacc.c. */
302 #line 303 "parser.tab.c"
303 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
304 # define YYSTYPE_IS_DECLARED 1
305 # define YYSTYPE_IS_TRIVIAL 1
306 #endif
307
308
309
310 /* Copy the second part of user declarations. */
311
312
313 /* Line 213 of yacc.c. */
314 #line 315 "parser.tab.c"
315
316 #if ! defined (yyoverflow) || YYERROR_VERBOSE
317
318 # ifndef YYFREE
319 # define YYFREE free
320 # endif
321 # ifndef YYMALLOC
322 # define YYMALLOC malloc
323 # endif
324
325 /* The parser invokes alloca or malloc; define the necessary symbols. */
326
327 # ifdef YYSTACK_USE_ALLOCA
328 # if YYSTACK_USE_ALLOCA
329 # ifdef __GNUC__
330 # define YYSTACK_ALLOC __builtin_alloca
331 # else
332 # define YYSTACK_ALLOC alloca
333 # endif
334 # endif
335 # endif
336
337 # ifdef YYSTACK_ALLOC
338 /* Pacify GCC's `empty if-body' warning. */
339 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
340 # else
341 # if defined (__STDC__) || defined (__cplusplus)
342 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
343 # define YYSIZE_T size_t
344 # endif
345 # define YYSTACK_ALLOC YYMALLOC
346 # define YYSTACK_FREE YYFREE
347 # endif
348 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
349
350
351 #if (! defined (yyoverflow) \
352 && (! defined (__cplusplus) \
353 || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
354
355 /* A type that is properly aligned for any stack member. */
356 union yyalloc
357 {
358 short int yyss;
359 YYSTYPE yyvs;
360 };
361
362 /* The size of the maximum gap between one aligned stack and the next. */
363 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
364
365 /* The size of an array large to enough to hold all stacks, each with
366 N elements. */
367 # define YYSTACK_BYTES(N) \
368 ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \
369 + YYSTACK_GAP_MAXIMUM)
370
371 /* Copy COUNT objects from FROM to TO. The source and destination do
372 not overlap. */
373 # ifndef YYCOPY
374 # if defined (__GNUC__) && 1 < __GNUC__
375 # define YYCOPY(To, From, Count) \
376 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
377 # else
378 # define YYCOPY(To, From, Count) \
379 do \
380 { \
381 register YYSIZE_T yyi; \
382 for (yyi = 0; yyi < (Count); yyi++) \
383 (To)[yyi] = (From)[yyi]; \
384 } \
385 while (0)
386 # endif
387 # endif
388
389 /* Relocate STACK from its old location to the new one. The
390 local variables YYSIZE and YYSTACKSIZE give the old and new number of
391 elements in the stack, and YYPTR gives the new location of the
392 stack. Advance YYPTR to a properly aligned location for the next
393 stack. */
394 # define YYSTACK_RELOCATE(Stack) \
395 do \
396 { \
397 YYSIZE_T yynewbytes; \
398 YYCOPY (&yyptr->Stack, Stack, yysize); \
399 Stack = &yyptr->Stack; \
400 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
401 yyptr += yynewbytes / sizeof (*yyptr); \
402 } \
403 while (0)
404
405 #endif
406
407 #if defined (__STDC__) || defined (__cplusplus)
408 typedef signed char yysigned_char;
409 #else
410 typedef short int yysigned_char;
411 #endif
412
413 /* YYFINAL -- State number of the termination state. */
414 #define YYFINAL 3
415 /* YYLAST -- Last index in YYTABLE. */
416 #define YYLAST 1219
417
418 /* YYNTOKENS -- Number of terminals. */
419 #define YYNTOKENS 90
420 /* YYNNTS -- Number of nonterminals. */
421 #define YYNNTS 95
422 /* YYNRULES -- Number of rules. */
423 #define YYNRULES 270
424 /* YYNRULES -- Number of states. */
425 #define YYNSTATES 549
426
427 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
428 #define YYUNDEFTOK 2
429 #define YYMAXUTOK 334
430
431 #define YYTRANSLATE(YYX) \
432 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
433
434 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
435 static const unsigned char yytranslate[] =
436 {
437 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
438 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
439 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
440 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
441 52, 53, 2, 2, 49, 2, 47, 2, 2, 2,
442 2, 2, 2, 2, 2, 2, 2, 2, 50, 51,
443 2, 2, 2, 2, 57, 2, 2, 2, 2, 2,
444 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
445 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
446 2, 54, 2, 55, 56, 2, 2, 2, 2, 2,
447 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
448 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
449 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
450 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
451 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
452 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
453 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
454 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
455 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
456 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
457 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
458 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
459 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
460 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
461 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
462 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
463 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
464 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
465 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
466 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
467 45, 46, 48, 58, 59, 60, 61, 62, 63, 64,
468 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
469 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
470 85, 86, 87, 88, 89
471 };
472
473 #if YYDEBUG
474 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
475 YYRHS. */
476 static const unsigned short int yyprhs[] =
477 {
478 0, 0, 3, 4, 7, 9, 11, 13, 16, 23,
479 24, 26, 28, 35, 45, 55, 62, 69, 71, 72,
480 76, 80, 82, 85, 86, 89, 91, 93, 95, 97,
481 99, 101, 103, 110, 114, 115, 118, 120, 122, 124,
482 126, 128, 130, 132, 133, 137, 141, 145, 149, 153,
483 157, 161, 165, 169, 172, 175, 181, 186, 193, 202,
484 207, 212, 215, 218, 220, 222, 227, 231, 235, 237,
485 241, 243, 247, 248, 250, 251, 255, 257, 261, 263,
486 265, 266, 268, 272, 276, 278, 282, 284, 288, 290,
487 294, 298, 302, 306, 310, 314, 318, 322, 326, 330,
488 334, 338, 342, 346, 350, 354, 358, 362, 366, 370,
489 374, 378, 382, 386, 390, 394, 398, 400, 403, 406,
490 409, 412, 415, 417, 421, 426, 430, 433, 438, 445,
491 447, 449, 451, 453, 457, 459, 460, 462, 466, 468,
492 472, 474, 478, 480, 484, 486, 487, 491, 493, 497,
493 501, 505, 507, 511, 513, 517, 523, 527, 529, 533,
494 535, 539, 542, 543, 547, 551, 557, 560, 561, 565,
495 569, 572, 573, 575, 579, 585, 589, 593, 599, 603,
496 609, 616, 625, 630, 637, 644, 653, 662, 673, 679,
497 688, 699, 707, 710, 713, 715, 717, 718, 722, 724,
498 728, 731, 733, 735, 739, 741, 743, 745, 747, 749,
499 751, 753, 755, 757, 759, 761, 763, 765, 767, 769,
500 771, 773, 775, 777, 782, 785, 790, 792, 794, 802,
501 810, 818, 826, 830, 834, 837, 842, 847, 852, 856,
502 863, 866, 868, 870, 872, 874, 877, 881, 883, 885,
503 888, 891, 896, 897, 899, 901, 905, 911, 913, 917,
504 919, 923, 926, 928, 930, 935, 939, 941, 943, 946,
505 950
506 };
507
508 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
509 static const short int yyrhs[] =
510 {
511 91, 0, -1, -1, 92, 93, -1, 94, -1, 96,
512 -1, 97, -1, 101, 47, -1, 29, 16, 99, 51,
513 101, 47, -1, -1, 47, -1, 102, -1, 29, 16,
514 99, 51, 102, 95, -1, 42, 16, 51, 20, 105,
515 19, 98, 10, 47, -1, 42, 16, 51, 20, 105,
516 19, 98, 108, 47, -1, 20, 105, 19, 98, 10,
517 47, -1, 20, 105, 19, 98, 108, 47, -1, 102,
518 -1, -1, 52, 100, 53, -1, 16, 49, 100, -1,
519 16, -1, 102, 108, -1, -1, 103, 102, -1, 133,
520 -1, 135, -1, 138, -1, 141, -1, 147, -1, 145,
521 -1, 104, -1, 42, 16, 51, 20, 105, 43, -1,
522 20, 105, 43, -1, -1, 106, 105, -1, 133, -1,
523 135, -1, 138, -1, 141, -1, 146, -1, 145, -1,
524 104, -1, -1, 120, 67, 118, -1, 120, 66, 118,
525 -1, 120, 65, 118, -1, 120, 64, 118, -1, 120,
526 63, 118, -1, 120, 62, 118, -1, 120, 61, 118,
527 -1, 120, 60, 118, -1, 120, 59, 118, -1, 15,
528 17, -1, 15, 16, -1, 5, 118, 24, 112, 10,
529 -1, 18, 118, 38, 107, -1, 18, 118, 38, 107,
530 9, 107, -1, 13, 16, 67, 118, 39, 118, 7,
531 107, -1, 45, 118, 7, 107, -1, 33, 109, 41,
532 118, -1, 48, 111, -1, 31, 110, -1, 120, -1,
533 34, -1, 46, 124, 7, 107, -1, 17, 50, 107,
534 -1, 16, 50, 107, -1, 108, -1, 4, 109, 10,
535 -1, 107, -1, 107, 51, 109, -1, -1, 130, -1,
536 -1, 52, 131, 53, -1, 114, -1, 114, 113, 109,
537 -1, 26, -1, 9, -1, -1, 115, -1, 115, 51,
538 114, -1, 116, 50, 107, -1, 117, -1, 117, 49,
539 116, -1, 118, -1, 118, 8, 118, -1, 119, -1,
540 118, 78, 118, -1, 118, 77, 118, -1, 118, 85,
541 118, -1, 118, 82, 118, -1, 118, 84, 118, -1,
542 118, 83, 118, -1, 120, 67, 118, -1, 120, 66,
543 118, -1, 120, 65, 118, -1, 120, 64, 118, -1,
544 120, 63, 118, -1, 120, 60, 118, -1, 120, 59,
545 118, -1, 120, 62, 118, -1, 120, 61, 118, -1,
546 118, 81, 118, -1, 118, 79, 118, -1, 118, 80,
547 118, -1, 118, 76, 118, -1, 118, 75, 118, -1,
548 118, 70, 118, -1, 118, 72, 118, -1, 118, 71,
549 118, -1, 118, 69, 118, -1, 118, 74, 118, -1,
550 118, 73, 118, -1, 118, 68, 118, -1, 120, -1,
551 78, 119, -1, 77, 119, -1, 87, 119, -1, 57,
552 120, -1, 81, 120, -1, 121, -1, 52, 124, 53,
553 -1, 120, 52, 125, 53, -1, 120, 47, 16, -1,
554 120, 56, -1, 120, 54, 124, 55, -1, 22, 52,
555 154, 49, 118, 53, -1, 127, -1, 17, -1, 30,
556 -1, 36, -1, 54, 122, 55, -1, 16, -1, -1,
557 123, -1, 123, 49, 122, -1, 118, -1, 118, 8,
558 118, -1, 118, -1, 118, 49, 124, -1, 126, -1,
559 126, 49, 125, -1, 118, -1, -1, 52, 128, 53,
560 -1, 129, -1, 129, 51, 128, -1, 16, 50, 118,
561 -1, 52, 124, 53, -1, 132, -1, 132, 49, 131,
562 -1, 118, -1, 118, 50, 118, -1, 118, 50, 118,
563 50, 118, -1, 21, 134, 51, -1, 17, -1, 17,
564 49, 134, -1, 16, -1, 16, 49, 134, -1, 6,
565 136, -1, -1, 137, 51, 136, -1, 16, 74, 118,
566 -1, 16, 50, 155, 74, 118, -1, 40, 139, -1,
567 -1, 140, 51, 139, -1, 16, 74, 154, -1, 44,
568 142, -1, -1, 143, -1, 143, 51, 58, -1, 143,
569 51, 58, 51, 142, -1, 143, 51, 142, -1, 100,
570 50, 154, -1, 16, 25, 118, 50, 158, -1, 28,
571 16, 149, -1, 14, 16, 149, 50, 154, -1, 28,
572 16, 149, 51, 148, 51, -1, 14, 16, 149, 50,
573 154, 51, 148, 51, -1, 28, 16, 149, 51, -1,
574 14, 16, 149, 50, 154, 51, -1, 28, 16, 149,
575 51, 101, 51, -1, 14, 16, 149, 50, 154, 51,
576 101, 51, -1, 28, 16, 47, 16, 149, 51, 101,
577 51, -1, 14, 16, 47, 16, 149, 50, 154, 51,
578 101, 51, -1, 14, 16, 51, 101, 51, -1, 28,
579 16, 149, 51, 12, 51, 101, 51, -1, 14, 16,
580 149, 50, 154, 51, 12, 51, 101, 51, -1, 14,
581 16, 51, 12, 51, 101, 51, -1, 16, 148, -1,
582 58, 148, -1, 16, -1, 58, -1, -1, 52, 150,
583 53, -1, 151, -1, 151, 51, 150, -1, 44, 152,
584 -1, 152, -1, 144, -1, 100, 50, 153, -1, 100,
585 -1, 158, -1, 161, -1, 158, -1, 159, -1, 167,
586 -1, 168, -1, 165, -1, 173, -1, 164, -1, 162,
587 -1, 163, -1, 157, -1, 156, -1, 158, -1, 160,
588 -1, 167, -1, 166, -1, 157, -1, 14, 149, 50,
589 154, -1, 28, 149, -1, 37, 54, 118, 55, -1,
590 16, -1, 37, -1, 174, 3, 54, 177, 55, 24,
591 154, -1, 174, 3, 54, 177, 55, 24, 155, -1,
592 174, 3, 54, 175, 55, 24, 158, -1, 174, 3,
593 54, 175, 55, 24, 161, -1, 52, 100, 53, -1,
594 118, 8, 118, -1, 56, 154, -1, 174, 35, 24,
595 154, -1, 174, 35, 24, 155, -1, 174, 32, 179,
596 10, -1, 23, 169, 10, -1, 23, 52, 16, 53,
597 169, 10, -1, 170, 172, -1, 172, -1, 170, -1,
598 171, -1, 143, -1, 143, 51, -1, 143, 51, 171,
599 -1, 145, -1, 146, -1, 145, 172, -1, 146, 172,
600 -1, 174, 11, 24, 154, -1, -1, 27, -1, 176,
601 -1, 176, 51, 175, -1, 16, 8, 16, 50, 154,
602 -1, 178, -1, 178, 49, 177, -1, 158, -1, 118,
603 8, 118, -1, 180, 181, -1, 180, -1, 142, -1,
604 5, 182, 24, 183, -1, 16, 50, 154, -1, 154,
605 -1, 184, -1, 184, 51, -1, 184, 51, 183, -1,
606 124, 50, 52, 179, 53, -1
607 };
608
609 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
610 static const unsigned short int yyrline[] =
611 {
612 0, 261, 261, 261, 285, 285, 285, 287, 288, 293,
613 293, 295, 296, 304, 306, 308, 310, 313, 316, 317,
614 319, 320, 322, 327, 328, 330, 330, 330, 330, 331,
615 331, 331, 333, 335, 339, 340, 342, 342, 342, 342,
616 343, 343, 343, 372, 373, 374, 375, 376, 377, 378,
617 379, 380, 381, 382, 383, 384, 385, 386, 388, 390,
618 391, 392, 393, 394, 395, 396, 397, 398, 399, 401,
619 403, 403, 405, 405, 407, 408, 410, 411, 423, 423,
620 425, 426, 427, 429, 431, 432, 434, 435, 459, 460,
621 461, 462, 463, 464, 465, 467, 468, 469, 470, 471,
622 472, 473, 474, 475, 478, 479, 480, 481, 482, 484,
623 485, 486, 487, 488, 489, 490, 492, 493, 495, 497,
624 499, 500, 502, 503, 504, 505, 506, 507, 508, 510,
625 511, 512, 513, 514, 515, 517, 518, 519, 521, 522,
626 524, 524, 526, 527, 529, 529, 532, 536, 537, 539,
627 542, 545, 545, 547, 548, 549, 591, 594, 595, 596,
628 597, 599, 602, 603, 605, 606, 608, 611, 612, 614,
629 616, 619, 620, 621, 626, 632, 634, 635, 639, 641,
630 646, 648, 652, 654, 658, 660, 662, 664, 666, 668,
631 670, 672, 675, 676, 677, 678, 681, 682, 684, 685,
632 687, 688, 688, 690, 691, 693, 693, 699, 699, 699,
633 699, 699, 699, 700, 700, 700, 700, 700, 702, 702,
634 702, 702, 702, 704, 706, 708, 710, 711, 713, 716,
635 719, 721, 724, 726, 729, 731, 733, 735, 738, 740,
636 743, 745, 746, 748, 751, 752, 753, 755, 755, 756,
637 757, 761, 763, 763, 765, 766, 768, 771, 771, 774,
638 775, 779, 781, 784, 786, 791, 792, 795, 796, 797,
639 799
640 };
641 #endif
642
643 #if YYDEBUG || YYERROR_VERBOSE
644 /* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
645 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
646 static const char *const yytname[] =
647 {
648 "$end", "error", "$undefined", "ARRAY", "BEGIN", "CASE", "CONST", "DO",
649 "DOTS", "ELSE", "END", "FIL", "FAR", "FOR", "FUNCTION", "GOTO", "IDENT",
650 "ICONST", "IF", "IMPLEMENTATION", "INTERFACE", "LABEL", "LOOPHOLE",
651 "OBJECT", "OF", "ORIGIN", "OTHERWISE", "PACKED", "PROCEDURE", "PROGRAM",
652 "RCONST", "READ", "RECORD", "REPEAT", "RETURN", "SET", "SCONST",
653 "STRING", "THEN", "TO", "TYPE", "UNTIL", "UNIT", "UNIT_END", "VAR",
654 "WHILE", "WITH", "'.'", "WRITE", "','", "':'", "';'", "'('", "')'",
655 "'['", "']'", "'^'", "'@'", "SCOPE", "LETSHR", "LETSHL", "LETOR",
656 "LETAND", "LETMUL", "LETDIV", "LETSUB", "LETADD", "LET", "IN", "GE",
657 "GT", "LE", "LT", "NE", "EQ", "XOR", "OR", "MINUS", "PLUS", "SHL", "SHR",
658 "AND", "MUL", "DIVR", "DIV", "MOD", "ADDRESS", "NOT", "UMINUS", "UPLUS",
659 "$accept", "translation", "@1", "input_file", "program", "progend",
660 "module", "unit", "unit_def_list", "prog_param_list", "ident_list",
661 "block", "decl_part_list", "decl_part", "unit_spec", "unit_decl_list",
662 "unit_decl", "statement", "compoundst", "sequence", "actual_params",
663 "write_params", "case_list", "otherwise", "case_items", "case_item",
664 "case_elem_list", "case_elem", "expr", "simple_expr", "primary",
665 "constant", "set_elem_list", "set_elem", "expr_list", "act_param_list",
666 "act_param", "record_constant", "field_init_list", "field_init_item",
667 "expr_group", "write_list", "write_param", "label_decl_part",
668 "label_list", "const_def_part", "const_def_list", "const_def",
669 "type_def_part", "type_def_list", "type_def", "var_decl_part",
670 "var_decl_list", "var_decl", "proc_decl", "proc_fwd_decl", "proc_spec",
671 "proc_def", "qualifiers", "formal_params", "formal_param_list",
672 "formal_param", "param_decl", "param_type", "type", "const_type",
673 "fptr_type", "string_type", "simple_type", "array_type",
674 "const_array_type", "conformant_array_type", "enum_type", "range_type",
675 "pointer_type", "set_type", "const_set_type", "record_type",
676 "object_type", "object_components", "object_fields", "field_decl_list",
677 "object_methods", "file_type", "packed", "conformant_indices",
678 "conformant_index", "indices", "index_spec", "field_list", "fixed_part",
679 "variant_part", "selector", "variant_list", "variant", 0
680 };
681 #endif
682
683 # ifdef YYPRINT
684 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
685 token YYLEX-NUM. */
686 static const unsigned short int yytoknum[] =
687 {
688 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
689 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
690 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
691 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
692 295, 296, 297, 298, 299, 300, 301, 46, 302, 44,
693 58, 59, 40, 41, 91, 93, 94, 64, 303, 304,
694 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
695 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
696 325, 326, 327, 328, 329, 330, 331, 332, 333, 334
697 };
698 # endif
699
700 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
701 static const unsigned char yyr1[] =
702 {
703 0, 90, 92, 91, 93, 93, 93, 94, 94, 95,
704 95, 96, 96, 97, 97, 97, 97, 98, 99, 99,
705 100, 100, 101, 102, 102, 103, 103, 103, 103, 103,
706 103, 103, 104, 104, 105, 105, 106, 106, 106, 106,
707 106, 106, 106, 107, 107, 107, 107, 107, 107, 107,
708 107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
709 107, 107, 107, 107, 107, 107, 107, 107, 107, 108,
710 109, 109, 110, 110, 111, 111, 112, 112, 113, 113,
711 114, 114, 114, 115, 116, 116, 117, 117, 118, 118,
712 118, 118, 118, 118, 118, 118, 118, 118, 118, 118,
713 118, 118, 118, 118, 118, 118, 118, 118, 118, 118,
714 118, 118, 118, 118, 118, 118, 119, 119, 119, 119,
715 119, 119, 120, 120, 120, 120, 120, 120, 120, 121,
716 121, 121, 121, 121, 121, 122, 122, 122, 123, 123,
717 124, 124, 125, 125, 126, 126, 127, 128, 128, 129,
718 130, 131, 131, 132, 132, 132, 133, 134, 134, 134,
719 134, 135, 136, 136, 137, 137, 138, 139, 139, 140,
720 141, 142, 142, 142, 142, 142, 143, 143, 144, 144,
721 145, 145, 146, 146, 147, 147, 147, 147, 147, 147,
722 147, 147, 148, 148, 148, 148, 149, 149, 150, 150,
723 151, 151, 151, 152, 152, 153, 153, 154, 154, 154,
724 154, 154, 154, 154, 154, 154, 154, 154, 155, 155,
725 155, 155, 155, 156, 156, 157, 158, 158, 159, 160,
726 161, 161, 162, 163, 164, 165, 166, 167, 168, 168,
727 169, 169, 169, 170, 171, 171, 171, 172, 172, 172,
728 172, 173, 174, 174, 175, 175, 176, 177, 177, 178,
729 178, 179, 179, 180, 181, 182, 182, 183, 183, 183,
730 184
731 };
732
733 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
734 static const unsigned char yyr2[] =
735 {
736 0, 2, 0, 2, 1, 1, 1, 2, 6, 0,
737 1, 1, 6, 9, 9, 6, 6, 1, 0, 3,
738 3, 1, 2, 0, 2, 1, 1, 1, 1, 1,
739 1, 1, 6, 3, 0, 2, 1, 1, 1, 1,
740 1, 1, 1, 0, 3, 3, 3, 3, 3, 3,
741 3, 3, 3, 2, 2, 5, 4, 6, 8, 4,
742 4, 2, 2, 1, 1, 4, 3, 3, 1, 3,
743 1, 3, 0, 1, 0, 3, 1, 3, 1, 1,
744 0, 1, 3, 3, 1, 3, 1, 3, 1, 3,
745 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
746 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
747 3, 3, 3, 3, 3, 3, 1, 2, 2, 2,
748 2, 2, 1, 3, 4, 3, 2, 4, 6, 1,
749 1, 1, 1, 3, 1, 0, 1, 3, 1, 3,
750 1, 3, 1, 3, 1, 0, 3, 1, 3, 3,
751 3, 1, 3, 1, 3, 5, 3, 1, 3, 1,
752 3, 2, 0, 3, 3, 5, 2, 0, 3, 3,
753 2, 0, 1, 3, 5, 3, 3, 5, 3, 5,
754 6, 8, 4, 6, 6, 8, 8, 10, 5, 8,
755 10, 7, 2, 2, 1, 1, 0, 3, 1, 3,
756 2, 1, 1, 3, 1, 1, 1, 1, 1, 1,
757 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
758 1, 1, 1, 4, 2, 4, 1, 1, 7, 7,
759 7, 7, 3, 3, 2, 4, 4, 4, 3, 6,
760 2, 1, 1, 1, 1, 2, 3, 1, 1, 2,
761 2, 4, 0, 1, 1, 3, 5, 1, 3, 1,
762 3, 2, 1, 1, 4, 3, 1, 1, 2, 3,
763 5
764 };
765
766 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
767 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
768 means the default is an error. */
769 static const unsigned short int yydefact[] =
770 {
771 2, 0, 23, 1, 162, 0, 34, 0, 0, 0,
772 167, 0, 171, 3, 4, 5, 6, 0, 11, 23,
773 31, 25, 26, 27, 28, 30, 29, 0, 161, 0,
774 196, 0, 34, 0, 0, 42, 0, 34, 36, 37,
775 38, 39, 41, 40, 159, 157, 0, 196, 18, 0,
776 166, 0, 0, 21, 0, 170, 172, 7, 43, 22,
777 24, 252, 0, 162, 0, 23, 0, 0, 196, 0,
778 196, 0, 23, 33, 35, 0, 0, 156, 0, 0,
779 0, 0, 252, 167, 0, 0, 0, 252, 171, 0,
780 0, 0, 134, 130, 0, 0, 131, 72, 43, 64,
781 132, 0, 0, 74, 0, 135, 70, 68, 0, 63,
782 122, 129, 226, 253, 227, 0, 222, 218, 219, 221,
783 220, 0, 134, 130, 0, 0, 0, 0, 0, 164,
784 88, 116, 163, 196, 0, 0, 0, 0, 21, 0,
785 0, 204, 202, 0, 198, 201, 252, 0, 0, 0,
786 0, 17, 160, 158, 196, 23, 0, 23, 196, 134,
787 0, 196, 0, 252, 0, 169, 217, 216, 207, 208,
788 214, 215, 213, 211, 209, 210, 212, 0, 168, 34,
789 0, 20, 176, 173, 175, 0, 0, 54, 53, 43,
790 43, 0, 252, 0, 62, 73, 0, 0, 140, 0,
791 0, 61, 134, 0, 0, 147, 138, 0, 136, 43,
792 69, 0, 145, 0, 126, 0, 0, 0, 0, 0,
793 0, 0, 0, 0, 0, 0, 0, 171, 0, 120,
794 118, 116, 117, 121, 119, 0, 0, 0, 0, 0,
795 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
796 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
797 0, 0, 0, 23, 188, 196, 196, 200, 252, 197,
798 0, 0, 252, 182, 34, 0, 0, 0, 0, 194,
799 195, 0, 0, 19, 0, 9, 0, 0, 244, 247,
800 248, 0, 242, 243, 241, 224, 134, 0, 234, 0,
801 0, 0, 0, 0, 0, 171, 80, 0, 67, 66,
802 43, 0, 0, 0, 43, 0, 43, 153, 0, 151,
803 0, 123, 146, 0, 0, 133, 135, 71, 125, 144,
804 0, 142, 0, 52, 51, 50, 49, 48, 47, 46,
805 45, 44, 0, 165, 0, 263, 0, 262, 252, 115,
806 112, 109, 111, 110, 114, 113, 108, 107, 90, 89,
807 105, 106, 104, 92, 94, 93, 91, 101, 100, 103,
808 102, 99, 98, 97, 96, 95, 252, 0, 0, 178,
809 227, 203, 205, 206, 0, 199, 23, 0, 0, 15,
810 16, 23, 23, 192, 193, 184, 180, 8, 10, 12,
811 252, 0, 245, 249, 250, 238, 240, 232, 233, 0,
812 252, 252, 23, 32, 177, 174, 0, 76, 81, 0,
813 84, 86, 0, 56, 0, 150, 60, 59, 141, 65,
814 0, 75, 0, 149, 0, 148, 139, 137, 124, 145,
815 127, 225, 0, 259, 0, 257, 237, 252, 261, 236,
816 0, 191, 252, 0, 0, 0, 0, 183, 0, 0,
817 223, 0, 246, 0, 251, 235, 0, 55, 79, 78,
818 43, 80, 43, 0, 0, 0, 43, 0, 154, 152,
819 143, 0, 0, 0, 134, 266, 0, 23, 179, 0,
820 23, 185, 181, 186, 189, 0, 0, 0, 0, 77,
821 82, 83, 85, 87, 0, 57, 128, 0, 260, 252,
822 258, 252, 0, 0, 0, 0, 254, 0, 239, 252,
823 13, 14, 43, 155, 229, 265, 0, 264, 267, 187,
824 0, 0, 0, 190, 228, 58, 0, 268, 0, 252,
825 255, 171, 269, 252, 230, 231, 0, 256, 270
826 };
827
828 /* YYDEFGOTO[NTERM-NUM]. */
829 static const short int yydefgoto[] =
830 {
831 -1, 1, 2, 13, 14, 399, 15, 16, 150, 81,
832 54, 17, 136, 19, 20, 36, 37, 106, 107, 108,
833 194, 201, 416, 470, 417, 418, 419, 420, 164, 130,
834 131, 110, 207, 208, 203, 330, 331, 111, 204, 205,
835 195, 318, 319, 21, 46, 22, 28, 29, 23, 50,
836 51, 24, 345, 56, 142, 25, 43, 26, 282, 67,
837 143, 144, 145, 381, 165, 115, 166, 167, 168, 169,
838 118, 383, 170, 171, 172, 173, 119, 174, 175, 291,
839 292, 293, 294, 176, 177, 515, 516, 444, 445, 346,
840 347, 448, 486, 527, 528
841 };
842
843 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
844 STATE-NUM. */
845 #define YYPACT_NINF -400
846 static const short int yypact[] =
847 {
848 -400, 13, 235, -400, 9, 16, 293, 245, 38, 42,
849 54, 90, 93, -400, -400, -400, -400, 72, 57, 360,
850 -400, -400, -400, -400, -400, -400, -400, -31, -400, 73,
851 188, 117, 293, 121, 123, -400, 5, 293, -400, -400,
852 -400, -400, -400, -400, 94, 98, 128, 29, 120, 140,
853 -400, 177, 181, 10, 186, -400, 187, -400, 934, -400,
854 -400, 99, 717, 9, 226, 351, 106, 204, 205, 113,
855 205, 208, 360, -400, -400, 245, 245, -400, 232, 229,
856 265, 231, 654, 54, 266, 717, 265, 654, -2, 717,
857 269, 250, 244, 246, 717, 248, -400, 249, 934, -400,
858 -400, 717, 717, 251, 728, 717, 253, -400, 287, 633,
859 -400, -400, -400, -400, 255, 224, -400, -400, -400, -400,
860 -400, 30, -400, -400, 75, 717, 717, 75, 717, 1134,
861 -400, 1133, -400, 205, 259, 267, 57, 300, 268, 306,
862 265, 273, -400, 271, 283, -400, 654, 286, 292, 318,
863 12, -400, -400, -400, 205, 890, 294, 360, 205, 873,
864 88, 205, 767, 654, 478, -400, -400, -400, -400, -400,
865 -400, -400, -400, -400, -400, -400, -400, 64, -400, 293,
866 958, -400, -400, 299, -400, 787, 284, -400, -400, 934,
867 934, 527, 654, 717, -400, -400, 311, 426, 922, 346,
868 717, -400, 312, 314, 315, 313, 504, 321, 324, 934,
869 -400, 354, 717, 717, -400, 717, 717, 717, 717, 717,
870 717, 717, 717, 717, 717, 717, 328, 93, 359, 175,
871 -400, 175, -400, 175, -400, 717, 717, 717, 717, 717,
872 717, 717, 717, 717, 717, 717, 717, 717, 717, 717,
873 717, 717, 717, 717, 717, 717, 717, 717, 717, 717,
874 717, 717, 335, 360, -400, 205, 205, -400, 196, -400,
875 106, 336, 654, -1, 293, 339, 342, 341, 343, -1,
876 -1, 347, 348, -400, 350, 8, 340, 387, 355, 104,
877 104, 395, 104, -400, -400, -400, 197, 358, -400, 717,
878 353, 384, 389, 82, 7, 93, 717, 717, -400, -400,
879 934, 368, 371, 717, 934, 717, 934, 994, 372, 378,
880 717, -400, -400, 405, 717, -400, 717, -400, -400, 1134,
881 382, 390, 376, 1134, 1134, 1134, 1134, 1134, 1134, 1134,
882 1134, 1134, 1094, 1134, 393, -400, 431, 437, 99, 438,
883 438, 438, 438, 438, 438, 438, 247, 247, 247, 247,
884 -400, -400, -400, -400, -400, -400, -400, 1134, 1134, 1134,
885 1134, 1134, 1134, 1134, 1134, 1134, 654, 385, 394, -400,
886 -400, -400, -400, -400, 443, -400, 915, 403, 412, -400,
887 -400, 360, 360, -400, -400, -400, -400, -400, -400, -400,
888 654, 406, 93, -400, -400, -400, -400, -400, 1134, 393,
889 654, 654, 360, -400, -400, -400, 448, 105, 410, 413,
890 415, 556, 757, 453, 717, -400, 1134, -400, -400, -400,
891 717, -400, 717, 1134, 312, -400, 1134, -400, -400, 717,
892 -400, -400, 582, -400, 411, 416, -400, 700, -400, -400,
893 418, -400, 654, 419, 421, 424, 425, -1, 430, 432,
894 -400, 114, -400, 422, -400, -400, 69, -400, -400, -400,
895 934, 717, 934, 717, 717, 717, 934, 1063, 1030, -400,
896 -400, 717, 461, 393, 3, -400, 463, 360, -400, 472,
897 360, -400, -400, -400, -400, 479, 466, 444, 446, -400,
898 -400, -400, -400, 1134, 460, -400, -400, 717, 1134, 99,
899 -400, 654, 717, 473, 517, 471, 515, 516, -400, 654,
900 -400, -400, 934, 1134, -400, -400, 518, -400, 519, -400,
901 553, 547, 472, -400, -400, -400, 539, 717, 542, 196,
902 -400, 93, -400, 654, -400, -400, 540, -400, -400
903 };
904
905 /* YYPGOTO[NTERM-NUM]. */
906 static const short int yypgoto[] =
907 {
908 -400, -400, -400, -400, -400, -400, -400, -400, 182, -400,
909 14, -47, 2, -400, 31, -6, -400, -161, -15, -92,
910 -400, -400, -400, -400, 142, -400, 141, -400, -55, 92,
911 -38, -400, 289, -400, -100, 178, -400, -400, 295, -400,
912 -400, 184, -400, 32, 198, 34, 557, -400, 45, 536,
913 -400, 46, -3, -149, -400, 66, -115, -400, -238, 76,
914 352, -400, 481, -400, -51, -331, -400, -56, -61, -400,
915 -400, 84, -400, -400, -400, -400, -400, -53, -400, 183,
916 -400, 240, 1, -400, -60, 111, -400, -399, -400, 107,
917 -400, -400, -400, 108, -400
918 };
919
920 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
921 positive, shift that token. If negative, reduce the rule which
922 number is the opposite. If zero, do what YYDEFACT says.
923 If YYTABLE_NINF, syntax error. */
924 #define YYTABLE_NINF -227
925 static const short int yytable[] =
926 {
927 117, 121, 199, 59, 18, 116, 196, 129, 120, 55,
928 463, 288, 58, 3, 53, 279, 58, 449, 135, 61,
929 109, 60, 275, 112, 72, 27, 69, -226, 308, 309,
930 180, 74, 30, 226, 185, 85, 182, 35, 38, 191,
931 39, 393, 394, 62, 380, 290, 197, 198, 73, 198,
932 206, 40, 41, 511, 47, 398, 183, 280, 48, 86,
933 109, 58, 227, 35, 38, 228, 39, 300, 35, 38,
934 49, 39, 42, 58, 151, 301, 78, 40, 41, 497,
935 141, 66, 40, 41, 510, 184, 229, 231, 231, 233,
936 231, 122, 123, 312, 156, 271, 227, 95, 42, 302,
937 181, 412, 31, 42, 53, 96, 52, 198, 281, 53,
938 284, 100, 298, 332, 468, 112, 33, 327, 31, 57,
939 137, 59, 138, 79, 63, 413, 113, 104, 31, 105,
940 53, 469, 33, 68, 139, 276, 114, 70, 198, 71,
941 287, 311, 33, 75, 147, 317, 148, 76, 456, 423,
942 140, 109, 109, 427, 141, 429, 73, 329, 198, 285,
943 333, 334, 335, 336, 337, 338, 339, 340, 341, 342,
944 343, 109, 80, 303, 290, 290, 297, 290, 524, 77,
945 349, 350, 351, 352, 353, 354, 355, 356, 357, 358,
946 359, 360, 361, 362, 363, 364, 365, 366, 367, 368,
947 369, 370, 371, 372, 373, 374, 375, 382, 384, 262,
948 35, 38, 112, 39, 82, 428, 377, 230, 232, 456,
949 234, 387, 211, 113, 40, 41, 289, 212, 83, 213,
950 277, 214, 84, 380, 286, 64, 87, 295, 88, 65,
951 66, 4, 133, 414, 408, 42, 86, 320, 154, 5,
952 -21, 421, 422, 288, 146, 6, 7, 66, 426, 149,
953 198, 44, 45, 8, 9, 433, 187, 188, 388, 436,
954 59, 206, 109, 152, 153, 10, 109, 11, 109, 12,
955 155, 138, 157, 443, 141, 186, 179, 117, 121, 442,
956 403, 404, 116, 406, 189, 120, 190, 210, 225, 4,
957 192, 193, 415, 200, 209, 35, 38, 31, 39, 224,
958 263, 501, 288, 32, 7, 505, 265, 86, 264, 40,
959 41, 33, 266, 268, 269, 450, 246, 247, 248, 249,
960 250, 251, 252, 10, 270, 34, 272, 12, 274, 455,
961 42, 378, 379, 273, 458, 459, 290, 283, 443, 460,
962 305, 307, 313, 316, 442, 289, 289, 4, 289, 464,
963 465, 535, 320, 134, 323, 5, 4, 321, 322, 477,
964 328, 32, 7, 326, 5, 478, 325, 317, 499, 8,
965 32, 7, 344, 348, 329, 376, 389, 386, 8, 390,
966 400, 10, 391, 34, 392, 12, 485, 397, 395, 396,
967 10, 488, 34, 401, 12, 405, 402, 409, 410, 159,
968 123, 407, 526, 411, 151, 95, 421, 424, 421, 503,
969 504, 434, 443, 96, 425, 431, 508, 432, 442, 100,
970 380, 440, 109, 314, 109, 438, 451, 526, 109, 439,
971 513, 446, 447, 517, 452, 104, 453, 105, 117, 121,
972 124, 498, 523, 116, 457, 413, 120, 198, 467, 461,
973 525, 471, 476, 472, 473, 483, 482, 522, 534, 487,
974 125, 126, 490, 489, 127, 491, 492, 496, 544, 384,
975 128, 493, 198, 494, 109, 509, 299, 512, 514, 518,
976 519, 520, 547, 521, 235, 236, 237, 238, 239, 240,
977 241, 242, 243, 244, 245, 246, 247, 248, 249, 250,
978 251, 252, 324, 242, 243, 244, 245, 246, 247, 248,
979 249, 250, 251, 252, 529, 530, 531, 289, 235, 236,
980 237, 238, 239, 240, 241, 242, 243, 244, 245, 246,
981 247, 248, 249, 250, 251, 252, 235, 236, 237, 238,
982 239, 240, 241, 242, 243, 244, 245, 246, 247, 248,
983 249, 250, 251, 252, 474, 310, 532, 533, 536, 538,
984 537, 539, 235, 236, 237, 238, 239, 240, 241, 242,
985 243, 244, 245, 246, 247, 248, 249, 250, 251, 252,
986 481, 541, 543, 548, 466, 235, 236, 237, 238, 239,
987 240, 241, 242, 243, 244, 245, 246, 247, 248, 249,
988 250, 251, 252, 500, 502, 437, 479, 480, 435, 178,
989 132, 267, 385, 545, 235, 236, 237, 238, 239, 240,
990 241, 242, 243, 244, 245, 246, 247, 248, 249, 250,
991 251, 252, 462, 540, 495, 542, 0, 0, 546, 0,
992 235, 236, 237, 238, 239, 240, 241, 242, 243, 244,
993 245, 246, 247, 248, 249, 250, 251, 252, 158, 0,
994 159, 123, 0, 0, 0, 0, 95, 160, 0, 0,
995 211, 113, 161, 0, 96, 212, 0, 213, 0, 214,
996 100, 114, 215, 216, 217, 218, 219, 220, 221, 222,
997 223, 0, 0, 0, 0, 0, 162, 0, 105, 0,
998 163, 124, 0, 0, 158, 0, 484, 123, 0, 0,
999 0, 0, 95, 160, 0, 0, 0, 113, 161, 0,
1000 96, 125, 126, 122, 123, 127, 100, 114, 0, 95,
1001 0, 128, 0, 0, 202, 123, 0, 96, 0, 0,
1002 95, 0, 162, 100, 105, 0, 163, 124, 96, 0,
1003 0, 0, 0, 0, 100, 0, 0, 0, 0, 104,
1004 0, 105, 0, 0, 124, 0, 0, 125, 126, 0,
1005 104, 127, 105, 296, 123, 124, 0, 128, 0, 95,
1006 0, 0, 0, 0, 125, 126, 475, 96, 127, 0,
1007 0, 0, 0, 100, 128, 125, 126, 0, 0, 127,
1008 0, 306, 0, 0, 0, 128, 0, 0, 0, 104,
1009 0, 105, 0, 0, 124, 235, 236, 237, 238, 239,
1010 240, 241, 242, 243, 244, 245, 246, 247, 248, 249,
1011 250, 251, 252, 0, 125, 126, 0, 0, 127, 0,
1012 0, 0, 0, 0, 128, 235, 236, 237, 238, 239,
1013 240, 241, 242, 243, 244, 245, 246, 247, 248, 249,
1014 250, 251, 252, -226, 0, 0, 0, -226, -226, -226,
1015 0, 0, 0, -226, 0, 0, 0, -226, 0, 0,
1016 0, 0, -226, -226, -226, 0, 4, -226, 0, 0,
1017 0, -226, 278, 0, 5, 0, 279, 0, 0, 0,
1018 32, 7, 0, -226, 0, -226, -226, -226, 8, 0,
1019 0, 4, -226, 0, -226, 0, -226, 454, -226, 5,
1020 10, 279, 34, 0, 12, 32, 7, 0, 58, 89,
1021 0, 0, 0, 8, 0, 0, 0, 90, 280, 91,
1022 92, 93, 94, 0, 0, 10, 95, 34, 0, 12,
1023 0, 0, 0, 0, 96, 97, 0, 98, 99, 0,
1024 100, 315, 0, 280, 0, 0, 0, 0, 0, 101,
1025 102, 0, 103, 0, 0, 0, 104, 0, 105, 0,
1026 235, 236, 237, 238, 239, 240, 241, 242, 243, 244,
1027 245, 246, 247, 248, 249, 250, 251, 252, 304, 0,
1028 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1029 0, 0, 0, 0, 0, 0, 235, 236, 237, 238,
1030 239, 240, 241, 242, 243, 244, 245, 246, 247, 248,
1031 249, 250, 251, 252, 430, 0, 0, 0, 0, 0,
1032 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1033 0, 0, 235, 236, 237, 238, 239, 240, 241, 242,
1034 243, 244, 245, 246, 247, 248, 249, 250, 251, 252,
1035 507, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1036 0, 0, 0, 0, 0, 0, 0, 0, 235, 236,
1037 237, 238, 239, 240, 241, 242, 243, 244, 245, 246,
1038 247, 248, 249, 250, 251, 252, 506, 0, 0, 0,
1039 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1040 0, 235, 236, 237, 238, 239, 240, 241, 242, 243,
1041 244, 245, 246, 247, 248, 249, 250, 251, 252, 441,
1042 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1043 0, 0, 235, 236, 237, 238, 239, 240, 241, 242,
1044 243, 244, 245, 246, 247, 248, 249, 250, 251, 252,
1045 211, 0, 0, 0, 0, 212, 0, 213, 0, 214,
1046 0, 0, 253, 254, 255, 256, 257, 258, 259, 260,
1047 261, 0, 235, 236, 237, 238, 239, 240, 241, 242,
1048 243, 244, 245, 246, 247, 248, 249, 250, 251, 252
1049 };
1050
1051 static const short int yycheck[] =
1052 {
1053 61, 61, 102, 18, 2, 61, 98, 62, 61, 12,
1054 409, 160, 4, 0, 16, 16, 4, 348, 65, 50,
1055 58, 19, 10, 16, 19, 16, 32, 24, 189, 190,
1056 85, 37, 16, 3, 89, 25, 87, 6, 6, 94,
1057 6, 279, 280, 74, 37, 160, 101, 102, 43, 104,
1058 105, 6, 6, 50, 16, 47, 58, 58, 16, 49,
1059 98, 4, 32, 32, 32, 35, 32, 3, 37, 37,
1060 16, 37, 6, 4, 72, 11, 47, 32, 32, 10,
1061 66, 52, 37, 37, 483, 88, 124, 125, 126, 127,
1062 128, 16, 17, 193, 80, 146, 32, 22, 32, 35,
1063 86, 19, 14, 37, 16, 30, 16, 162, 155, 16,
1064 157, 36, 163, 213, 9, 16, 28, 209, 14, 47,
1065 14, 136, 16, 47, 51, 43, 27, 52, 14, 54,
1066 16, 26, 28, 16, 28, 150, 37, 16, 193, 16,
1067 52, 192, 28, 49, 68, 200, 70, 49, 386, 310,
1068 44, 189, 190, 314, 140, 316, 43, 212, 213, 157,
1069 215, 216, 217, 218, 219, 220, 221, 222, 223, 224,
1070 225, 209, 52, 179, 289, 290, 162, 292, 509, 51,
1071 235, 236, 237, 238, 239, 240, 241, 242, 243, 244,
1072 245, 246, 247, 248, 249, 250, 251, 252, 253, 254,
1073 255, 256, 257, 258, 259, 260, 261, 268, 268, 133,
1074 179, 179, 16, 179, 74, 315, 263, 125, 126, 457,
1075 128, 272, 47, 27, 179, 179, 160, 52, 51, 54,
1076 154, 56, 51, 37, 158, 47, 50, 161, 51, 51,
1077 52, 6, 16, 304, 299, 179, 49, 50, 16, 14,
1078 53, 306, 307, 402, 50, 20, 21, 52, 313, 51,
1079 315, 16, 17, 28, 29, 320, 16, 17, 274, 324,
1080 285, 326, 310, 75, 76, 40, 314, 42, 316, 44,
1081 51, 16, 51, 344, 270, 16, 20, 348, 348, 344,
1082 289, 290, 348, 292, 50, 348, 50, 10, 74, 6,
1083 52, 52, 305, 52, 51, 274, 274, 14, 274, 54,
1084 51, 472, 461, 20, 21, 476, 16, 49, 51, 274,
1085 274, 28, 16, 50, 53, 376, 79, 80, 81, 82,
1086 83, 84, 85, 40, 51, 42, 50, 44, 20, 386,
1087 274, 265, 266, 51, 391, 392, 461, 53, 409, 400,
1088 51, 67, 41, 7, 409, 289, 290, 6, 292, 410,
1089 411, 522, 50, 12, 51, 14, 6, 53, 53, 424,
1090 16, 20, 21, 49, 14, 430, 55, 432, 470, 28,
1091 20, 21, 54, 24, 439, 50, 47, 51, 28, 47,
1092 50, 40, 51, 42, 51, 44, 447, 47, 51, 51,
1093 40, 452, 42, 16, 44, 10, 51, 54, 24, 16,
1094 17, 53, 512, 24, 412, 22, 471, 49, 473, 474,
1095 475, 16, 483, 30, 53, 53, 481, 49, 483, 36,
1096 37, 55, 470, 7, 472, 53, 51, 537, 476, 49,
1097 487, 10, 5, 490, 50, 52, 3, 54, 509, 509,
1098 57, 466, 507, 509, 51, 43, 509, 512, 10, 53,
1099 511, 51, 9, 50, 49, 49, 55, 7, 519, 51,
1100 77, 78, 51, 54, 81, 51, 51, 55, 539, 539,
1101 87, 51, 537, 51, 522, 24, 8, 24, 16, 10,
1102 24, 47, 543, 47, 68, 69, 70, 71, 72, 73,
1103 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
1104 84, 85, 8, 75, 76, 77, 78, 79, 80, 81,
1105 82, 83, 84, 85, 51, 8, 55, 461, 68, 69,
1106 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1107 80, 81, 82, 83, 84, 85, 68, 69, 70, 71,
1108 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
1109 82, 83, 84, 85, 8, 38, 51, 51, 50, 16,
1110 51, 24, 68, 69, 70, 71, 72, 73, 74, 75,
1111 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
1112 8, 52, 50, 53, 412, 68, 69, 70, 71, 72,
1113 73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
1114 83, 84, 85, 471, 473, 326, 432, 439, 323, 83,
1115 63, 140, 270, 539, 68, 69, 70, 71, 72, 73,
1116 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
1117 84, 85, 402, 532, 461, 537, -1, -1, 541, -1,
1118 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
1119 78, 79, 80, 81, 82, 83, 84, 85, 14, -1,
1120 16, 17, -1, -1, -1, -1, 22, 23, -1, -1,
1121 47, 27, 28, -1, 30, 52, -1, 54, -1, 56,
1122 36, 37, 59, 60, 61, 62, 63, 64, 65, 66,
1123 67, -1, -1, -1, -1, -1, 52, -1, 54, -1,
1124 56, 57, -1, -1, 14, -1, 16, 17, -1, -1,
1125 -1, -1, 22, 23, -1, -1, -1, 27, 28, -1,
1126 30, 77, 78, 16, 17, 81, 36, 37, -1, 22,
1127 -1, 87, -1, -1, 16, 17, -1, 30, -1, -1,
1128 22, -1, 52, 36, 54, -1, 56, 57, 30, -1,
1129 -1, -1, -1, -1, 36, -1, -1, -1, -1, 52,
1130 -1, 54, -1, -1, 57, -1, -1, 77, 78, -1,
1131 52, 81, 54, 16, 17, 57, -1, 87, -1, 22,
1132 -1, -1, -1, -1, 77, 78, 39, 30, 81, -1,
1133 -1, -1, -1, 36, 87, 77, 78, -1, -1, 81,
1134 -1, 24, -1, -1, -1, 87, -1, -1, -1, 52,
1135 -1, 54, -1, -1, 57, 68, 69, 70, 71, 72,
1136 73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
1137 83, 84, 85, -1, 77, 78, -1, -1, 81, -1,
1138 -1, -1, -1, -1, 87, 68, 69, 70, 71, 72,
1139 73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
1140 83, 84, 85, 0, -1, -1, -1, 4, 5, 6,
1141 -1, -1, -1, 10, -1, -1, -1, 14, -1, -1,
1142 -1, -1, 19, 20, 21, -1, 6, 24, -1, -1,
1143 -1, 28, 12, -1, 14, -1, 16, -1, -1, -1,
1144 20, 21, -1, 40, -1, 42, 43, 44, 28, -1,
1145 -1, 6, 49, -1, 51, -1, 53, 12, 55, 14,
1146 40, 16, 42, -1, 44, 20, 21, -1, 4, 5,
1147 -1, -1, -1, 28, -1, -1, -1, 13, 58, 15,
1148 16, 17, 18, -1, -1, 40, 22, 42, -1, 44,
1149 -1, -1, -1, -1, 30, 31, -1, 33, 34, -1,
1150 36, 49, -1, 58, -1, -1, -1, -1, -1, 45,
1151 46, -1, 48, -1, -1, -1, 52, -1, 54, -1,
1152 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
1153 78, 79, 80, 81, 82, 83, 84, 85, 50, -1,
1154 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1155 -1, -1, -1, -1, -1, -1, 68, 69, 70, 71,
1156 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
1157 82, 83, 84, 85, 50, -1, -1, -1, -1, -1,
1158 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1159 -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
1160 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
1161 50, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1162 -1, -1, -1, -1, -1, -1, -1, -1, 68, 69,
1163 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1164 80, 81, 82, 83, 84, 85, 53, -1, -1, -1,
1165 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1166 -1, 68, 69, 70, 71, 72, 73, 74, 75, 76,
1167 77, 78, 79, 80, 81, 82, 83, 84, 85, 55,
1168 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1169 -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
1170 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
1171 47, -1, -1, -1, -1, 52, -1, 54, -1, 56,
1172 -1, -1, 59, 60, 61, 62, 63, 64, 65, 66,
1173 67, -1, 68, 69, 70, 71, 72, 73, 74, 75,
1174 76, 77, 78, 79, 80, 81, 82, 83, 84, 85
1175 };
1176
1177 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1178 symbol of state STATE-NUM. */
1179 static const unsigned char yystos[] =
1180 {
1181 0, 91, 92, 0, 6, 14, 20, 21, 28, 29,
1182 40, 42, 44, 93, 94, 96, 97, 101, 102, 103,
1183 104, 133, 135, 138, 141, 145, 147, 16, 136, 137,
1184 16, 14, 20, 28, 42, 104, 105, 106, 133, 135,
1185 138, 141, 145, 146, 16, 17, 134, 16, 16, 16,
1186 139, 140, 16, 16, 100, 142, 143, 47, 4, 108,
1187 102, 50, 74, 51, 47, 51, 52, 149, 16, 105,
1188 16, 16, 19, 43, 105, 49, 49, 51, 47, 149,
1189 52, 99, 74, 51, 51, 25, 49, 50, 51, 5,
1190 13, 15, 16, 17, 18, 22, 30, 31, 33, 34,
1191 36, 45, 46, 48, 52, 54, 107, 108, 109, 120,
1192 121, 127, 16, 27, 37, 155, 157, 158, 160, 166,
1193 167, 174, 16, 17, 57, 77, 78, 81, 87, 118,
1194 119, 120, 136, 16, 12, 101, 102, 14, 16, 28,
1195 44, 100, 144, 150, 151, 152, 50, 149, 149, 51,
1196 98, 102, 134, 134, 16, 51, 100, 51, 14, 16,
1197 23, 28, 52, 56, 118, 154, 156, 157, 158, 159,
1198 162, 163, 164, 165, 167, 168, 173, 174, 139, 20,
1199 118, 100, 154, 58, 142, 118, 16, 16, 17, 50,
1200 50, 118, 52, 52, 110, 130, 109, 118, 118, 124,
1201 52, 111, 16, 124, 128, 129, 118, 122, 123, 51,
1202 10, 47, 52, 54, 56, 59, 60, 61, 62, 63,
1203 64, 65, 66, 67, 54, 74, 3, 32, 35, 120,
1204 119, 120, 119, 120, 119, 68, 69, 70, 71, 72,
1205 73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
1206 83, 84, 85, 59, 60, 61, 62, 63, 64, 65,
1207 66, 67, 149, 51, 51, 16, 16, 152, 50, 53,
1208 51, 154, 50, 51, 20, 10, 108, 149, 12, 16,
1209 58, 101, 148, 53, 101, 102, 149, 52, 143, 145,
1210 146, 169, 170, 171, 172, 149, 16, 100, 154, 8,
1211 3, 11, 35, 105, 50, 51, 24, 67, 107, 107,
1212 38, 154, 124, 41, 7, 49, 7, 118, 131, 132,
1213 50, 53, 53, 51, 8, 55, 49, 109, 16, 118,
1214 125, 126, 124, 118, 118, 118, 118, 118, 118, 118,
1215 118, 118, 118, 118, 54, 142, 179, 180, 24, 118,
1216 118, 118, 118, 118, 118, 118, 118, 118, 118, 118,
1217 118, 118, 118, 118, 118, 118, 118, 118, 118, 118,
1218 118, 118, 118, 118, 118, 118, 50, 101, 149, 149,
1219 37, 153, 158, 161, 174, 150, 51, 154, 105, 47,
1220 47, 51, 51, 148, 148, 51, 51, 47, 47, 95,
1221 50, 16, 51, 172, 172, 10, 172, 53, 118, 54,
1222 24, 24, 19, 43, 158, 142, 112, 114, 115, 116,
1223 117, 118, 118, 107, 49, 53, 118, 107, 124, 107,
1224 50, 53, 49, 118, 16, 128, 118, 122, 53, 49,
1225 55, 55, 118, 158, 177, 178, 10, 5, 181, 155,
1226 154, 51, 50, 3, 12, 101, 148, 51, 101, 101,
1227 154, 53, 171, 177, 154, 154, 98, 10, 9, 26,
1228 113, 51, 50, 49, 8, 39, 9, 118, 118, 131,
1229 125, 8, 55, 49, 16, 154, 182, 51, 154, 54,
1230 51, 51, 51, 51, 51, 169, 55, 10, 108, 109,
1231 114, 107, 116, 118, 118, 107, 53, 50, 118, 24,
1232 177, 50, 24, 101, 16, 175, 176, 101, 10, 24,
1233 47, 47, 7, 118, 155, 154, 124, 183, 184, 51,
1234 8, 55, 51, 51, 154, 107, 50, 51, 16, 24,
1235 175, 52, 183, 50, 158, 161, 179, 154, 53
1236 };
1237
1238 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
1239 # define YYSIZE_T __SIZE_TYPE__
1240 #endif
1241 #if ! defined (YYSIZE_T) && defined (size_t)
1242 # define YYSIZE_T size_t
1243 #endif
1244 #if ! defined (YYSIZE_T)
1245 # if defined (__STDC__) || defined (__cplusplus)
1246 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
1247 # define YYSIZE_T size_t
1248 # endif
1249 #endif
1250 #if ! defined (YYSIZE_T)
1251 # define YYSIZE_T unsigned int
1252 #endif
1253
1254 #define yyerrok (yyerrstatus = 0)
1255 #define yyclearin (yychar = YYEMPTY)
1256 #define YYEMPTY (-2)
1257 #define YYEOF 0
1258
1259 #define YYACCEPT goto yyacceptlab
1260 #define YYABORT goto yyabortlab
1261 #define YYERROR goto yyerrorlab
1262
1263
1264 /* Like YYERROR except do call yyerror. This remains here temporarily
1265 to ease the transition to the new meaning of YYERROR, for GCC.
1266 Once GCC version 2 has supplanted version 1, this can go. */
1267
1268 #define YYFAIL goto yyerrlab
1269
1270 #define YYRECOVERING() (!!yyerrstatus)
1271
1272 #define YYBACKUP(Token, Value) \
1273 do \
1274 if (yychar == YYEMPTY && yylen == 1) \
1275 { \
1276 yychar = (Token); \
1277 yylval = (Value); \
1278 yytoken = YYTRANSLATE (yychar); \
1279 YYPOPSTACK; \
1280 goto yybackup; \
1281 } \
1282 else \
1283 { \
1284 yyerror ("syntax error: cannot back up");\
1285 YYERROR; \
1286 } \
1287 while (0)
1288
1289
1290 #define YYTERROR 1
1291 #define YYERRCODE 256
1292
1293
1294 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
1295 If N is 0, then set CURRENT to the empty location which ends
1296 the previous symbol: RHS[0] (always defined). */
1297
1298 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
1299 #ifndef YYLLOC_DEFAULT
1300 # define YYLLOC_DEFAULT(Current, Rhs, N) \
1301 do \
1302 if (N) \
1303 { \
1304 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
1305 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
1306 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
1307 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
1308 } \
1309 else \
1310 { \
1311 (Current).first_line = (Current).last_line = \
1312 YYRHSLOC (Rhs, 0).last_line; \
1313 (Current).first_column = (Current).last_column = \
1314 YYRHSLOC (Rhs, 0).last_column; \
1315 } \
1316 while (0)
1317 #endif
1318
1319
1320 /* YY_LOCATION_PRINT -- Print the location on the stream.
1321 This macro was not mandated originally: define only if we know
1322 we won't break user code: when these are the locations we know. */
1323
1324 #ifndef YY_LOCATION_PRINT
1325 # if YYLTYPE_IS_TRIVIAL
1326 # define YY_LOCATION_PRINT(File, Loc) \
1327 fprintf (File, "%d.%d-%d.%d", \
1328 (Loc).first_line, (Loc).first_column, \
1329 (Loc).last_line, (Loc).last_column)
1330 # else
1331 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1332 # endif
1333 #endif
1334
1335
1336 /* YYLEX -- calling `yylex' with the right arguments. */
1337
1338 #ifdef YYLEX_PARAM
1339 # define YYLEX yylex (YYLEX_PARAM)
1340 #else
1341 # define YYLEX yylex ()
1342 #endif
1343
1344 /* Enable debugging if requested. */
1345 #if YYDEBUG
1346
1347 # ifndef YYFPRINTF
1348 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1349 # define YYFPRINTF fprintf
1350 # endif
1351
1352 # define YYDPRINTF(Args) \
1353 do { \
1354 if (yydebug) \
1355 YYFPRINTF Args; \
1356 } while (0)
1357
1358 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1359 do { \
1360 if (yydebug) \
1361 { \
1362 YYFPRINTF (stderr, "%s ", Title); \
1363 yysymprint (stderr, \
1364 Type, Value); \
1365 YYFPRINTF (stderr, "\n"); \
1366 } \
1367 } while (0)
1368
1369 /*------------------------------------------------------------------.
1370 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1371 | TOP (included). |
1372 `------------------------------------------------------------------*/
1373
1374 #if defined (__STDC__) || defined (__cplusplus)
1375 static void
yy_stack_print(short int * bottom,short int * top)1376 yy_stack_print (short int *bottom, short int *top)
1377 #else
1378 static void
1379 yy_stack_print (bottom, top)
1380 short int *bottom;
1381 short int *top;
1382 #endif
1383 {
1384 YYFPRINTF (stderr, "Stack now");
1385 for (/* Nothing. */; bottom <= top; ++bottom)
1386 YYFPRINTF (stderr, " %d", *bottom);
1387 YYFPRINTF (stderr, "\n");
1388 }
1389
1390 # define YY_STACK_PRINT(Bottom, Top) \
1391 do { \
1392 if (yydebug) \
1393 yy_stack_print ((Bottom), (Top)); \
1394 } while (0)
1395
1396
1397 /*------------------------------------------------.
1398 | Report that the YYRULE is going to be reduced. |
1399 `------------------------------------------------*/
1400
1401 #if defined (__STDC__) || defined (__cplusplus)
1402 static void
yy_reduce_print(int yyrule)1403 yy_reduce_print (int yyrule)
1404 #else
1405 static void
1406 yy_reduce_print (yyrule)
1407 int yyrule;
1408 #endif
1409 {
1410 int yyi;
1411 unsigned int yylno = yyrline[yyrule];
1412 YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
1413 yyrule - 1, yylno);
1414 /* Print the symbols being reduced, and their result. */
1415 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
1416 YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
1417 YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
1418 }
1419
1420 # define YY_REDUCE_PRINT(Rule) \
1421 do { \
1422 if (yydebug) \
1423 yy_reduce_print (Rule); \
1424 } while (0)
1425
1426 /* Nonzero means print parse trace. It is left uninitialized so that
1427 multiple parsers can coexist. */
1428 int yydebug;
1429 #else /* !YYDEBUG */
1430 # define YYDPRINTF(Args)
1431 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1432 # define YY_STACK_PRINT(Bottom, Top)
1433 # define YY_REDUCE_PRINT(Rule)
1434 #endif /* !YYDEBUG */
1435
1436
1437 /* YYINITDEPTH -- initial size of the parser's stacks. */
1438 #ifndef YYINITDEPTH
1439 # define YYINITDEPTH 200
1440 #endif
1441
1442 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1443 if the built-in stack extension method is used).
1444
1445 Do not make this value too large; the results are undefined if
1446 SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
1447 evaluated with infinite-precision integer arithmetic. */
1448
1449 #ifndef YYMAXDEPTH
1450 # define YYMAXDEPTH 10000
1451 #endif
1452
1453
1454
1455 #if YYERROR_VERBOSE
1456
1457 # ifndef yystrlen
1458 # if defined (__GLIBC__) && defined (_STRING_H)
1459 # define yystrlen strlen
1460 # else
1461 /* Return the length of YYSTR. */
1462 static YYSIZE_T
1463 # if defined (__STDC__) || defined (__cplusplus)
yystrlen(const char * yystr)1464 yystrlen (const char *yystr)
1465 # else
1466 yystrlen (yystr)
1467 const char *yystr;
1468 # endif
1469 {
1470 register const char *yys = yystr;
1471
1472 while (*yys++ != '\0')
1473 continue;
1474
1475 return yys - yystr - 1;
1476 }
1477 # endif
1478 # endif
1479
1480 # ifndef yystpcpy
1481 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
1482 # define yystpcpy stpcpy
1483 # else
1484 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1485 YYDEST. */
1486 static char *
1487 # if defined (__STDC__) || defined (__cplusplus)
yystpcpy(char * yydest,const char * yysrc)1488 yystpcpy (char *yydest, const char *yysrc)
1489 # else
1490 yystpcpy (yydest, yysrc)
1491 char *yydest;
1492 const char *yysrc;
1493 # endif
1494 {
1495 register char *yyd = yydest;
1496 register const char *yys = yysrc;
1497
1498 while ((*yyd++ = *yys++) != '\0')
1499 continue;
1500
1501 return yyd - 1;
1502 }
1503 # endif
1504 # endif
1505
1506 #endif /* !YYERROR_VERBOSE */
1507
1508
1509
1510 #if YYDEBUG
1511 /*--------------------------------.
1512 | Print this symbol on YYOUTPUT. |
1513 `--------------------------------*/
1514
1515 #if defined (__STDC__) || defined (__cplusplus)
1516 static void
yysymprint(FILE * yyoutput,int yytype,YYSTYPE * yyvaluep)1517 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
1518 #else
1519 static void
1520 yysymprint (yyoutput, yytype, yyvaluep)
1521 FILE *yyoutput;
1522 int yytype;
1523 YYSTYPE *yyvaluep;
1524 #endif
1525 {
1526 /* Pacify ``unused variable'' warnings. */
1527 (void) yyvaluep;
1528
1529 if (yytype < YYNTOKENS)
1530 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1531 else
1532 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1533
1534
1535 # ifdef YYPRINT
1536 if (yytype < YYNTOKENS)
1537 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1538 # endif
1539 switch (yytype)
1540 {
1541 default:
1542 break;
1543 }
1544 YYFPRINTF (yyoutput, ")");
1545 }
1546
1547 #endif /* ! YYDEBUG */
1548 /*-----------------------------------------------.
1549 | Release the memory associated to this symbol. |
1550 `-----------------------------------------------*/
1551
1552 #if defined (__STDC__) || defined (__cplusplus)
1553 static void
yydestruct(const char * yymsg,int yytype,YYSTYPE * yyvaluep)1554 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1555 #else
1556 static void
1557 yydestruct (yymsg, yytype, yyvaluep)
1558 const char *yymsg;
1559 int yytype;
1560 YYSTYPE *yyvaluep;
1561 #endif
1562 {
1563 /* Pacify ``unused variable'' warnings. */
1564 (void) yyvaluep;
1565
1566 if (!yymsg)
1567 yymsg = "Deleting";
1568 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1569
1570 switch (yytype)
1571 {
1572
1573 default:
1574 break;
1575 }
1576 }
1577
1578
1579 /* Prevent warnings from -Wmissing-prototypes. */
1580
1581 #ifdef YYPARSE_PARAM
1582 # if defined (__STDC__) || defined (__cplusplus)
1583 int yyparse (void *YYPARSE_PARAM);
1584 # else
1585 int yyparse ();
1586 # endif
1587 #else /* ! YYPARSE_PARAM */
1588 #if defined (__STDC__) || defined (__cplusplus)
1589 int yyparse (void);
1590 #else
1591 int yyparse ();
1592 #endif
1593 #endif /* ! YYPARSE_PARAM */
1594
1595
1596
1597 /* The look-ahead symbol. */
1598 int yychar;
1599
1600 /* The semantic value of the look-ahead symbol. */
1601 YYSTYPE yylval;
1602
1603 /* Number of syntax errors so far. */
1604 int yynerrs;
1605
1606
1607
1608 /*----------.
1609 | yyparse. |
1610 `----------*/
1611
1612 #ifdef YYPARSE_PARAM
1613 # if defined (__STDC__) || defined (__cplusplus)
yyparse(void * YYPARSE_PARAM)1614 int yyparse (void *YYPARSE_PARAM)
1615 # else
1616 int yyparse (YYPARSE_PARAM)
1617 void *YYPARSE_PARAM;
1618 # endif
1619 #else /* ! YYPARSE_PARAM */
1620 #if defined (__STDC__) || defined (__cplusplus)
1621 int
1622 yyparse (void)
1623 #else
1624 int
1625 yyparse ()
1626
1627 #endif
1628 #endif
1629 {
1630
1631 register int yystate;
1632 register int yyn;
1633 int yyresult;
1634 /* Number of tokens to shift before error messages enabled. */
1635 int yyerrstatus;
1636 /* Look-ahead token as an internal (translated) token number. */
1637 int yytoken = 0;
1638
1639 /* Three stacks and their tools:
1640 `yyss': related to states,
1641 `yyvs': related to semantic values,
1642 `yyls': related to locations.
1643
1644 Refer to the stacks thru separate pointers, to allow yyoverflow
1645 to reallocate them elsewhere. */
1646
1647 /* The state stack. */
1648 short int yyssa[YYINITDEPTH];
1649 short int *yyss = yyssa;
1650 register short int *yyssp;
1651
1652 /* The semantic value stack. */
1653 YYSTYPE yyvsa[YYINITDEPTH];
1654 YYSTYPE *yyvs = yyvsa;
1655 register YYSTYPE *yyvsp;
1656
1657
1658
1659 #define YYPOPSTACK (yyvsp--, yyssp--)
1660
1661 YYSIZE_T yystacksize = YYINITDEPTH;
1662
1663 /* The variables used to return semantic value and location from the
1664 action routines. */
1665 YYSTYPE yyval;
1666
1667
1668 /* When reducing, the number of symbols on the RHS of the reduced
1669 rule. */
1670 int yylen;
1671
1672 YYDPRINTF ((stderr, "Starting parse\n"));
1673
1674 yystate = 0;
1675 yyerrstatus = 0;
1676 yynerrs = 0;
1677 yychar = YYEMPTY; /* Cause a token to be read. */
1678
1679 /* Initialize stack pointers.
1680 Waste one element of value and location stack
1681 so that they stay on the same level as the state stack.
1682 The wasted elements are never initialized. */
1683
1684 yyssp = yyss;
1685 yyvsp = yyvs;
1686
1687
1688 yyvsp[0] = yylval;
1689
1690 goto yysetstate;
1691
1692 /*------------------------------------------------------------.
1693 | yynewstate -- Push a new state, which is found in yystate. |
1694 `------------------------------------------------------------*/
1695 yynewstate:
1696 /* In all cases, when you get here, the value and location stacks
1697 have just been pushed. so pushing a state here evens the stacks.
1698 */
1699 yyssp++;
1700
1701 yysetstate:
1702 *yyssp = yystate;
1703
1704 if (yyss + yystacksize - 1 <= yyssp)
1705 {
1706 /* Get the current used size of the three stacks, in elements. */
1707 YYSIZE_T yysize = yyssp - yyss + 1;
1708
1709 #ifdef yyoverflow
1710 {
1711 /* Give user a chance to reallocate the stack. Use copies of
1712 these so that the &'s don't force the real ones into
1713 memory. */
1714 YYSTYPE *yyvs1 = yyvs;
1715 short int *yyss1 = yyss;
1716
1717
1718 /* Each stack pointer address is followed by the size of the
1719 data in use in that stack, in bytes. This used to be a
1720 conditional around just the two extra args, but that might
1721 be undefined if yyoverflow is a macro. */
1722 yyoverflow ("parser stack overflow",
1723 &yyss1, yysize * sizeof (*yyssp),
1724 &yyvs1, yysize * sizeof (*yyvsp),
1725
1726 &yystacksize);
1727
1728 yyss = yyss1;
1729 yyvs = yyvs1;
1730 }
1731 #else /* no yyoverflow */
1732 # ifndef YYSTACK_RELOCATE
1733 goto yyoverflowlab;
1734 # else
1735 /* Extend the stack our own way. */
1736 if (YYMAXDEPTH <= yystacksize)
1737 goto yyoverflowlab;
1738 yystacksize *= 2;
1739 if (YYMAXDEPTH < yystacksize)
1740 yystacksize = YYMAXDEPTH;
1741
1742 {
1743 short int *yyss1 = yyss;
1744 union yyalloc *yyptr =
1745 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1746 if (! yyptr)
1747 goto yyoverflowlab;
1748 YYSTACK_RELOCATE (yyss);
1749 YYSTACK_RELOCATE (yyvs);
1750
1751 # undef YYSTACK_RELOCATE
1752 if (yyss1 != yyssa)
1753 YYSTACK_FREE (yyss1);
1754 }
1755 # endif
1756 #endif /* no yyoverflow */
1757
1758 yyssp = yyss + yysize - 1;
1759 yyvsp = yyvs + yysize - 1;
1760
1761
1762 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1763 (unsigned long int) yystacksize));
1764
1765 if (yyss + yystacksize - 1 <= yyssp)
1766 YYABORT;
1767 }
1768
1769 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1770
1771 goto yybackup;
1772
1773 /*-----------.
1774 | yybackup. |
1775 `-----------*/
1776 yybackup:
1777
1778 /* Do appropriate processing given the current state. */
1779 /* Read a look-ahead token if we need one and don't already have one. */
1780 /* yyresume: */
1781
1782 /* First try to decide what to do without reference to look-ahead token. */
1783
1784 yyn = yypact[yystate];
1785 if (yyn == YYPACT_NINF)
1786 goto yydefault;
1787
1788 /* Not known => get a look-ahead token if don't already have one. */
1789
1790 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
1791 if (yychar == YYEMPTY)
1792 {
1793 YYDPRINTF ((stderr, "Reading a token: "));
1794 yychar = YYLEX;
1795 }
1796
1797 if (yychar <= YYEOF)
1798 {
1799 yychar = yytoken = YYEOF;
1800 YYDPRINTF ((stderr, "Now at end of input.\n"));
1801 }
1802 else
1803 {
1804 yytoken = YYTRANSLATE (yychar);
1805 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1806 }
1807
1808 /* If the proper action on seeing token YYTOKEN is to reduce or to
1809 detect an error, take that action. */
1810 yyn += yytoken;
1811 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1812 goto yydefault;
1813 yyn = yytable[yyn];
1814 if (yyn <= 0)
1815 {
1816 if (yyn == 0 || yyn == YYTABLE_NINF)
1817 goto yyerrlab;
1818 yyn = -yyn;
1819 goto yyreduce;
1820 }
1821
1822 if (yyn == YYFINAL)
1823 YYACCEPT;
1824
1825 /* Shift the look-ahead token. */
1826 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1827
1828 /* Discard the token being shifted unless it is eof. */
1829 if (yychar != YYEOF)
1830 yychar = YYEMPTY;
1831
1832 *++yyvsp = yylval;
1833
1834
1835 /* Count tokens shifted since error; after three, turn off error
1836 status. */
1837 if (yyerrstatus)
1838 yyerrstatus--;
1839
1840 yystate = yyn;
1841 goto yynewstate;
1842
1843
1844 /*-----------------------------------------------------------.
1845 | yydefault -- do the default action for the current state. |
1846 `-----------------------------------------------------------*/
1847 yydefault:
1848 yyn = yydefact[yystate];
1849 if (yyn == 0)
1850 goto yyerrlab;
1851 goto yyreduce;
1852
1853
1854 /*-----------------------------.
1855 | yyreduce -- Do a reduction. |
1856 `-----------------------------*/
1857 yyreduce:
1858 /* yyn is the number of a rule to reduce with. */
1859 yylen = yyr2[yyn];
1860
1861 /* If YYLEN is nonzero, implement the default value of the action:
1862 `$$ = $1'.
1863
1864 Otherwise, the following line sets YYVAL to garbage.
1865 This behavior is undocumented and Bison
1866 users should not rely upon it. Assigning to YYVAL
1867 unconditionally makes the parser a bit smaller, and it avoids a
1868 GCC warning that YYVAL may be used uninitialized. */
1869 yyval = yyvsp[1-yylen];
1870
1871
1872 YY_REDUCE_PRINT (yyn);
1873 switch (yyn)
1874 {
1875 case 2:
1876 #line 261 "parser.y"
1877 {
1878 if (turbo_pascal) {
1879 zzcnv_table[TKN_STRING] = STRING;
1880 zzcnv_table[TKN_STR] = WRITE;
1881 zzcnv_table[TKN_SHL] = SHL;
1882 zzcnv_table[TKN_SHR] = SHR;
1883 zzcnv_table[TKN_XOR] = XOR;
1884 zzcnv_table[TKN_UNIT] = UNIT;
1885 zzcnv_table[TKN_FAR] = FAR;
1886 zzcnv_table[TKN_IMPLEMENTATION] = IMPLEMENTATION;
1887 zzcnv_table[TKN_INTERFACE] = INTERFACE;
1888
1889 zzcnv_table[TKN_OBJECT] = OBJECT;
1890 zzcnv_table[TKN_CONSTRUCTOR] = PROCEDURE;
1891 zzcnv_table[TKN_DESTRUCTOR] = PROCEDURE;
1892 } else {
1893 zzcnv_table[TKN_ORIGIN] = ORIGIN;
1894 }
1895 ;}
1896 break;
1897
1898 case 3:
1899 #line 280 "parser.y"
1900 {
1901 (yyvsp[0].n_node)->attrib(ctx_program);
1902 (yyvsp[0].n_node)->translate(ctx_program);
1903 ;}
1904 break;
1905
1906 case 7:
1907 #line 287 "parser.y"
1908 { (yyval.n_node) = new program_node(NULL, NULL, NULL, NULL, (yyvsp[-1].n_block), (yyvsp[0].tok)); ;}
1909 break;
1910
1911 case 8:
1912 #line 289 "parser.y"
1913 {
1914 (yyval.n_node) = new program_node((yyvsp[-5].tok), (yyvsp[-4].tok), (yyvsp[-3].n_imp), (yyvsp[-2].tok), (yyvsp[-1].n_block), (yyvsp[0].tok));
1915 ;}
1916 break;
1917
1918 case 9:
1919 #line 293 "parser.y"
1920 { (yyval.tok) = NULL; ;}
1921 break;
1922
1923 case 11:
1924 #line 295 "parser.y"
1925 { (yyval.n_node) = new module_node(NULL, NULL, NULL, NULL, (yyvsp[0].n_decl), NULL); ;}
1926 break;
1927
1928 case 12:
1929 #line 297 "parser.y"
1930 {
1931 (yyval.n_node) = new module_node((yyvsp[-5].tok), (yyvsp[-4].tok), (yyvsp[-3].n_imp), (yyvsp[-2].tok), (yyvsp[-1].n_decl), (yyvsp[0].tok));
1932 ;}
1933 break;
1934
1935 case 13:
1936 #line 305 "parser.y"
1937 { (yyval.n_node) = new unit_node((yyvsp[-8].tok), (yyvsp[-7].tok), (yyvsp[-6].tok), (yyvsp[-5].tok), (yyvsp[-4].n_decl), (yyvsp[-3].tok), (yyvsp[-2].n_decl), NULL, (yyvsp[-1].tok), (yyvsp[0].tok)); ;}
1938 break;
1939
1940 case 14:
1941 #line 307 "parser.y"
1942 { (yyval.n_node) = new unit_node((yyvsp[-8].tok), (yyvsp[-7].tok), (yyvsp[-6].tok), (yyvsp[-5].tok), (yyvsp[-4].n_decl), (yyvsp[-3].tok), (yyvsp[-2].n_decl), (yyvsp[-1].n_comp), NULL, (yyvsp[0].tok)); ;}
1943 break;
1944
1945 case 15:
1946 #line 309 "parser.y"
1947 { (yyval.n_node) = new unit_node(NULL, NULL, NULL, (yyvsp[-5].tok), (yyvsp[-4].n_decl), (yyvsp[-3].tok), (yyvsp[-2].n_decl), NULL, (yyvsp[-1].tok), (yyvsp[0].tok)); ;}
1948 break;
1949
1950 case 16:
1951 #line 311 "parser.y"
1952 { (yyval.n_node) = new unit_node(NULL, NULL, NULL, (yyvsp[-5].tok), (yyvsp[-4].n_decl), (yyvsp[-3].tok), (yyvsp[-2].n_decl), (yyvsp[-1].n_comp), NULL, (yyvsp[0].tok)); ;}
1953 break;
1954
1955 case 18:
1956 #line 316 "parser.y"
1957 { (yyval.n_imp) = NULL; ;}
1958 break;
1959
1960 case 19:
1961 #line 317 "parser.y"
1962 { (yyval.n_imp) = new import_list_node((yyvsp[-2].tok), (yyvsp[-1].toks), (yyvsp[0].tok)); ;}
1963 break;
1964
1965 case 20:
1966 #line 319 "parser.y"
1967 { (yyval.toks) = new token_list((yyvsp[-2].tok), (yyvsp[0].toks)); ;}
1968 break;
1969
1970 case 21:
1971 #line 320 "parser.y"
1972 { (yyval.toks) = new token_list((yyvsp[0].tok)); ;}
1973 break;
1974
1975 case 22:
1976 #line 323 "parser.y"
1977 {
1978 (yyval.n_block) = new block_node((yyvsp[-1].n_decl), (yyvsp[0].n_comp));
1979 ;}
1980 break;
1981
1982 case 23:
1983 #line 327 "parser.y"
1984 { (yyval.n_decl) = NULL; ;}
1985 break;
1986
1987 case 24:
1988 #line 328 "parser.y"
1989 { (yyvsp[-1].n_decl)->next = (yyvsp[0].n_decl); (yyval.n_decl) = (yyvsp[-1].n_decl); ;}
1990 break;
1991
1992 case 32:
1993 #line 334 "parser.y"
1994 { (yyval.n_decl) = new unit_spec_node((yyvsp[-5].tok), (yyvsp[-4].tok), (yyvsp[-3].tok), (yyvsp[-2].tok), (yyvsp[-1].n_decl)); ;}
1995 break;
1996
1997 case 33:
1998 #line 336 "parser.y"
1999 { (yyval.n_decl) = new unit_spec_node(NULL, NULL, NULL, (yyvsp[-2].tok), (yyvsp[-1].n_decl)); ;}
2000 break;
2001
2002 case 34:
2003 #line 339 "parser.y"
2004 { (yyval.n_decl) = NULL; ;}
2005 break;
2006
2007 case 35:
2008 #line 340 "parser.y"
2009 { (yyvsp[-1].n_decl)->next = (yyvsp[0].n_decl); (yyval.n_decl) = (yyvsp[-1].n_decl); ;}
2010 break;
2011
2012 case 43:
2013 #line 372 "parser.y"
2014 { (yyval.n_stmt) = new empty_node(curr_token->prev_relevant()); ;}
2015 break;
2016
2017 case 44:
2018 #line 373 "parser.y"
2019 { (yyval.n_stmt) = new assign_node((yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2020 break;
2021
2022 case 45:
2023 #line 374 "parser.y"
2024 { (yyval.n_stmt) = new assign_node((yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2025 break;
2026
2027 case 46:
2028 #line 375 "parser.y"
2029 { (yyval.n_stmt) = new assign_node((yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2030 break;
2031
2032 case 47:
2033 #line 376 "parser.y"
2034 { (yyval.n_stmt) = new assign_node((yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2035 break;
2036
2037 case 48:
2038 #line 377 "parser.y"
2039 { (yyval.n_stmt) = new assign_node((yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2040 break;
2041
2042 case 49:
2043 #line 378 "parser.y"
2044 { (yyval.n_stmt) = new assign_node((yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2045 break;
2046
2047 case 50:
2048 #line 379 "parser.y"
2049 { (yyval.n_stmt) = new assign_node((yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2050 break;
2051
2052 case 51:
2053 #line 380 "parser.y"
2054 { (yyval.n_stmt) = new assign_node((yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2055 break;
2056
2057 case 52:
2058 #line 381 "parser.y"
2059 { (yyval.n_stmt) = new assign_node((yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2060 break;
2061
2062 case 53:
2063 #line 382 "parser.y"
2064 { (yyval.n_stmt) = new goto_node((yyvsp[-1].tok), (yyvsp[0].tok)); ;}
2065 break;
2066
2067 case 54:
2068 #line 383 "parser.y"
2069 { (yyval.n_stmt) = new goto_node((yyvsp[-1].tok), (yyvsp[0].tok)); ;}
2070 break;
2071
2072 case 55:
2073 #line 384 "parser.y"
2074 { (yyval.n_stmt) = new switch_node((yyvsp[-4].tok), (yyvsp[-3].n_expr), (yyvsp[-2].tok), (yyvsp[-1].n_case), (yyvsp[0].tok)); ;}
2075 break;
2076
2077 case 56:
2078 #line 385 "parser.y"
2079 { (yyval.n_stmt) = new if_node((yyvsp[-3].tok), (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_stmt)); ;}
2080 break;
2081
2082 case 57:
2083 #line 387 "parser.y"
2084 { (yyval.n_stmt) = new if_node((yyvsp[-5].tok), (yyvsp[-4].n_expr), (yyvsp[-3].tok), (yyvsp[-2].n_stmt), (yyvsp[-1].tok), (yyvsp[0].n_stmt)); ;}
2085 break;
2086
2087 case 58:
2088 #line 389 "parser.y"
2089 { (yyval.n_stmt) = new for_node((yyvsp[-7].tok), (yyvsp[-6].tok), (yyvsp[-5].tok), (yyvsp[-4].n_expr), (yyvsp[-3].tok), (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_stmt)); ;}
2090 break;
2091
2092 case 59:
2093 #line 390 "parser.y"
2094 { (yyval.n_stmt) = new while_node((yyvsp[-3].tok), (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_stmt)); ;}
2095 break;
2096
2097 case 60:
2098 #line 391 "parser.y"
2099 { (yyval.n_stmt) = new repeat_node((yyvsp[-3].tok), (yyvsp[-2].n_stmt), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2100 break;
2101
2102 case 61:
2103 #line 392 "parser.y"
2104 { (yyval.n_stmt) = new write_node((yyvsp[-1].tok), (yyvsp[0].n_wrls)); ;}
2105 break;
2106
2107 case 62:
2108 #line 393 "parser.y"
2109 { (yyval.n_stmt) = new read_node((yyvsp[-1].tok), (yyvsp[0].n_grp)); ;}
2110 break;
2111
2112 case 63:
2113 #line 394 "parser.y"
2114 { (yyval.n_stmt) = new pcall_node((yyvsp[0].n_expr)); ;}
2115 break;
2116
2117 case 64:
2118 #line 395 "parser.y"
2119 { (yyval.n_stmt) = new return_node((yyvsp[0].tok)); ;}
2120 break;
2121
2122 case 65:
2123 #line 396 "parser.y"
2124 { (yyval.n_stmt) = new with_node((yyvsp[-3].tok), (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_stmt)); ;}
2125 break;
2126
2127 case 66:
2128 #line 397 "parser.y"
2129 { (yyval.n_stmt) = new label_node((yyvsp[-2].tok), (yyvsp[-1].tok), (yyvsp[0].n_stmt)); ;}
2130 break;
2131
2132 case 67:
2133 #line 398 "parser.y"
2134 { (yyval.n_stmt) = new label_node((yyvsp[-2].tok), (yyvsp[-1].tok), (yyvsp[0].n_stmt)); ;}
2135 break;
2136
2137 case 68:
2138 #line 399 "parser.y"
2139 { (yyval.n_stmt) = (yyvsp[0].n_comp); ;}
2140 break;
2141
2142 case 69:
2143 #line 401 "parser.y"
2144 { (yyval.n_comp) = new compound_node((yyvsp[-2].tok), (yyvsp[-1].n_stmt), (yyvsp[0].tok)); ;}
2145 break;
2146
2147 case 71:
2148 #line 403 "parser.y"
2149 { (yyvsp[-2].n_stmt)->next = (yyvsp[0].n_stmt); (yyval.n_stmt) = (yyvsp[-2].n_stmt); ;}
2150 break;
2151
2152 case 72:
2153 #line 405 "parser.y"
2154 { (yyval.n_grp) = NULL; ;}
2155 break;
2156
2157 case 73:
2158 #line 405 "parser.y"
2159 { (yyval.n_grp) = (yyvsp[0].n_grp); ;}
2160 break;
2161
2162 case 74:
2163 #line 407 "parser.y"
2164 { (yyval.n_wrls) = NULL; ;}
2165 break;
2166
2167 case 75:
2168 #line 408 "parser.y"
2169 { (yyval.n_wrls) = new write_list_node((yyvsp[-2].tok), (yyvsp[-1].n_wrtp), (yyvsp[0].tok)); ;}
2170 break;
2171
2172 case 77:
2173 #line 412 "parser.y"
2174 {
2175 if ((yyvsp[-2].n_case) != NULL) {
2176 case_node** cpp;
2177 for(cpp = &(yyvsp[-2].n_case)->next; *cpp != NULL; cpp = &(*cpp)->next);
2178 *cpp = new case_node(NULL, (yyvsp[-1].tok), (yyvsp[0].n_stmt));
2179 (yyval.n_case) = (yyvsp[-2].n_case);
2180 } else {
2181 (yyval.n_case) = new case_node(NULL, (yyvsp[-1].tok), (yyvsp[0].n_stmt));
2182 }
2183 ;}
2184 break;
2185
2186 case 80:
2187 #line 425 "parser.y"
2188 { (yyval.n_case) = NULL; ;}
2189 break;
2190
2191 case 82:
2192 #line 427 "parser.y"
2193 { (yyvsp[-2].n_case)->next = (yyvsp[0].n_case); (yyval.n_case) = (yyvsp[-2].n_case); ;}
2194 break;
2195
2196 case 83:
2197 #line 429 "parser.y"
2198 { (yyval.n_case) = new case_node((yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_stmt)); ;}
2199 break;
2200
2201 case 85:
2202 #line 432 "parser.y"
2203 { (yyvsp[-2].n_expr)->next = (yyvsp[0].n_expr); (yyval.n_expr) = (yyvsp[-2].n_expr); ;}
2204 break;
2205
2206 case 86:
2207 #line 434 "parser.y"
2208 { (yyval.n_expr) = (yyvsp[0].n_expr); ;}
2209 break;
2210
2211 case 87:
2212 #line 435 "parser.y"
2213 { (yyval.n_expr) = new case_range_node((yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2214 break;
2215
2216 case 89:
2217 #line 460 "parser.y"
2218 { (yyval.n_expr) = new op_node(tn_add, (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2219 break;
2220
2221 case 90:
2222 #line 461 "parser.y"
2223 { (yyval.n_expr) = new op_node(tn_sub, (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2224 break;
2225
2226 case 91:
2227 #line 462 "parser.y"
2228 { (yyval.n_expr) = new op_node(tn_mod, (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2229 break;
2230
2231 case 92:
2232 #line 463 "parser.y"
2233 { (yyval.n_expr) = new op_node(tn_mul, (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2234 break;
2235
2236 case 93:
2237 #line 464 "parser.y"
2238 { (yyval.n_expr) = new op_node(tn_div, (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2239 break;
2240
2241 case 94:
2242 #line 465 "parser.y"
2243 { (yyval.n_expr) = new op_node(tn_divr, (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2244 break;
2245
2246 case 95:
2247 #line 467 "parser.y"
2248 { (yyval.n_expr) = new op_node(tn_let, (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2249 break;
2250
2251 case 96:
2252 #line 468 "parser.y"
2253 { (yyval.n_expr) = new op_node(tn_letadd, (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2254 break;
2255
2256 case 97:
2257 #line 469 "parser.y"
2258 { (yyval.n_expr) = new op_node(tn_letsub, (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2259 break;
2260
2261 case 98:
2262 #line 470 "parser.y"
2263 { (yyval.n_expr) = new op_node(tn_letdiv, (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2264 break;
2265
2266 case 99:
2267 #line 471 "parser.y"
2268 { (yyval.n_expr) = new op_node(tn_letmul, (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2269 break;
2270
2271 case 100:
2272 #line 472 "parser.y"
2273 { (yyval.n_expr) = new op_node(tn_letshl, (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2274 break;
2275
2276 case 101:
2277 #line 473 "parser.y"
2278 { (yyval.n_expr) = new op_node(tn_letshr, (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2279 break;
2280
2281 case 102:
2282 #line 474 "parser.y"
2283 { (yyval.n_expr) = new op_node(tn_letand, (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2284 break;
2285
2286 case 103:
2287 #line 475 "parser.y"
2288 { (yyval.n_expr) = new op_node(tn_letor, (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2289 break;
2290
2291 case 104:
2292 #line 478 "parser.y"
2293 { (yyval.n_expr) = new op_node(tn_and, (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2294 break;
2295
2296 case 105:
2297 #line 479 "parser.y"
2298 { (yyval.n_expr) = new op_node(tn_shl, (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2299 break;
2300
2301 case 106:
2302 #line 480 "parser.y"
2303 { (yyval.n_expr) = new op_node(tn_shr, (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2304 break;
2305
2306 case 107:
2307 #line 481 "parser.y"
2308 { (yyval.n_expr) = new op_node(tn_or, (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2309 break;
2310
2311 case 108:
2312 #line 482 "parser.y"
2313 { (yyval.n_expr) = new op_node(tn_xor, (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2314 break;
2315
2316 case 109:
2317 #line 484 "parser.y"
2318 { (yyval.n_expr) = new op_node(tn_gt, (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2319 break;
2320
2321 case 110:
2322 #line 485 "parser.y"
2323 { (yyval.n_expr) = new op_node(tn_lt, (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2324 break;
2325
2326 case 111:
2327 #line 486 "parser.y"
2328 { (yyval.n_expr) = new op_node(tn_le, (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2329 break;
2330
2331 case 112:
2332 #line 487 "parser.y"
2333 { (yyval.n_expr) = new op_node(tn_ge, (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2334 break;
2335
2336 case 113:
2337 #line 488 "parser.y"
2338 { (yyval.n_expr) = new op_node(tn_eq, (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2339 break;
2340
2341 case 114:
2342 #line 489 "parser.y"
2343 { (yyval.n_expr) = new op_node(tn_ne, (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2344 break;
2345
2346 case 115:
2347 #line 490 "parser.y"
2348 { (yyval.n_expr) = new op_node(tn_in, (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2349 break;
2350
2351 case 117:
2352 #line 493 "parser.y"
2353 {
2354 (yyval.n_expr) = new op_node(tn_plus, NULL, (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2355 break;
2356
2357 case 118:
2358 #line 496 "parser.y"
2359 { (yyval.n_expr) = new op_node(tn_minus, NULL, (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2360 break;
2361
2362 case 119:
2363 #line 498 "parser.y"
2364 { (yyval.n_expr) = new op_node(tn_not, NULL, (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2365 break;
2366
2367 case 120:
2368 #line 499 "parser.y"
2369 { (yyval.n_expr) = new address_node((yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2370 break;
2371
2372 case 121:
2373 #line 500 "parser.y"
2374 { (yyval.n_expr) = new address_node((yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2375 break;
2376
2377 case 123:
2378 #line 503 "parser.y"
2379 { (yyval.n_expr) = new expr_group_node((yyvsp[-2].tok), (yyvsp[-1].n_expr), (yyvsp[0].tok)); ;}
2380 break;
2381
2382 case 124:
2383 #line 504 "parser.y"
2384 { (yyval.n_expr) = new fcall_node((yyvsp[-3].n_expr), (yyvsp[-2].tok), (yyvsp[-1].n_expr), (yyvsp[0].tok)); ;}
2385 break;
2386
2387 case 125:
2388 #line 505 "parser.y"
2389 { (yyval.n_expr) = new access_expr_node((yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].tok)); ;}
2390 break;
2391
2392 case 126:
2393 #line 506 "parser.y"
2394 { (yyval.n_expr) = new deref_expr_node((yyvsp[-1].n_expr), (yyvsp[0].tok)); ;}
2395 break;
2396
2397 case 127:
2398 #line 507 "parser.y"
2399 { (yyval.n_expr) = new idx_expr_node((yyvsp[-3].n_expr), (yyvsp[-2].tok), (yyvsp[-1].n_expr), (yyvsp[0].tok)); ;}
2400 break;
2401
2402 case 128:
2403 #line 508 "parser.y"
2404 { (yyval.n_expr) = new loophole_node((yyvsp[-5].tok), (yyvsp[-4].tok), (yyvsp[-3].n_tpd), (yyvsp[-2].tok), (yyvsp[-1].n_expr), (yyvsp[0].tok)); ;}
2405 break;
2406
2407 case 130:
2408 #line 511 "parser.y"
2409 { (yyval.n_expr) = new integer_node((yyvsp[0].tok)); ;}
2410 break;
2411
2412 case 131:
2413 #line 512 "parser.y"
2414 { (yyval.n_expr) = new real_node((yyvsp[0].tok)); ;}
2415 break;
2416
2417 case 132:
2418 #line 513 "parser.y"
2419 { (yyval.n_expr) = new string_node((yyvsp[0].tok)); ;}
2420 break;
2421
2422 case 133:
2423 #line 514 "parser.y"
2424 { (yyval.n_expr) = new set_node((yyvsp[-2].tok), (yyvsp[-1].n_item), (yyvsp[0].tok)); ;}
2425 break;
2426
2427 case 134:
2428 #line 515 "parser.y"
2429 { (yyval.n_expr) = new atom_expr_node((yyvsp[0].tok)); ;}
2430 break;
2431
2432 case 135:
2433 #line 517 "parser.y"
2434 { (yyval.n_item) = NULL; ;}
2435 break;
2436
2437 case 137:
2438 #line 519 "parser.y"
2439 { (yyvsp[-2].n_item)->next = (yyvsp[0].n_item); (yyval.n_item) = (yyvsp[-2].n_item); ;}
2440 break;
2441
2442 case 138:
2443 #line 521 "parser.y"
2444 { (yyval.n_item) = new set_elem_node((yyvsp[0].n_expr)); ;}
2445 break;
2446
2447 case 139:
2448 #line 522 "parser.y"
2449 { (yyval.n_item) = new set_range_node((yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2450 break;
2451
2452 case 141:
2453 #line 524 "parser.y"
2454 { (yyvsp[-2].n_expr)->next = (yyvsp[0].n_expr); (yyval.n_expr) = (yyvsp[-2].n_expr); ;}
2455 break;
2456
2457 case 143:
2458 #line 527 "parser.y"
2459 { (yyvsp[-2].n_expr)->next = (yyvsp[0].n_expr); (yyval.n_expr) = (yyvsp[-2].n_expr); ;}
2460 break;
2461
2462 case 145:
2463 #line 529 "parser.y"
2464 { (yyval.n_expr) = new skipped_node(curr_token->prev_relevant()); ;}
2465 break;
2466
2467 case 146:
2468 #line 532 "parser.y"
2469 {
2470 (yyval.n_expr) = new record_constant_node((yyvsp[-2].tok), (yyvsp[-1].n_field), (yyvsp[0].tok));
2471 ;}
2472 break;
2473
2474 case 147:
2475 #line 536 "parser.y"
2476 { (yyval.n_field) = (yyvsp[0].n_field); ;}
2477 break;
2478
2479 case 148:
2480 #line 537 "parser.y"
2481 { (yyvsp[-2].n_field)->next = (yyvsp[0].n_field); (yyval.n_field) = (yyvsp[-2].n_field); ;}
2482 break;
2483
2484 case 149:
2485 #line 539 "parser.y"
2486 { (yyval.n_field) = new field_init_node((yyvsp[-2].tok), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2487 break;
2488
2489 case 150:
2490 #line 542 "parser.y"
2491 { (yyval.n_grp) = new expr_group_node((yyvsp[-2].tok), (yyvsp[-1].n_expr), (yyvsp[0].tok)); ;}
2492 break;
2493
2494 case 152:
2495 #line 545 "parser.y"
2496 { (yyvsp[-2].n_wrtp)->next = (yyvsp[0].n_wrtp); (yyval.n_wrtp) = (yyvsp[-2].n_wrtp); ;}
2497 break;
2498
2499 case 153:
2500 #line 547 "parser.y"
2501 { (yyval.n_wrtp) = new write_param_node((yyvsp[0].n_expr)); ;}
2502 break;
2503
2504 case 154:
2505 #line 548 "parser.y"
2506 { (yyval.n_wrtp) = new write_param_node((yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2507 break;
2508
2509 case 155:
2510 #line 549 "parser.y"
2511 { (yyval.n_wrtp) = new write_param_node((yyvsp[-4].n_expr), (yyvsp[-3].tok), (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2512 break;
2513
2514 case 156:
2515 #line 592 "parser.y"
2516 { (yyval.n_decl) = new label_decl_part_node((yyvsp[-2].tok), (yyvsp[-1].toks), (yyvsp[0].tok)); ;}
2517 break;
2518
2519 case 157:
2520 #line 594 "parser.y"
2521 { (yyval.toks) = new token_list((yyvsp[0].tok)); ;}
2522 break;
2523
2524 case 158:
2525 #line 595 "parser.y"
2526 { (yyval.toks) = new token_list((yyvsp[-2].tok), (yyvsp[0].toks)); ;}
2527 break;
2528
2529 case 159:
2530 #line 596 "parser.y"
2531 { (yyval.toks) = new token_list((yyvsp[0].tok)); ;}
2532 break;
2533
2534 case 160:
2535 #line 597 "parser.y"
2536 { (yyval.toks) = new token_list((yyvsp[-2].tok), (yyvsp[0].toks)); ;}
2537 break;
2538
2539 case 161:
2540 #line 600 "parser.y"
2541 { (yyval.n_decl) = new const_def_part_node((yyvsp[-1].tok), (yyvsp[0].n_cdef)); ;}
2542 break;
2543
2544 case 162:
2545 #line 602 "parser.y"
2546 { (yyval.n_cdef) = NULL; ;}
2547 break;
2548
2549 case 163:
2550 #line 603 "parser.y"
2551 { (yyvsp[-2].n_cdef)->next = (yyvsp[0].n_cdef); (yyval.n_cdef) = (yyvsp[-2].n_cdef); ;}
2552 break;
2553
2554 case 164:
2555 #line 605 "parser.y"
2556 { (yyval.n_cdef) = new const_def_node((yyvsp[-2].tok), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2557 break;
2558
2559 case 165:
2560 #line 606 "parser.y"
2561 { (yyval.n_cdef) = new typed_const_def_node((yyvsp[-4].tok), (yyvsp[-3].tok), (yyvsp[-2].n_tpd), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2562 break;
2563
2564 case 166:
2565 #line 609 "parser.y"
2566 { (yyval.n_decl) = new type_def_part_node((yyvsp[-1].tok), (yyvsp[0].n_tdef)); ;}
2567 break;
2568
2569 case 167:
2570 #line 611 "parser.y"
2571 { (yyval.n_tdef) = NULL; ;}
2572 break;
2573
2574 case 168:
2575 #line 612 "parser.y"
2576 { (yyvsp[-2].n_tdef)->next = (yyvsp[0].n_tdef); (yyval.n_tdef) = (yyvsp[-2].n_tdef); ;}
2577 break;
2578
2579 case 169:
2580 #line 614 "parser.y"
2581 { (yyval.n_tdef) = new type_def_node((yyvsp[-2].tok), (yyvsp[-1].tok), (yyvsp[0].n_tpd)); ;}
2582 break;
2583
2584 case 170:
2585 #line 617 "parser.y"
2586 { (yyval.n_decl) = new var_decl_part_node((yyvsp[-1].tok), (yyvsp[0].n_vdcl)); ;}
2587 break;
2588
2589 case 171:
2590 #line 619 "parser.y"
2591 { (yyval.n_vdcl) = NULL; ;}
2592 break;
2593
2594 case 173:
2595 #line 622 "parser.y"
2596 {
2597 (yyvsp[-2].n_vdcl)->scope = (yyvsp[0].tok);
2598 (yyvsp[0].tok)->disable();
2599 ;}
2600 break;
2601
2602 case 174:
2603 #line 627 "parser.y"
2604 {
2605 (yyvsp[-4].n_vdcl)->scope = (yyvsp[-2].tok);
2606 token::remove((yyvsp[-2].tok), (yyvsp[-1].tok));
2607 (yyvsp[-4].n_vdcl)->next = (yyvsp[0].n_vdcl); (yyval.n_vdcl) = (yyvsp[-4].n_vdcl);
2608 ;}
2609 break;
2610
2611 case 175:
2612 #line 632 "parser.y"
2613 { (yyvsp[-2].n_vdcl)->next = (yyvsp[0].n_vdcl); (yyval.n_vdcl) = (yyvsp[-2].n_vdcl); ;}
2614 break;
2615
2616 case 176:
2617 #line 634 "parser.y"
2618 { (yyval.n_vdcl) = new var_decl_node((yyvsp[-2].toks), (yyvsp[-1].tok), (yyvsp[0].n_tpd)); ;}
2619 break;
2620
2621 case 177:
2622 #line 636 "parser.y"
2623 { (yyval.n_vdcl) = (var_decl_node*)new var_origin_decl_node((yyvsp[-4].tok), (yyvsp[-3].tok), (yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_tpd)); ;}
2624 break;
2625
2626 case 178:
2627 #line 640 "parser.y"
2628 { (yyval.n_decl) = new proc_decl_node((yyvsp[-2].tok), (yyvsp[-1].tok), (yyvsp[0].n_plist)); ;}
2629 break;
2630
2631 case 179:
2632 #line 642 "parser.y"
2633 { (yyval.n_decl) = new proc_decl_node((yyvsp[-4].tok), (yyvsp[-3].tok), (yyvsp[-2].n_plist), (yyvsp[-1].tok), (yyvsp[0].n_tpd)); ;}
2634 break;
2635
2636 case 180:
2637 #line 647 "parser.y"
2638 { (yyval.n_decl) = new proc_fwd_decl_node((yyvsp[-5].tok), (yyvsp[-4].tok), (yyvsp[-3].n_plist), NULL, NULL, (yyvsp[-2].tok), (yyvsp[-1].toks), (yyvsp[0].tok)); ;}
2639 break;
2640
2641 case 181:
2642 #line 649 "parser.y"
2643 { (yyval.n_decl) = new proc_fwd_decl_node((yyvsp[-7].tok), (yyvsp[-6].tok), (yyvsp[-5].n_plist), (yyvsp[-4].tok), (yyvsp[-3].n_tpd), (yyvsp[-2].tok), (yyvsp[-1].toks), (yyvsp[0].tok)); ;}
2644 break;
2645
2646 case 182:
2647 #line 653 "parser.y"
2648 { (yyval.n_decl) = new proc_fwd_decl_node((yyvsp[-3].tok), (yyvsp[-2].tok), (yyvsp[-1].n_plist), NULL, NULL, (yyvsp[0].tok)); ;}
2649 break;
2650
2651 case 183:
2652 #line 655 "parser.y"
2653 { (yyval.n_decl) = new proc_fwd_decl_node((yyvsp[-5].tok), (yyvsp[-4].tok), (yyvsp[-3].n_plist), (yyvsp[-2].tok), (yyvsp[-1].n_tpd), (yyvsp[0].tok)); ;}
2654 break;
2655
2656 case 184:
2657 #line 659 "parser.y"
2658 { (yyval.n_decl) = new proc_def_node((yyvsp[-5].tok), NULL, NULL, (yyvsp[-4].tok), (yyvsp[-3].n_plist), NULL, NULL, (yyvsp[-2].tok), NULL, NULL, (yyvsp[-1].n_block), (yyvsp[0].tok)); ;}
2659 break;
2660
2661 case 185:
2662 #line 661 "parser.y"
2663 { (yyval.n_decl) = new proc_def_node((yyvsp[-7].tok), NULL, NULL, (yyvsp[-6].tok), (yyvsp[-5].n_plist), (yyvsp[-4].tok), (yyvsp[-3].n_tpd), (yyvsp[-2].tok), NULL, NULL, (yyvsp[-1].n_block), (yyvsp[0].tok)); ;}
2664 break;
2665
2666 case 186:
2667 #line 663 "parser.y"
2668 { (yyval.n_decl) = new proc_def_node((yyvsp[-7].tok), (yyvsp[-6].tok), (yyvsp[-5].tok), (yyvsp[-4].tok), (yyvsp[-3].n_plist), NULL, NULL, (yyvsp[-2].tok), NULL, NULL, (yyvsp[-1].n_block), (yyvsp[0].tok)); ;}
2669 break;
2670
2671 case 187:
2672 #line 665 "parser.y"
2673 { (yyval.n_decl) = new proc_def_node((yyvsp[-9].tok), (yyvsp[-8].tok), (yyvsp[-7].tok), (yyvsp[-6].tok), (yyvsp[-5].n_plist), (yyvsp[-4].tok), (yyvsp[-3].n_tpd), (yyvsp[-2].tok), NULL, NULL, (yyvsp[-1].n_block), (yyvsp[0].tok)); ;}
2674 break;
2675
2676 case 188:
2677 #line 667 "parser.y"
2678 { (yyval.n_decl) = new proc_def_node((yyvsp[-4].tok), NULL, NULL, (yyvsp[-3].tok), NULL, NULL, NULL, (yyvsp[-2].tok), NULL, NULL, (yyvsp[-1].n_block), (yyvsp[0].tok)); ;}
2679 break;
2680
2681 case 189:
2682 #line 669 "parser.y"
2683 { (yyval.n_decl) = new proc_def_node((yyvsp[-7].tok), NULL, NULL, (yyvsp[-6].tok), (yyvsp[-5].n_plist), NULL, NULL, (yyvsp[-4].tok), (yyvsp[-3].tok), (yyvsp[-2].tok), (yyvsp[-1].n_block), (yyvsp[0].tok)); ;}
2684 break;
2685
2686 case 190:
2687 #line 671 "parser.y"
2688 { (yyval.n_decl) = new proc_def_node((yyvsp[-9].tok), NULL, NULL, (yyvsp[-8].tok), (yyvsp[-7].n_plist), (yyvsp[-6].tok), (yyvsp[-5].n_tpd), (yyvsp[-4].tok), (yyvsp[-3].tok), (yyvsp[-2].tok), (yyvsp[-1].n_block), (yyvsp[0].tok)); ;}
2689 break;
2690
2691 case 191:
2692 #line 673 "parser.y"
2693 { (yyval.n_decl) = new proc_def_node((yyvsp[-6].tok), NULL, NULL, (yyvsp[-5].tok), NULL, NULL, NULL, (yyvsp[-4].tok), (yyvsp[-3].tok), (yyvsp[-2].tok), (yyvsp[-1].n_block), (yyvsp[0].tok)); ;}
2694 break;
2695
2696 case 192:
2697 #line 675 "parser.y"
2698 { (yyval.toks) = new token_list((yyvsp[-1].tok), (yyvsp[0].toks)); ;}
2699 break;
2700
2701 case 193:
2702 #line 676 "parser.y"
2703 { (yyval.toks) = new token_list((yyvsp[-1].tok), (yyvsp[0].toks)); ;}
2704 break;
2705
2706 case 194:
2707 #line 677 "parser.y"
2708 { (yyval.toks) = new token_list((yyvsp[0].tok)); ;}
2709 break;
2710
2711 case 195:
2712 #line 678 "parser.y"
2713 { (yyval.toks) = new token_list((yyvsp[0].tok)); ;}
2714 break;
2715
2716 case 196:
2717 #line 681 "parser.y"
2718 { (yyval.n_plist) = NULL; ;}
2719 break;
2720
2721 case 197:
2722 #line 682 "parser.y"
2723 { (yyval.n_plist) = new param_list_node((yyvsp[-2].tok), (yyvsp[-1].n_decl), (yyvsp[0].tok)); ;}
2724 break;
2725
2726 case 199:
2727 #line 685 "parser.y"
2728 { (yyvsp[-2].n_decl)->next = (yyvsp[0].n_decl); (yyval.n_decl) = (yyvsp[-2].n_decl); ;}
2729 break;
2730
2731 case 200:
2732 #line 687 "parser.y"
2733 { (yyval.n_decl) = new var_decl_part_node((yyvsp[-1].tok), (yyvsp[0].n_vdcl)); ;}
2734 break;
2735
2736 case 201:
2737 #line 688 "parser.y"
2738 { (yyval.n_decl) = (yyvsp[0].n_vdcl); ;}
2739 break;
2740
2741 case 203:
2742 #line 690 "parser.y"
2743 { (yyval.n_vdcl) = new var_decl_node((yyvsp[-2].toks), (yyvsp[-1].tok), (yyvsp[0].n_tpd)); ;}
2744 break;
2745
2746 case 204:
2747 #line 691 "parser.y"
2748 { (yyval.n_vdcl) = new var_decl_node((yyvsp[0].toks), NULL, NULL); ;}
2749 break;
2750
2751 case 223:
2752 #line 705 "parser.y"
2753 { (yyval.n_tpd) = new fptr_tpd_node((yyvsp[-3].tok), (yyvsp[-2].n_plist), (yyvsp[-1].tok), (yyvsp[0].n_tpd)); ;}
2754 break;
2755
2756 case 224:
2757 #line 706 "parser.y"
2758 { (yyval.n_tpd) = new fptr_tpd_node((yyvsp[-1].tok), (yyvsp[0].n_plist)); ;}
2759 break;
2760
2761 case 225:
2762 #line 708 "parser.y"
2763 { (yyval.n_tpd) = new varying_tpd_node((yyvsp[-3].tok), (yyvsp[-2].tok), (yyvsp[-1].n_expr), (yyvsp[0].tok)); ;}
2764 break;
2765
2766 case 226:
2767 #line 710 "parser.y"
2768 { (yyval.n_tpd) = new simple_tpd_node((yyvsp[0].tok)); ;}
2769 break;
2770
2771 case 227:
2772 #line 711 "parser.y"
2773 { (yyval.n_tpd) = new string_tpd_node((yyvsp[0].tok)); ;}
2774 break;
2775
2776 case 228:
2777 #line 714 "parser.y"
2778 { (yyval.n_tpd) = new array_tpd_node((yyvsp[-6].tok), (yyvsp[-5].tok), (yyvsp[-4].tok), (yyvsp[-3].n_idx), (yyvsp[-2].tok), (yyvsp[-1].tok), (yyvsp[0].n_tpd)); ;}
2779 break;
2780
2781 case 229:
2782 #line 717 "parser.y"
2783 { (yyval.n_tpd) = new array_tpd_node((yyvsp[-6].tok), (yyvsp[-5].tok), (yyvsp[-4].tok), (yyvsp[-3].n_idx), (yyvsp[-2].tok), (yyvsp[-1].tok), (yyvsp[0].n_tpd)); ;}
2784 break;
2785
2786 case 230:
2787 #line 720 "parser.y"
2788 { (yyval.n_tpd) = new array_tpd_node((yyvsp[-6].tok), (yyvsp[-5].tok), (yyvsp[-4].tok), (yyvsp[-3].n_idx), (yyvsp[-2].tok), (yyvsp[-1].tok), (yyvsp[0].n_tpd)); ;}
2789 break;
2790
2791 case 231:
2792 #line 722 "parser.y"
2793 { (yyval.n_tpd) = new array_tpd_node((yyvsp[-6].tok), (yyvsp[-5].tok), (yyvsp[-4].tok), (yyvsp[-3].n_idx), (yyvsp[-2].tok), (yyvsp[-1].tok), (yyvsp[0].n_tpd)); ;}
2794 break;
2795
2796 case 232:
2797 #line 724 "parser.y"
2798 { (yyval.n_tpd) = new enum_tpd_node((yyvsp[-2].tok), (yyvsp[-1].toks), (yyvsp[0].tok)); ;}
2799 break;
2800
2801 case 233:
2802 #line 727 "parser.y"
2803 { (yyval.n_tpd) = new range_tpd_node((yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2804 break;
2805
2806 case 234:
2807 #line 729 "parser.y"
2808 { (yyval.n_tpd) = new ptr_tpd_node((yyvsp[-1].tok), (yyvsp[0].n_tpd)); ;}
2809 break;
2810
2811 case 235:
2812 #line 731 "parser.y"
2813 { (yyval.n_tpd) = new set_tpd_node((yyvsp[-3].tok), (yyvsp[-2].tok), (yyvsp[-1].tok), (yyvsp[0].n_tpd)); ;}
2814 break;
2815
2816 case 236:
2817 #line 733 "parser.y"
2818 { (yyval.n_tpd) = new set_tpd_node((yyvsp[-3].tok), (yyvsp[-2].tok), (yyvsp[-1].tok), (yyvsp[0].n_tpd)); ;}
2819 break;
2820
2821 case 237:
2822 #line 736 "parser.y"
2823 { (yyval.n_tpd) = new record_tpd_node((yyvsp[-3].tok), (yyvsp[-2].tok), (yyvsp[-1].n_fldls), (yyvsp[0].tok)); ;}
2824 break;
2825
2826 case 238:
2827 #line 739 "parser.y"
2828 { (yyval.n_tpd) = new object_tpd_node((yyvsp[-2].tok), NULL, NULL, NULL, (yyvsp[-1].n_decl), (yyvsp[0].tok)); ;}
2829 break;
2830
2831 case 239:
2832 #line 741 "parser.y"
2833 { (yyval.n_tpd) = new object_tpd_node((yyvsp[-5].tok), (yyvsp[-4].tok), (yyvsp[-3].tok), (yyvsp[-2].tok), (yyvsp[-1].n_decl), (yyvsp[0].tok)); ;}
2834 break;
2835
2836 case 240:
2837 #line 744 "parser.y"
2838 { (yyvsp[-1].n_decl)->next = (yyvsp[0].n_decl); (yyval.n_decl) = (yyvsp[-1].n_decl); ;}
2839 break;
2840
2841 case 243:
2842 #line 749 "parser.y"
2843 { (yyval.n_decl) = new var_decl_part_node(NULL, (yyvsp[0].n_vdcl)); ;}
2844 break;
2845
2846 case 245:
2847 #line 752 "parser.y"
2848 { (yyval.n_vdcl) = (yyvsp[-1].n_vdcl); ;}
2849 break;
2850
2851 case 246:
2852 #line 753 "parser.y"
2853 { (yyvsp[-2].n_vdcl)->next = (yyvsp[0].n_vdcl); (yyval.n_vdcl) = (yyvsp[-2].n_vdcl); ;}
2854 break;
2855
2856 case 249:
2857 #line 756 "parser.y"
2858 { (yyvsp[-1].n_decl)->next = (yyvsp[0].n_decl); (yyval.n_decl) = (yyvsp[-1].n_decl); ;}
2859 break;
2860
2861 case 250:
2862 #line 757 "parser.y"
2863 { (yyvsp[-1].n_decl)->next = (yyvsp[0].n_decl); (yyval.n_decl) = (yyvsp[-1].n_decl); ;}
2864 break;
2865
2866 case 251:
2867 #line 761 "parser.y"
2868 { (yyval.n_tpd) = new file_tpd_node((yyvsp[-3].tok), (yyvsp[-2].tok), (yyvsp[-1].tok), (yyvsp[0].n_tpd)); ;}
2869 break;
2870
2871 case 252:
2872 #line 763 "parser.y"
2873 { (yyval.tok) = NULL; ;}
2874 break;
2875
2876 case 255:
2877 #line 766 "parser.y"
2878 { (yyvsp[-2].n_idx)->next = (yyvsp[0].n_idx); (yyval.n_idx) = (yyvsp[-2].n_idx); ;}
2879 break;
2880
2881 case 256:
2882 #line 769 "parser.y"
2883 { (yyval.n_idx) = new conformant_index_node((yyvsp[-4].tok), (yyvsp[-3].tok), (yyvsp[-2].tok), (yyvsp[-1].tok), (yyvsp[0].n_tpd)); ;}
2884 break;
2885
2886 case 258:
2887 #line 772 "parser.y"
2888 { (yyvsp[-2].n_idx)->next = (yyvsp[0].n_idx); (yyval.n_idx) = (yyvsp[-2].n_idx); ;}
2889 break;
2890
2891 case 259:
2892 #line 774 "parser.y"
2893 { (yyval.n_idx) = new type_index_node((yyvsp[0].n_tpd)); ;}
2894 break;
2895
2896 case 260:
2897 #line 775 "parser.y"
2898 { (yyval.n_idx) = new range_index_node((yyvsp[-2].n_expr), (yyvsp[-1].tok), (yyvsp[0].n_expr)); ;}
2899 break;
2900
2901 case 261:
2902 #line 780 "parser.y"
2903 { (yyval.n_fldls) = new field_list_node((yyvsp[-1].n_vdcl), (yyvsp[0].n_varp)); ;}
2904 break;
2905
2906 case 262:
2907 #line 782 "parser.y"
2908 { (yyval.n_fldls) = new field_list_node((yyvsp[0].n_vdcl)); ;}
2909 break;
2910
2911 case 264:
2912 #line 787 "parser.y"
2913 {
2914 (yyval.n_varp) = new variant_part_node((yyvsp[-3].tok), (yyvsp[-2].n_sel), (yyvsp[-1].tok), (yyvsp[0].n_vari));
2915 ;}
2916 break;
2917
2918 case 265:
2919 #line 791 "parser.y"
2920 { (yyval.n_sel) = new selector_node((yyvsp[-2].tok), (yyvsp[-1].tok), (yyvsp[0].n_tpd)); ;}
2921 break;
2922
2923 case 266:
2924 #line 792 "parser.y"
2925 { (yyval.n_sel) = new selector_node(NULL, NULL, (yyvsp[0].n_tpd)); ;}
2926 break;
2927
2928 case 268:
2929 #line 796 "parser.y"
2930 { (yyval.n_vari) = (yyvsp[-1].n_vari); ;}
2931 break;
2932
2933 case 269:
2934 #line 797 "parser.y"
2935 { (yyvsp[-2].n_vari)->next = (yyvsp[0].n_vari); (yyval.n_vari) = (yyvsp[-2].n_vari); ;}
2936 break;
2937
2938 case 270:
2939 #line 800 "parser.y"
2940 {
2941 (yyval.n_vari) = new variant_node((yyvsp[-4].n_expr), (yyvsp[-3].tok), (yyvsp[-2].tok), (yyvsp[-1].n_fldls), (yyvsp[0].tok));
2942 ;}
2943 break;
2944
2945
2946 }
2947
2948 /* Line 1037 of yacc.c. */
2949 #line 2950 "parser.tab.c"
2950
2951 yyvsp -= yylen;
2952 yyssp -= yylen;
2953
2954
2955 YY_STACK_PRINT (yyss, yyssp);
2956
2957 *++yyvsp = yyval;
2958
2959
2960 /* Now `shift' the result of the reduction. Determine what state
2961 that goes to, based on the state we popped back to and the rule
2962 number reduced by. */
2963
2964 yyn = yyr1[yyn];
2965
2966 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
2967 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2968 yystate = yytable[yystate];
2969 else
2970 yystate = yydefgoto[yyn - YYNTOKENS];
2971
2972 goto yynewstate;
2973
2974
2975 /*------------------------------------.
2976 | yyerrlab -- here on detecting error |
2977 `------------------------------------*/
2978 yyerrlab:
2979 /* If not already recovering from an error, report this error. */
2980 if (!yyerrstatus)
2981 {
2982 ++yynerrs;
2983 #if YYERROR_VERBOSE
2984 yyn = yypact[yystate];
2985
2986 if (YYPACT_NINF < yyn && yyn < YYLAST)
2987 {
2988 YYSIZE_T yysize = 0;
2989 int yytype = YYTRANSLATE (yychar);
2990 const char* yyprefix;
2991 char *yymsg;
2992 int yyx;
2993
2994 /* Start YYX at -YYN if negative to avoid negative indexes in
2995 YYCHECK. */
2996 int yyxbegin = yyn < 0 ? -yyn : 0;
2997
2998 /* Stay within bounds of both yycheck and yytname. */
2999 int yychecklim = YYLAST - yyn;
3000 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
3001 int yycount = 0;
3002
3003 yyprefix = ", expecting ";
3004 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
3005 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
3006 {
3007 yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]);
3008 yycount += 1;
3009 if (yycount == 5)
3010 {
3011 yysize = 0;
3012 break;
3013 }
3014 }
3015 yysize += (sizeof ("syntax error, unexpected ")
3016 + yystrlen (yytname[yytype]));
3017 yymsg = (char *) YYSTACK_ALLOC (yysize);
3018 if (yymsg != 0)
3019 {
3020 char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
3021 yyp = yystpcpy (yyp, yytname[yytype]);
3022
3023 if (yycount < 5)
3024 {
3025 yyprefix = ", expecting ";
3026 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
3027 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
3028 {
3029 yyp = yystpcpy (yyp, yyprefix);
3030 yyp = yystpcpy (yyp, yytname[yyx]);
3031 yyprefix = " or ";
3032 }
3033 }
3034 yyerror (yymsg);
3035 YYSTACK_FREE (yymsg);
3036 }
3037 else
3038 yyerror ("syntax error; also virtual memory exhausted");
3039 }
3040 else
3041 #endif /* YYERROR_VERBOSE */
3042 yyerror ("syntax error");
3043 }
3044
3045
3046
3047 if (yyerrstatus == 3)
3048 {
3049 /* If just tried and failed to reuse look-ahead token after an
3050 error, discard it. */
3051
3052 if (yychar <= YYEOF)
3053 {
3054 /* If at end of input, pop the error token,
3055 then the rest of the stack, then return failure. */
3056 if (yychar == YYEOF)
3057 for (;;)
3058 {
3059
3060 YYPOPSTACK;
3061 if (yyssp == yyss)
3062 YYABORT;
3063 yydestruct ("Error: popping",
3064 yystos[*yyssp], yyvsp);
3065 }
3066 }
3067 else
3068 {
3069 yydestruct ("Error: discarding", yytoken, &yylval);
3070 yychar = YYEMPTY;
3071 }
3072 }
3073
3074 /* Else will try to reuse look-ahead token after shifting the error
3075 token. */
3076 goto yyerrlab1;
3077
3078
3079 /*---------------------------------------------------.
3080 | yyerrorlab -- error raised explicitly by YYERROR. |
3081 `---------------------------------------------------*/
3082 yyerrorlab:
3083
3084 #ifdef __GNUC__
3085 /* Pacify GCC when the user code never invokes YYERROR and the label
3086 yyerrorlab therefore never appears in user code. */
3087 if (0)
3088 goto yyerrorlab;
3089 #endif
3090
3091 yyvsp -= yylen;
3092 yyssp -= yylen;
3093 yystate = *yyssp;
3094 goto yyerrlab1;
3095
3096
3097 /*-------------------------------------------------------------.
3098 | yyerrlab1 -- common code for both syntax error and YYERROR. |
3099 `-------------------------------------------------------------*/
3100 yyerrlab1:
3101 yyerrstatus = 3; /* Each real token shifted decrements this. */
3102
3103 for (;;)
3104 {
3105 yyn = yypact[yystate];
3106 if (yyn != YYPACT_NINF)
3107 {
3108 yyn += YYTERROR;
3109 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
3110 {
3111 yyn = yytable[yyn];
3112 if (0 < yyn)
3113 break;
3114 }
3115 }
3116
3117 /* Pop the current state because it cannot handle the error token. */
3118 if (yyssp == yyss)
3119 YYABORT;
3120
3121
3122 yydestruct ("Error: popping", yystos[yystate], yyvsp);
3123 YYPOPSTACK;
3124 yystate = *yyssp;
3125 YY_STACK_PRINT (yyss, yyssp);
3126 }
3127
3128 if (yyn == YYFINAL)
3129 YYACCEPT;
3130
3131 *++yyvsp = yylval;
3132
3133
3134 /* Shift the error token. */
3135 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
3136
3137 yystate = yyn;
3138 goto yynewstate;
3139
3140
3141 /*-------------------------------------.
3142 | yyacceptlab -- YYACCEPT comes here. |
3143 `-------------------------------------*/
3144 yyacceptlab:
3145 yyresult = 0;
3146 goto yyreturn;
3147
3148 /*-----------------------------------.
3149 | yyabortlab -- YYABORT comes here. |
3150 `-----------------------------------*/
3151 yyabortlab:
3152 yydestruct ("Error: discarding lookahead",
3153 yytoken, &yylval);
3154 yychar = YYEMPTY;
3155 yyresult = 1;
3156 goto yyreturn;
3157
3158 #ifndef yyoverflow
3159 /*----------------------------------------------.
3160 | yyoverflowlab -- parser overflow comes here. |
3161 `----------------------------------------------*/
3162 yyoverflowlab:
3163 yyerror ("parser stack overflow");
3164 yyresult = 2;
3165 /* Fall through. */
3166 #endif
3167
3168 yyreturn:
3169 #ifndef yyoverflow
3170 if (yyss != yyssa)
3171 YYSTACK_FREE (yyss);
3172 #endif
3173 return yyresult;
3174 }
3175
3176
3177 #line 804 "parser.y"
3178
3179
zzlex()3180 int zzlex() {
3181 curr_token = curr_token ? curr_token->next_relevant()
3182 : token::first_relevant();
3183 if (curr_token->tag == TKN_SCONST) {
3184 while (curr_token->next != NULL && curr_token->next->tag == TKN_SCONST)
3185 {
3186 curr_token->in_text = curr_token->out_text =
3187 dprintf("%s%s", curr_token->in_text, curr_token->next->in_text);
3188 curr_token->next->remove();
3189 }
3190 } else if (turbo_pascal && curr_token->tag == TKN_FILE
3191 && curr_token->next_relevant()->tag != TKN_OF)
3192 {
3193 curr_token->tag = TKN_IDENT;
3194 curr_token->in_text = curr_token->out_text = "untyped_file";
3195 curr_token->name = nm_entry::find("untyped_file");
3196 }
3197 zzlval.tok = curr_token;
3198 return zzcnv_table[curr_token->tag];
3199 }
3200
3201
3202
3203