?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
supernova: fix for small audio vector sizes
[supercollider.git] / lang / LangSource / Bison / lang11d_tab.cpp
blobd64c764c71a3eb55c659b0bab460040cf72a9399
1
2 /* A Bison parser, made by GNU Bison 2.4.1. */
3
4 /* Skeleton implementation for Bison's Yacc-like parsers in C
5
6 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
7 Free Software Foundation, Inc.
8
9 This program is free software: you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation, either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21
22 /* As a special exception, you may create a larger work that contains
23 part or all of the Bison parser skeleton and distribute that work
24 under terms of your choice, so long as that work isn't itself a
25 parser generator using the skeleton or a modified version thereof
26 as a parser skeleton. Alternatively, if you modify or redistribute
27 the parser skeleton itself, you may (at your option) remove this
28 special exception, which will cause the skeleton and the resulting
29 Bison output files to be licensed under the GNU General Public
30 License without this special exception.
31
32 This special exception was added by the Free Software Foundation in
33 version 2.2 of Bison. */
34
35 /* C LALR(1) parser skeleton written by Richard Stallman, by
36 simplifying the original so-called "semantic" parser. */
37
38 /* All symbols defined below should begin with yy or YY, to avoid
39 infringing on user name space. This should be done even for local
40 variables, as they might otherwise be expanded by user macros.
41 There are some unavoidable exceptions within include files to
42 define necessary library symbols; they are noted "INFRINGES ON
43 USER NAME SPACE" below. */
44
45 /* Identify Bison output. */
46 #define YYBISON 1
47
48 /* Bison version. */
49 #define YYBISON_VERSION "2.4.1"
50
51 /* Skeleton name. */
52 #define YYSKELETON_NAME "yacc.c"
53
54 /* Pure parsers. */
55 #define YYPURE 0
56
57 /* Push parsers. */
58 #define YYPUSH 0
59
60 /* Pull parsers. */
61 #define YYPULL 1
62
63 /* Using locations. */
64 #define YYLSP_NEEDED 0
65
66
67
68 /* Copy the first part of user declarations. */
69
70 /* Line 189 of yacc.c */
71 #line 16 "lang11d"
72
73
74 #include <stdlib.h>
75 #include <string.h>
76 #include "PyrLexer.h"
77 #include "PyrParseNode.h"
78 #include "SC_Constants.h"
79 #include "SC_InlineUnaryOp.h"
80 #include "SC_InlineBinaryOp.h"
81 #include "InitAlloc.h"
82 #include "PredefinedSymbols.h"
83 #include "SimpleStack.h"
84
85 void bcopy(void *src, void *dst, size_t size) ;
86 int yyparse();
87 extern bool compilingCmdLine;
88 extern LongStack generatorStack;
89
90
91
92
93 /* Line 189 of yacc.c */
94 #line 95 "lang11d_tab.cpp"
95
96 /* Enabling traces. */
97 #ifndef YYDEBUG
98 # define YYDEBUG 0
99 #endif
100
101 /* Enabling verbose error messages. */
102 #ifdef YYERROR_VERBOSE
103 # undef YYERROR_VERBOSE
104 # define YYERROR_VERBOSE 1
105 #else
106 # define YYERROR_VERBOSE 0
107 #endif
108
109 /* Enabling the token table. */
110 #ifndef YYTOKEN_TABLE
111 # define YYTOKEN_TABLE 0
112 #endif
113
114
115 /* Tokens. */
116 #ifndef YYTOKENTYPE
117 # define YYTOKENTYPE
118 /* Put the tokens into the symbol table, so that GDB and other debuggers
119 know about them. */
120 enum yytokentype {
121 NAME = 258,
122 INTEGER = 259,
123 SC_FLOAT = 260,
124 ACCIDENTAL = 261,
125 SYMBOL = 262,
126 STRING = 263,
127 ASCII = 264,
128 PRIMITIVENAME = 265,
129 CLASSNAME = 266,
130 CURRYARG = 267,
131 VAR = 268,
132 ARG = 269,
133 CLASSVAR = 270,
134 SC_CONST = 271,
135 NILOBJ = 272,
136 TRUEOBJ = 273,
137 FALSEOBJ = 274,
138 PSEUDOVAR = 275,
139 ELLIPSIS = 276,
140 DOTDOT = 277,
141 PIE = 278,
142 BEGINCLOSEDFUNC = 279,
143 BADTOKEN = 280,
144 INTERPRET = 281,
145 BEGINGENERATOR = 282,
146 LEFTARROW = 283,
147 WHILE = 284,
148 READWRITEVAR = 285,
149 KEYBINOP = 286,
150 BINOP = 287,
151 UMINUS = 288
152 };
153 #endif
154
155
156
157 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
158 typedef int YYSTYPE;
159 # define YYSTYPE_IS_TRIVIAL 1
160 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
161 # define YYSTYPE_IS_DECLARED 1
162 #endif
163
164
165 /* Copy the second part of user declarations. */
166
167
168 /* Line 264 of yacc.c */
169 #line 170 "lang11d_tab.cpp"
170
171 #ifdef short
172 # undef short
173 #endif
174
175 #ifdef YYTYPE_UINT8
176 typedef YYTYPE_UINT8 yytype_uint8;
177 #else
178 typedef unsigned char yytype_uint8;
179 #endif
180
181 #ifdef YYTYPE_INT8
182 typedef YYTYPE_INT8 yytype_int8;
183 #elif (defined __STDC__ || defined __C99__FUNC__ \
184 || defined __cplusplus || defined _MSC_VER)
185 typedef signed char yytype_int8;
186 #else
187 typedef short int yytype_int8;
188 #endif
189
190 #ifdef YYTYPE_UINT16
191 typedef YYTYPE_UINT16 yytype_uint16;
192 #else
193 typedef unsigned short int yytype_uint16;
194 #endif
195
196 #ifdef YYTYPE_INT16
197 typedef YYTYPE_INT16 yytype_int16;
198 #else
199 typedef short int yytype_int16;
200 #endif
201
202 #ifndef YYSIZE_T
203 # ifdef __SIZE_TYPE__
204 # define YYSIZE_T __SIZE_TYPE__
205 # elif defined size_t
206 # define YYSIZE_T size_t
207 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
208 || defined __cplusplus || defined _MSC_VER)
209 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
210 # define YYSIZE_T size_t
211 # else
212 # define YYSIZE_T unsigned int
213 # endif
214 #endif
215
216 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
217
218 #ifndef YY_
219 # if YYENABLE_NLS
220 # if ENABLE_NLS
221 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
222 # define YY_(msgid) dgettext ("bison-runtime", msgid)
223 # endif
224 # endif
225 # ifndef YY_
226 # define YY_(msgid) msgid
227 # endif
228 #endif
229
230 /* Suppress unused-variable warnings by "using" E. */
231 #if ! defined lint || defined __GNUC__
232 # define YYUSE(e) ((void) (e))
233 #else
234 # define YYUSE(e) /* empty */
235 #endif
236
237 /* Identity function, used to suppress warnings about constant conditions. */
238 #ifndef lint
239 # define YYID(n) (n)
240 #else
241 #if (defined __STDC__ || defined __C99__FUNC__ \
242 || defined __cplusplus || defined _MSC_VER)
243 static int
244 YYID (int yyi)
245 #else
246 static int
247 YYID (yyi)
248 int yyi;
249 #endif
250 {
251 return yyi;
252 }
253 #endif
254
255 #if ! defined yyoverflow || YYERROR_VERBOSE
256
257 /* The parser invokes alloca or malloc; define the necessary symbols. */
258
259 # ifdef YYSTACK_USE_ALLOCA
260 # if YYSTACK_USE_ALLOCA
261 # ifdef __GNUC__
262 # define YYSTACK_ALLOC __builtin_alloca
263 # elif defined __BUILTIN_VA_ARG_INCR
264 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
265 # elif defined _AIX
266 # define YYSTACK_ALLOC __alloca
267 # elif defined _MSC_VER
268 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
269 # define alloca _alloca
270 # else
271 # define YYSTACK_ALLOC alloca
272 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
273 || defined __cplusplus || defined _MSC_VER)
274 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
275 # ifndef _STDLIB_H
276 # define _STDLIB_H 1
277 # endif
278 # endif
279 # endif
280 # endif
281 # endif
282
283 # ifdef YYSTACK_ALLOC
284 /* Pacify GCC's `empty if-body' warning. */
285 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
286 # ifndef YYSTACK_ALLOC_MAXIMUM
287 /* The OS might guarantee only one guard page at the bottom of the stack,
288 and a page size can be as small as 4096 bytes. So we cannot safely
289 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
290 to allow for a few compiler-allocated temporary stack slots. */
291 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
292 # endif
293 # else
294 # define YYSTACK_ALLOC YYMALLOC
295 # define YYSTACK_FREE YYFREE
296 # ifndef YYSTACK_ALLOC_MAXIMUM
297 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
298 # endif
299 # if (defined __cplusplus && ! defined _STDLIB_H \
300 && ! ((defined YYMALLOC || defined malloc) \
301 && (defined YYFREE || defined free)))
302 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
303 # ifndef _STDLIB_H
304 # define _STDLIB_H 1
305 # endif
306 # endif
307 # ifndef YYMALLOC
308 # define YYMALLOC malloc
309 # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
310 || defined __cplusplus || defined _MSC_VER)
311 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
312 # endif
313 # endif
314 # ifndef YYFREE
315 # define YYFREE free
316 # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
317 || defined __cplusplus || defined _MSC_VER)
318 void free (void *); /* INFRINGES ON USER NAME SPACE */
319 # endif
320 # endif
321 # endif
322 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
323
324
325 #if (! defined yyoverflow \
326 && (! defined __cplusplus \
327 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
328
329 /* A type that is properly aligned for any stack member. */
330 union yyalloc
331 {
332 yytype_int16 yyss_alloc;
333 YYSTYPE yyvs_alloc;
334 };
335
336 /* The size of the maximum gap between one aligned stack and the next. */
337 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
338
339 /* The size of an array large to enough to hold all stacks, each with
340 N elements. */
341 # define YYSTACK_BYTES(N) \
342 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
343 + YYSTACK_GAP_MAXIMUM)
344
345 /* Copy COUNT objects from FROM to TO. The source and destination do
346 not overlap. */
347 # ifndef YYCOPY
348 # if defined __GNUC__ && 1 < __GNUC__
349 # define YYCOPY(To, From, Count) \
350 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
351 # else
352 # define YYCOPY(To, From, Count) \
353 do \
354 { \
355 YYSIZE_T yyi; \
356 for (yyi = 0; yyi < (Count); yyi++) \
357 (To)[yyi] = (From)[yyi]; \
358 } \
359 while (YYID (0))
360 # endif
361 # endif
362
363 /* Relocate STACK from its old location to the new one. The
364 local variables YYSIZE and YYSTACKSIZE give the old and new number of
365 elements in the stack, and YYPTR gives the new location of the
366 stack. Advance YYPTR to a properly aligned location for the next
367 stack. */
368 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
369 do \
370 { \
371 YYSIZE_T yynewbytes; \
372 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
373 Stack = &yyptr->Stack_alloc; \
374 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
375 yyptr += yynewbytes / sizeof (*yyptr); \
376 } \
377 while (YYID (0))
378
379 #endif
380
381 /* YYFINAL -- State number of the termination state. */
382 #define YYFINAL 68
383 /* YYLAST -- Last index in YYTABLE. */
384 #define YYLAST 1968
385
386 /* YYNTOKENS -- Number of terminals. */
387 #define YYNTOKENS 55
388 /* YYNNTS -- Number of nonterminals. */
389 #define YYNNTS 102
390 /* YYNRULES -- Number of rules. */
391 #define YYNRULES 295
392 /* YYNRULES -- Number of states. */
393 #define YYNSTATES 532
394
395 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
396 #define YYUNDEFTOK 2
397 #define YYMAXUTOK 288
398
399 #define YYTRANSLATE(YYX) \
400 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
401
402 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
403 static const yytype_uint8 yytranslate[] =
404 {
405 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
406 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
407 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
408 2, 2, 2, 2, 2, 54, 2, 2, 2, 2,
409 50, 51, 35, 36, 49, 32, 41, 2, 2, 2,
410 2, 2, 2, 2, 2, 2, 2, 2, 30, 48,
411 33, 31, 34, 2, 2, 2, 2, 2, 2, 2,
412 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
413 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
414 2, 46, 2, 47, 52, 2, 42, 2, 2, 2,
415 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
416 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
417 2, 2, 2, 44, 37, 45, 53, 2, 2, 2,
418 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
419 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
420 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
421 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
422 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
423 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
424 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
425 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
426 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
427 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
428 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
429 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
430 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
431 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
432 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
433 25, 26, 27, 28, 29, 38, 39, 40, 43
434 };
435
436 #if YYDEBUG
437 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
438 YYRHS. */
439 static const yytype_uint16 yyprhs[] =
440 {
441 0, 0, 3, 5, 7, 10, 11, 14, 16, 19,
442 26, 36, 42, 43, 45, 46, 49, 50, 53, 57,
443 61, 65, 66, 69, 77, 86, 94, 103, 104, 106,
444 107, 109, 110, 112, 114, 117, 122, 125, 127, 129,
445 132, 133, 136, 137, 141, 142, 146, 148, 151, 153,
446 155, 156, 158, 161, 166, 171, 178, 185, 194, 200,
447 208, 213, 216, 221, 227, 234, 240, 246, 253, 261,
448 269, 276, 283, 292, 300, 305, 306, 314, 315, 323,
449 324, 327, 332, 338, 344, 347, 352, 357, 359, 361,
450 363, 365, 367, 369, 373, 376, 380, 384, 389, 393,
451 395, 400, 402, 408, 414, 421, 429, 437, 446, 453,
452 460, 468, 477, 486, 496, 499, 502, 506, 512, 517,
453 520, 523, 527, 532, 538, 540, 542, 544, 546, 552,
454 555, 560, 564, 569, 575, 583, 588, 595, 603, 604,
455 607, 610, 615, 617, 621, 624, 625, 628, 630, 634,
456 637, 641, 646, 652, 654, 658, 661, 666, 668, 672,
457 675, 676, 679, 681, 685, 687, 691, 693, 695, 697,
458 699, 701, 703, 705, 707, 709, 711, 713, 715, 717,
459 719, 721, 723, 725, 727, 729, 731, 733, 735, 737,
460 739, 741, 743, 745, 747, 749, 751, 753, 755, 757,
461 763, 769, 770, 773, 775, 778, 782, 783, 787, 793,
462 797, 803, 805, 809, 814, 815, 817, 819, 823, 825,
463 829, 835, 836, 838, 840, 844, 846, 850, 855, 859,
464 862, 864, 868, 869, 871, 873, 877, 880, 885, 890,
465 894, 898, 901, 903, 907, 908, 910, 915, 921, 925,
466 930, 931, 934, 936, 940, 941, 943, 945, 947, 948,
467 950, 952, 955, 957, 960, 962, 965, 967, 969, 971,
468 974, 977, 979, 982, 984, 986, 988, 990, 992, 994,
469 996, 998, 1000, 1002, 1004, 1006, 1008, 1010, 1012, 1014,
470 1016, 1018, 1020, 1022, 1024, 1026
471 };
472
473 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
474 static const yytype_int16 yyrhs[] =
475 {
476 56, 0, -1, 57, -1, 58, -1, 26, 71, -1,
477 -1, 57, 59, -1, 60, -1, 58, 60, -1, 144,
478 62, 44, 63, 65, 45, -1, 144, 46, 61, 47,
479 62, 44, 63, 65, 45, -1, 36, 144, 44, 65,
480 45, -1, -1, 143, -1, -1, 30, 144, -1, -1,
481 63, 64, -1, 15, 125, 48, -1, 13, 125, 48,
482 -1, 16, 114, 48, -1, -1, 65, 66, -1, 143,
483 44, 113, 110, 73, 72, 45, -1, 35, 143, 44,
484 113, 110, 73, 72, 45, -1, 153, 44, 113, 110,
485 73, 72, 45, -1, 35, 153, 44, 113, 110, 73,
486 72, 45, -1, -1, 48, -1, -1, 49, -1, -1,
487 31, -1, 75, -1, 94, 75, -1, 50, 111, 70,
488 51, -1, 111, 70, -1, 70, -1, 74, -1, 94,
489 74, -1, -1, 145, 67, -1, -1, 52, 91, 67,
490 -1, -1, 52, 91, 67, -1, 77, -1, 76, 77,
491 -1, 105, -1, 80, -1, -1, 76, -1, 143, 76,
492 -1, 50, 155, 51, 76, -1, 143, 50, 51, 76,
493 -1, 143, 50, 97, 101, 51, 78, -1, 50, 155,
494 51, 50, 51, 76, -1, 50, 155, 51, 50, 97,
495 101, 51, 78, -1, 143, 50, 98, 101, 51, -1,
496 50, 155, 51, 50, 98, 101, 51, -1, 144, 46,
497 95, 47, -1, 144, 76, -1, 144, 50, 51, 78,
498 -1, 144, 50, 99, 51, 78, -1, 144, 50, 97,
499 101, 51, 78, -1, 144, 50, 98, 101, 51, -1,
500 91, 41, 50, 51, 78, -1, 91, 41, 50, 99,
501 51, 78, -1, 91, 41, 143, 50, 99, 51, 78,
502 -1, 91, 41, 50, 97, 101, 51, 78, -1, 91,
503 41, 50, 98, 101, 51, -1, 91, 41, 143, 50,
504 51, 78, -1, 91, 41, 143, 50, 97, 101, 51,
505 78, -1, 91, 41, 143, 50, 98, 101, 51, -1,
506 91, 41, 143, 78, -1, -1, 44, 30, 94, 81,
507 49, 84, 45, -1, -1, 44, 48, 94, 82, 49,
508 84, 45, -1, -1, 49, 84, -1, 143, 28, 94,
509 83, -1, 143, 143, 28, 94, 83, -1, 13, 143,
510 31, 94, 83, -1, 94, 83, -1, 30, 30, 94,
511 83, -1, 30, 29, 94, 83, -1, 107, -1, 105,
512 -1, 80, -1, 106, -1, 156, -1, 79, -1, 50,
513 94, 51, -1, 53, 143, -1, 46, 95, 47, -1,
514 50, 89, 51, -1, 50, 30, 90, 51, -1, 50,
515 124, 51, -1, 152, -1, 85, 46, 97, 47, -1,
516 86, -1, 85, 46, 97, 22, 47, -1, 85, 46,
517 22, 94, 47, -1, 85, 46, 97, 22, 94, 47,
518 -1, 85, 46, 97, 22, 47, 31, 91, -1, 85,
519 46, 22, 94, 47, 31, 91, -1, 85, 46, 97,
520 22, 94, 47, 31, 91, -1, 91, 41, 46, 97,
521 22, 47, -1, 91, 41, 46, 22, 94, 47, -1,
522 91, 41, 46, 97, 22, 94, 47, -1, 91, 41,
523 46, 97, 22, 47, 31, 91, -1, 91, 41, 46,
524 22, 94, 47, 31, 91, -1, 91, 41, 46, 97,
525 22, 94, 47, 31, 91, -1, 94, 22, -1, 22,
526 94, -1, 94, 22, 94, -1, 94, 49, 94, 22,
527 94, -1, 94, 49, 94, 22, -1, 22, 94, -1,
528 94, 22, -1, 94, 22, 94, -1, 94, 49, 94,
529 22, -1, 94, 49, 94, 22, 94, -1, 85, -1,
530 88, -1, 87, -1, 144, -1, 91, 41, 46, 97,
531 47, -1, 42, 91, -1, 91, 155, 92, 91, -1,
532 143, 31, 91, -1, 53, 143, 31, 91, -1, 91,
533 41, 143, 31, 91, -1, 143, 50, 97, 101, 51,
534 31, 91, -1, 54, 102, 31, 91, -1, 85, 46,
535 97, 47, 31, 91, -1, 91, 41, 46, 97, 47,
536 31, 91, -1, -1, 41, 143, -1, 41, 138, -1,
537 41, 50, 94, 51, -1, 91, -1, 93, 48, 91,
538 -1, 93, 67, -1, -1, 96, 68, -1, 94, -1,
539 94, 30, 94, -1, 154, 94, -1, 96, 49, 94,
540 -1, 96, 49, 154, 94, -1, 96, 49, 94, 30,
541 94, -1, 94, -1, 97, 49, 94, -1, 35, 94,
542 -1, 97, 49, 35, 94, -1, 100, -1, 99, 49,
543 100, -1, 154, 94, -1, -1, 49, 99, -1, 103,
544 -1, 103, 21, 143, -1, 143, -1, 103, 49, 143,
545 -1, 138, -1, 142, -1, 149, -1, 151, -1, 150,
546 -1, 146, -1, 147, -1, 148, -1, 132, -1, 127,
547 -1, 109, -1, 143, -1, 138, -1, 142, -1, 149,
548 -1, 151, -1, 150, -1, 146, -1, 147, -1, 148,
549 -1, 132, -1, 127, -1, 138, -1, 142, -1, 149,
550 -1, 151, -1, 150, -1, 143, -1, 146, -1, 147,
551 -1, 148, -1, 133, -1, 128, -1, 44, 113, 110,
552 70, 45, -1, 24, 113, 110, 70, 45, -1, -1,
553 110, 112, -1, 112, -1, 111, 112, -1, 13, 120,
554 48, -1, -1, 14, 120, 48, -1, 14, 119, 21,
555 143, 48, -1, 37, 117, 37, -1, 37, 116, 21,
556 143, 37, -1, 115, -1, 114, 68, 115, -1, 137,
557 143, 31, 104, -1, -1, 117, -1, 118, -1, 117,
558 68, 118, -1, 143, -1, 143, 69, 104, -1, 143,
559 69, 50, 94, 51, -1, -1, 120, -1, 121, -1,
560 120, 49, 121, -1, 143, -1, 143, 31, 91, -1,
561 143, 50, 94, 51, -1, 94, 30, 94, -1, 154,
562 94, -1, 122, -1, 123, 49, 122, -1, -1, 123,
563 -1, 126, -1, 125, 49, 126, -1, 136, 143, -1,
564 136, 143, 31, 104, -1, 54, 50, 131, 51, -1,
565 50, 131, 51, -1, 108, 30, 108, -1, 154, 108,
566 -1, 129, -1, 130, 49, 129, -1, -1, 130, -1,
567 54, 46, 134, 47, -1, 54, 144, 46, 134, 47,
568 -1, 46, 134, 47, -1, 144, 46, 134, 47, -1,
569 -1, 135, 68, -1, 108, -1, 135, 49, 108, -1,
570 -1, 33, -1, 38, -1, 34, -1, -1, 33, -1,
571 4, -1, 32, 4, -1, 5, -1, 32, 5, -1,
572 6, -1, 32, 6, -1, 23, -1, 139, -1, 140,
573 -1, 139, 141, -1, 138, 141, -1, 141, -1, 32,
574 141, -1, 3, -1, 29, -1, 11, -1, 10, -1,
575 18, -1, 19, -1, 17, -1, 9, -1, 7, -1,
576 8, -1, 20, -1, 40, -1, 38, -1, 33, -1,
577 34, -1, 32, -1, 35, -1, 36, -1, 37, -1,
578 39, -1, 153, -1, 154, -1, 12, -1
579 };
580
581 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
582 static const yytype_uint16 yyrline[] =
583 {
584 0, 39, 39, 41, 43, 47, 48, 52, 53, 57,
585 61, 68, 74, 75, 78, 79, 83, 84, 88, 90,
586 92, 96, 97, 101, 104, 107, 110, 115, 116, 119,
587 120, 123, 124, 127, 128, 132, 134, 136, 140, 141,
588 145, 146, 151, 152, 157, 158, 162, 163, 169, 170,
589 173, 174, 177, 181, 185, 189, 194, 198, 203, 221,
590 234, 236, 247, 258, 269, 282, 303, 312, 321, 326,
591 339, 359, 363, 369, 387, 393, 393, 403, 403, 410,
592 431, 435, 469, 507, 521, 532, 536, 561, 562, 563,
593 564, 565, 566, 567, 573, 583, 585, 587, 589, 591,
594 593, 606, 609, 636, 654, 681, 709, 728, 756, 783,
595 801, 826, 854, 873, 901, 920, 939, 956, 970, 991,
596 1010, 1028, 1045, 1061, 1077, 1078, 1079, 1080, 1081, 1094,
597 1108, 1113, 1117, 1128, 1133, 1143, 1148, 1162, 1178, 1179,
598 1180, 1181, 1184, 1185, 1191, 1194, 1195, 1199, 1200, 1202,
599 1207, 1209, 1216, 1224, 1225, 1229, 1231, 1235, 1236, 1240,
600 1244, 1245, 1248, 1250, 1254, 1255, 1260, 1261, 1262, 1263,
601 1264, 1265, 1266, 1267, 1268, 1269, 1272, 1275, 1278, 1279,
602 1280, 1281, 1282, 1283, 1284, 1285, 1286, 1287, 1290, 1291,
603 1292, 1293, 1294, 1295, 1296, 1297, 1298, 1299, 1300, 1303,
604 1306, 1311, 1312, 1316, 1317, 1321, 1325, 1326, 1330, 1334,
605 1338, 1344, 1345, 1349, 1353, 1354, 1357, 1358, 1362, 1364,
606 1366, 1374, 1375, 1378, 1379, 1383, 1385, 1387, 1395, 1397,
607 1404, 1405, 1409, 1410, 1413, 1414, 1418, 1420, 1424, 1428,
608 1432, 1434, 1441, 1442, 1446, 1447, 1452, 1454, 1458, 1460,
609 1464, 1465, 1468, 1469, 1473, 1474, 1476, 1478, 1482, 1483,
610 1487, 1488, 1497, 1498, 1507, 1508, 1519, 1522, 1523, 1524,
611 1530, 1538, 1545, 1554, 1555, 1558, 1561, 1564, 1567, 1570,
612 1573, 1576, 1579, 1582, 1585, 1586, 1587, 1588, 1589, 1590,
613 1591, 1592, 1595, 1598, 1599, 1602
614 };
615 #endif
616
617 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
618 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
619 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
620 static const char *const yytname[] =
621 {
622 "$end", "error", "$undefined", "NAME", "INTEGER", "SC_FLOAT",
623 "ACCIDENTAL", "SYMBOL", "STRING", "ASCII", "PRIMITIVENAME", "CLASSNAME",
624 "CURRYARG", "VAR", "ARG", "CLASSVAR", "SC_CONST", "NILOBJ", "TRUEOBJ",
625 "FALSEOBJ", "PSEUDOVAR", "ELLIPSIS", "DOTDOT", "PIE", "BEGINCLOSEDFUNC",
626 "BADTOKEN", "INTERPRET", "BEGINGENERATOR", "LEFTARROW", "WHILE", "':'",
627 "'='", "'-'", "'<'", "'>'", "'*'", "'+'", "'|'", "READWRITEVAR",
628 "KEYBINOP", "BINOP", "'.'", "'`'", "UMINUS", "'{'", "'}'", "'['", "']'",
629 "';'", "','", "'('", "')'", "'^'", "'~'", "'#'", "$accept", "root",
630 "classes", "classextensions", "classdef", "classextension", "optname",
631 "superclass", "classvardecls", "classvardecl", "methods", "methoddef",
632 "optsemi", "optcomma", "optequal", "funcbody", "cmdlinecode", "methbody",
633 "primitive", "retval", "funretval", "blocklist1", "blocklistitem",
634 "blocklist", "msgsend", "generator", "$@1", "$@2", "nextqual", "qual",
635 "expr1", "valrangex1", "valrangeassign", "valrangexd", "valrange2",
636 "valrange3", "expr", "adverb", "exprn", "exprseq", "arrayelems",
637 "arrayelems1", "arglist1", "arglistv1", "keyarglist1", "keyarg",
638 "optkeyarglist", "mavars", "mavarlist", "slotliteral", "blockliteral",
639 "pushname", "pushliteral", "listliteral", "block", "funcvardecls",
640 "funcvardecls1", "funcvardecl", "argdecls", "constdeflist", "constdef",
641 "slotdeflist0", "slotdeflist", "slotdef", "vardeflist0", "vardeflist",
642 "vardef", "dictslotdef", "dictslotlist1", "dictslotlist",
643 "rwslotdeflist", "rwslotdef", "dictlit", "dictlit2", "litdictslotdef",
644 "litdictslotlist1", "litdictslotlist", "listlit", "listlit2",
645 "literallistc", "literallist1", "rwspec", "rspec", "integer", "floatr",
646 "accidental", "pie", "floatp", "name", "classname", "primname",
647 "trueobj", "falseobj", "nilobj", "ascii", "symbol", "string",
648 "pseudovar", "binop", "keybinop", "binop2", "curryarg", 0
649 };
650 #endif
651
652 # ifdef YYPRINT
653 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
654 token YYLEX-NUM. */
655 static const yytype_uint16 yytoknum[] =
656 {
657 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
658 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
659 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
660 58, 61, 45, 60, 62, 42, 43, 124, 285, 286,
661 287, 46, 96, 288, 123, 125, 91, 93, 59, 44,
662 40, 41, 94, 126, 35
663 };
664 # endif
665
666 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
667 static const yytype_uint8 yyr1[] =
668 {
669 0, 55, 56, 56, 56, 57, 57, 58, 58, 59,
670 59, 60, 61, 61, 62, 62, 63, 63, 64, 64,
671 64, 65, 65, 66, 66, 66, 66, 67, 67, 68,
672 68, 69, 69, 70, 70, 71, 71, 71, 72, 72,
673 73, 73, 74, 74, 75, 75, 76, 76, 77, 77,
674 78, 78, 79, 79, 79, 79, 79, 79, 79, 79,
675 79, 79, 79, 79, 79, 79, 79, 79, 79, 79,
676 79, 79, 79, 79, 79, 81, 80, 82, 80, 83,
677 83, 84, 84, 84, 84, 84, 84, 85, 85, 85,
678 85, 85, 85, 85, 85, 85, 85, 85, 85, 85,
679 85, 85, 86, 86, 86, 87, 87, 87, 88, 88,
680 88, 88, 88, 88, 89, 89, 89, 89, 89, 90,
681 90, 90, 90, 90, 91, 91, 91, 91, 91, 91,
682 91, 91, 91, 91, 91, 91, 91, 91, 92, 92,
683 92, 92, 93, 93, 94, 95, 95, 96, 96, 96,
684 96, 96, 96, 97, 97, 98, 98, 99, 99, 100,
685 101, 101, 102, 102, 103, 103, 104, 104, 104, 104,
686 104, 104, 104, 104, 104, 104, 105, 106, 107, 107,
687 107, 107, 107, 107, 107, 107, 107, 107, 108, 108,
688 108, 108, 108, 108, 108, 108, 108, 108, 108, 109,
689 109, 110, 110, 111, 111, 112, 113, 113, 113, 113,
690 113, 114, 114, 115, 116, 116, 117, 117, 118, 118,
691 118, 119, 119, 120, 120, 121, 121, 121, 122, 122,
692 123, 123, 124, 124, 125, 125, 126, 126, 127, 128,
693 129, 129, 130, 130, 131, 131, 132, 132, 133, 133,
694 134, 134, 135, 135, 136, 136, 136, 136, 137, 137,
695 138, 138, 139, 139, 140, 140, 141, 142, 142, 142,
696 142, 142, 142, 143, 143, 144, 145, 146, 147, 148,
697 149, 150, 151, 152, 153, 153, 153, 153, 153, 153,
698 153, 153, 154, 155, 155, 156
699 };
700
701 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
702 static const yytype_uint8 yyr2[] =
703 {
704 0, 2, 1, 1, 2, 0, 2, 1, 2, 6,
705 9, 5, 0, 1, 0, 2, 0, 2, 3, 3,
706 3, 0, 2, 7, 8, 7, 8, 0, 1, 0,
707 1, 0, 1, 1, 2, 4, 2, 1, 1, 2,
708 0, 2, 0, 3, 0, 3, 1, 2, 1, 1,
709 0, 1, 2, 4, 4, 6, 6, 8, 5, 7,
710 4, 2, 4, 5, 6, 5, 5, 6, 7, 7,
711 6, 6, 8, 7, 4, 0, 7, 0, 7, 0,
712 2, 4, 5, 5, 2, 4, 4, 1, 1, 1,
713 1, 1, 1, 3, 2, 3, 3, 4, 3, 1,
714 4, 1, 5, 5, 6, 7, 7, 8, 6, 6,
715 7, 8, 8, 9, 2, 2, 3, 5, 4, 2,
716 2, 3, 4, 5, 1, 1, 1, 1, 5, 2,
717 4, 3, 4, 5, 7, 4, 6, 7, 0, 2,
718 2, 4, 1, 3, 2, 0, 2, 1, 3, 2,
719 3, 4, 5, 1, 3, 2, 4, 1, 3, 2,
720 0, 2, 1, 3, 1, 3, 1, 1, 1, 1,
721 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
722 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
723 1, 1, 1, 1, 1, 1, 1, 1, 1, 5,
724 5, 0, 2, 1, 2, 3, 0, 3, 5, 3,
725 5, 1, 3, 4, 0, 1, 1, 3, 1, 3,
726 5, 0, 1, 1, 3, 1, 3, 4, 3, 2,
727 1, 3, 0, 1, 1, 3, 2, 4, 4, 3,
728 3, 2, 1, 3, 0, 1, 4, 5, 3, 4,
729 0, 2, 1, 3, 0, 1, 1, 1, 0, 1,
730 1, 2, 1, 2, 1, 2, 1, 1, 1, 2,
731 2, 1, 2, 1, 1, 1, 1, 1, 1, 1,
732 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
733 1, 1, 1, 1, 1, 1
734 };
735
736 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
737 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
738 means the default is an error. */
739 static const yytype_uint16 yydefact[] =
740 {
741 5, 44, 0, 0, 2, 3, 7, 273, 260, 262,
742 264, 281, 282, 280, 275, 295, 0, 279, 277, 278,
743 283, 266, 206, 274, 0, 0, 206, 145, 232, 0,
744 0, 0, 37, 4, 33, 92, 89, 124, 101, 126,
745 125, 142, 27, 44, 88, 90, 87, 176, 44, 203,
746 187, 186, 178, 267, 268, 271, 179, 177, 127, 183,
747 184, 185, 180, 182, 181, 99, 91, 0, 1, 6,
748 14, 8, 0, 223, 225, 221, 214, 201, 261, 263,
749 265, 272, 232, 129, 0, 0, 201, 292, 147, 0,
750 29, 0, 0, 0, 288, 286, 287, 289, 290, 291,
751 285, 284, 0, 0, 44, 230, 233, 0, 293, 294,
752 0, 27, 94, 250, 244, 0, 162, 164, 0, 0,
753 288, 0, 294, 138, 28, 144, 34, 36, 204, 270,
754 269, 0, 0, 52, 46, 49, 48, 145, 0, 61,
755 21, 0, 12, 0, 205, 0, 0, 0, 0, 222,
756 0, 29, 216, 31, 44, 75, 77, 44, 0, 95,
757 30, 146, 149, 115, 0, 0, 0, 96, 114, 0,
758 0, 93, 0, 0, 98, 229, 0, 28, 45, 0,
759 250, 244, 252, 198, 197, 0, 29, 188, 189, 193,
760 0, 194, 195, 196, 190, 192, 191, 0, 242, 245,
761 0, 0, 0, 0, 0, 250, 0, 153, 0, 0,
762 0, 50, 0, 0, 143, 131, 0, 0, 160, 160,
763 47, 0, 50, 160, 160, 0, 157, 0, 0, 15,
764 0, 13, 16, 224, 226, 0, 0, 207, 0, 209,
765 30, 0, 32, 0, 0, 202, 0, 0, 0, 148,
766 150, 0, 119, 97, 120, 0, 116, 228, 0, 35,
767 0, 231, 0, 0, 53, 132, 0, 0, 246, 30,
768 251, 250, 0, 0, 238, 241, 135, 163, 165, 0,
769 0, 0, 100, 0, 0, 0, 50, 160, 160, 0,
770 0, 0, 51, 74, 0, 0, 140, 139, 130, 155,
771 54, 0, 0, 0, 0, 60, 62, 0, 0, 0,
772 50, 159, 289, 11, 22, 0, 0, 14, 21, 227,
773 0, 0, 217, 0, 0, 219, 175, 174, 166, 167,
774 171, 172, 173, 168, 170, 169, 200, 0, 0, 199,
775 0, 151, 121, 0, 118, 0, 160, 160, 248, 239,
776 253, 0, 240, 243, 247, 103, 102, 0, 0, 154,
777 0, 0, 128, 66, 0, 0, 50, 133, 50, 160,
778 160, 0, 0, 0, 161, 50, 58, 50, 65, 158,
779 63, 0, 0, 206, 206, 0, 254, 254, 258, 17,
780 0, 208, 210, 0, 0, 0, 0, 79, 177, 0,
781 152, 122, 117, 56, 0, 0, 249, 0, 0, 104,
782 136, 109, 108, 0, 0, 50, 70, 67, 71, 0,
783 0, 50, 141, 156, 0, 55, 64, 206, 206, 201,
784 201, 16, 255, 257, 256, 0, 234, 0, 0, 259,
785 29, 211, 0, 9, 220, 0, 0, 0, 76, 0,
786 84, 0, 0, 78, 123, 50, 59, 106, 105, 0,
787 0, 0, 110, 137, 69, 50, 73, 68, 134, 201,
788 201, 40, 40, 21, 19, 254, 236, 18, 20, 258,
789 0, 0, 79, 79, 80, 79, 0, 57, 107, 112,
790 111, 0, 72, 40, 40, 276, 42, 27, 42, 0,
791 235, 0, 212, 0, 79, 86, 85, 81, 79, 113,
792 42, 42, 0, 0, 38, 42, 41, 0, 10, 237,
793 213, 83, 82, 0, 0, 27, 23, 39, 25, 24,
794 26, 43
795 };
796
797 /* YYDEFGOTO[NTERM-NUM]. */
798 static const yytype_int16 yydefgoto[] =
799 {
800 -1, 3, 4, 5, 69, 6, 230, 143, 318, 389,
801 228, 314, 125, 161, 243, 32, 33, 513, 496, 514,
802 34, 292, 134, 293, 35, 36, 246, 247, 450, 396,
803 37, 38, 39, 40, 102, 165, 41, 213, 42, 207,
804 89, 90, 208, 219, 374, 226, 302, 115, 116, 325,
805 44, 45, 46, 182, 47, 154, 48, 245, 77, 440,
806 441, 150, 151, 152, 148, 72, 73, 105, 106, 107,
807 435, 436, 50, 183, 198, 199, 200, 51, 184, 185,
808 186, 437, 442, 52, 53, 54, 55, 56, 57, 58,
809 497, 59, 60, 61, 62, 63, 64, 65, 108, 122,
810 123, 66
811 };
812
813 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
814 STATE-NUM. */
815 #define YYPACT_NINF -331
816 static const yytype_int16 yypact[] =
817 {
818 71, 1102, 60, 20, 60, -12, -331, -331, -331, -331,
819 -331, -331, -331, -331, -331, -331, 13, -331, -331, -331,
820 -331, -331, 31, -331, 372, 1778, 48, 1414, 842, 1778,
821 13, 43, -331, -331, -331, -331, -331, 29, -331, -331,
822 -331, 765, 38, 52, -331, -331, -331, -331, 1154, -331,
823 -331, -331, 107, 107, -331, -331, -331, 214, 231, -331,
824 -331, -331, -331, -331, -331, -331, -331, 96, -331, -331,
825 119, -331, 198, -331, 108, 13, 13, -331, -331, -331,
826 -331, -331, 894, -331, 1778, 1778, -331, -331, 114, 100,
827 106, 1778, 1778, 1466, 372, -331, -331, -331, -331, -331,
828 -331, -331, 128, 99, 1154, -331, 133, 134, -331, 1778,
829 137, 703, 160, 1878, 1830, 169, 39, -331, 161, 1518,
830 -331, 168, -331, 172, 1778, -331, -331, -331, -331, -331,
831 -331, 1778, 1206, 17, -331, -331, -331, 1414, 946, 17,
832 -331, 60, 13, 175, -331, 13, 1778, 1778, 195, 236,
833 206, 18, -331, 45, 1154, -331, -331, 1154, 1778, -331,
834 1414, -331, -331, -331, 1778, 185, 8, -331, 1778, 1778,
835 1778, -331, 201, 1414, -331, -331, 110, -331, -331, 1778,
836 1878, 1830, -331, -331, -331, 240, 244, 107, -331, -331,
837 250, -331, -331, -331, -331, -331, -331, 284, -331, 256,
838 274, 1878, 1778, 13, 13, 1878, 1778, -331, 65, 1570,
839 998, 245, 95, 1778, 765, 765, 1778, 17, 280, 286,
840 -331, 291, 17, 280, 286, -26, -331, 1778, 1885, -331,
841 295, -331, -331, -331, 765, 301, 13, -331, 13, -331,
842 -331, 13, -331, 741, 303, -331, 306, 319, 328, -331,
843 345, 1778, -331, -331, 1778, 1778, -331, -331, 359, -331,
844 355, -331, 1778, 1258, 17, 765, 336, 340, -331, 1878,
845 -331, 1878, 1878, 1830, -331, -331, 765, -331, -331, 350,
846 358, 1622, 371, 1778, 1778, 94, 17, 280, 286, 147,
847 1778, 1050, 17, -331, 405, 1778, -331, -331, 369, -331,
848 17, 1310, 362, 375, 370, -331, -331, 374, 376, 375,
849 17, -331, 283, -331, -331, 379, 382, 390, 388, -331,
850 380, 393, -331, 1778, 6, -331, -331, -331, 107, -331,
851 -331, -331, -331, -331, -331, -331, -331, 1362, 1362, -331,
852 1778, -331, -331, 410, 1778, 17, 280, 286, -331, -331,
853 -331, 387, -331, -331, -331, 404, 406, 389, 1778, -331,
854 392, 1674, 413, -331, 396, 398, 17, 765, 17, 280,
855 286, 179, 400, 1778, 403, 300, -331, 17, -331, -331,
856 -331, 409, 412, 31, 31, 415, 275, 275, 424, -331,
857 1900, -331, -331, 411, 13, 272, 416, 414, 9, 422,
858 -331, 1778, -331, 17, 417, 418, -331, 1778, 1778, 429,
859 765, 440, 441, 427, 1778, 17, -331, -331, -331, 425,
860 426, 17, -331, -331, 1778, -331, -331, 31, 31, -331,
861 -331, -331, -331, -331, -331, 297, -331, 13, 313, -331,
862 317, -331, 13, -331, -331, 447, 1778, 1778, -331, 1362,
863 -331, 1778, 451, -331, -331, 17, -331, 765, 765, 1778,
864 1778, 1778, 450, 765, -331, 17, -331, -331, 765, -331,
865 -331, 67, 67, 388, -331, 275, 457, -331, -331, 424,
866 458, 1778, 414, 414, -331, 414, 1778, -331, 765, 765,
867 765, 1778, -331, 67, 67, -331, 1726, 434, 1726, 1923,
868 -331, 671, -331, 671, 414, -331, -331, -331, 414, 765,
869 1726, 1726, 1778, 446, -331, 444, -331, 453, -331, -331,
870 -331, -331, -331, 456, 459, 703, -331, -331, -331, -331,
871 -331, -331
872 };
873
874 /* YYPGOTO[NTERM-NUM]. */
875 static const yytype_int16 yypgoto[] =
876 {
877 -331, -331, -331, -331, -331, 487, -331, 186, 74, -331,
878 -303, -331, -109, -150, -331, -34, -331, -267, -237, -13,
879 463, -39, -75, 353, -331, 253, -331, -331, -234, -330,
880 -331, -331, -331, -331, -331, -331, -18, -331, -331, -1,
881 378, -331, -23, -59, -110, 199, 10, -331, -331, -264,
882 354, -331, -331, -49, -331, -76, 479, 21, -20, -331,
883 32, -331, -331, 271, -331, 438, 373, 346, -331, -331,
884 136, 49, -238, -331, 247, -331, 344, -230, -331, -176,
885 -331, -331, -331, -79, -331, -331, -21, -70, 146, 512,
886 -331, -63, 61, 98, 285, 341, 386, -331, -207, 523,
887 -19, -331
888 };
889
890 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
891 positive, shift that token. If negative, reduce the rule which
892 number is the opposite. If zero, do what YYDEFACT says.
893 If YYTABLE_NINF, syntax error. */
894 #define YYTABLE_NINF -219
895 static const yytype_int16 yytable[] =
896 {
897 43, 241, 178, 81, 266, 326, 86, 83, 399, 110,
898 157, 111, 7, 327, 127, 390, 7, 14, 133, 139,
899 68, 316, 49, 309, 2, 310, 88, 103, 225, 279,
900 254, 129, 130, 22, 187, 187, 270, 451, 23, -215,
901 131, 22, 23, 188, 188, 75, 7, 43, -218, 49,
902 191, 191, 113, 26, 14, 239, 114, 255, 220, 132,
903 203, 26, 75, 110, 220, 197, -218, 240, 76, 128,
904 172, 14, 23, 81, -218, 119, 242, 495, 84, 224,
905 16, 103, -218, 155, 156, 76, 124, 281, 204, 113,
906 162, 163, 166, 114, -218, 351, 85, 1, 7, 8,
907 289, 187, 187, 43, 29, 382, 214, 2, 175, 218,
908 188, 188, 282, 215, 283, 223, 361, 191, 191, 484,
909 244, 168, 187, 248, 23, 128, 187, 294, 234, 169,
910 21, 188, 197, 296, 22, 188, 88, 264, 191, 146,
911 140, 362, 191, 283, 158, 295, 235, 159, 170, 141,
912 171, 288, 275, 43, 26, 160, 43, 249, 147, 250,
913 263, 265, 74, 252, 328, 142, 129, 256, 257, 258,
914 499, 7, 260, 329, 192, 192, 112, 117, 300, 167,
915 330, 371, 173, 316, 276, 174, 285, 287, 176, 220,
916 187, 179, 187, 187, 187, 298, 309, 23, 366, 188,
917 202, 188, 188, 188, 347, 280, 191, 205, 191, 191,
918 191, 193, 193, 212, 209, 299, 236, 220, 210, 232,
919 350, 74, 153, 352, 197, 220, 311, 238, 309, 304,
920 421, 517, 370, 307, 308, 498, 253, 519, 22, 520,
921 346, 192, 192, 523, 524, 131, 144, 145, 505, 506,
922 341, 507, 259, 342, 343, 22, 510, 511, 26, 189,
923 189, 175, 192, 326, 132, 326, 192, 211, 369, 22,
924 521, 327, 367, 327, 522, 26, 290, 137, 193, 193,
925 357, 138, 359, 360, 237, 145, 7, 268, 231, 26,
926 479, 74, 316, 269, 372, 291, 271, 364, 365, 193,
927 359, 446, 447, 193, 331, 273, 403, 129, 432, 433,
928 135, 135, 23, 434, 272, 120, 95, 96, 97, 98,
929 99, 100, 393, 101, 22, 274, 189, 189, 220, 301,
930 192, 424, 192, 192, 192, 303, 397, 397, 305, 400,
931 410, 332, 317, 402, 26, 474, 475, 189, 336, 277,
932 278, 189, 319, 471, 472, 337, 404, 405, 297, 133,
933 413, 477, 475, 429, 430, 478, 240, 193, 338, 193,
934 193, 193, 423, 339, 315, 340, 78, 79, 80, 419,
935 420, 344, 320, 348, 321, 169, 135, 153, 516, 457,
936 458, 349, 135, 493, 494, 21, 463, 354, 194, 194,
937 454, 386, 358, 387, 388, 355, 468, 469, 470, 78,
938 121, 136, 136, 375, 87, 189, 531, 189, 189, 189,
939 141, 376, 328, 383, 328, 377, 384, 378, 391, 135,
940 392, 329, 401, 329, 406, 407, 409, 408, 330, 411,
941 330, 488, 489, 490, 414, 482, 483, 415, 397, 416,
942 485, 422, 309, 427, 195, 195, 428, 439, 381, 431,
943 459, 448, 444, 449, 135, 194, 194, 453, 455, 456,
944 135, 460, 461, 509, 462, 135, 465, 466, 481, 486,
945 504, 491, 177, 398, 398, 508, 194, 136, 501, 503,
946 194, 526, 71, 136, 525, 515, 512, 515, 528, 196,
947 196, 529, 527, 385, 530, 473, 126, 104, 379, 515,
948 515, 502, 322, 149, 67, 221, 70, 135, 233, 261,
949 353, 195, 195, 438, 500, 267, 0, 0, 333, 0,
950 136, 0, 0, 0, 0, 0, 315, 0, 0, 135,
951 445, 0, 195, 118, 452, 135, 195, 0, 0, 0,
952 91, 109, 0, 135, 194, 0, 194, 194, 194, 0,
953 0, 0, 331, 135, 331, 136, 196, 196, 0, 0,
954 0, 136, 0, 0, 0, 306, 136, 0, 0, 0,
955 0, 0, 0, 476, 334, 0, 0, 196, 480, 0,
956 0, 196, 0, 0, 0, 398, 0, 0, 135, 332,
957 0, 332, 0, 0, 0, 109, 0, 0, 0, 0,
958 195, 0, 195, 195, 195, 0, 0, 0, 136, 135,
959 0, 135, 0, 0, 0, 190, 190, 0, 135, 335,
960 135, 0, 0, 0, 0, 0, 0, 201, 0, 363,
961 136, 0, 0, 0, 0, 315, 136, 0, 0, 0,
962 0, 135, 0, 229, 136, 196, 135, 196, 196, 196,
963 91, 227, 0, 380, 136, 0, 0, 0, 135, 0,
964 0, 0, 0, 0, 135, 8, 9, 10, 11, 12,
965 13, 0, 0, 251, 0, 0, 0, 0, 17, 18,
966 19, 0, 190, 190, 21, 0, 262, 0, 0, 136,
967 0, 0, 0, 24, 201, 0, 0, 0, 135, 0,
968 0, 0, 0, 190, 0, 0, 0, 190, 135, 417,
969 136, 418, 136, 0, 0, 324, 0, 0, 425, 136,
970 426, 136, 0, 227, 0, 120, 95, 96, 97, 98,
971 99, 100, 87, 101, 121, 8, 9, 10, 11, 12,
972 13, 177, 136, 0, 0, 0, 0, 136, 17, 18,
973 19, 0, 0, 0, 21, 0, 0, 0, 464, 136,
974 0, 0, 0, 24, 467, 136, 0, 0, 0, 0,
975 0, 190, 0, 190, 190, 190, 333, 0, 333, 0,
976 0, 323, 0, 0, 0, 324, 201, 120, 95, 96,
977 97, 98, 99, 100, 87, 101, 121, 0, 487, 136,
978 0, 0, 0, 0, 227, 0, 0, 0, 492, 136,
979 0, 0, 0, 0, 227, 0, 227, 0, 0, 0,
980 0, 0, 227, 0, 0, 0, 118, 0, 0, 0,
981 0, 0, 334, 0, 334, 7, 8, 9, 10, 11,
982 12, 13, 0, 14, 15, 16, 0, 0, 0, 17,
983 18, 19, 20, 0, 92, 21, 22, 0, 0, 0,
984 0, 23, 93, 0, 94, 95, 96, 97, 98, 99,
985 100, 87, 101, 0, 25, 0, 26, 335, 27, 335,
986 0, 0, 82, 0, 0, 30, 31, 7, 8, 9,
987 10, 11, 12, 13, 0, 14, 15, 0, 0, 0,
988 0, 17, 18, 19, 20, 0, 92, 21, 22, 0,
989 0, 0, 0, 23, 93, 0, 94, 95, 96, 97,
990 98, 99, 100, 87, 101, 0, 25, 0, 26, 0,
991 27, 0, 0, 0, 82, 0, 0, 30, 31, 7,
992 8, 9, 10, 11, 12, 13, 0, 14, 15, 0,
993 0, 0, 0, 17, 18, 19, 20, 0, 0, 21,
994 22, 0, 0, 0, 0, 23, 0, 0, 24, 0,
995 0, 216, 0, 0, 0, 87, 0, 0, 25, 0,
996 26, 0, 27, 0, 0, 0, 82, 222, 0, 30,
997 31, 7, 8, 9, 10, 11, 12, 13, 0, 14,
998 15, 0, 0, 0, 0, 17, 18, 19, 20, 0,
999 0, 21, 22, 0, 0, 0, 0, 23, 0, 0,
1000 24, 0, 0, 216, 0, 0, 0, 87, 0, 0,
1001 25, 0, 26, 0, 27, 0, 0, 0, 82, 286,
1002 0, 30, 31, 7, 8, 9, 10, 11, 12, 13,
1003 0, 14, 15, 0, 0, 0, 0, 17, 18, 19,
1004 20, 0, 0, 21, 22, 0, 0, 0, 0, 23,
1005 0, 0, 24, 0, 0, 216, 0, 0, 0, 87,
1006 0, 0, 25, 0, 26, 0, 27, 0, 0, 0,
1007 82, 368, 0, 30, 31, 7, 8, 9, 10, 11,
1008 12, 13, 0, 14, 15, 16, 0, 0, 0, 17,
1009 18, 19, 20, 0, 0, 21, 22, 0, 0, 0,
1010 0, 23, 0, 0, 24, 0, 0, 0, 0, 0,
1011 0, 0, 0, 0, 25, 0, 26, 0, 27, 0,
1012 0, 0, 28, 0, 29, 30, 31, 7, 8, 9,
1013 10, 11, 12, 13, 0, 14, 15, 16, 0, 0,
1014 0, 17, 18, 19, 20, 0, 0, 21, 22, 0,
1015 0, 0, 0, 23, 0, 0, 24, 0, 0, 0,
1016 0, 0, 0, 0, 0, 0, 25, 0, 26, 0,
1017 27, 0, 0, 0, 82, 0, 29, 30, 31, 7,
1018 8, 9, 10, 11, 12, 13, 0, 14, 15, 0,
1019 0, 0, 0, 17, 18, 19, 20, 0, 0, 21,
1020 22, 0, 0, 0, 0, 23, 0, 0, 24, 0,
1021 0, 216, 0, 0, 0, 0, 0, 0, 25, 0,
1022 26, 0, 27, 0, 0, 0, 82, 217, 0, 30,
1023 31, 7, 8, 9, 10, 11, 12, 13, 0, 14,
1024 15, 0, 0, 0, 0, 17, 18, 19, 20, 0,
1025 0, 21, 22, 0, 0, 0, 0, 23, 0, 0,
1026 24, 0, 0, 216, 0, 0, 0, 0, 0, 0,
1027 25, 0, 26, 0, 27, 0, 0, 0, 82, 345,
1028 0, 30, 31, 7, 8, 9, 10, 11, 12, 13,
1029 0, 14, 15, 0, 0, 0, 0, 17, 18, 19,
1030 20, 0, 0, 21, 22, 0, 0, 0, 0, 23,
1031 0, 0, 24, 0, 0, 373, 0, 0, 0, 87,
1032 0, 0, 25, 0, 26, 0, 27, 0, 0, 0,
1033 82, 0, 0, 30, 31, 7, 8, 9, 10, 11,
1034 12, 13, 0, 14, 15, 394, 0, 0, 0, 17,
1035 18, 19, 20, 0, 0, 21, 22, 0, 0, 0,
1036 0, 23, 395, 0, 24, 0, 0, 0, 0, 0,
1037 0, 0, 0, 0, 25, 0, 26, 0, 27, 0,
1038 0, 0, 82, 0, 0, 30, 31, 7, 8, 9,
1039 10, 11, 12, 13, 0, 14, 15, 0, 0, 0,
1040 0, 17, 18, 19, 20, 0, 0, 21, 22, 0,
1041 0, 0, 0, 23, 0, 0, 24, 0, 0, 0,
1042 0, 0, 0, 87, 0, 0, 25, 0, 26, 0,
1043 27, 0, 0, 0, 82, 0, 0, 30, 31, 7,
1044 8, 9, 10, 11, 12, 13, 0, 14, 15, 0,
1045 0, 0, 0, 17, 18, 19, 20, 0, 164, 21,
1046 22, 0, 0, 0, 0, 23, 0, 0, 24, 0,
1047 0, 0, 0, 0, 0, 0, 0, 0, 25, 0,
1048 26, 0, 27, 0, 0, 0, 82, 0, 0, 30,
1049 31, 7, 8, 9, 10, 11, 12, 13, 0, 14,
1050 15, 0, 0, 0, 0, 17, 18, 19, 20, 0,
1051 206, 21, 22, 0, 0, 0, 0, 23, 0, 0,
1052 24, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1053 25, 0, 26, 0, 27, 0, 0, 0, 82, 0,
1054 0, 30, 31, 7, 8, 9, 10, 11, 12, 13,
1055 0, 14, 15, 0, 0, 0, 0, 17, 18, 19,
1056 20, 0, 284, 21, 22, 0, 0, 0, 0, 23,
1057 0, 0, 24, 0, 0, 0, 0, 0, 0, 0,
1058 0, 0, 25, 0, 26, 0, 27, 0, 0, 0,
1059 82, 0, 0, 30, 31, 7, 8, 9, 10, 11,
1060 12, 13, 0, 14, 15, 0, 0, 0, 0, 17,
1061 18, 19, 20, 0, 0, 21, 22, 0, 0, 0,
1062 0, 23, 0, 0, 24, 0, 0, 0, 0, 0,
1063 0, 0, 0, 0, 25, 0, 26, 0, 27, 356,
1064 0, 0, 82, 0, 0, 30, 31, 7, 8, 9,
1065 10, 11, 12, 13, 0, 14, 15, 0, 0, 0,
1066 0, 17, 18, 19, 20, 0, 0, 21, 22, 0,
1067 0, 0, 0, 23, 0, 0, 24, 0, 0, 0,
1068 0, 0, 0, 0, 0, 0, 25, 0, 26, 0,
1069 27, 412, 0, 0, 82, 0, 0, 30, 31, 7,
1070 8, 9, 10, 11, 12, 13, 0, 14, 15, 0,
1071 0, 0, 0, 17, 18, 19, 20, 0, 0, 21,
1072 22, 0, 0, 0, 0, 23, 0, 0, 24, 0,
1073 0, 0, 0, 0, 0, 0, 0, 0, 25, 0,
1074 26, 0, 27, 0, 0, 0, 82, 0, 512, 30,
1075 31, 7, 8, 9, 10, 11, 12, 13, 0, 14,
1076 15, 0, 0, 0, 0, 17, 18, 19, 20, 0,
1077 0, 21, 22, 0, 0, 0, 0, 23, 0, 0,
1078 24, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1079 25, 0, 26, 0, 27, 0, 0, 0, 82, 0,
1080 0, 30, 31, 7, 8, 9, 10, 11, 12, 13,
1081 0, 14, 0, 0, 0, 0, 0, 17, 18, 19,
1082 0, 0, 0, 21, 0, 0, 0, 0, 0, 23,
1083 0, 0, 24, 0, 0, 0, 0, 0, 0, 87,
1084 0, 0, 0, 0, 0, 0, 180, 0, 0, 0,
1085 181, 7, 8, 9, 10, 11, 12, 13, 7, 14,
1086 0, 0, 0, 0, 0, 17, 18, 19, 0, 0,
1087 0, 21, 0, 7, 0, 0, 0, 23, 0, 0,
1088 24, 0, 0, 0, 23, 0, 0, 120, 95, 96,
1089 312, 98, 99, 100, 180, 101, 7, 0, 181, 23,
1090 313, 0, 120, 95, 96, 312, 98, 99, 100, 0,
1091 101, 0, 0, 0, 0, 443, 0, 0, 0, 0,
1092 0, 0, 23, 0, 0, 120, 95, 96, 312, 98,
1093 99, 100, 0, 101, 0, 0, 0, 0, 518
1094 };
1095
1096 static const yytype_int16 yycheck[] =
1097 {
1098 1, 151, 111, 24, 180, 243, 26, 25, 338, 28,
1099 86, 29, 3, 243, 48, 318, 3, 11, 57, 58,
1100 0, 228, 1, 49, 36, 51, 27, 28, 138, 205,
1101 22, 52, 53, 24, 113, 114, 186, 28, 29, 21,
1102 31, 24, 29, 113, 114, 14, 3, 48, 3, 28,
1103 113, 114, 46, 44, 11, 37, 50, 49, 133, 50,
1104 21, 44, 14, 82, 139, 114, 21, 49, 37, 48,
1105 104, 11, 29, 94, 29, 46, 31, 10, 30, 138,
1106 13, 82, 37, 84, 85, 37, 48, 22, 49, 46,
1107 91, 92, 93, 50, 49, 271, 48, 26, 3, 4,
1108 210, 180, 181, 104, 52, 312, 124, 36, 109, 132,
1109 180, 181, 47, 131, 49, 138, 22, 180, 181, 449,
1110 154, 22, 201, 157, 29, 104, 205, 32, 146, 30,
1111 23, 201, 181, 212, 24, 205, 137, 176, 201, 31,
1112 44, 47, 205, 49, 30, 50, 147, 47, 49, 30,
1113 51, 210, 201, 154, 44, 49, 157, 158, 50, 160,
1114 50, 179, 16, 164, 243, 46, 187, 168, 169, 170,
1115 473, 3, 173, 243, 113, 114, 30, 31, 217, 51,
1116 243, 291, 49, 390, 202, 51, 209, 210, 51, 264,
1117 269, 31, 271, 272, 273, 213, 49, 29, 51, 269,
1118 31, 271, 272, 273, 263, 206, 269, 46, 271, 272,
1119 273, 113, 114, 41, 46, 216, 21, 292, 50, 44,
1120 269, 75, 76, 272, 273, 300, 227, 21, 49, 219,
1121 51, 498, 291, 223, 224, 472, 51, 501, 24, 503,
1122 263, 180, 181, 510, 511, 31, 48, 49, 482, 483,
1123 251, 485, 51, 254, 255, 24, 493, 494, 44, 113,
1124 114, 262, 201, 501, 50, 503, 205, 121, 291, 24,
1125 504, 501, 290, 503, 508, 44, 31, 46, 180, 181,
1126 281, 50, 283, 284, 48, 49, 3, 47, 142, 44,
1127 440, 145, 499, 49, 295, 50, 46, 287, 288, 201,
1128 301, 29, 30, 205, 243, 49, 345, 328, 33, 34,
1129 57, 58, 29, 38, 30, 32, 33, 34, 35, 36,
1130 37, 38, 323, 40, 24, 51, 180, 181, 403, 49,
1131 269, 31, 271, 272, 273, 49, 337, 338, 47, 340,
1132 358, 243, 47, 344, 44, 48, 49, 201, 45, 203,
1133 204, 205, 51, 429, 430, 49, 346, 347, 212, 398,
1134 361, 48, 49, 383, 384, 48, 49, 269, 49, 271,
1135 272, 273, 373, 45, 228, 30, 4, 5, 6, 369,
1136 370, 22, 236, 47, 238, 30, 133, 241, 497, 407,
1137 408, 51, 139, 469, 470, 23, 414, 47, 113, 114,
1138 401, 13, 31, 15, 16, 47, 424, 427, 428, 4,
1139 41, 57, 58, 51, 39, 269, 525, 271, 272, 273,
1140 30, 51, 501, 44, 503, 51, 44, 51, 48, 176,
1141 37, 501, 22, 503, 47, 31, 47, 31, 501, 47,
1142 503, 459, 460, 461, 31, 446, 447, 51, 449, 51,
1143 451, 51, 49, 44, 113, 114, 44, 33, 312, 44,
1144 31, 45, 51, 49, 211, 180, 181, 45, 51, 51,
1145 217, 31, 31, 491, 47, 222, 51, 51, 31, 28,
1146 481, 31, 48, 337, 338, 486, 201, 133, 31, 31,
1147 205, 45, 5, 139, 512, 496, 52, 498, 45, 113,
1148 114, 45, 515, 317, 45, 431, 43, 28, 309, 510,
1149 511, 479, 241, 75, 2, 137, 4, 264, 145, 173,
1150 273, 180, 181, 387, 475, 181, -1, -1, 243, -1,
1151 176, -1, -1, -1, -1, -1, 390, -1, -1, 286,
1152 394, -1, 201, 31, 398, 292, 205, -1, -1, -1,
1153 27, 28, -1, 300, 269, -1, 271, 272, 273, -1,
1154 -1, -1, 501, 310, 503, 211, 180, 181, -1, -1,
1155 -1, 217, -1, -1, -1, 222, 222, -1, -1, -1,
1156 -1, -1, -1, 437, 243, -1, -1, 201, 442, -1,
1157 -1, 205, -1, -1, -1, 449, -1, -1, 345, 501,
1158 -1, 503, -1, -1, -1, 82, -1, -1, -1, -1,
1159 269, -1, 271, 272, 273, -1, -1, -1, 264, 366,
1160 -1, 368, -1, -1, -1, 113, 114, -1, 375, 243,
1161 377, -1, -1, -1, -1, -1, -1, 114, -1, 286,
1162 286, -1, -1, -1, -1, 499, 292, -1, -1, -1,
1163 -1, 398, -1, 141, 300, 269, 403, 271, 272, 273,
1164 137, 138, -1, 310, 310, -1, -1, -1, 415, -1,
1165 -1, -1, -1, -1, 421, 4, 5, 6, 7, 8,
1166 9, -1, -1, 160, -1, -1, -1, -1, 17, 18,
1167 19, -1, 180, 181, 23, -1, 173, -1, -1, 345,
1168 -1, -1, -1, 32, 181, -1, -1, -1, 455, -1,
1169 -1, -1, -1, 201, -1, -1, -1, 205, 465, 366,
1170 366, 368, 368, -1, -1, 54, -1, -1, 375, 375,
1171 377, 377, -1, 210, -1, 32, 33, 34, 35, 36,
1172 37, 38, 39, 40, 41, 4, 5, 6, 7, 8,
1173 9, 48, 398, -1, -1, -1, -1, 403, 17, 18,
1174 19, -1, -1, -1, 23, -1, -1, -1, 415, 415,
1175 -1, -1, -1, 32, 421, 421, -1, -1, -1, -1,
1176 -1, 269, -1, 271, 272, 273, 501, -1, 503, -1,
1177 -1, 50, -1, -1, -1, 54, 273, 32, 33, 34,
1178 35, 36, 37, 38, 39, 40, 41, -1, 455, 455,
1179 -1, -1, -1, -1, 291, -1, -1, -1, 465, 465,
1180 -1, -1, -1, -1, 301, -1, 303, -1, -1, -1,
1181 -1, -1, 309, -1, -1, -1, 324, -1, -1, -1,
1182 -1, -1, 501, -1, 503, 3, 4, 5, 6, 7,
1183 8, 9, -1, 11, 12, 13, -1, -1, -1, 17,
1184 18, 19, 20, -1, 22, 23, 24, -1, -1, -1,
1185 -1, 29, 30, -1, 32, 33, 34, 35, 36, 37,
1186 38, 39, 40, -1, 42, -1, 44, 501, 46, 503,
1187 -1, -1, 50, -1, -1, 53, 54, 3, 4, 5,
1188 6, 7, 8, 9, -1, 11, 12, -1, -1, -1,
1189 -1, 17, 18, 19, 20, -1, 22, 23, 24, -1,
1190 -1, -1, -1, 29, 30, -1, 32, 33, 34, 35,
1191 36, 37, 38, 39, 40, -1, 42, -1, 44, -1,
1192 46, -1, -1, -1, 50, -1, -1, 53, 54, 3,
1193 4, 5, 6, 7, 8, 9, -1, 11, 12, -1,
1194 -1, -1, -1, 17, 18, 19, 20, -1, -1, 23,
1195 24, -1, -1, -1, -1, 29, -1, -1, 32, -1,
1196 -1, 35, -1, -1, -1, 39, -1, -1, 42, -1,
1197 44, -1, 46, -1, -1, -1, 50, 51, -1, 53,
1198 54, 3, 4, 5, 6, 7, 8, 9, -1, 11,
1199 12, -1, -1, -1, -1, 17, 18, 19, 20, -1,
1200 -1, 23, 24, -1, -1, -1, -1, 29, -1, -1,
1201 32, -1, -1, 35, -1, -1, -1, 39, -1, -1,
1202 42, -1, 44, -1, 46, -1, -1, -1, 50, 51,
1203 -1, 53, 54, 3, 4, 5, 6, 7, 8, 9,
1204 -1, 11, 12, -1, -1, -1, -1, 17, 18, 19,
1205 20, -1, -1, 23, 24, -1, -1, -1, -1, 29,
1206 -1, -1, 32, -1, -1, 35, -1, -1, -1, 39,
1207 -1, -1, 42, -1, 44, -1, 46, -1, -1, -1,
1208 50, 51, -1, 53, 54, 3, 4, 5, 6, 7,
1209 8, 9, -1, 11, 12, 13, -1, -1, -1, 17,
1210 18, 19, 20, -1, -1, 23, 24, -1, -1, -1,
1211 -1, 29, -1, -1, 32, -1, -1, -1, -1, -1,
1212 -1, -1, -1, -1, 42, -1, 44, -1, 46, -1,
1213 -1, -1, 50, -1, 52, 53, 54, 3, 4, 5,
1214 6, 7, 8, 9, -1, 11, 12, 13, -1, -1,
1215 -1, 17, 18, 19, 20, -1, -1, 23, 24, -1,
1216 -1, -1, -1, 29, -1, -1, 32, -1, -1, -1,
1217 -1, -1, -1, -1, -1, -1, 42, -1, 44, -1,
1218 46, -1, -1, -1, 50, -1, 52, 53, 54, 3,
1219 4, 5, 6, 7, 8, 9, -1, 11, 12, -1,
1220 -1, -1, -1, 17, 18, 19, 20, -1, -1, 23,
1221 24, -1, -1, -1, -1, 29, -1, -1, 32, -1,
1222 -1, 35, -1, -1, -1, -1, -1, -1, 42, -1,
1223 44, -1, 46, -1, -1, -1, 50, 51, -1, 53,
1224 54, 3, 4, 5, 6, 7, 8, 9, -1, 11,
1225 12, -1, -1, -1, -1, 17, 18, 19, 20, -1,
1226 -1, 23, 24, -1, -1, -1, -1, 29, -1, -1,
1227 32, -1, -1, 35, -1, -1, -1, -1, -1, -1,
1228 42, -1, 44, -1, 46, -1, -1, -1, 50, 51,
1229 -1, 53, 54, 3, 4, 5, 6, 7, 8, 9,
1230 -1, 11, 12, -1, -1, -1, -1, 17, 18, 19,
1231 20, -1, -1, 23, 24, -1, -1, -1, -1, 29,
1232 -1, -1, 32, -1, -1, 35, -1, -1, -1, 39,
1233 -1, -1, 42, -1, 44, -1, 46, -1, -1, -1,
1234 50, -1, -1, 53, 54, 3, 4, 5, 6, 7,
1235 8, 9, -1, 11, 12, 13, -1, -1, -1, 17,
1236 18, 19, 20, -1, -1, 23, 24, -1, -1, -1,
1237 -1, 29, 30, -1, 32, -1, -1, -1, -1, -1,
1238 -1, -1, -1, -1, 42, -1, 44, -1, 46, -1,
1239 -1, -1, 50, -1, -1, 53, 54, 3, 4, 5,
1240 6, 7, 8, 9, -1, 11, 12, -1, -1, -1,
1241 -1, 17, 18, 19, 20, -1, -1, 23, 24, -1,
1242 -1, -1, -1, 29, -1, -1, 32, -1, -1, -1,
1243 -1, -1, -1, 39, -1, -1, 42, -1, 44, -1,
1244 46, -1, -1, -1, 50, -1, -1, 53, 54, 3,
1245 4, 5, 6, 7, 8, 9, -1, 11, 12, -1,
1246 -1, -1, -1, 17, 18, 19, 20, -1, 22, 23,
1247 24, -1, -1, -1, -1, 29, -1, -1, 32, -1,
1248 -1, -1, -1, -1, -1, -1, -1, -1, 42, -1,
1249 44, -1, 46, -1, -1, -1, 50, -1, -1, 53,
1250 54, 3, 4, 5, 6, 7, 8, 9, -1, 11,
1251 12, -1, -1, -1, -1, 17, 18, 19, 20, -1,
1252 22, 23, 24, -1, -1, -1, -1, 29, -1, -1,
1253 32, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1254 42, -1, 44, -1, 46, -1, -1, -1, 50, -1,
1255 -1, 53, 54, 3, 4, 5, 6, 7, 8, 9,
1256 -1, 11, 12, -1, -1, -1, -1, 17, 18, 19,
1257 20, -1, 22, 23, 24, -1, -1, -1, -1, 29,
1258 -1, -1, 32, -1, -1, -1, -1, -1, -1, -1,
1259 -1, -1, 42, -1, 44, -1, 46, -1, -1, -1,
1260 50, -1, -1, 53, 54, 3, 4, 5, 6, 7,
1261 8, 9, -1, 11, 12, -1, -1, -1, -1, 17,
1262 18, 19, 20, -1, -1, 23, 24, -1, -1, -1,
1263 -1, 29, -1, -1, 32, -1, -1, -1, -1, -1,
1264 -1, -1, -1, -1, 42, -1, 44, -1, 46, 47,
1265 -1, -1, 50, -1, -1, 53, 54, 3, 4, 5,
1266 6, 7, 8, 9, -1, 11, 12, -1, -1, -1,
1267 -1, 17, 18, 19, 20, -1, -1, 23, 24, -1,
1268 -1, -1, -1, 29, -1, -1, 32, -1, -1, -1,
1269 -1, -1, -1, -1, -1, -1, 42, -1, 44, -1,
1270 46, 47, -1, -1, 50, -1, -1, 53, 54, 3,
1271 4, 5, 6, 7, 8, 9, -1, 11, 12, -1,
1272 -1, -1, -1, 17, 18, 19, 20, -1, -1, 23,
1273 24, -1, -1, -1, -1, 29, -1, -1, 32, -1,
1274 -1, -1, -1, -1, -1, -1, -1, -1, 42, -1,
1275 44, -1, 46, -1, -1, -1, 50, -1, 52, 53,
1276 54, 3, 4, 5, 6, 7, 8, 9, -1, 11,
1277 12, -1, -1, -1, -1, 17, 18, 19, 20, -1,
1278 -1, 23, 24, -1, -1, -1, -1, 29, -1, -1,
1279 32, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1280 42, -1, 44, -1, 46, -1, -1, -1, 50, -1,
1281 -1, 53, 54, 3, 4, 5, 6, 7, 8, 9,
1282 -1, 11, -1, -1, -1, -1, -1, 17, 18, 19,
1283 -1, -1, -1, 23, -1, -1, -1, -1, -1, 29,
1284 -1, -1, 32, -1, -1, -1, -1, -1, -1, 39,
1285 -1, -1, -1, -1, -1, -1, 46, -1, -1, -1,
1286 50, 3, 4, 5, 6, 7, 8, 9, 3, 11,
1287 -1, -1, -1, -1, -1, 17, 18, 19, -1, -1,
1288 -1, 23, -1, 3, -1, -1, -1, 29, -1, -1,
1289 32, -1, -1, -1, 29, -1, -1, 32, 33, 34,
1290 35, 36, 37, 38, 46, 40, 3, -1, 50, 29,
1291 45, -1, 32, 33, 34, 35, 36, 37, 38, -1,
1292 40, -1, -1, -1, -1, 45, -1, -1, -1, -1,
1293 -1, -1, 29, -1, -1, 32, 33, 34, 35, 36,
1294 37, 38, -1, 40, -1, -1, -1, -1, 45
1295 };
1296
1297 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1298 symbol of state STATE-NUM. */
1299 static const yytype_uint8 yystos[] =
1300 {
1301 0, 26, 36, 56, 57, 58, 60, 3, 4, 5,
1302 6, 7, 8, 9, 11, 12, 13, 17, 18, 19,
1303 20, 23, 24, 29, 32, 42, 44, 46, 50, 52,
1304 53, 54, 70, 71, 75, 79, 80, 85, 86, 87,
1305 88, 91, 93, 94, 105, 106, 107, 109, 111, 112,
1306 127, 132, 138, 139, 140, 141, 142, 143, 144, 146,
1307 147, 148, 149, 150, 151, 152, 156, 144, 0, 59,
1308 144, 60, 120, 121, 143, 14, 37, 113, 4, 5,
1309 6, 141, 50, 91, 30, 48, 113, 39, 94, 95,
1310 96, 154, 22, 30, 32, 33, 34, 35, 36, 37,
1311 38, 40, 89, 94, 111, 122, 123, 124, 153, 154,
1312 155, 91, 143, 46, 50, 102, 103, 143, 144, 46,
1313 32, 41, 154, 155, 48, 67, 75, 70, 112, 141,
1314 141, 31, 50, 76, 77, 80, 105, 46, 50, 76,
1315 44, 30, 46, 62, 48, 49, 31, 50, 119, 120,
1316 116, 117, 118, 143, 110, 94, 94, 110, 30, 47,
1317 49, 68, 94, 94, 22, 90, 94, 51, 22, 30,
1318 49, 51, 70, 49, 51, 94, 51, 48, 67, 31,
1319 46, 50, 108, 128, 133, 134, 135, 138, 142, 143,
1320 144, 146, 147, 148, 149, 150, 151, 108, 129, 130,
1321 131, 154, 31, 21, 49, 46, 22, 94, 97, 46,
1322 50, 143, 41, 92, 91, 91, 35, 51, 97, 98,
1323 77, 95, 51, 97, 98, 99, 100, 154, 65, 144,
1324 61, 143, 44, 121, 91, 94, 21, 48, 21, 37,
1325 49, 68, 31, 69, 70, 112, 81, 82, 70, 94,
1326 94, 154, 94, 51, 22, 49, 94, 94, 94, 51,
1327 94, 122, 154, 50, 76, 91, 134, 131, 47, 49,
1328 68, 46, 30, 49, 51, 108, 91, 143, 143, 134,
1329 94, 22, 47, 49, 22, 97, 51, 97, 98, 99,
1330 31, 50, 76, 78, 32, 50, 138, 143, 91, 94,
1331 76, 49, 101, 49, 101, 47, 78, 101, 101, 49,
1332 51, 94, 35, 45, 66, 143, 153, 47, 63, 51,
1333 143, 143, 118, 50, 54, 104, 127, 132, 138, 142,
1334 146, 147, 148, 149, 150, 151, 45, 49, 49, 45,
1335 30, 94, 94, 94, 22, 51, 97, 98, 47, 51,
1336 108, 134, 108, 129, 47, 47, 47, 94, 31, 94,
1337 94, 22, 47, 78, 101, 101, 51, 91, 51, 97,
1338 98, 99, 94, 35, 99, 51, 51, 51, 51, 100,
1339 78, 143, 153, 44, 44, 62, 13, 15, 16, 64,
1340 65, 48, 37, 94, 13, 30, 84, 94, 143, 84,
1341 94, 22, 94, 76, 101, 101, 47, 31, 31, 47,
1342 91, 47, 47, 94, 31, 51, 51, 78, 78, 101,
1343 101, 51, 51, 94, 31, 78, 78, 44, 44, 113,
1344 113, 44, 33, 34, 38, 125, 126, 136, 125, 33,
1345 114, 115, 137, 45, 51, 143, 29, 30, 45, 49,
1346 83, 28, 143, 45, 94, 51, 51, 91, 91, 31,
1347 31, 31, 47, 91, 78, 51, 51, 78, 91, 113,
1348 113, 110, 110, 63, 48, 49, 143, 48, 48, 68,
1349 143, 31, 94, 94, 84, 94, 28, 78, 91, 91,
1350 91, 31, 78, 110, 110, 10, 73, 145, 73, 65,
1351 126, 31, 115, 31, 94, 83, 83, 83, 94, 91,
1352 73, 73, 52, 72, 74, 94, 67, 72, 45, 104,
1353 104, 83, 83, 72, 72, 91, 45, 74, 45, 45,
1354 45, 67
1355 };
1356
1357 #define yyerrok (yyerrstatus = 0)
1358 #define yyclearin (yychar = YYEMPTY)
1359 #define YYEMPTY (-2)
1360 #define YYEOF 0
1361
1362 #define YYACCEPT goto yyacceptlab
1363 #define YYABORT goto yyabortlab
1364 #define YYERROR goto yyerrorlab
1365
1366
1367 /* Like YYERROR except do call yyerror. This remains here temporarily
1368 to ease the transition to the new meaning of YYERROR, for GCC.
1369 Once GCC version 2 has supplanted version 1, this can go. */
1370
1371 #define YYFAIL goto yyerrlab
1372
1373 #define YYRECOVERING() (!!yyerrstatus)
1374
1375 #define YYBACKUP(Token, Value) \
1376 do \
1377 if (yychar == YYEMPTY && yylen == 1) \
1378 { \
1379 yychar = (Token); \
1380 yylval = (Value); \
1381 yytoken = YYTRANSLATE (yychar); \
1382 YYPOPSTACK (1); \
1383 goto yybackup; \
1384 } \
1385 else \
1386 { \
1387 yyerror (YY_("syntax error: cannot back up")); \
1388 YYERROR; \
1389 } \
1390 while (YYID (0))
1391
1392
1393 #define YYTERROR 1
1394 #define YYERRCODE 256
1395
1396
1397 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
1398 If N is 0, then set CURRENT to the empty location which ends
1399 the previous symbol: RHS[0] (always defined). */
1400
1401 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
1402 #ifndef YYLLOC_DEFAULT
1403 # define YYLLOC_DEFAULT(Current, Rhs, N) \
1404 do \
1405 if (YYID (N)) \
1406 { \
1407 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
1408 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
1409 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
1410 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
1411 } \
1412 else \
1413 { \
1414 (Current).first_line = (Current).last_line = \
1415 YYRHSLOC (Rhs, 0).last_line; \
1416 (Current).first_column = (Current).last_column = \
1417 YYRHSLOC (Rhs, 0).last_column; \
1418 } \
1419 while (YYID (0))
1420 #endif
1421
1422
1423 /* YY_LOCATION_PRINT -- Print the location on the stream.
1424 This macro was not mandated originally: define only if we know
1425 we won't break user code: when these are the locations we know. */
1426
1427 #ifndef YY_LOCATION_PRINT
1428 # if YYLTYPE_IS_TRIVIAL
1429 # define YY_LOCATION_PRINT(File, Loc) \
1430 fprintf (File, "%d.%d-%d.%d", \
1431 (Loc).first_line, (Loc).first_column, \
1432 (Loc).last_line, (Loc).last_column)
1433 # else
1434 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1435 # endif
1436 #endif
1437
1438
1439 /* YYLEX -- calling `yylex' with the right arguments. */
1440
1441 #ifdef YYLEX_PARAM
1442 # define YYLEX yylex (YYLEX_PARAM)
1443 #else
1444 # define YYLEX yylex ()
1445 #endif
1446
1447 /* Enable debugging if requested. */
1448 #if YYDEBUG
1449
1450 # ifndef YYFPRINTF
1451 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1452 # define YYFPRINTF fprintf
1453 # endif
1454
1455 # define YYDPRINTF(Args) \
1456 do { \
1457 if (yydebug) \
1458 YYFPRINTF Args; \
1459 } while (YYID (0))
1460
1461 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1462 do { \
1463 if (yydebug) \
1464 { \
1465 YYFPRINTF (stderr, "%s ", Title); \
1466 yy_symbol_print (stderr, \
1467 Type, Value); \
1468 YYFPRINTF (stderr, "\n"); \
1469 } \
1470 } while (YYID (0))
1471
1472
1473 /*--------------------------------.
1474 | Print this symbol on YYOUTPUT. |
1475 `--------------------------------*/
1476
1477 /*ARGSUSED*/
1478 #if (defined __STDC__ || defined __C99__FUNC__ \
1479 || defined __cplusplus || defined _MSC_VER)
1480 static void
1481 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1482 #else
1483 static void
1484 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
1485 FILE *yyoutput;
1486 int yytype;
1487 YYSTYPE const * const yyvaluep;
1488 #endif
1489 {
1490 if (!yyvaluep)
1491 return;
1492 # ifdef YYPRINT
1493 if (yytype < YYNTOKENS)
1494 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1495 # else
1496 YYUSE (yyoutput);
1497 # endif
1498 switch (yytype)
1499 {
1500 default:
1501 break;
1502 }
1503 }
1504
1505
1506 /*--------------------------------.
1507 | Print this symbol on YYOUTPUT. |
1508 `--------------------------------*/
1509
1510 #if (defined __STDC__ || defined __C99__FUNC__ \
1511 || defined __cplusplus || defined _MSC_VER)
1512 static void
1513 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1514 #else
1515 static void
1516 yy_symbol_print (yyoutput, yytype, yyvaluep)
1517 FILE *yyoutput;
1518 int yytype;
1519 YYSTYPE const * const yyvaluep;
1520 #endif
1521 {
1522 if (yytype < YYNTOKENS)
1523 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1524 else
1525 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1526
1527 yy_symbol_value_print (yyoutput, yytype, yyvaluep);
1528 YYFPRINTF (yyoutput, ")");
1529 }
1530
1531 /*------------------------------------------------------------------.
1532 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1533 | TOP (included). |
1534 `------------------------------------------------------------------*/
1535
1536 #if (defined __STDC__ || defined __C99__FUNC__ \
1537 || defined __cplusplus || defined _MSC_VER)
1538 static void
1539 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1540 #else
1541 static void
1542 yy_stack_print (yybottom, yytop)
1543 yytype_int16 *yybottom;
1544 yytype_int16 *yytop;
1545 #endif
1546 {
1547 YYFPRINTF (stderr, "Stack now");
1548 for (; yybottom <= yytop; yybottom++)
1549 {
1550 int yybot = *yybottom;
1551 YYFPRINTF (stderr, " %d", yybot);
1552 }
1553 YYFPRINTF (stderr, "\n");
1554 }
1555
1556 # define YY_STACK_PRINT(Bottom, Top) \
1557 do { \
1558 if (yydebug) \
1559 yy_stack_print ((Bottom), (Top)); \
1560 } while (YYID (0))
1561
1562
1563 /*------------------------------------------------.
1564 | Report that the YYRULE is going to be reduced. |
1565 `------------------------------------------------*/
1566
1567 #if (defined __STDC__ || defined __C99__FUNC__ \
1568 || defined __cplusplus || defined _MSC_VER)
1569 static void
1570 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1571 #else
1572 static void
1573 yy_reduce_print (yyvsp, yyrule)
1574 YYSTYPE *yyvsp;
1575 int yyrule;
1576 #endif
1577 {
1578 int yynrhs = yyr2[yyrule];
1579 int yyi;
1580 unsigned long int yylno = yyrline[yyrule];
1581 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1582 yyrule - 1, yylno);
1583 /* The symbols being reduced. */
1584 for (yyi = 0; yyi < yynrhs; yyi++)
1585 {
1586 YYFPRINTF (stderr, " $%d = ", yyi + 1);
1587 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1588 &(yyvsp[(yyi + 1) - (yynrhs)])
1589 );
1590 YYFPRINTF (stderr, "\n");
1591 }
1592 }
1593
1594 # define YY_REDUCE_PRINT(Rule) \
1595 do { \
1596 if (yydebug) \
1597 yy_reduce_print (yyvsp, Rule); \
1598 } while (YYID (0))
1599
1600 /* Nonzero means print parse trace. It is left uninitialized so that
1601 multiple parsers can coexist. */
1602 int yydebug;
1603 #else /* !YYDEBUG */
1604 # define YYDPRINTF(Args)
1605 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1606 # define YY_STACK_PRINT(Bottom, Top)
1607 # define YY_REDUCE_PRINT(Rule)
1608 #endif /* !YYDEBUG */
1609
1610
1611 /* YYINITDEPTH -- initial size of the parser's stacks. */
1612 #ifndef YYINITDEPTH
1613 # define YYINITDEPTH 200
1614 #endif
1615
1616 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1617 if the built-in stack extension method is used).
1618
1619 Do not make this value too large; the results are undefined if
1620 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1621 evaluated with infinite-precision integer arithmetic. */
1622
1623 #ifndef YYMAXDEPTH
1624 # define YYMAXDEPTH 10000
1625 #endif
1626
1627 \f
1628
1629 #if YYERROR_VERBOSE
1630
1631 # ifndef yystrlen
1632 # if defined __GLIBC__ && defined _STRING_H
1633 # define yystrlen strlen
1634 # else
1635 /* Return the length of YYSTR. */
1636 #if (defined __STDC__ || defined __C99__FUNC__ \
1637 || defined __cplusplus || defined _MSC_VER)
1638 static YYSIZE_T
1639 yystrlen (const char *yystr)
1640 #else
1641 static YYSIZE_T
1642 yystrlen (yystr)
1643 const char *yystr;
1644 #endif
1645 {
1646 YYSIZE_T yylen;
1647 for (yylen = 0; yystr[yylen]; yylen++)
1648 continue;
1649 return yylen;
1650 }
1651 # endif
1652 # endif
1653
1654 # ifndef yystpcpy
1655 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1656 # define yystpcpy stpcpy
1657 # else
1658 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1659 YYDEST. */
1660 #if (defined __STDC__ || defined __C99__FUNC__ \
1661 || defined __cplusplus || defined _MSC_VER)
1662 static char *
1663 yystpcpy (char *yydest, const char *yysrc)
1664 #else
1665 static char *
1666 yystpcpy (yydest, yysrc)
1667 char *yydest;
1668 const char *yysrc;
1669 #endif
1670 {
1671 char *yyd = yydest;
1672 const char *yys = yysrc;
1673
1674 while ((*yyd++ = *yys++) != '\0')
1675 continue;
1676
1677 return yyd - 1;
1678 }
1679 # endif
1680 # endif
1681
1682 # ifndef yytnamerr
1683 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1684 quotes and backslashes, so that it's suitable for yyerror. The
1685 heuristic is that double-quoting is unnecessary unless the string
1686 contains an apostrophe, a comma, or backslash (other than
1687 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1688 null, do not copy; instead, return the length of what the result
1689 would have been. */
1690 static YYSIZE_T
1691 yytnamerr (char *yyres, const char *yystr)
1692 {
1693 if (*yystr == '"')
1694 {
1695 YYSIZE_T yyn = 0;
1696 char const *yyp = yystr;
1697
1698 for (;;)
1699 switch (*++yyp)
1700 {
1701 case '\'':
1702 case ',':
1703 goto do_not_strip_quotes;
1704
1705 case '\\':
1706 if (*++yyp != '\\')
1707 goto do_not_strip_quotes;
1708 /* Fall through. */
1709 default:
1710 if (yyres)
1711 yyres[yyn] = *yyp;
1712 yyn++;
1713 break;
1714
1715 case '"':
1716 if (yyres)
1717 yyres[yyn] = '\0';
1718 return yyn;
1719 }
1720 do_not_strip_quotes: ;
1721 }
1722
1723 if (! yyres)
1724 return yystrlen (yystr);
1725
1726 return yystpcpy (yyres, yystr) - yyres;
1727 }
1728 # endif
1729
1730 /* Copy into YYRESULT an error message about the unexpected token
1731 YYCHAR while in state YYSTATE. Return the number of bytes copied,
1732 including the terminating null byte. If YYRESULT is null, do not
1733 copy anything; just return the number of bytes that would be
1734 copied. As a special case, return 0 if an ordinary "syntax error"
1735 message will do. Return YYSIZE_MAXIMUM if overflow occurs during
1736 size calculation. */
1737 static YYSIZE_T
1738 yysyntax_error (char *yyresult, int yystate, int yychar)
1739 {
1740 int yyn = yypact[yystate];
1741
1742 if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
1743 return 0;
1744 else
1745 {
1746 int yytype = YYTRANSLATE (yychar);
1747 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
1748 YYSIZE_T yysize = yysize0;
1749 YYSIZE_T yysize1;
1750 int yysize_overflow = 0;
1751 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1752 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1753 int yyx;
1754
1755 # if 0
1756 /* This is so xgettext sees the translatable formats that are
1757 constructed on the fly. */
1758 YY_("syntax error, unexpected %s");
1759 YY_("syntax error, unexpected %s, expecting %s");
1760 YY_("syntax error, unexpected %s, expecting %s or %s");
1761 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
1762 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1763 # endif
1764 char *yyfmt;
1765 char const *yyf;
1766 static char const yyunexpected[] = "syntax error, unexpected %s";
1767 static char const yyexpecting[] = ", expecting %s";
1768 static char const yyor[] = " or %s";
1769 char yyformat[sizeof yyunexpected
1770 + sizeof yyexpecting - 1
1771 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1772 * (sizeof yyor - 1))];
1773 char const *yyprefix = yyexpecting;
1774
1775 /* Start YYX at -YYN if negative to avoid negative indexes in
1776 YYCHECK. */
1777 int yyxbegin = yyn < 0 ? -yyn : 0;
1778
1779 /* Stay within bounds of both yycheck and yytname. */
1780 int yychecklim = YYLAST - yyn + 1;
1781 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1782 int yycount = 1;
1783
1784 yyarg[0] = yytname[yytype];
1785 yyfmt = yystpcpy (yyformat, yyunexpected);
1786
1787 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1788 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1789 {
1790 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1791 {
1792 yycount = 1;
1793 yysize = yysize0;
1794 yyformat[sizeof yyunexpected - 1] = '\0';
1795 break;
1796 }
1797 yyarg[yycount++] = yytname[yyx];
1798 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1799 yysize_overflow |= (yysize1 < yysize);
1800 yysize = yysize1;
1801 yyfmt = yystpcpy (yyfmt, yyprefix);
1802 yyprefix = yyor;
1803 }
1804
1805 yyf = YY_(yyformat);
1806 yysize1 = yysize + yystrlen (yyf);
1807 yysize_overflow |= (yysize1 < yysize);
1808 yysize = yysize1;
1809
1810 if (yysize_overflow)
1811 return YYSIZE_MAXIMUM;
1812
1813 if (yyresult)
1814 {
1815 /* Avoid sprintf, as that infringes on the user's name space.
1816 Don't have undefined behavior even if the translation
1817 produced a string with the wrong number of "%s"s. */
1818 char *yyp = yyresult;
1819 int yyi = 0;
1820 while ((*yyp = *yyf) != '\0')
1821 {
1822 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1823 {
1824 yyp += yytnamerr (yyp, yyarg[yyi++]);
1825 yyf += 2;
1826 }
1827 else
1828 {
1829 yyp++;
1830 yyf++;
1831 }
1832 }
1833 }
1834 return yysize;
1835 }
1836 }
1837 #endif /* YYERROR_VERBOSE */
1838 \f
1839
1840 /*-----------------------------------------------.
1841 | Release the memory associated to this symbol. |
1842 `-----------------------------------------------*/
1843
1844 /*ARGSUSED*/
1845 #if (defined __STDC__ || defined __C99__FUNC__ \
1846 || defined __cplusplus || defined _MSC_VER)
1847 static void
1848 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1849 #else
1850 static void
1851 yydestruct (yymsg, yytype, yyvaluep)
1852 const char *yymsg;
1853 int yytype;
1854 YYSTYPE *yyvaluep;
1855 #endif
1856 {
1857 YYUSE (yyvaluep);
1858
1859 if (!yymsg)
1860 yymsg = "Deleting";
1861 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1862
1863 switch (yytype)
1864 {
1865
1866 default:
1867 break;
1868 }
1869 }
1870
1871 /* Prevent warnings from -Wmissing-prototypes. */
1872 #ifdef YYPARSE_PARAM
1873 #if defined __STDC__ || defined __cplusplus
1874 int yyparse (void *YYPARSE_PARAM);
1875 #else
1876 int yyparse ();
1877 #endif
1878 #else /* ! YYPARSE_PARAM */
1879 #if defined __STDC__ || defined __cplusplus
1880 int yyparse (void);
1881 #else
1882 int yyparse ();
1883 #endif
1884 #endif /* ! YYPARSE_PARAM */
1885
1886
1887 /* The lookahead symbol. */
1888 int yychar;
1889
1890 /* The semantic value of the lookahead symbol. */
1891 YYSTYPE yylval;
1892
1893 /* Number of syntax errors so far. */
1894 int yynerrs;
1895
1896
1897
1898 /*-------------------------.
1899 | yyparse or yypush_parse. |
1900 `-------------------------*/
1901
1902 #ifdef YYPARSE_PARAM
1903 #if (defined __STDC__ || defined __C99__FUNC__ \
1904 || defined __cplusplus || defined _MSC_VER)
1905 int
1906 yyparse (void *YYPARSE_PARAM)
1907 #else
1908 int
1909 yyparse (YYPARSE_PARAM)
1910 void *YYPARSE_PARAM;
1911 #endif
1912 #else /* ! YYPARSE_PARAM */
1913 #if (defined __STDC__ || defined __C99__FUNC__ \
1914 || defined __cplusplus || defined _MSC_VER)
1915 int
1916 yyparse (void)
1917 #else
1918 int
1919 yyparse ()
1920
1921 #endif
1922 #endif
1923 {
1924
1925
1926 int yystate;
1927 /* Number of tokens to shift before error messages enabled. */
1928 int yyerrstatus;
1929
1930 /* The stacks and their tools:
1931 `yyss': related to states.
1932 `yyvs': related to semantic values.
1933
1934 Refer to the stacks thru separate pointers, to allow yyoverflow
1935 to reallocate them elsewhere. */
1936
1937 /* The state stack. */
1938 yytype_int16 yyssa[YYINITDEPTH];
1939 yytype_int16 *yyss;
1940 yytype_int16 *yyssp;
1941
1942 /* The semantic value stack. */
1943 YYSTYPE yyvsa[YYINITDEPTH];
1944 YYSTYPE *yyvs;
1945 YYSTYPE *yyvsp;
1946
1947 YYSIZE_T yystacksize;
1948
1949 int yyn;
1950 int yyresult;
1951 /* Lookahead token as an internal (translated) token number. */
1952 int yytoken;
1953 /* The variables used to return semantic value and location from the
1954 action routines. */
1955 YYSTYPE yyval;
1956
1957 #if YYERROR_VERBOSE
1958 /* Buffer for error messages, and its allocated size. */
1959 char yymsgbuf[128];
1960 char *yymsg = yymsgbuf;
1961 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1962 #endif
1963
1964 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1965
1966 /* The number of symbols on the RHS of the reduced rule.
1967 Keep to zero when no symbol should be popped. */
1968 int yylen = 0;
1969
1970 yytoken = 0;
1971 yyss = yyssa;
1972 yyvs = yyvsa;
1973 yystacksize = YYINITDEPTH;
1974
1975 YYDPRINTF ((stderr, "Starting parse\n"));
1976
1977 yystate = 0;
1978 yyerrstatus = 0;
1979 yynerrs = 0;
1980 yychar = YYEMPTY; /* Cause a token to be read. */
1981
1982 /* Initialize stack pointers.
1983 Waste one element of value and location stack
1984 so that they stay on the same level as the state stack.
1985 The wasted elements are never initialized. */
1986 yyssp = yyss;
1987 yyvsp = yyvs;
1988
1989 goto yysetstate;
1990
1991 /*------------------------------------------------------------.
1992 | yynewstate -- Push a new state, which is found in yystate. |
1993 `------------------------------------------------------------*/
1994 yynewstate:
1995 /* In all cases, when you get here, the value and location stacks
1996 have just been pushed. So pushing a state here evens the stacks. */
1997 yyssp++;
1998
1999 yysetstate:
2000 *yyssp = yystate;
2001
2002 if (yyss + yystacksize - 1 <= yyssp)
2003 {
2004 /* Get the current used size of the three stacks, in elements. */
2005 YYSIZE_T yysize = yyssp - yyss + 1;
2006
2007 #ifdef yyoverflow
2008 {
2009 /* Give user a chance to reallocate the stack. Use copies of
2010 these so that the &'s don't force the real ones into
2011 memory. */
2012 YYSTYPE *yyvs1 = yyvs;
2013 yytype_int16 *yyss1 = yyss;
2014
2015 /* Each stack pointer address is followed by the size of the
2016 data in use in that stack, in bytes. This used to be a
2017 conditional around just the two extra args, but that might
2018 be undefined if yyoverflow is a macro. */
2019 yyoverflow (YY_("memory exhausted"),
2020 &yyss1, yysize * sizeof (*yyssp),
2021 &yyvs1, yysize * sizeof (*yyvsp),
2022 &yystacksize);
2023
2024 yyss = yyss1;
2025 yyvs = yyvs1;
2026 }
2027 #else /* no yyoverflow */
2028 # ifndef YYSTACK_RELOCATE
2029 goto yyexhaustedlab;
2030 # else
2031 /* Extend the stack our own way. */
2032 if (YYMAXDEPTH <= yystacksize)
2033 goto yyexhaustedlab;
2034 yystacksize *= 2;
2035 if (YYMAXDEPTH < yystacksize)
2036 yystacksize = YYMAXDEPTH;
2037
2038 {
2039 yytype_int16 *yyss1 = yyss;
2040 union yyalloc *yyptr =
2041 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
2042 if (! yyptr)
2043 goto yyexhaustedlab;
2044 YYSTACK_RELOCATE (yyss_alloc, yyss);
2045 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
2046 # undef YYSTACK_RELOCATE
2047 if (yyss1 != yyssa)
2048 YYSTACK_FREE (yyss1);
2049 }
2050 # endif
2051 #endif /* no yyoverflow */
2052
2053 yyssp = yyss + yysize - 1;
2054 yyvsp = yyvs + yysize - 1;
2055
2056 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2057 (unsigned long int) yystacksize));
2058
2059 if (yyss + yystacksize - 1 <= yyssp)
2060 YYABORT;
2061 }
2062
2063 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2064
2065 if (yystate == YYFINAL)
2066 YYACCEPT;
2067
2068 goto yybackup;
2069
2070 /*-----------.
2071 | yybackup. |
2072 `-----------*/
2073 yybackup:
2074
2075 /* Do appropriate processing given the current state. Read a
2076 lookahead token if we need one and don't already have one. */
2077
2078 /* First try to decide what to do without reference to lookahead token. */
2079 yyn = yypact[yystate];
2080 if (yyn == YYPACT_NINF)
2081 goto yydefault;
2082
2083 /* Not known => get a lookahead token if don't already have one. */
2084
2085 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
2086 if (yychar == YYEMPTY)
2087 {
2088 YYDPRINTF ((stderr, "Reading a token: "));
2089 yychar = YYLEX;
2090 }
2091
2092 if (yychar <= YYEOF)
2093 {
2094 yychar = yytoken = YYEOF;
2095 YYDPRINTF ((stderr, "Now at end of input.\n"));
2096 }
2097 else
2098 {
2099 yytoken = YYTRANSLATE (yychar);
2100 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2101 }
2102
2103 /* If the proper action on seeing token YYTOKEN is to reduce or to
2104 detect an error, take that action. */
2105 yyn += yytoken;
2106 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2107 goto yydefault;
2108 yyn = yytable[yyn];
2109 if (yyn <= 0)
2110 {
2111 if (yyn == 0 || yyn == YYTABLE_NINF)
2112 goto yyerrlab;
2113 yyn = -yyn;
2114 goto yyreduce;
2115 }
2116
2117 /* Count tokens shifted since error; after three, turn off error
2118 status. */
2119 if (yyerrstatus)
2120 yyerrstatus--;
2121
2122 /* Shift the lookahead token. */
2123 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2124
2125 /* Discard the shifted token. */
2126 yychar = YYEMPTY;
2127
2128 yystate = yyn;
2129 *++yyvsp = yylval;
2130
2131 goto yynewstate;
2132
2133
2134 /*-----------------------------------------------------------.
2135 | yydefault -- do the default action for the current state. |
2136 `-----------------------------------------------------------*/
2137 yydefault:
2138 yyn = yydefact[yystate];
2139 if (yyn == 0)
2140 goto yyerrlab;
2141 goto yyreduce;
2142
2143
2144 /*-----------------------------.
2145 | yyreduce -- Do a reduction. |
2146 `-----------------------------*/
2147 yyreduce:
2148 /* yyn is the number of a rule to reduce with. */
2149 yylen = yyr2[yyn];
2150
2151 /* If YYLEN is nonzero, implement the default value of the action:
2152 `$$ = $1'.
2153
2154 Otherwise, the following line sets YYVAL to garbage.
2155 This behavior is undocumented and Bison
2156 users should not rely upon it. Assigning to YYVAL
2157 unconditionally makes the parser a bit smaller, and it avoids a
2158 GCC warning that YYVAL may be used uninitialized. */
2159 yyval = yyvsp[1-yylen];
2160
2161
2162 YY_REDUCE_PRINT (yyn);
2163 switch (yyn)
2164 {
2165 case 2:
2166
2167 /* Line 1455 of yacc.c */
2168 #line 40 "lang11d"
2169 { gRootParseNode = (PyrParseNode*)(yyvsp[(1) - (1)]); gParserResult = 1; ;}
2170 break;
2171
2172 case 3:
2173
2174 /* Line 1455 of yacc.c */
2175 #line 42 "lang11d"
2176 { gRootParseNode = (PyrParseNode*)(yyvsp[(1) - (1)]); gParserResult = 1; ;}
2177 break;
2178
2179 case 4:
2180
2181 /* Line 1455 of yacc.c */
2182 #line 44 "lang11d"
2183 { gRootParseNode = (PyrParseNode*)(yyvsp[(2) - (2)]); gParserResult = 2; ;}
2184 break;
2185
2186 case 5:
2187
2188 /* Line 1455 of yacc.c */
2189 #line 47 "lang11d"
2190 { (yyval) = 0; ;}
2191 break;
2192
2193 case 6:
2194
2195 /* Line 1455 of yacc.c */
2196 #line 49 "lang11d"
2197 { (yyval) = (long)linkNextNode((PyrParseNode*)(yyvsp[(1) - (2)]), (PyrParseNode*)(yyvsp[(2) - (2)])); ;}
2198 break;
2199
2200 case 8:
2201
2202 /* Line 1455 of yacc.c */
2203 #line 54 "lang11d"
2204 { (yyval) = (long)linkNextNode((PyrParseNode*)(yyvsp[(1) - (2)]), (PyrParseNode*)(yyvsp[(2) - (2)])); ;}
2205 break;
2206
2207 case 9:
2208
2209 /* Line 1455 of yacc.c */
2210 #line 58 "lang11d"
2211 { (yyval) = (long)newPyrClassNode((PyrSlotNode*)(yyvsp[(1) - (6)]), (PyrSlotNode*)(yyvsp[(2) - (6)]),
2212 (PyrVarListNode*)(yyvsp[(4) - (6)]), (PyrMethodNode*)(yyvsp[(5) - (6)]), 0);
2213 ;}
2214 break;
2215
2216 case 10:
2217
2218 /* Line 1455 of yacc.c */
2219 #line 62 "lang11d"
2220 { (yyval) = (long)newPyrClassNode((PyrSlotNode*)(yyvsp[(1) - (9)]), (PyrSlotNode*)(yyvsp[(5) - (9)]),
2221 (PyrVarListNode*)(yyvsp[(7) - (9)]), (PyrMethodNode*)(yyvsp[(8) - (9)]),
2222 (PyrSlotNode*)(yyvsp[(3) - (9)]));
2223 ;}
2224 break;
2225
2226 case 11:
2227
2228 /* Line 1455 of yacc.c */
2229 #line 69 "lang11d"
2230 {
2231 (yyval) = (long)newPyrClassExtNode((PyrSlotNode*)(yyvsp[(2) - (5)]), (PyrMethodNode*)(yyvsp[(4) - (5)]));
2232 ;}
2233 break;
2234
2235 case 12:
2236
2237 /* Line 1455 of yacc.c */
2238 #line 74 "lang11d"
2239 { (yyval) = 0; ;}
2240 break;
2241
2242 case 14:
2243
2244 /* Line 1455 of yacc.c */
2245 #line 78 "lang11d"
2246 { (yyval) = 0; ;}
2247 break;
2248
2249 case 15:
2250
2251 /* Line 1455 of yacc.c */
2252 #line 80 "lang11d"
2253 { (yyval) = (yyvsp[(2) - (2)]); ;}
2254 break;
2255
2256 case 16:
2257
2258 /* Line 1455 of yacc.c */
2259 #line 83 "lang11d"
2260 { (yyval) = 0; ;}
2261 break;
2262
2263 case 17:
2264
2265 /* Line 1455 of yacc.c */
2266 #line 85 "lang11d"
2267 { (yyval) = (long)linkNextNode((PyrParseNode*)(yyvsp[(1) - (2)]), (PyrParseNode*)(yyvsp[(2) - (2)])); ;}
2268 break;
2269
2270 case 18:
2271
2272 /* Line 1455 of yacc.c */
2273 #line 89 "lang11d"
2274 { (yyval) = (long)newPyrVarListNode((PyrVarDefNode*)(yyvsp[(2) - (3)]), varClass); ;}
2275 break;
2276
2277 case 19:
2278
2279 /* Line 1455 of yacc.c */
2280 #line 91 "lang11d"
2281 { (yyval) = (long)newPyrVarListNode((PyrVarDefNode*)(yyvsp[(2) - (3)]), varInst); ;}
2282 break;
2283
2284 case 20:
2285
2286 /* Line 1455 of yacc.c */
2287 #line 93 "lang11d"
2288 { (yyval) = (long)newPyrVarListNode((PyrVarDefNode*)(yyvsp[(2) - (3)]), varConst); ;}
2289 break;
2290
2291 case 21:
2292
2293 /* Line 1455 of yacc.c */
2294 #line 96 "lang11d"
2295 { (yyval) = 0; ;}
2296 break;
2297
2298 case 22:
2299
2300 /* Line 1455 of yacc.c */
2301 #line 98 "lang11d"
2302 { (yyval) = (long)linkNextNode((PyrParseNode*)(yyvsp[(1) - (2)]), (PyrParseNode*)(yyvsp[(2) - (2)])); ;}
2303 break;
2304
2305 case 23:
2306
2307 /* Line 1455 of yacc.c */
2308 #line 102 "lang11d"
2309 { (yyval) = (long)newPyrMethodNode((PyrSlotNode*)(yyvsp[(1) - (7)]), (PyrSlotNode*)(yyvsp[(5) - (7)]),
2310 (PyrArgListNode*)(yyvsp[(3) - (7)]), (PyrVarListNode*)(yyvsp[(4) - (7)]), (PyrParseNode*)(yyvsp[(6) - (7)]), 0); ;}
2311 break;
2312
2313 case 24:
2314
2315 /* Line 1455 of yacc.c */
2316 #line 105 "lang11d"
2317 { (yyval) = (long)newPyrMethodNode((PyrSlotNode*)(yyvsp[(2) - (8)]), (PyrSlotNode*)(yyvsp[(6) - (8)]),
2318 (PyrArgListNode*)(yyvsp[(4) - (8)]), (PyrVarListNode*)(yyvsp[(5) - (8)]), (PyrParseNode*)(yyvsp[(7) - (8)]), 1); ;}
2319 break;
2320
2321 case 25:
2322
2323 /* Line 1455 of yacc.c */
2324 #line 108 "lang11d"
2325 { (yyval) = (long)newPyrMethodNode((PyrSlotNode*)(yyvsp[(1) - (7)]), (PyrSlotNode*)(yyvsp[(5) - (7)]),
2326 (PyrArgListNode*)(yyvsp[(3) - (7)]), (PyrVarListNode*)(yyvsp[(4) - (7)]), (PyrParseNode*)(yyvsp[(6) - (7)]), 0); ;}
2327 break;
2328
2329 case 26:
2330
2331 /* Line 1455 of yacc.c */
2332 #line 111 "lang11d"
2333 { (yyval) = (long)newPyrMethodNode((PyrSlotNode*)(yyvsp[(2) - (8)]), (PyrSlotNode*)(yyvsp[(6) - (8)]),
2334 (PyrArgListNode*)(yyvsp[(4) - (8)]), (PyrVarListNode*)(yyvsp[(5) - (8)]), (PyrParseNode*)(yyvsp[(7) - (8)]), 1); ;}
2335 break;
2336
2337 case 34:
2338
2339 /* Line 1455 of yacc.c */
2340 #line 129 "lang11d"
2341 { (yyval) = (long)newPyrDropNode((PyrParseNode*)(yyvsp[(1) - (2)]), (PyrParseNode*)(yyvsp[(2) - (2)])); ;}
2342 break;
2343
2344 case 35:
2345
2346 /* Line 1455 of yacc.c */
2347 #line 133 "lang11d"
2348 { (yyval) = (long)newPyrBlockNode(NULL, (PyrVarListNode*)(yyvsp[(2) - (4)]), (PyrParseNode*)(yyvsp[(3) - (4)]), false); ;}
2349 break;
2350
2351 case 36:
2352
2353 /* Line 1455 of yacc.c */
2354 #line 135 "lang11d"
2355 { (yyval) = (long)newPyrBlockNode(NULL, (PyrVarListNode*)(yyvsp[(1) - (2)]), (PyrParseNode*)(yyvsp[(2) - (2)]), false); ;}
2356 break;
2357
2358 case 37:
2359
2360 /* Line 1455 of yacc.c */
2361 #line 137 "lang11d"
2362 { (yyval) = (long)newPyrBlockNode(NULL, NULL, (PyrParseNode*)(yyvsp[(1) - (1)]), false); ;}
2363 break;
2364
2365 case 39:
2366
2367 /* Line 1455 of yacc.c */
2368 #line 142 "lang11d"
2369 { (yyval) = (long)newPyrDropNode((PyrParseNode*)(yyvsp[(1) - (2)]), (PyrParseNode*)(yyvsp[(2) - (2)])); ;}
2370 break;
2371
2372 case 40:
2373
2374 /* Line 1455 of yacc.c */
2375 #line 145 "lang11d"
2376 { (yyval) = 0; ;}
2377 break;
2378
2379 case 41:
2380
2381 /* Line 1455 of yacc.c */
2382 #line 147 "lang11d"
2383 { (yyval) = (yyvsp[(1) - (2)]); ;}
2384 break;
2385
2386 case 42:
2387
2388 /* Line 1455 of yacc.c */
2389 #line 151 "lang11d"
2390 { (yyval) = (long)newPyrReturnNode(NULL); ;}
2391 break;
2392
2393 case 43:
2394
2395 /* Line 1455 of yacc.c */
2396 #line 153 "lang11d"
2397 { (yyval) = (long)newPyrReturnNode((PyrParseNode*)(yyvsp[(2) - (3)])); ;}
2398 break;
2399
2400 case 44:
2401
2402 /* Line 1455 of yacc.c */
2403 #line 157 "lang11d"
2404 { (yyval) = (long)newPyrBlockReturnNode(); ;}
2405 break;
2406
2407 case 45:
2408
2409 /* Line 1455 of yacc.c */
2410 #line 159 "lang11d"
2411 { (yyval) = (long)newPyrReturnNode((PyrParseNode*)(yyvsp[(2) - (3)])); ;}
2412 break;
2413
2414 case 47:
2415
2416 /* Line 1455 of yacc.c */
2417 #line 164 "lang11d"
2418 {
2419 (yyval) = (long)linkNextNode((PyrParseNode*)(yyvsp[(1) - (2)]), (PyrParseNode*)(yyvsp[(2) - (2)]));
2420 ;}
2421 break;
2422
2423 case 50:
2424
2425 /* Line 1455 of yacc.c */
2426 #line 173 "lang11d"
2427 { (yyval) = 0; ;}
2428 break;
2429
2430 case 52:
2431
2432 /* Line 1455 of yacc.c */
2433 #line 178 "lang11d"
2434 {
2435 (yyval) = (long)newPyrCallNode((PyrSlotNode*)(yyvsp[(1) - (2)]), (PyrParseNode*)(yyvsp[(2) - (2)]), 0, 0);
2436 ;}
2437 break;
2438
2439 case 53:
2440
2441 /* Line 1455 of yacc.c */
2442 #line 182 "lang11d"
2443 {
2444 (yyval) = (long)newPyrCallNode((PyrSlotNode*)(yyvsp[(2) - (4)]), (PyrParseNode*)(yyvsp[(4) - (4)]), 0, 0);
2445 ;}
2446 break;
2447
2448 case 54:
2449
2450 /* Line 1455 of yacc.c */
2451 #line 186 "lang11d"
2452 {
2453 (yyval) = (long)newPyrCallNode((PyrSlotNode*)(yyvsp[(1) - (4)]), NULL, NULL, (PyrParseNode*)(yyvsp[(4) - (4)]));
2454 ;}
2455 break;
2456
2457 case 55:
2458
2459 /* Line 1455 of yacc.c */
2460 #line 190 "lang11d"
2461 {
2462 (yyval) = (long)newPyrCallNode((PyrSlotNode*)(yyvsp[(1) - (6)]), (PyrParseNode*)(yyvsp[(3) - (6)]),
2463 (PyrParseNode*)(yyvsp[(4) - (6)]), (PyrParseNode*)(yyvsp[(6) - (6)]));
2464 ;}
2465 break;
2466
2467 case 56:
2468
2469 /* Line 1455 of yacc.c */
2470 #line 195 "lang11d"
2471 {
2472 (yyval) = (long)newPyrCallNode((PyrSlotNode*)(yyvsp[(2) - (6)]), NULL, NULL, (PyrParseNode*)(yyvsp[(6) - (6)]));
2473 ;}
2474 break;
2475
2476 case 57:
2477
2478 /* Line 1455 of yacc.c */
2479 #line 199 "lang11d"
2480 {
2481 (yyval) = (long)newPyrCallNode((PyrSlotNode*)(yyvsp[(2) - (8)]), (PyrParseNode*)(yyvsp[(5) - (8)]),
2482 (PyrParseNode*)(yyvsp[(6) - (8)]), (PyrParseNode*)(yyvsp[(8) - (8)]));
2483 ;}
2484 break;
2485
2486 case 58:
2487
2488 /* Line 1455 of yacc.c */
2489 #line 204 "lang11d"
2490 {
2491 PyrSlotNode *selectornode;
2492 PyrSlot slot;
2493 PyrParseNode* args;
2494
2495 if (isSuperObjNode((PyrParseNode*)(yyvsp[(3) - (5)]))) {
2496 SetRaw(&((PyrPushNameNode*)(yyvsp[(3) - (5)]))->mSlot, s_this);
2497 SetSymbol(&slot, s_superPerformList);
2498 } else {
2499 SetSymbol(&slot, s_performList);
2500 }
2501 selectornode = newPyrSlotNode(&slot);
2502 args = linkAfterHead(
2503 (PyrParseNode*)(yyvsp[(3) - (5)]),
2504 newPyrPushLitNode((PyrSlotNode*)(yyvsp[(1) - (5)]), NULL));
2505 (yyval) = (long)newPyrCallNode(selectornode, args, (PyrParseNode*)(yyvsp[(4) - (5)]), 0);
2506 ;}
2507 break;
2508
2509 case 59:
2510
2511 /* Line 1455 of yacc.c */
2512 #line 222 "lang11d"
2513 {
2514 PyrSlotNode *selectornode;
2515 PyrSlot slot;
2516 PyrParseNode* args;
2517
2518 SetSymbol(&slot, s_performList);
2519 selectornode = newPyrSlotNode(&slot);
2520 args = linkAfterHead(
2521 (PyrParseNode*)(yyvsp[(5) - (7)]),
2522 newPyrPushLitNode((PyrSlotNode*)(yyvsp[(2) - (7)]), NULL));
2523 (yyval) = (long)newPyrCallNode(selectornode, args, (PyrParseNode*)(yyvsp[(6) - (7)]), 0);
2524 ;}
2525 break;
2526
2527 case 60:
2528
2529 /* Line 1455 of yacc.c */
2530 #line 235 "lang11d"
2531 { (yyval) = (long)newPyrDynListNode((PyrParseNode*)(yyvsp[(1) - (4)]), (PyrParseNode*)(yyvsp[(3) - (4)])); ;}
2532 break;
2533
2534 case 61:
2535
2536 /* Line 1455 of yacc.c */
2537 #line 237 "lang11d"
2538 {
2539 PyrSlotNode *selectornode;
2540 PyrSlot slot;
2541 PyrParseNode* args;
2542
2543 SetSymbol(&slot, s_new);
2544 selectornode = newPyrSlotNode(&slot);
2545 args = (PyrParseNode*)newPyrPushNameNode((PyrSlotNode*)(yyvsp[(1) - (2)]));
2546 (yyval) = (long)newPyrCallNode(selectornode, args, 0, (PyrParseNode*)(yyvsp[(2) - (2)]));
2547 ;}
2548 break;
2549
2550 case 62:
2551
2552 /* Line 1455 of yacc.c */
2553 #line 248 "lang11d"
2554 {
2555 PyrSlotNode *selectornode;
2556 PyrSlot slot;
2557 PyrParseNode* args;
2558
2559 SetSymbol(&slot, s_new);
2560 selectornode = newPyrSlotNode(&slot);
2561 args = (PyrParseNode*)newPyrPushNameNode((PyrSlotNode*)(yyvsp[(1) - (4)]));
2562 (yyval) = (long)newPyrCallNode(selectornode, args, NULL, (PyrParseNode*)(yyvsp[(4) - (4)]));
2563 ;}
2564 break;
2565
2566 case 63:
2567
2568 /* Line 1455 of yacc.c */
2569 #line 259 "lang11d"
2570 {
2571 PyrSlotNode *selectornode;
2572 PyrSlot slot;
2573 PyrParseNode* args;
2574
2575 SetSymbol(&slot, s_new);
2576 selectornode = newPyrSlotNode(&slot);
2577 args = (PyrParseNode*)newPyrPushNameNode((PyrSlotNode*)(yyvsp[(1) - (5)]));
2578 (yyval) = (long)newPyrCallNode(selectornode, args, (PyrParseNode*)(yyvsp[(3) - (5)]), (PyrParseNode*)(yyvsp[(5) - (5)]));
2579 ;}
2580 break;
2581
2582 case 64:
2583
2584 /* Line 1455 of yacc.c */
2585 #line 270 "lang11d"
2586 {
2587 PyrSlotNode *selectornode;
2588 PyrSlot slot;
2589 PyrParseNode* args;
2590
2591 SetSymbol(&slot, s_new);
2592 selectornode = newPyrSlotNode(&slot);
2593 args = linkNextNode(
2594 (PyrParseNode*)newPyrPushNameNode((PyrSlotNode*)(yyvsp[(1) - (6)])),
2595 (PyrParseNode*)(yyvsp[(3) - (6)]));
2596 (yyval) = (long)newPyrCallNode(selectornode, args, (PyrParseNode*)(yyvsp[(4) - (6)]), (PyrParseNode*)(yyvsp[(6) - (6)]));
2597 ;}
2598 break;
2599
2600 case 65:
2601
2602 /* Line 1455 of yacc.c */
2603 #line 283 "lang11d"
2604 {
2605 PyrSlotNode *selectornode, *selectornode2;
2606 PyrSlot slot, slot2;
2607 PyrParseNode* args;
2608
2609 if (isSuperObjNode((PyrParseNode*)(yyvsp[(1) - (5)]))) {
2610 SetRaw(&((PyrPushNameNode*)(yyvsp[(1) - (5)]))->mSlot, s_this);
2611 SetSymbol(&slot, s_superPerformList);
2612 } else {
2613 SetSymbol(&slot, s_performList);
2614 }
2615 SetSymbol(&slot2, s_new);
2616 selectornode = newPyrSlotNode(&slot);
2617 selectornode2 = newPyrSlotNode(&slot2);
2618 args = linkNextNode(
2619 (PyrParseNode*)newPyrPushNameNode((PyrSlotNode*)(yyvsp[(1) - (5)])),
2620 newPyrPushLitNode(selectornode2, NULL));
2621 args = linkNextNode(args, (PyrParseNode*)(yyvsp[(3) - (5)]));
2622 (yyval) = (long)newPyrCallNode(selectornode, args, (PyrParseNode*)(yyvsp[(5) - (5)]), 0);
2623 ;}
2624 break;
2625
2626 case 66:
2627
2628 /* Line 1455 of yacc.c */
2629 #line 304 "lang11d"
2630 {
2631 PyrSlotNode *selectornode;
2632 PyrSlot slot;
2633
2634 SetSymbol(&slot, s_value);
2635 selectornode = newPyrSlotNode(&slot);
2636 (yyval) = (long)newPyrCallNode(selectornode, (PyrParseNode*)(yyvsp[(1) - (5)]), NULL, (PyrParseNode*)(yyvsp[(5) - (5)]));
2637 ;}
2638 break;
2639
2640 case 67:
2641
2642 /* Line 1455 of yacc.c */
2643 #line 313 "lang11d"
2644 {
2645 PyrSlotNode *selectornode;
2646 PyrSlot slot;
2647
2648 SetSymbol(&slot, s_value);
2649 selectornode = newPyrSlotNode(&slot);
2650 (yyval) = (long)newPyrCallNode(selectornode, (PyrParseNode*)(yyvsp[(1) - (6)]), (PyrParseNode*)(yyvsp[(4) - (6)]), (PyrParseNode*)(yyvsp[(6) - (6)]));
2651 ;}
2652 break;
2653
2654 case 68:
2655
2656 /* Line 1455 of yacc.c */
2657 #line 322 "lang11d"
2658 {
2659 (yyval) = (long)newPyrCallNode((PyrSlotNode*)(yyvsp[(3) - (7)]), (PyrParseNode*)(yyvsp[(1) - (7)]),
2660 (PyrParseNode*)(yyvsp[(5) - (7)]), (PyrParseNode*)(yyvsp[(7) - (7)]));
2661 ;}
2662 break;
2663
2664 case 69:
2665
2666 /* Line 1455 of yacc.c */
2667 #line 327 "lang11d"
2668 {
2669 PyrSlotNode *selectornode;
2670 PyrSlot slot;
2671 PyrParseNode* args;
2672
2673 SetSymbol(&slot, s_value);
2674 selectornode = newPyrSlotNode(&slot);
2675 args = linkNextNode(
2676 (PyrParseNode*)(yyvsp[(1) - (7)]),
2677 (PyrParseNode*)(yyvsp[(4) - (7)]));
2678 (yyval) = (long)newPyrCallNode(selectornode, args, (PyrParseNode*)(yyvsp[(5) - (7)]), (PyrParseNode*)(yyvsp[(7) - (7)]));
2679 ;}
2680 break;
2681
2682 case 70:
2683
2684 /* Line 1455 of yacc.c */
2685 #line 340 "lang11d"
2686 {
2687 PyrSlotNode *selectornode;
2688 PyrSlot slot, slot2;
2689 PyrParseNode* args;
2690
2691 if (isSuperObjNode((PyrParseNode*)(yyvsp[(1) - (6)]))) {
2692 SetRaw(&((PyrPushNameNode*)(yyvsp[(1) - (6)]))->mSlot, s_this);
2693 SetSymbol(&slot, s_superPerformList);
2694 } else {
2695 SetSymbol(&slot, s_performList);
2696 }
2697 SetSymbol(&slot2, s_value);
2698 selectornode = newPyrSlotNode(&slot);
2699 args = linkNextNode(
2700 (PyrParseNode*)(yyvsp[(1) - (6)]),
2701 newPyrPushLitNode(newPyrSlotNode(&slot2), NULL));
2702 args = linkNextNode(args, (PyrParseNode*)(yyvsp[(4) - (6)]));
2703 (yyval) = (long)newPyrCallNode(selectornode, args, (PyrParseNode*)(yyvsp[(5) - (6)]), 0);
2704 ;}
2705 break;
2706
2707 case 71:
2708
2709 /* Line 1455 of yacc.c */
2710 #line 360 "lang11d"
2711 {
2712 (yyval) = (long)newPyrCallNode((PyrSlotNode*)(yyvsp[(3) - (6)]), (PyrParseNode*)(yyvsp[(1) - (6)]), NULL, (PyrParseNode*)(yyvsp[(6) - (6)]));
2713 ;}
2714 break;
2715
2716 case 72:
2717
2718 /* Line 1455 of yacc.c */
2719 #line 364 "lang11d"
2720 {
2721 PyrParseNode* args;
2722 args = linkNextNode((PyrParseNode*)(yyvsp[(1) - (8)]), (PyrParseNode*)(yyvsp[(5) - (8)]));
2723 (yyval) = (long)newPyrCallNode((PyrSlotNode*)(yyvsp[(3) - (8)]), args, (PyrParseNode*)(yyvsp[(6) - (8)]), (PyrParseNode*)(yyvsp[(8) - (8)]));
2724 ;}
2725 break;
2726
2727 case 73:
2728
2729 /* Line 1455 of yacc.c */
2730 #line 370 "lang11d"
2731 {
2732 PyrSlotNode *selectornode;
2733 PyrSlot slot;
2734 PyrParseNode* args;
2735
2736 if (isSuperObjNode((PyrParseNode*)(yyvsp[(1) - (7)]))) {
2737 SetRaw(&((PyrPushNameNode*)(yyvsp[(1) - (7)]))->mSlot, s_this);
2738 SetSymbol(&slot, s_superPerformList);
2739 } else {
2740 SetSymbol(&slot, s_performList);
2741 }
2742 selectornode = newPyrSlotNode(&slot);
2743
2744 args = linkNextNode((PyrParseNode*)(yyvsp[(1) - (7)]), newPyrPushLitNode((PyrSlotNode*)(yyvsp[(3) - (7)]), NULL));
2745 args = linkNextNode(args, (PyrParseNode*)(yyvsp[(5) - (7)]));
2746 (yyval) = (long)newPyrCallNode(selectornode, args, (PyrParseNode*)(yyvsp[(6) - (7)]), 0);
2747 ;}
2748 break;
2749
2750 case 74:
2751
2752 /* Line 1455 of yacc.c */
2753 #line 388 "lang11d"
2754 {
2755 (yyval) = (long)newPyrCallNode((PyrSlotNode*)(yyvsp[(3) - (4)]), (PyrParseNode*)(yyvsp[(1) - (4)]), 0, (PyrParseNode*)(yyvsp[(4) - (4)]));
2756 ;}
2757 break;
2758
2759 case 75:
2760
2761 /* Line 1455 of yacc.c */
2762 #line 393 "lang11d"
2763 { pushls(&generatorStack, (yyvsp[(3) - (3)])); pushls(&generatorStack, 1); ;}
2764 break;
2765
2766 case 76:
2767
2768 /* Line 1455 of yacc.c */
2769 #line 394 "lang11d"
2770 {
2771 PyrSlot slot;
2772 SetSymbol(&slot, getsym("r"));
2773 PyrSlotNode* selectornode = newPyrSlotNode(&slot);
2774
2775 PyrParseNode *block = (PyrParseNode*)newPyrBlockNode(0, 0, (PyrParseNode*)(yyvsp[(6) - (7)]), false);
2776 PyrParseNode *blocklit = (PyrParseNode*)newPyrPushLitNode(NULL, block);
2777 (yyval) = (long)newPyrCallNode(selectornode, (PyrParseNode*)blocklit, 0, 0);
2778 ;}
2779 break;
2780
2781 case 77:
2782
2783 /* Line 1455 of yacc.c */
2784 #line 403 "lang11d"
2785 { pushls(&generatorStack, (yyvsp[(3) - (3)])); pushls(&generatorStack, 2); ;}
2786 break;
2787
2788 case 78:
2789
2790 /* Line 1455 of yacc.c */
2791 #line 404 "lang11d"
2792 {
2793 (yyval) = (yyvsp[(6) - (7)]);
2794 ;}
2795 break;
2796
2797 case 79:
2798
2799 /* Line 1455 of yacc.c */
2800 #line 410 "lang11d"
2801 {
2802 // innermost part
2803 int action = popls(&generatorStack);
2804 PyrParseNode* expr = (PyrParseNode*)popls(&generatorStack);
2805
2806 switch (action)
2807 {
2808 case 1 :
2809 {
2810 PyrSlot slot;
2811 SetSymbol(&slot, getsym("yield"));
2812 PyrSlotNode* selectornode = newPyrSlotNode(&slot);
2813
2814 (yyval) = (long)newPyrCallNode(selectornode, expr, 0, 0);
2815 } break;
2816 case 2 :
2817 {
2818 (yyval) = (long)expr;
2819 } break;
2820 }
2821 ;}
2822 break;
2823
2824 case 80:
2825
2826 /* Line 1455 of yacc.c */
2827 #line 432 "lang11d"
2828 { (yyval) = (yyvsp[(2) - (2)]); ;}
2829 break;
2830
2831 case 81:
2832
2833 /* Line 1455 of yacc.c */
2834 #line 436 "lang11d"
2835 {
2836 // later should check if exprseq is a series and optimize it to for loop
2837 PyrParseNode *exprseq = (PyrParseNode*)(yyvsp[(3) - (4)]);
2838 if (exprseq->mClassno == pn_CallNode) {
2839 PyrCallNode *callnode = (PyrCallNode*)exprseq;
2840 if (slotRawSymbol(&callnode->mSelector->mSlot) == s_series)
2841 {
2842 SetSymbol(&callnode->mSelector->mSlot, getsym("forSeries"));
2843
2844 PyrVarDefNode* var = newPyrVarDefNode((PyrSlotNode*)(yyvsp[(1) - (4)]), NULL, 0);
2845 PyrArgListNode* args = newPyrArgListNode(var, NULL);
2846 PyrParseNode *block = (PyrParseNode*)newPyrBlockNode(args, 0, (PyrParseNode*)(yyvsp[(4) - (4)]), false);
2847 PyrParseNode *blocklit = (PyrParseNode*)newPyrPushLitNode(NULL, block);
2848
2849 callnode->mArglist = linkNextNode(callnode->mArglist, blocklit);
2850 (yyval) = (long)callnode;
2851
2852 } else goto notoptimized1;
2853 } else {
2854 notoptimized1:
2855 PyrSlot slot;
2856 SetSymbol(&slot, getsym("do"));
2857 PyrSlotNode* selectornode = newPyrSlotNode(&slot);
2858
2859 PyrVarDefNode* var = newPyrVarDefNode((PyrSlotNode*)(yyvsp[(1) - (4)]), NULL, 0);
2860 PyrArgListNode* args = newPyrArgListNode(var, NULL);
2861 PyrParseNode *block = (PyrParseNode*)newPyrBlockNode(args, 0, (PyrParseNode*)(yyvsp[(4) - (4)]), false);
2862 PyrParseNode *blocklit = (PyrParseNode*)newPyrPushLitNode(NULL, block);
2863
2864 PyrParseNode* args2 = linkNextNode(exprseq, blocklit);
2865 (yyval) = (long)newPyrCallNode(selectornode, args2, 0, 0);
2866 }
2867 ;}
2868 break;
2869
2870 case 82:
2871
2872 /* Line 1455 of yacc.c */
2873 #line 470 "lang11d"
2874 {
2875 // later should check if exprseq is a series and optimize it to for loop
2876 PyrParseNode *exprseq = (PyrParseNode*)(yyvsp[(4) - (5)]);
2877 if (exprseq->mClassno == pn_CallNode) {
2878 PyrCallNode *callnode = (PyrCallNode*)exprseq;
2879 if (slotRawSymbol(&callnode->mSelector->mSlot) == s_series)
2880 {
2881 SetSymbol(&callnode->mSelector->mSlot, getsym("forSeries"));
2882
2883 PyrVarDefNode* var1 = newPyrVarDefNode((PyrSlotNode*)(yyvsp[(1) - (5)]), NULL, 0);
2884 PyrVarDefNode* var2 = newPyrVarDefNode((PyrSlotNode*)(yyvsp[(2) - (5)]), NULL, 0);
2885 PyrVarDefNode* vars = (PyrVarDefNode*)linkNextNode(var1, var2);
2886 PyrArgListNode* args = newPyrArgListNode(vars, NULL);
2887 PyrParseNode *block = (PyrParseNode*)newPyrBlockNode(args, 0, (PyrParseNode*)(yyvsp[(5) - (5)]), false);
2888 PyrParseNode *blocklit = (PyrParseNode*)newPyrPushLitNode(NULL, block);
2889
2890 callnode->mArglist = linkNextNode(callnode->mArglist, blocklit);
2891 (yyval) = (long)callnode;
2892
2893 } else goto notoptimized2;
2894 } else {
2895 notoptimized2:
2896 PyrSlot slot;
2897 SetSymbol(&slot, getsym("do"));
2898 PyrSlotNode* selectornode = newPyrSlotNode(&slot);
2899
2900 PyrVarDefNode* var1 = newPyrVarDefNode((PyrSlotNode*)(yyvsp[(1) - (5)]), NULL, 0);
2901 PyrVarDefNode* var2 = newPyrVarDefNode((PyrSlotNode*)(yyvsp[(2) - (5)]), NULL, 0);
2902 PyrVarDefNode* vars = (PyrVarDefNode*)linkNextNode(var1, var2);
2903 PyrArgListNode* args = newPyrArgListNode(vars, NULL);
2904 PyrParseNode *block = (PyrParseNode*)newPyrBlockNode(args, 0, (PyrParseNode*)(yyvsp[(5) - (5)]), false);
2905 PyrParseNode *blocklit = (PyrParseNode*)newPyrPushLitNode(NULL, block);
2906
2907 PyrParseNode* args2 = linkNextNode(exprseq, blocklit);
2908 (yyval) = (long)newPyrCallNode(selectornode, args2, 0, 0);
2909 }
2910 ;}
2911 break;
2912
2913 case 83:
2914
2915 /* Line 1455 of yacc.c */
2916 #line 508 "lang11d"
2917 {
2918 PyrSlot slot;
2919 SetSymbol(&slot, s_value);
2920 PyrSlotNode* selectornode = newPyrSlotNode(&slot);
2921
2922 PyrVarDefNode* var = newPyrVarDefNode((PyrSlotNode*)(yyvsp[(2) - (5)]), NULL, 0);
2923 PyrArgListNode* args = newPyrArgListNode(var, NULL);
2924 PyrParseNode *block = (PyrParseNode*)newPyrBlockNode(args, 0, (PyrParseNode*)(yyvsp[(5) - (5)]), false);
2925 PyrParseNode *blocklit = (PyrParseNode*)newPyrPushLitNode(NULL, block);
2926 PyrParseNode* args2 = (PyrParseNode*)linkNextNode(blocklit, (PyrParseNode*)(yyvsp[(4) - (5)]));
2927
2928 (yyval) = (long)newPyrCallNode(selectornode, args2, 0, 0);
2929 ;}
2930 break;
2931
2932 case 84:
2933
2934 /* Line 1455 of yacc.c */
2935 #line 522 "lang11d"
2936 {
2937 PyrSlot slot;
2938 SetSymbol(&slot, getsym("if"));
2939 PyrSlotNode* selectornode = newPyrSlotNode(&slot);
2940 PyrParseNode *block = (PyrParseNode*)newPyrBlockNode(0, 0, (PyrParseNode*)(yyvsp[(2) - (2)]), false);
2941 PyrParseNode *blocklit = (PyrParseNode*)newPyrPushLitNode(NULL, block);
2942 PyrParseNode* args2 = (PyrParseNode*)linkNextNode((PyrParseNode*)(yyvsp[(1) - (2)]), blocklit);
2943
2944 (yyval) = (long)newPyrCallNode(selectornode, args2, 0, 0);
2945 ;}
2946 break;
2947
2948 case 85:
2949
2950 /* Line 1455 of yacc.c */
2951 #line 533 "lang11d"
2952 {
2953 (yyval) = (long)newPyrDropNode((PyrParseNode*)(yyvsp[(3) - (4)]), (PyrParseNode*)(yyvsp[(4) - (4)]));
2954 ;}
2955 break;
2956
2957 case 86:
2958
2959 /* Line 1455 of yacc.c */
2960 #line 537 "lang11d"
2961 {
2962 PyrSlot slot;
2963 SetSymbol(&slot, getsym("alwaysYield"));
2964 PyrSlotNode* selectornode1 = newPyrSlotNode(&slot);
2965
2966 SetSymbol(&slot, getsym("if"));
2967 PyrSlotNode* selectornode2 = newPyrSlotNode(&slot);
2968
2969 SetNil(&slot);
2970 PyrParseNode *pushnil = (PyrParseNode*)newPyrPushLitNode(newPyrSlotNode(&slot), NULL);
2971
2972 PyrParseNode *yieldNil = (PyrParseNode*)newPyrCallNode(selectornode1, pushnil, 0, 0);
2973
2974 PyrParseNode *block1 = (PyrParseNode*)newPyrBlockNode(0, 0, yieldNil, false);
2975 PyrParseNode *blocklit1 = (PyrParseNode*)newPyrPushLitNode(NULL, block1);
2976 PyrParseNode *block2 = (PyrParseNode*)newPyrBlockNode(0, 0, (PyrParseNode*)(yyvsp[(4) - (4)]), false);
2977 PyrParseNode *blocklit2 = (PyrParseNode*)newPyrPushLitNode(NULL, block2);
2978 PyrParseNode* args2 = (PyrParseNode*)linkNextNode((PyrParseNode*)(yyvsp[(3) - (4)]), blocklit2);
2979 PyrParseNode* args3 = (PyrParseNode*)linkNextNode(args2, blocklit1);
2980
2981 (yyval) = (long)newPyrCallNode(selectornode2, args3, 0, 0);
2982 ;}
2983 break;
2984
2985 case 93:
2986
2987 /* Line 1455 of yacc.c */
2988 #line 568 "lang11d"
2989 {
2990 PyrParseNode* node = (PyrParseNode*)(yyvsp[(2) - (3)]);
2991 node->mParens = 1;
2992 (yyval) = (yyvsp[(2) - (3)]);
2993 ;}
2994 break;
2995
2996 case 94:
2997
2998 /* Line 1455 of yacc.c */
2999 #line 574 "lang11d"
3000 {
3001 PyrParseNode* argnode;
3002 PyrSlotNode* selectornode;
3003 PyrSlot slot;
3004 argnode = (PyrParseNode*)newPyrPushLitNode((PyrSlotNode*)(yyvsp[(2) - (2)]), NULL);
3005 SetSymbol(&slot, s_envirGet);
3006 selectornode = newPyrSlotNode(&slot);
3007 (yyval) = (long)newPyrCallNode(selectornode, argnode, 0, 0);
3008 ;}
3009 break;
3010
3011 case 95:
3012
3013 /* Line 1455 of yacc.c */
3014 #line 584 "lang11d"
3015 { (yyval) = (long)newPyrDynListNode(0, (PyrParseNode*)(yyvsp[(2) - (3)])); ;}
3016 break;
3017
3018 case 96:
3019
3020 /* Line 1455 of yacc.c */
3021 #line 586 "lang11d"
3022 { (yyval) = (yyvsp[(2) - (3)]); ;}
3023 break;
3024
3025 case 97:
3026
3027 /* Line 1455 of yacc.c */
3028 #line 588 "lang11d"
3029 { (yyval) = (yyvsp[(3) - (4)]); ;}
3030 break;
3031
3032 case 98:
3033
3034 /* Line 1455 of yacc.c */
3035 #line 590 "lang11d"
3036 { (yyval) = (long)newPyrDynDictNode((PyrParseNode*)(yyvsp[(2) - (3)])); ;}
3037 break;
3038
3039 case 99:
3040
3041 /* Line 1455 of yacc.c */
3042 #line 592 "lang11d"
3043 { (yyval) = (long)newPyrPushNameNode((PyrSlotNode*)(yyvsp[(1) - (1)])); ;}
3044 break;
3045
3046 case 100:
3047
3048 /* Line 1455 of yacc.c */
3049 #line 594 "lang11d"
3050 {
3051 PyrSlotNode *selectornode;
3052 PyrSlot slot;
3053 PyrParseNode* args;
3054
3055 SetSymbol(&slot, s_at);
3056 selectornode = newPyrSlotNode(&slot);
3057 args = linkNextNode(
3058 (PyrParseNode*)(yyvsp[(1) - (4)]),
3059 (PyrParseNode*)(yyvsp[(3) - (4)]));
3060 (yyval) = (long)newPyrCallNode(selectornode, args, 0, 0);
3061 ;}
3062 break;
3063
3064 case 102:
3065
3066 /* Line 1455 of yacc.c */
3067 #line 610 "lang11d"
3068 {
3069 PyrSlotNode *selectornode;
3070 PyrPushLitNode *nilnode1, *nilnode2;
3071 PyrSlot selectorSlot, nilSlot;
3072 PyrParseNode* args;
3073
3074 int arglen = nodeListLength((PyrParseNode*)(yyvsp[(3) - (5)]));
3075 if (arglen > 2) {
3076 error("ArrayedCollection subrange has too many arguments.\n");
3077 nodePostErrorLine((PyrParseNode*)(yyvsp[(3) - (5)]));
3078 compileErrors++;
3079 }
3080
3081 SetNil(&nilSlot);
3082 nilnode2 = newPyrPushLitNode(newPyrSlotNode(&nilSlot), NULL);
3083
3084 SetSymbol(&selectorSlot, s_copyseries);
3085 selectornode = newPyrSlotNode(&selectorSlot);
3086 args = linkNextNode((PyrParseNode*)(yyvsp[(1) - (5)]), (PyrParseNode*)(yyvsp[(3) - (5)]));
3087 if (arglen < 2) {
3088 nilnode1 = newPyrPushLitNode(newPyrSlotNode(&nilSlot), NULL);
3089 args = linkNextNode(args, nilnode1);
3090 }
3091 args = linkNextNode(args, nilnode2);
3092 (yyval) = (long)newPyrCallNode(selectornode, args, 0, 0);
3093 ;}
3094 break;
3095
3096 case 103:
3097
3098 /* Line 1455 of yacc.c */
3099 #line 637 "lang11d"
3100 {
3101 PyrSlotNode *selectornode;
3102 PyrPushLitNode *nilnode1, *nilnode2;
3103 PyrSlot selectorSlot, nilSlot;
3104 PyrParseNode* args;
3105
3106 SetNil(&nilSlot);
3107 nilnode1 = newPyrPushLitNode(newPyrSlotNode(&nilSlot), NULL);
3108 nilnode2 = newPyrPushLitNode(newPyrSlotNode(&nilSlot), NULL);
3109
3110 SetSymbol(&selectorSlot, s_copyseries);
3111 selectornode = newPyrSlotNode(&selectorSlot);
3112 args = linkNextNode((PyrParseNode*)(yyvsp[(1) - (5)]), nilnode1);
3113 args = linkNextNode(args, nilnode2);
3114 args = linkNextNode(args, (PyrParseNode*)(yyvsp[(4) - (5)]));
3115 (yyval) = (long)newPyrCallNode(selectornode, args, 0, 0);
3116 ;}
3117 break;
3118
3119 case 104:
3120
3121 /* Line 1455 of yacc.c */
3122 #line 655 "lang11d"
3123 {
3124 PyrSlotNode *selectornode;
3125 PyrPushLitNode *nilnode1;
3126 PyrSlot selectorSlot, nilSlot;
3127 PyrParseNode* args;
3128
3129 int arglen = nodeListLength((PyrParseNode*)(yyvsp[(3) - (6)]));
3130 if (arglen > 2) {
3131 error("ArrayedCollection subrange has too many arguments.\n");
3132 nodePostErrorLine((PyrParseNode*)(yyvsp[(3) - (6)]));
3133 compileErrors++;
3134 }
3135
3136 SetSymbol(&selectorSlot, s_copyseries);
3137 selectornode = newPyrSlotNode(&selectorSlot);
3138 args = linkNextNode((PyrParseNode*)(yyvsp[(1) - (6)]), (PyrParseNode*)(yyvsp[(3) - (6)]));
3139 if (arglen < 2) {
3140 SetNil(&nilSlot);
3141 nilnode1 = newPyrPushLitNode(newPyrSlotNode(&nilSlot), NULL);
3142 args = linkNextNode(args, nilnode1);
3143 }
3144 args = linkNextNode(args, (PyrParseNode*)(yyvsp[(5) - (6)]));
3145 (yyval) = (long)newPyrCallNode(selectornode, args, 0, 0);
3146 ;}
3147 break;
3148
3149 case 105:
3150
3151 /* Line 1455 of yacc.c */
3152 #line 682 "lang11d"
3153 {
3154 PyrSlotNode *selectornode;
3155 PyrPushLitNode *nilnode1, *nilnode2;
3156 PyrSlot selectorSlot, nilSlot;
3157 PyrParseNode* args;
3158
3159 int arglen = nodeListLength((PyrParseNode*)(yyvsp[(3) - (7)]));
3160 if (arglen > 2) {
3161 error("ArrayedCollection subrange has too many arguments.\n");
3162 nodePostErrorLine((PyrParseNode*)(yyvsp[(3) - (7)]));
3163 compileErrors++;
3164 }
3165
3166 SetNil(&nilSlot);
3167 nilnode2 = newPyrPushLitNode(newPyrSlotNode(&nilSlot), NULL);
3168
3169 SetSymbol(&selectorSlot, s_putseries);
3170 selectornode = newPyrSlotNode(&selectorSlot);
3171 args = linkNextNode((PyrParseNode*)(yyvsp[(1) - (7)]), (PyrParseNode*)(yyvsp[(3) - (7)]));
3172 if (arglen < 2) {
3173 nilnode1 = newPyrPushLitNode(newPyrSlotNode(&nilSlot), NULL);
3174 args = linkNextNode(args, nilnode1);
3175 }
3176 args = linkNextNode(args, nilnode2);
3177 args = linkNextNode(args, (PyrParseNode*)(yyvsp[(7) - (7)]));
3178 (yyval) = (long)newPyrCallNode(selectornode, args, 0, 0);
3179 ;}
3180 break;
3181
3182 case 106:
3183
3184 /* Line 1455 of yacc.c */
3185 #line 710 "lang11d"
3186 {
3187 PyrSlotNode *selectornode;
3188 PyrPushLitNode *nilnode1, *nilnode2;
3189 PyrSlot selectorSlot, nilSlot;
3190 PyrParseNode* args;
3191
3192 SetNil(&nilSlot);
3193 nilnode1 = newPyrPushLitNode(newPyrSlotNode(&nilSlot), NULL);
3194 nilnode2 = newPyrPushLitNode(newPyrSlotNode(&nilSlot), NULL);
3195
3196 SetSymbol(&selectorSlot, s_putseries);
3197 selectornode = newPyrSlotNode(&selectorSlot);
3198 args = linkNextNode((PyrParseNode*)(yyvsp[(1) - (7)]), nilnode1);
3199 args = linkNextNode(args, nilnode2);
3200 args = linkNextNode(args, (PyrParseNode*)(yyvsp[(4) - (7)]));
3201 args = linkNextNode(args, (PyrParseNode*)(yyvsp[(7) - (7)]));
3202 (yyval) = (long)newPyrCallNode(selectornode, args, 0, 0);
3203 ;}
3204 break;
3205
3206 case 107:
3207
3208 /* Line 1455 of yacc.c */
3209 #line 729 "lang11d"
3210 {
3211 PyrSlotNode *selectornode;
3212 PyrPushLitNode *nilnode1;
3213 PyrSlot selectorSlot, nilSlot;
3214 PyrParseNode* args;
3215
3216 int arglen = nodeListLength((PyrParseNode*)(yyvsp[(3) - (8)]));
3217 if (arglen > 2) {
3218 error("ArrayedCollection subrange has too many arguments.\n");
3219 nodePostErrorLine((PyrParseNode*)(yyvsp[(3) - (8)]));
3220 compileErrors++;
3221 }
3222
3223 SetSymbol(&selectorSlot, s_putseries);
3224 selectornode = newPyrSlotNode(&selectorSlot);
3225 args = linkNextNode((PyrParseNode*)(yyvsp[(1) - (8)]), (PyrParseNode*)(yyvsp[(3) - (8)]));
3226 if (arglen < 2) {
3227 SetNil(&nilSlot);
3228 nilnode1 = newPyrPushLitNode(newPyrSlotNode(&nilSlot), NULL);
3229 args = linkNextNode(args, nilnode1);
3230 }
3231 args = linkNextNode(args, (PyrParseNode*)(yyvsp[(5) - (8)]));
3232 args = linkNextNode(args, (PyrParseNode*)(yyvsp[(8) - (8)]));
3233 (yyval) = (long)newPyrCallNode(selectornode, args, 0, 0);
3234 ;}
3235 break;
3236
3237 case 108:
3238
3239 /* Line 1455 of yacc.c */
3240 #line 757 "lang11d"
3241 {
3242 PyrSlotNode *selectornode;
3243 PyrPushLitNode *nilnode1, *nilnode2;
3244 PyrSlot selectorSlot, nilSlot;
3245 PyrParseNode* args;
3246
3247 int arglen = nodeListLength((PyrParseNode*)(yyvsp[(4) - (6)]));
3248 if (arglen > 2) {
3249 error("ArrayedCollection subrange has too many arguments.\n");
3250 nodePostErrorLine((PyrParseNode*)(yyvsp[(3) - (6)]));
3251 compileErrors++;
3252 }
3253
3254 SetNil(&nilSlot);
3255 nilnode2 = newPyrPushLitNode(newPyrSlotNode(&nilSlot), NULL);
3256
3257 SetSymbol(&selectorSlot, s_copyseries);
3258 selectornode = newPyrSlotNode(&selectorSlot);
3259 args = linkNextNode((PyrParseNode*)(yyvsp[(1) - (6)]), (PyrParseNode*)(yyvsp[(4) - (6)]));
3260 if (arglen < 2) {
3261 nilnode1 = newPyrPushLitNode(newPyrSlotNode(&nilSlot), NULL);
3262 args = linkNextNode(args, nilnode1);
3263 }
3264 args = linkNextNode(args, nilnode2);
3265 (yyval) = (long)newPyrCallNode(selectornode, args, 0, 0);
3266 ;}
3267 break;
3268
3269 case 109:
3270
3271 /* Line 1455 of yacc.c */
3272 #line 784 "lang11d"
3273 {
3274 PyrSlotNode *selectornode;
3275 PyrPushLitNode *nilnode1, *nilnode2;
3276 PyrSlot selectorSlot, nilSlot;
3277 PyrParseNode* args;
3278
3279 SetNil(&nilSlot);
3280 nilnode1 = newPyrPushLitNode(newPyrSlotNode(&nilSlot), NULL);
3281 nilnode2 = newPyrPushLitNode(newPyrSlotNode(&nilSlot), NULL);
3282
3283 SetSymbol(&selectorSlot, s_copyseries);
3284 selectornode = newPyrSlotNode(&selectorSlot);
3285 args = linkNextNode((PyrParseNode*)(yyvsp[(1) - (6)]), nilnode1);
3286 args = linkNextNode(args, nilnode2);
3287 args = linkNextNode(args, (PyrParseNode*)(yyvsp[(5) - (6)]));
3288 (yyval) = (long)newPyrCallNode(selectornode, args, 0, 0);
3289 ;}
3290 break;
3291
3292 case 110:
3293
3294 /* Line 1455 of yacc.c */
3295 #line 802 "lang11d"
3296 {
3297 PyrSlotNode *selectornode;
3298 PyrPushLitNode *nilnode1;
3299 PyrSlot selectorSlot, nilSlot;
3300 PyrParseNode* args;
3301
3302 int arglen = nodeListLength((PyrParseNode*)(yyvsp[(4) - (7)]));
3303 if (arglen > 2) {
3304 error("ArrayedCollection subrange has too many arguments.\n");
3305 nodePostErrorLine((PyrParseNode*)(yyvsp[(3) - (7)]));
3306 compileErrors++;
3307 }
3308
3309 SetSymbol(&selectorSlot, s_copyseries);
3310 selectornode = newPyrSlotNode(&selectorSlot);
3311 args = linkNextNode((PyrParseNode*)(yyvsp[(1) - (7)]), (PyrParseNode*)(yyvsp[(4) - (7)]));
3312 if (arglen < 2) {
3313 SetNil(&nilSlot);
3314 nilnode1 = newPyrPushLitNode(newPyrSlotNode(&nilSlot), NULL);
3315 args = linkNextNode(args, nilnode1);
3316 }
3317 args = linkNextNode(args, (PyrParseNode*)(yyvsp[(6) - (7)]));
3318 (yyval) = (long)newPyrCallNode(selectornode, args, 0, 0);
3319 ;}
3320 break;
3321
3322 case 111:
3323
3324 /* Line 1455 of yacc.c */
3325 #line 827 "lang11d"
3326 {
3327 PyrSlotNode *selectornode;
3328 PyrPushLitNode *nilnode1, *nilnode2;
3329 PyrSlot selectorSlot, nilSlot;
3330 PyrParseNode* args;
3331
3332 int arglen = nodeListLength((PyrParseNode*)(yyvsp[(4) - (8)]));
3333 if (arglen > 2) {
3334 error("ArrayedCollection subrange has too many arguments.\n");
3335 nodePostErrorLine((PyrParseNode*)(yyvsp[(3) - (8)]));
3336 compileErrors++;
3337 }
3338
3339 SetNil(&nilSlot);
3340 nilnode2 = newPyrPushLitNode(newPyrSlotNode(&nilSlot), NULL);
3341
3342 SetSymbol(&selectorSlot, s_putseries);
3343 selectornode = newPyrSlotNode(&selectorSlot);
3344 args = linkNextNode((PyrParseNode*)(yyvsp[(1) - (8)]), (PyrParseNode*)(yyvsp[(4) - (8)]));
3345 if (arglen < 2) {
3346 nilnode1 = newPyrPushLitNode(newPyrSlotNode(&nilSlot), NULL);
3347 args = linkNextNode(args, nilnode1);
3348 }
3349 args = linkNextNode(args, nilnode2);
3350 args = linkNextNode(args, (PyrParseNode*)(yyvsp[(8) - (8)]));
3351 (yyval) = (long)newPyrCallNode(selectornode, args, 0, 0);
3352 ;}
3353 break;
3354
3355 case 112:
3356
3357 /* Line 1455 of yacc.c */
3358 #line 855 "lang11d"
3359 {
3360 PyrSlotNode *selectornode;
3361 PyrPushLitNode *nilnode1, *nilnode2;
3362 PyrSlot selectorSlot, nilSlot;
3363 PyrParseNode* args;
3364
3365 SetNil(&nilSlot);
3366 nilnode1 = newPyrPushLitNode(newPyrSlotNode(&nilSlot), NULL);
3367 nilnode2 = newPyrPushLitNode(newPyrSlotNode(&nilSlot), NULL);
3368
3369 SetSymbol(&selectorSlot, s_putseries);
3370 selectornode = newPyrSlotNode(&selectorSlot);
3371 args = linkNextNode((PyrParseNode*)(yyvsp[(1) - (8)]), nilnode1);
3372 args = linkNextNode(args, nilnode2);
3373 args = linkNextNode(args, (PyrParseNode*)(yyvsp[(5) - (8)]));
3374 args = linkNextNode(args, (PyrParseNode*)(yyvsp[(8) - (8)]));
3375 (yyval) = (long)newPyrCallNode(selectornode, args, 0, 0);
3376 ;}
3377 break;
3378
3379 case 113:
3380
3381 /* Line 1455 of yacc.c */
3382 #line 874 "lang11d"
3383 {
3384 PyrSlotNode *selectornode;
3385 PyrPushLitNode *nilnode1;
3386 PyrSlot selectorSlot, nilSlot;
3387 PyrParseNode* args;
3388
3389 int arglen = nodeListLength((PyrParseNode*)(yyvsp[(4) - (9)]));
3390 if (arglen > 2) {
3391 error("ArrayedCollection subrange has too many arguments.\n");
3392 nodePostErrorLine((PyrParseNode*)(yyvsp[(3) - (9)]));
3393 compileErrors++;
3394 }
3395
3396 SetSymbol(&selectorSlot, s_putseries);
3397 selectornode = newPyrSlotNode(&selectorSlot);
3398 args = linkNextNode((PyrParseNode*)(yyvsp[(1) - (9)]), (PyrParseNode*)(yyvsp[(4) - (9)]));
3399 if (arglen < 2) {
3400 SetNil(&nilSlot);
3401 nilnode1 = newPyrPushLitNode(newPyrSlotNode(&nilSlot), NULL);
3402 args = linkNextNode(args, nilnode1);
3403 }
3404 args = linkNextNode(args, (PyrParseNode*)(yyvsp[(6) - (9)]));
3405 args = linkNextNode(args, (PyrParseNode*)(yyvsp[(9) - (9)]));
3406 (yyval) = (long)newPyrCallNode(selectornode, args, 0, 0);
3407 ;}
3408 break;
3409
3410 case 114:
3411
3412 /* Line 1455 of yacc.c */
3413 #line 902 "lang11d"
3414 {
3415 // if this is not used in a 'do' or list comprehension, then should return an error.
3416 PyrSlotNode *selectornode;
3417 PyrPushLitNode *nilnode, *nilnode2;
3418 PyrSlot selectorSlot, nilSlot;
3419 PyrParseNode* args;
3420
3421 SetNil(&nilSlot);
3422 nilnode = newPyrPushLitNode(newPyrSlotNode(&nilSlot), NULL);
3423 nilnode2 = newPyrPushLitNode(newPyrSlotNode(&nilSlot), NULL);
3424
3425 SetSymbol(&selectorSlot, s_series);
3426 selectornode = newPyrSlotNode(&selectorSlot);
3427 args = linkNextNode((PyrParseNode*)(yyvsp[(1) - (2)]), nilnode);
3428 args = linkNextNode(args, nilnode2);
3429 (yyval) = (long)newPyrCallNode(selectornode, args, 0, 0);
3430 ;}
3431 break;
3432
3433 case 115:
3434
3435 /* Line 1455 of yacc.c */
3436 #line 921 "lang11d"
3437 {
3438 PyrSlotNode *selectornode;
3439 PyrPushLitNode *nilnode, *zeronode;
3440 PyrSlot selectorSlot, nilSlot, zeroSlot;
3441 PyrParseNode* args;
3442
3443 SetInt(&zeroSlot, 0);
3444 SetNil(&nilSlot);
3445 nilnode = newPyrPushLitNode(newPyrSlotNode(&nilSlot), NULL);
3446 zeronode = newPyrPushLitNode(newPyrSlotNode(&zeroSlot), NULL);
3447
3448 SetSymbol(&selectorSlot, s_series);
3449 selectornode = newPyrSlotNode(&selectorSlot);
3450 args = linkNextNode(zeronode, nilnode);
3451 args = linkNextNode(args, (PyrParseNode*)(yyvsp[(2) - (2)]));
3452 (yyval) = (long)newPyrCallNode(selectornode, args, 0, 0);
3453 ;}
3454 break;
3455
3456 case 116:
3457
3458 /* Line 1455 of yacc.c */
3459 #line 940 "lang11d"
3460 {
3461 PyrSlotNode *selectornode;
3462 PyrPushLitNode *nilnode;
3463 PyrSlot selectorSlot, nilSlot;
3464 PyrParseNode* args;
3465
3466 SetNil(&nilSlot);
3467 nilnode = newPyrPushLitNode(newPyrSlotNode(&nilSlot), NULL);
3468
3469 SetSymbol(&selectorSlot, s_series);
3470 selectornode = newPyrSlotNode(&selectorSlot);
3471 args = linkNextNode((PyrParseNode*)(yyvsp[(1) - (3)]), nilnode);
3472 args = linkNextNode(args, (PyrParseNode*)(yyvsp[(3) - (3)]));
3473 (yyval) = (long)newPyrCallNode(selectornode, args, 0, 0);
3474 ;}
3475 break;
3476
3477 case 117:
3478
3479 /* Line 1455 of yacc.c */
3480 #line 957 "lang11d"
3481 {
3482 PyrSlotNode *selectornode;
3483 PyrSlot selectorSlot;
3484 PyrParseNode* args;
3485
3486 SetSymbol(&selectorSlot, s_series);
3487 selectornode = newPyrSlotNode(&selectorSlot);
3488 args = linkNextNode(
3489 (PyrParseNode*)(yyvsp[(1) - (5)]),
3490 (PyrParseNode*)(yyvsp[(3) - (5)]));
3491 args = linkNextNode(args, (PyrParseNode*)(yyvsp[(5) - (5)]));
3492 (yyval) = (long)newPyrCallNode(selectornode, args, 0, 0);
3493 ;}
3494 break;
3495
3496 case 118:
3497
3498 /* Line 1455 of yacc.c */
3499 #line 971 "lang11d"
3500 {
3501 // if this is not used in a 'do' or list comprehension, then should return an error.
3502 PyrSlotNode *selectornode;
3503 PyrSlot selectorSlot, nilSlot;
3504 PyrParseNode* args;
3505 PyrPushLitNode *nilnode;
3506
3507 SetNil(&nilSlot);
3508 nilnode = newPyrPushLitNode(newPyrSlotNode(&nilSlot), NULL);
3509
3510 SetSymbol(&selectorSlot, s_series);
3511 selectornode = newPyrSlotNode(&selectorSlot);
3512 args = linkNextNode(
3513 (PyrParseNode*)(yyvsp[(1) - (4)]),
3514 (PyrParseNode*)(yyvsp[(3) - (4)]));
3515 args = linkNextNode(args, nilnode);
3516 (yyval) = (long)newPyrCallNode(selectornode, args, 0, 0);
3517 ;}
3518 break;
3519
3520 case 119:
3521
3522 /* Line 1455 of yacc.c */
3523 #line 992 "lang11d"
3524 {
3525 PyrSlotNode *selectornode;
3526 PyrPushLitNode *nilnode, *zeronode;
3527 PyrSlot selectorSlot, nilSlot, zeroSlot;
3528 PyrParseNode* args;
3529
3530 SetInt(&zeroSlot, 0);
3531 SetNil(&nilSlot);
3532 nilnode = newPyrPushLitNode(newPyrSlotNode(&nilSlot), NULL);
3533 zeronode = newPyrPushLitNode(newPyrSlotNode(&zeroSlot), NULL);
3534
3535 SetSymbol(&selectorSlot, getsym("seriesIter"));
3536 selectornode = newPyrSlotNode(&selectorSlot);
3537 args = linkNextNode(zeronode, nilnode);
3538 args = linkNextNode(args, (PyrParseNode*)(yyvsp[(2) - (2)]));
3539 (yyval) = (long)newPyrCallNode(selectornode, args, 0, 0);
3540 ;}
3541 break;
3542
3543 case 120:
3544
3545 /* Line 1455 of yacc.c */
3546 #line 1011 "lang11d"
3547 {
3548 PyrSlotNode *selectornode;
3549 PyrPushLitNode *nilnode, *nilnode2;
3550 PyrSlot selectorSlot, nilSlot;
3551 PyrParseNode* args;
3552
3553 SetNil(&nilSlot);
3554 nilnode = newPyrPushLitNode(newPyrSlotNode(&nilSlot), NULL);
3555 nilnode2 = newPyrPushLitNode(newPyrSlotNode(&nilSlot), NULL);
3556
3557 SetSymbol(&selectorSlot, getsym("seriesIter"));
3558 selectornode = newPyrSlotNode(&selectorSlot);
3559 args = linkNextNode((PyrParseNode*)(yyvsp[(1) - (2)]), nilnode);
3560 args = linkNextNode(args, nilnode2);
3561 (yyval) = (long)newPyrCallNode(selectornode, args, 0, 0);
3562 ;}
3563 break;
3564
3565 case 121:
3566
3567 /* Line 1455 of yacc.c */
3568 #line 1029 "lang11d"
3569 {
3570 PyrSlotNode *selectornode;
3571 PyrPushLitNode *nilnode;
3572 PyrSlot selectorSlot, nilSlot;
3573 PyrParseNode* args;
3574
3575 SetNil(&nilSlot);
3576 nilnode = newPyrPushLitNode(newPyrSlotNode(&nilSlot), NULL);
3577
3578 SetSymbol(&selectorSlot, getsym("seriesIter"));
3579 selectornode = newPyrSlotNode(&selectorSlot);
3580 args = linkNextNode((PyrParseNode*)(yyvsp[(1) - (3)]), nilnode);
3581 args = linkNextNode(args, (PyrParseNode*)(yyvsp[(3) - (3)]));
3582 (yyval) = (long)newPyrCallNode(selectornode, args, 0, 0);
3583 ;}
3584 break;
3585
3586 case 122:
3587
3588 /* Line 1455 of yacc.c */
3589 #line 1046 "lang11d"
3590 {
3591 PyrSlotNode *selectornode;
3592 PyrPushLitNode *nilnode;
3593 PyrSlot selectorSlot, nilSlot;
3594 PyrParseNode* args;
3595
3596 SetNil(&nilSlot);
3597 nilnode = newPyrPushLitNode(newPyrSlotNode(&nilSlot), NULL);
3598
3599 SetSymbol(&selectorSlot, getsym("seriesIter"));
3600 selectornode = newPyrSlotNode(&selectorSlot);
3601 args = linkNextNode((PyrParseNode*)(yyvsp[(1) - (4)]), (PyrParseNode*)(yyvsp[(3) - (4)]));
3602 args = linkNextNode(args, nilnode);
3603 (yyval) = (long)newPyrCallNode(selectornode, args, 0, 0);
3604 ;}
3605 break;
3606
3607 case 123:
3608
3609 /* Line 1455 of yacc.c */
3610 #line 1062 "lang11d"
3611 {
3612 PyrSlotNode *selectornode;
3613 PyrSlot selectorSlot;
3614 PyrParseNode* args;
3615
3616 SetSymbol(&selectorSlot, getsym("seriesIter"));
3617 selectornode = newPyrSlotNode(&selectorSlot);
3618 args = linkNextNode(
3619 (PyrParseNode*)(yyvsp[(1) - (5)]),
3620 (PyrParseNode*)(yyvsp[(3) - (5)]));
3621 args = linkNextNode(args, (PyrParseNode*)(yyvsp[(5) - (5)]));
3622 (yyval) = (long)newPyrCallNode(selectornode, args, 0, 0);
3623 ;}
3624 break;
3625
3626 case 127:
3627
3628 /* Line 1455 of yacc.c */
3629 #line 1080 "lang11d"
3630 { (yyval) = (long)newPyrPushNameNode((PyrSlotNode*)(yyvsp[(1) - (1)])); ;}
3631 break;
3632
3633 case 128:
3634
3635 /* Line 1455 of yacc.c */
3636 #line 1082 "lang11d"
3637 {
3638 PyrSlotNode *selectornode;
3639 PyrSlot slot;
3640 PyrParseNode* args;
3641
3642 SetSymbol(&slot, s_at);
3643 selectornode = newPyrSlotNode(&slot);
3644 args = linkNextNode(
3645 (PyrParseNode*)(yyvsp[(1) - (5)]),
3646 (PyrParseNode*)(yyvsp[(4) - (5)]));
3647 (yyval) = (long)newPyrCallNode(selectornode, args, 0, 0);
3648 ;}
3649 break;
3650
3651 case 129:
3652
3653 /* Line 1455 of yacc.c */
3654 #line 1095 "lang11d"
3655 {
3656 PyrParseNode *node, *args;
3657 PyrSlotNode *slotnode;
3658 PyrSlot slot;
3659
3660 SetSymbol(&slot, s_ref);
3661 slotnode = newPyrSlotNode(&slot);
3662 node = (PyrParseNode*)newPyrPushNameNode(slotnode);
3663 args = linkNextNode(node, (PyrParseNode*)(yyvsp[(2) - (2)]));
3664 SetSymbol(&slot, s_new);
3665 slotnode = newPyrSlotNode(&slot);
3666 (yyval) = (long)newPyrCallNode(slotnode, args, 0, 0);
3667 ;}
3668 break;
3669
3670 case 130:
3671
3672 /* Line 1455 of yacc.c */
3673 #line 1109 "lang11d"
3674 {
3675 (yyval) = (long)newPyrBinopCallNode((PyrSlotNode*)(yyvsp[(2) - (4)]),
3676 (PyrParseNode*)(yyvsp[(1) - (4)]), (PyrParseNode*)(yyvsp[(4) - (4)]), (PyrParseNode*)(yyvsp[(3) - (4)]));
3677 ;}
3678 break;
3679
3680 case 131:
3681
3682 /* Line 1455 of yacc.c */
3683 #line 1114 "lang11d"
3684 {
3685 (yyval) = (long)newPyrAssignNode((PyrSlotNode*)(yyvsp[(1) - (3)]), (PyrParseNode*)(yyvsp[(3) - (3)]), 0);
3686 ;}
3687 break;
3688
3689 case 132:
3690
3691 /* Line 1455 of yacc.c */
3692 #line 1118 "lang11d"
3693 {
3694 PyrParseNode *argnode, *args;
3695 PyrSlotNode* selectornode;
3696 PyrSlot slot;
3697 argnode = (PyrParseNode*)newPyrPushLitNode((PyrSlotNode*)(yyvsp[(2) - (4)]), NULL);
3698 args = linkNextNode(argnode, (PyrParseNode*)(yyvsp[(4) - (4)]));
3699 SetSymbol(&slot, s_envirPut);
3700 selectornode = newPyrSlotNode(&slot);
3701 (yyval) = (long)newPyrCallNode(selectornode, args, 0, 0);
3702 ;}
3703 break;
3704
3705 case 133:
3706
3707 /* Line 1455 of yacc.c */
3708 #line 1129 "lang11d"
3709 {
3710 (yyval) = (long)newPyrSetterNode((PyrSlotNode*)(yyvsp[(3) - (5)]),
3711 (PyrParseNode*)(yyvsp[(1) - (5)]), (PyrParseNode*)(yyvsp[(5) - (5)]));
3712 ;}
3713 break;
3714
3715 case 134:
3716
3717 /* Line 1455 of yacc.c */
3718 #line 1134 "lang11d"
3719 {
3720 if ((yyvsp[(4) - (7)]) != 0) {
3721 error("Setter method called with keyword arguments.\n");
3722 nodePostErrorLine((PyrParseNode*)(yyvsp[(4) - (7)]));
3723 compileErrors++;
3724 }
3725 (yyval) = (long)newPyrSetterNode((PyrSlotNode*)(yyvsp[(1) - (7)]),
3726 (PyrParseNode*)(yyvsp[(3) - (7)]), (PyrParseNode*)(yyvsp[(7) - (7)]));
3727 ;}
3728 break;
3729
3730 case 135:
3731
3732 /* Line 1455 of yacc.c */
3733 #line 1144 "lang11d"
3734 {
3735 (yyval) = (long)newPyrMultiAssignNode((PyrMultiAssignVarListNode*)(yyvsp[(2) - (4)]),
3736 (PyrParseNode*)(yyvsp[(4) - (4)]), 0);
3737 ;}
3738 break;
3739
3740 case 136:
3741
3742 /* Line 1455 of yacc.c */
3743 #line 1149 "lang11d"
3744 {
3745 PyrSlotNode *selectornode;
3746 PyrSlot slot;
3747 PyrParseNode* args;
3748
3749 SetSymbol(&slot, s_put);
3750 selectornode = newPyrSlotNode(&slot);
3751 args = linkNextNode(
3752 (PyrParseNode*)(yyvsp[(1) - (6)]),
3753 (PyrParseNode*)(yyvsp[(3) - (6)]));
3754 args = linkNextNode( args, (PyrParseNode*)(yyvsp[(6) - (6)]));
3755 (yyval) = (long)newPyrCallNode(selectornode, args, 0, 0);
3756 ;}
3757 break;
3758
3759 case 137:
3760
3761 /* Line 1455 of yacc.c */
3762 #line 1163 "lang11d"
3763 {
3764 PyrSlotNode *selectornode;
3765 PyrSlot slot;
3766 PyrParseNode* args;
3767
3768 SetSymbol(&slot, s_put);
3769 selectornode = newPyrSlotNode(&slot);
3770 args = linkNextNode(
3771 (PyrParseNode*)(yyvsp[(1) - (7)]),
3772 (PyrParseNode*)(yyvsp[(4) - (7)]));
3773 args = linkNextNode( args, (PyrParseNode*)(yyvsp[(7) - (7)]));
3774 (yyval) = (long)newPyrCallNode(selectornode, args, 0, 0);
3775 ;}
3776 break;
3777
3778 case 138:
3779
3780 /* Line 1455 of yacc.c */
3781 #line 1178 "lang11d"
3782 { (yyval) = 0; ;}
3783 break;
3784
3785 case 139:
3786
3787 /* Line 1455 of yacc.c */
3788 #line 1179 "lang11d"
3789 { (yyval) = (long)newPyrPushLitNode((PyrSlotNode*)(yyvsp[(2) - (2)]), NULL); ;}
3790 break;
3791
3792 case 140:
3793
3794 /* Line 1455 of yacc.c */
3795 #line 1180 "lang11d"
3796 { (yyval) = (long)newPyrPushLitNode((PyrSlotNode*)(yyvsp[(2) - (2)]), NULL); ;}
3797 break;
3798
3799 case 141:
3800
3801 /* Line 1455 of yacc.c */
3802 #line 1181 "lang11d"
3803 { (yyval) = (yyvsp[(3) - (4)]); ;}
3804 break;
3805
3806 case 143:
3807
3808 /* Line 1455 of yacc.c */
3809 #line 1186 "lang11d"
3810 {
3811 (yyval) = (long)newPyrDropNode((PyrParseNode*)(yyvsp[(1) - (3)]), (PyrParseNode*)(yyvsp[(3) - (3)]));
3812 ;}
3813 break;
3814
3815 case 145:
3816
3817 /* Line 1455 of yacc.c */
3818 #line 1194 "lang11d"
3819 { (yyval) = 0; ;}
3820 break;
3821
3822 case 146:
3823
3824 /* Line 1455 of yacc.c */
3825 #line 1196 "lang11d"
3826 { (yyval) = (yyvsp[(1) - (2)]); ;}
3827 break;
3828
3829 case 148:
3830
3831 /* Line 1455 of yacc.c */
3832 #line 1201 "lang11d"
3833 { (yyval) = (long)linkNextNode((PyrParseNode*)(yyvsp[(1) - (3)]), (PyrParseNode*)(yyvsp[(3) - (3)])); ;}
3834 break;
3835
3836 case 149:
3837
3838 /* Line 1455 of yacc.c */
3839 #line 1203 "lang11d"
3840 {
3841 PyrParseNode* key = newPyrPushLitNode((PyrSlotNode*)(yyvsp[(1) - (2)]), NULL);
3842 (yyval) = (long)linkNextNode(key, (PyrParseNode*)(yyvsp[(2) - (2)]));
3843 ;}
3844 break;
3845
3846 case 150:
3847
3848 /* Line 1455 of yacc.c */
3849 #line 1208 "lang11d"
3850 { (yyval) = (long)linkNextNode((PyrParseNode*)(yyvsp[(1) - (3)]), (PyrParseNode*)(yyvsp[(3) - (3)])); ;}
3851 break;
3852
3853 case 151:
3854
3855 /* Line 1455 of yacc.c */
3856 #line 1210 "lang11d"
3857 {
3858 PyrParseNode* elems;
3859 PyrParseNode* key = newPyrPushLitNode((PyrSlotNode*)(yyvsp[(3) - (4)]), NULL);
3860 elems = (PyrParseNode*)linkNextNode(key, (PyrParseNode*)(yyvsp[(4) - (4)]));
3861 (yyval) = (long)linkNextNode((PyrParseNode*)(yyvsp[(1) - (4)]), elems);
3862 ;}
3863 break;
3864
3865 case 152:
3866
3867 /* Line 1455 of yacc.c */
3868 #line 1217 "lang11d"
3869 {
3870 PyrParseNode* elems;
3871 elems = (PyrParseNode*)linkNextNode((PyrParseNode*)(yyvsp[(3) - (5)]), (PyrParseNode*)(yyvsp[(5) - (5)]));
3872 (yyval) = (long)linkNextNode((PyrParseNode*)(yyvsp[(1) - (5)]), elems);
3873 ;}
3874 break;
3875
3876 case 154:
3877
3878 /* Line 1455 of yacc.c */
3879 #line 1226 "lang11d"
3880 { (yyval) = (long)linkNextNode((PyrParseNode*)(yyvsp[(1) - (3)]), (PyrParseNode*)(yyvsp[(3) - (3)])); ;}
3881 break;
3882
3883 case 155:
3884
3885 /* Line 1455 of yacc.c */
3886 #line 1230 "lang11d"
3887 { (yyval) = (yyvsp[(2) - (2)]); ;}
3888 break;
3889
3890 case 156:
3891
3892 /* Line 1455 of yacc.c */
3893 #line 1232 "lang11d"
3894 { (yyval) = (long)linkNextNode((PyrParseNode*)(yyvsp[(1) - (4)]), (PyrParseNode*)(yyvsp[(4) - (4)])); ;}
3895 break;
3896
3897 case 158:
3898
3899 /* Line 1455 of yacc.c */
3900 #line 1237 "lang11d"
3901 { (yyval) = (long)linkNextNode((PyrParseNode*)(yyvsp[(1) - (3)]), (PyrParseNode*)(yyvsp[(3) - (3)])); ;}
3902 break;
3903
3904 case 159:
3905
3906 /* Line 1455 of yacc.c */
3907 #line 1241 "lang11d"
3908 { (yyval) = (long)newPyrPushKeyArgNode((PyrSlotNode*)(yyvsp[(1) - (2)]), (PyrParseNode*)(yyvsp[(2) - (2)])); ;}
3909 break;
3910
3911 case 160:
3912
3913 /* Line 1455 of yacc.c */
3914 #line 1244 "lang11d"
3915 { (yyval) = 0; ;}
3916 break;
3917
3918 case 161:
3919
3920 /* Line 1455 of yacc.c */
3921 #line 1245 "lang11d"
3922 { (yyval) = (yyvsp[(2) - (2)]); ;}
3923 break;
3924
3925 case 162:
3926
3927 /* Line 1455 of yacc.c */
3928 #line 1249 "lang11d"
3929 { (yyval) = (long)newPyrMultiAssignVarListNode((PyrSlotNode*)(yyvsp[(1) - (1)]), NULL); ;}
3930 break;
3931
3932 case 163:
3933
3934 /* Line 1455 of yacc.c */
3935 #line 1251 "lang11d"
3936 { (yyval) = (long)newPyrMultiAssignVarListNode((PyrSlotNode*)(yyvsp[(1) - (3)]), (PyrSlotNode*)(yyvsp[(3) - (3)])); ;}
3937 break;
3938
3939 case 165:
3940
3941 /* Line 1455 of yacc.c */
3942 #line 1256 "lang11d"
3943 { (yyval) = (long)linkNextNode((PyrParseNode*)(yyvsp[(1) - (3)]), (PyrParseNode*)(yyvsp[(3) - (3)])); ;}
3944 break;
3945
3946 case 166:
3947
3948 /* Line 1455 of yacc.c */
3949 #line 1260 "lang11d"
3950 { (yyval) = (long)newPyrLiteralNode((PyrSlotNode*)(yyvsp[(1) - (1)]), NULL); ;}
3951 break;
3952
3953 case 167:
3954
3955 /* Line 1455 of yacc.c */
3956 #line 1261 "lang11d"
3957 { (yyval) = (long)newPyrLiteralNode((PyrSlotNode*)(yyvsp[(1) - (1)]), NULL); ;}
3958 break;
3959
3960 case 168:
3961
3962 /* Line 1455 of yacc.c */
3963 #line 1262 "lang11d"
3964 { (yyval) = (long)newPyrLiteralNode((PyrSlotNode*)(yyvsp[(1) - (1)]), NULL); ;}
3965 break;
3966
3967 case 169:
3968
3969 /* Line 1455 of yacc.c */
3970 #line 1263 "lang11d"
3971 { (yyval) = (long)newPyrLiteralNode((PyrSlotNode*)(yyvsp[(1) - (1)]), NULL); ;}
3972 break;
3973
3974 case 170:
3975
3976 /* Line 1455 of yacc.c */
3977 #line 1264 "lang11d"
3978 { (yyval) = (long)newPyrLiteralNode((PyrSlotNode*)(yyvsp[(1) - (1)]), NULL); ;}
3979 break;
3980
3981 case 171:
3982
3983 /* Line 1455 of yacc.c */
3984 #line 1265 "lang11d"
3985 { (yyval) = (long)newPyrLiteralNode((PyrSlotNode*)(yyvsp[(1) - (1)]), NULL); ;}
3986 break;
3987
3988 case 172:
3989
3990 /* Line 1455 of yacc.c */
3991 #line 1266 "lang11d"
3992 { (yyval) = (long)newPyrLiteralNode((PyrSlotNode*)(yyvsp[(1) - (1)]), NULL); ;}
3993 break;
3994
3995 case 173:
3996
3997 /* Line 1455 of yacc.c */
3998 #line 1267 "lang11d"
3999 { (yyval) = (long)newPyrLiteralNode((PyrSlotNode*)(yyvsp[(1) - (1)]), NULL); ;}
4000 break;
4001
4002 case 174:
4003
4004 /* Line 1455 of yacc.c */
4005 #line 1268 "lang11d"
4006 { (yyval) = (long)newPyrLiteralNode(NULL, (PyrParseNode*)(yyvsp[(1) - (1)])); ;}
4007 break;
4008
4009 case 175:
4010
4011 /* Line 1455 of yacc.c */
4012 #line 1269 "lang11d"
4013 { (yyval) = (long)newPyrLiteralNode(NULL, (PyrParseNode*)(yyvsp[(1) - (1)])); ;}
4014 break;
4015
4016 case 176:
4017
4018 /* Line 1455 of yacc.c */
4019 #line 1272 "lang11d"
4020 { (yyval) = (long)newPyrPushLitNode(NULL, (PyrParseNode*)(yyvsp[(1) - (1)])); ;}
4021 break;
4022
4023 case 177:
4024
4025 /* Line 1455 of yacc.c */
4026 #line 1275 "lang11d"
4027 { (yyval) = (long)newPyrPushNameNode((PyrSlotNode*)(yyvsp[(1) - (1)])); ;}
4028 break;
4029
4030 case 178:
4031
4032 /* Line 1455 of yacc.c */
4033 #line 1278 "lang11d"
4034 { (yyval) = (long)newPyrPushLitNode((PyrSlotNode*)(yyvsp[(1) - (1)]), NULL); ;}
4035 break;
4036
4037 case 179:
4038
4039 /* Line 1455 of yacc.c */
4040 #line 1279 "lang11d"
4041 { (yyval) = (long)newPyrPushLitNode((PyrSlotNode*)(yyvsp[(1) - (1)]), NULL); ;}
4042 break;
4043
4044 case 180:
4045
4046 /* Line 1455 of yacc.c */
4047 #line 1280 "lang11d"
4048 { (yyval) = (long)newPyrPushLitNode((PyrSlotNode*)(yyvsp[(1) - (1)]), NULL); ;}
4049 break;
4050
4051 case 181:
4052
4053 /* Line 1455 of yacc.c */
4054 #line 1281 "lang11d"
4055 { (yyval) = (long)newPyrPushLitNode((PyrSlotNode*)(yyvsp[(1) - (1)]), NULL); ;}
4056 break;
4057
4058 case 182:
4059
4060 /* Line 1455 of yacc.c */
4061 #line 1282 "lang11d"
4062 { (yyval) = (long)newPyrPushLitNode((PyrSlotNode*)(yyvsp[(1) - (1)]), NULL); ;}
4063 break;
4064
4065 case 183:
4066
4067 /* Line 1455 of yacc.c */
4068 #line 1283 "lang11d"
4069 { (yyval) = (long)newPyrPushLitNode((PyrSlotNode*)(yyvsp[(1) - (1)]), NULL); ;}
4070 break;
4071
4072 case 184:
4073
4074 /* Line 1455 of yacc.c */
4075 #line 1284 "lang11d"
4076 { (yyval) = (long)newPyrPushLitNode((PyrSlotNode*)(yyvsp[(1) - (1)]), NULL); ;}
4077 break;
4078
4079 case 185:
4080
4081 /* Line 1455 of yacc.c */
4082 #line 1285 "lang11d"
4083 { (yyval) = (long)newPyrPushLitNode((PyrSlotNode*)(yyvsp[(1) - (1)]), NULL); ;}
4084 break;
4085
4086 case 186:
4087
4088 /* Line 1455 of yacc.c */
4089 #line 1286 "lang11d"
4090 { (yyval) = (long)newPyrPushLitNode(NULL, (PyrParseNode*)(yyvsp[(1) - (1)])); ;}
4091 break;
4092
4093 case 187:
4094
4095 /* Line 1455 of yacc.c */
4096 #line 1287 "lang11d"
4097 { (yyval) = (long)newPyrPushLitNode(NULL, (PyrParseNode*)(yyvsp[(1) - (1)])); ;}
4098 break;
4099
4100 case 188:
4101
4102 /* Line 1455 of yacc.c */
4103 #line 1290 "lang11d"
4104 { (yyval) = (long)newPyrLiteralNode((PyrSlotNode*)(yyvsp[(1) - (1)]), NULL); ;}
4105 break;
4106
4107 case 189:
4108
4109 /* Line 1455 of yacc.c */
4110 #line 1291 "lang11d"
4111 { (yyval) = (long)newPyrLiteralNode((PyrSlotNode*)(yyvsp[(1) - (1)]), NULL); ;}
4112 break;
4113
4114 case 190:
4115
4116 /* Line 1455 of yacc.c */
4117 #line 1292 "lang11d"
4118 { (yyval) = (long)newPyrLiteralNode((PyrSlotNode*)(yyvsp[(1) - (1)]), NULL); ;}
4119 break;
4120
4121 case 191:
4122
4123 /* Line 1455 of yacc.c */
4124 #line 1293 "lang11d"
4125 { (yyval) = (long)newPyrLiteralNode((PyrSlotNode*)(yyvsp[(1) - (1)]), NULL); ;}
4126 break;
4127
4128 case 192:
4129
4130 /* Line 1455 of yacc.c */
4131 #line 1294 "lang11d"
4132 { (yyval) = (long)newPyrLiteralNode((PyrSlotNode*)(yyvsp[(1) - (1)]), NULL); ;}
4133 break;
4134
4135 case 193:
4136
4137 /* Line 1455 of yacc.c */
4138 #line 1295 "lang11d"
4139 { (yyval) = (long)newPyrLiteralNode((PyrSlotNode*)(yyvsp[(1) - (1)]), NULL); ;}
4140 break;
4141
4142 case 194:
4143
4144 /* Line 1455 of yacc.c */
4145 #line 1296 "lang11d"
4146 { (yyval) = (long)newPyrLiteralNode((PyrSlotNode*)(yyvsp[(1) - (1)]), NULL); ;}
4147 break;
4148
4149 case 195:
4150
4151 /* Line 1455 of yacc.c */
4152 #line 1297 "lang11d"
4153 { (yyval) = (long)newPyrLiteralNode((PyrSlotNode*)(yyvsp[(1) - (1)]), NULL); ;}
4154 break;
4155
4156 case 196:
4157
4158 /* Line 1455 of yacc.c */
4159 #line 1298 "lang11d"
4160 { (yyval) = (long)newPyrLiteralNode((PyrSlotNode*)(yyvsp[(1) - (1)]), NULL); ;}
4161 break;
4162
4163 case 197:
4164
4165 /* Line 1455 of yacc.c */
4166 #line 1299 "lang11d"
4167 { (yyval) = (long)newPyrLiteralNode(NULL, (PyrParseNode*)(yyvsp[(1) - (1)])); ;}
4168 break;
4169
4170 case 198:
4171
4172 /* Line 1455 of yacc.c */
4173 #line 1300 "lang11d"
4174 { (yyval) = (long)newPyrLiteralNode(NULL, (PyrParseNode*)(yyvsp[(1) - (1)])); ;}
4175 break;
4176
4177 case 199:
4178
4179 /* Line 1455 of yacc.c */
4180 #line 1304 "lang11d"
4181 { (yyval) = (long)newPyrBlockNode((PyrArgListNode*)(yyvsp[(2) - (5)]), (PyrVarListNode*)(yyvsp[(3) - (5)]),
4182 (PyrParseNode*)(yyvsp[(4) - (5)]), false); ;}
4183 break;
4184
4185 case 200:
4186
4187 /* Line 1455 of yacc.c */
4188 #line 1307 "lang11d"
4189 { (yyval) = (long)newPyrBlockNode((PyrArgListNode*)(yyvsp[(2) - (5)]), (PyrVarListNode*)(yyvsp[(3) - (5)]),
4190 (PyrParseNode*)(yyvsp[(4) - (5)]), true); ;}
4191 break;
4192
4193 case 201:
4194
4195 /* Line 1455 of yacc.c */
4196 #line 1311 "lang11d"
4197 { (yyval) = 0; ;}
4198 break;
4199
4200 case 202:
4201
4202 /* Line 1455 of yacc.c */
4203 #line 1313 "lang11d"
4204 { (yyval) = (long)linkNextNode((PyrParseNode*)(yyvsp[(1) - (2)]), (PyrParseNode*)(yyvsp[(2) - (2)])); ;}
4205 break;
4206
4207 case 204:
4208
4209 /* Line 1455 of yacc.c */
4210 #line 1318 "lang11d"
4211 { (yyval) = (long)linkNextNode((PyrParseNode*)(yyvsp[(1) - (2)]), (PyrParseNode*)(yyvsp[(2) - (2)])); ;}
4212 break;
4213
4214 case 205:
4215
4216 /* Line 1455 of yacc.c */
4217 #line 1322 "lang11d"
4218 { (yyval) = (long)newPyrVarListNode((PyrVarDefNode*)(yyvsp[(2) - (3)]), varLocal); ;}
4219 break;
4220
4221 case 206:
4222
4223 /* Line 1455 of yacc.c */
4224 #line 1325 "lang11d"
4225 { (yyval) = 0; ;}
4226 break;
4227
4228 case 207:
4229
4230 /* Line 1455 of yacc.c */
4231 #line 1327 "lang11d"
4232 {
4233 (yyval) = (long)newPyrArgListNode((PyrVarDefNode*)(yyvsp[(2) - (3)]), NULL);
4234 ;}
4235 break;
4236
4237 case 208:
4238
4239 /* Line 1455 of yacc.c */
4240 #line 1331 "lang11d"
4241 {
4242 (yyval) = (long)newPyrArgListNode((PyrVarDefNode*)(yyvsp[(2) - (5)]), (PyrSlotNode*)(yyvsp[(4) - (5)]));
4243 ;}
4244 break;
4245
4246 case 209:
4247
4248 /* Line 1455 of yacc.c */
4249 #line 1335 "lang11d"
4250 {
4251 (yyval) = (long)newPyrArgListNode((PyrVarDefNode*)(yyvsp[(2) - (3)]), NULL);
4252 ;}
4253 break;
4254
4255 case 210:
4256
4257 /* Line 1455 of yacc.c */
4258 #line 1339 "lang11d"
4259 {
4260 (yyval) = (long)newPyrArgListNode((PyrVarDefNode*)(yyvsp[(2) - (5)]), (PyrSlotNode*)(yyvsp[(4) - (5)]));
4261 ;}
4262 break;
4263
4264 case 212:
4265
4266 /* Line 1455 of yacc.c */
4267 #line 1346 "lang11d"
4268 { (yyval) = (long)linkNextNode((PyrParseNode*)(yyvsp[(1) - (3)]), (PyrParseNode*)(yyvsp[(3) - (3)])); ;}
4269 break;
4270
4271 case 213:
4272
4273 /* Line 1455 of yacc.c */
4274 #line 1350 "lang11d"
4275 { (yyval) = (long)newPyrVarDefNode((PyrSlotNode*)(yyvsp[(2) - (4)]), (PyrParseNode*)(yyvsp[(4) - (4)]), (yyvsp[(1) - (4)])); ;}
4276 break;
4277
4278 case 214:
4279
4280 /* Line 1455 of yacc.c */
4281 #line 1353 "lang11d"
4282 { (yyval) = 0; ;}
4283 break;
4284
4285 case 217:
4286
4287 /* Line 1455 of yacc.c */
4288 #line 1359 "lang11d"
4289 { (yyval) = (long)linkNextNode((PyrParseNode*)(yyvsp[(1) - (3)]), (PyrParseNode*)(yyvsp[(3) - (3)])); ;}
4290 break;
4291
4292 case 218:
4293
4294 /* Line 1455 of yacc.c */
4295 #line 1363 "lang11d"
4296 { (yyval) = (long)newPyrVarDefNode((PyrSlotNode*)(yyvsp[(1) - (1)]), NULL, 0); ;}
4297 break;
4298
4299 case 219:
4300
4301 /* Line 1455 of yacc.c */
4302 #line 1365 "lang11d"
4303 { (yyval) = (long)newPyrVarDefNode((PyrSlotNode*)(yyvsp[(1) - (3)]), (PyrParseNode*)(yyvsp[(3) - (3)]), 0); ;}
4304 break;
4305
4306 case 220:
4307
4308 /* Line 1455 of yacc.c */
4309 #line 1367 "lang11d"
4310 {
4311 PyrParseNode* node = (PyrParseNode*)(yyvsp[(4) - (5)]);
4312 node->mParens = 1;
4313 (yyval) = (long)newPyrVarDefNode((PyrSlotNode*)(yyvsp[(1) - (5)]), node, 0);
4314 ;}
4315 break;
4316
4317 case 221:
4318
4319 /* Line 1455 of yacc.c */
4320 #line 1374 "lang11d"
4321 { (yyval) = 0; ;}
4322 break;
4323
4324 case 224:
4325
4326 /* Line 1455 of yacc.c */
4327 #line 1380 "lang11d"
4328 { (yyval) = (long)linkNextNode((PyrParseNode*)(yyvsp[(1) - (3)]), (PyrParseNode*)(yyvsp[(3) - (3)])); ;}
4329 break;
4330
4331 case 225:
4332
4333 /* Line 1455 of yacc.c */
4334 #line 1384 "lang11d"
4335 { (yyval) = (long)newPyrVarDefNode((PyrSlotNode*)(yyvsp[(1) - (1)]), NULL, 0); ;}
4336 break;
4337
4338 case 226:
4339
4340 /* Line 1455 of yacc.c */
4341 #line 1386 "lang11d"
4342 { (yyval) = (long)newPyrVarDefNode((PyrSlotNode*)(yyvsp[(1) - (3)]), (PyrParseNode*)(yyvsp[(3) - (3)]), 0); ;}
4343 break;
4344
4345 case 227:
4346
4347 /* Line 1455 of yacc.c */
4348 #line 1388 "lang11d"
4349 {
4350 PyrParseNode* node = (PyrParseNode*)(yyvsp[(3) - (4)]);
4351 node->mParens = 1;
4352 (yyval) = (long)newPyrVarDefNode((PyrSlotNode*)(yyvsp[(1) - (4)]), node, 0);
4353 ;}
4354 break;
4355
4356 case 228:
4357
4358 /* Line 1455 of yacc.c */
4359 #line 1396 "lang11d"
4360 { (yyval) = (long)linkNextNode((PyrParseNode*)(yyvsp[(1) - (3)]), (PyrParseNode*)(yyvsp[(3) - (3)])); ;}
4361 break;
4362
4363 case 229:
4364
4365 /* Line 1455 of yacc.c */
4366 #line 1398 "lang11d"
4367 {
4368 PyrParseNode* key = newPyrPushLitNode((PyrSlotNode*)(yyvsp[(1) - (2)]), NULL);
4369 (yyval) = (long)linkNextNode(key, (PyrParseNode*)(yyvsp[(2) - (2)]));
4370 ;}
4371 break;
4372
4373 case 231:
4374
4375 /* Line 1455 of yacc.c */
4376 #line 1406 "lang11d"
4377 { (yyval) = (long)linkNextNode((PyrParseNode*)(yyvsp[(1) - (3)]), (PyrParseNode*)(yyvsp[(3) - (3)])); ;}
4378 break;
4379
4380 case 232:
4381
4382 /* Line 1455 of yacc.c */
4383 #line 1409 "lang11d"
4384 { (yyval) = 0; ;}
4385 break;
4386
4387 case 235:
4388
4389 /* Line 1455 of yacc.c */
4390 #line 1415 "lang11d"
4391 { (yyval) = (long)linkNextNode((PyrParseNode*)(yyvsp[(1) - (3)]), (PyrParseNode*)(yyvsp[(3) - (3)])); ;}
4392 break;
4393
4394 case 236:
4395
4396 /* Line 1455 of yacc.c */
4397 #line 1419 "lang11d"
4398 { (yyval) = (long)newPyrVarDefNode((PyrSlotNode*)(yyvsp[(2) - (2)]), NULL, (yyvsp[(1) - (2)])); ;}
4399 break;
4400
4401 case 237:
4402
4403 /* Line 1455 of yacc.c */
4404 #line 1421 "lang11d"
4405 { (yyval) = (long)newPyrVarDefNode((PyrSlotNode*)(yyvsp[(2) - (4)]), (PyrParseNode*)(yyvsp[(4) - (4)]), (yyvsp[(1) - (4)])); ;}
4406 break;
4407
4408 case 238:
4409
4410 /* Line 1455 of yacc.c */
4411 #line 1425 "lang11d"
4412 { (yyval) = (long)newPyrLitDictNode((PyrParseNode*)(yyvsp[(3) - (4)])); ;}
4413 break;
4414
4415 case 239:
4416
4417 /* Line 1455 of yacc.c */
4418 #line 1429 "lang11d"
4419 { (yyval) = (long)newPyrLitDictNode((PyrParseNode*)(yyvsp[(2) - (3)])); ;}
4420 break;
4421
4422 case 240:
4423
4424 /* Line 1455 of yacc.c */
4425 #line 1433 "lang11d"
4426 { (yyval) = (long)linkNextNode((PyrParseNode*)(yyvsp[(1) - (3)]), (PyrParseNode*)(yyvsp[(3) - (3)])); ;}
4427 break;
4428
4429 case 241:
4430
4431 /* Line 1455 of yacc.c */
4432 #line 1435 "lang11d"
4433 {
4434 PyrParseNode* key = newPyrPushLitNode((PyrSlotNode*)(yyvsp[(1) - (2)]), NULL);
4435 (yyval) = (long)linkNextNode(key, (PyrParseNode*)(yyvsp[(2) - (2)]));
4436 ;}
4437 break;
4438
4439 case 243:
4440
4441 /* Line 1455 of yacc.c */
4442 #line 1443 "lang11d"
4443 { (yyval) = (long)linkNextNode((PyrParseNode*)(yyvsp[(1) - (3)]), (PyrParseNode*)(yyvsp[(3) - (3)])); ;}
4444 break;
4445
4446 case 244:
4447
4448 /* Line 1455 of yacc.c */
4449 #line 1446 "lang11d"
4450 { (yyval) = 0; ;}
4451 break;
4452
4453 case 246:
4454
4455 /* Line 1455 of yacc.c */
4456 #line 1453 "lang11d"
4457 { (yyval) = (long)newPyrLitListNode(0, (PyrParseNode*)(yyvsp[(3) - (4)])); ;}
4458 break;
4459
4460 case 247:
4461
4462 /* Line 1455 of yacc.c */
4463 #line 1455 "lang11d"
4464 { (yyval) = (long)newPyrLitListNode((PyrParseNode*)(yyvsp[(2) - (5)]), (PyrParseNode*)(yyvsp[(4) - (5)])); ;}
4465 break;
4466
4467 case 248:
4468
4469 /* Line 1455 of yacc.c */
4470 #line 1459 "lang11d"
4471 { (yyval) = (long)newPyrLitListNode(0, (PyrParseNode*)(yyvsp[(2) - (3)])); ;}
4472 break;
4473
4474 case 249:
4475
4476 /* Line 1455 of yacc.c */
4477 #line 1461 "lang11d"
4478 { (yyval) = (long)newPyrLitListNode((PyrParseNode*)(yyvsp[(1) - (4)]), (PyrParseNode*)(yyvsp[(3) - (4)])); ;}
4479 break;
4480
4481 case 250:
4482
4483 /* Line 1455 of yacc.c */
4484 #line 1464 "lang11d"
4485 { (yyval) = 0; ;}
4486 break;
4487
4488 case 253:
4489
4490 /* Line 1455 of yacc.c */
4491 #line 1470 "lang11d"
4492 { (yyval) = (long)linkNextNode((PyrParseNode*)(yyvsp[(1) - (3)]), (PyrParseNode*)(yyvsp[(3) - (3)])); ;}
4493 break;
4494
4495 case 254:
4496
4497 /* Line 1455 of yacc.c */
4498 #line 1473 "lang11d"
4499 { (yyval) = rwPrivate; ;}
4500 break;
4501
4502 case 255:
4503
4504 /* Line 1455 of yacc.c */
4505 #line 1475 "lang11d"
4506 { (yyval) = rwReadOnly; ;}
4507 break;
4508
4509 case 256:
4510
4511 /* Line 1455 of yacc.c */
4512 #line 1477 "lang11d"
4513 { (yyval) = rwReadWrite; ;}
4514 break;
4515
4516 case 257:
4517
4518 /* Line 1455 of yacc.c */
4519 #line 1479 "lang11d"
4520 { (yyval) = rwWriteOnly; ;}
4521 break;
4522
4523 case 258:
4524
4525 /* Line 1455 of yacc.c */
4526 #line 1482 "lang11d"
4527 { (yyval) = rwPrivate; ;}
4528 break;
4529
4530 case 259:
4531
4532 /* Line 1455 of yacc.c */
4533 #line 1484 "lang11d"
4534 { (yyval) = rwReadOnly; ;}
4535 break;
4536
4537 case 260:
4538
4539 /* Line 1455 of yacc.c */
4540 #line 1487 "lang11d"
4541 { (yyval) = zzval; ;}
4542 break;
4543
4544 case 261:
4545
4546 /* Line 1455 of yacc.c */
4547 #line 1489 "lang11d"
4548 {
4549 PyrSlotNode *node;
4550 node = (PyrSlotNode*)zzval;
4551 SetRaw(&node->mSlot, -slotRawInt(&node->mSlot));
4552 (yyval) = zzval;
4553 ;}
4554 break;
4555
4556 case 262:
4557
4558 /* Line 1455 of yacc.c */
4559 #line 1497 "lang11d"
4560 { (yyval) = zzval; ;}
4561 break;
4562
4563 case 263:
4564
4565 /* Line 1455 of yacc.c */
4566 #line 1499 "lang11d"
4567 {
4568 PyrSlotNode *node;
4569 node = (PyrSlotNode*)zzval;
4570 SetRaw(&node->mSlot, -slotRawFloat(&node->mSlot));
4571 (yyval) = zzval;
4572 ;}
4573 break;
4574
4575 case 264:
4576
4577 /* Line 1455 of yacc.c */
4578 #line 1507 "lang11d"
4579 { (yyval) = zzval; ;}
4580 break;
4581
4582 case 265:
4583
4584 /* Line 1455 of yacc.c */
4585 #line 1509 "lang11d"
4586 {
4587 PyrSlotNode *node;
4588 double intval, fracval;
4589 node = (PyrSlotNode*)zzval;
4590 intval = floor(slotRawFloat(&node->mSlot) + 0.5);
4591 fracval = slotRawFloat(&node->mSlot) - intval;
4592 SetRaw(&node->mSlot, -intval + fracval);
4593 (yyval) = zzval;
4594 ;}
4595 break;
4596
4597 case 266:
4598
4599 /* Line 1455 of yacc.c */
4600 #line 1519 "lang11d"
4601 { (yyval) = zzval; ;}
4602 break;
4603
4604 case 269:
4605
4606 /* Line 1455 of yacc.c */
4607 #line 1525 "lang11d"
4608 {
4609 PyrSlotNode *node;
4610 node = (PyrSlotNode*)(yyvsp[(1) - (2)]);
4611 SetRaw(&node->mSlot, slotRawFloat(&node->mSlot) * pi);
4612 ;}
4613 break;
4614
4615 case 270:
4616
4617 /* Line 1455 of yacc.c */
4618 #line 1531 "lang11d"
4619 {
4620 PyrSlotNode *node;
4621 double ival;
4622 node = (PyrSlotNode*)(yyvsp[(1) - (2)]);
4623 ival = slotRawInt(&node->mSlot);
4624 SetFloat(&node->mSlot, ival * pi);
4625 ;}
4626 break;
4627
4628 case 271:
4629
4630 /* Line 1455 of yacc.c */
4631 #line 1539 "lang11d"
4632 {
4633 PyrSlotNode *node;
4634 node = (PyrSlotNode*)zzval;
4635 SetFloat(&node->mSlot, pi);
4636 (yyval) = zzval;
4637 ;}
4638 break;
4639
4640 case 272:
4641
4642 /* Line 1455 of yacc.c */
4643 #line 1546 "lang11d"
4644 {
4645 PyrSlotNode *node;
4646 node = (PyrSlotNode*)zzval;
4647 SetFloat(&node->mSlot, -pi);
4648 (yyval) = zzval;
4649 ;}
4650 break;
4651
4652 case 273:
4653
4654 /* Line 1455 of yacc.c */
4655 #line 1554 "lang11d"
4656 { (yyval) = zzval; ;}
4657 break;
4658
4659 case 274:
4660
4661 /* Line 1455 of yacc.c */
4662 #line 1555 "lang11d"
4663 { (yyval) = zzval; ;}
4664 break;
4665
4666 case 275:
4667
4668 /* Line 1455 of yacc.c */
4669 #line 1558 "lang11d"
4670 { (yyval) = zzval; ;}
4671 break;
4672
4673 case 276:
4674
4675 /* Line 1455 of yacc.c */
4676 #line 1561 "lang11d"
4677 { (yyval) = zzval; ;}
4678 break;
4679
4680 case 277:
4681
4682 /* Line 1455 of yacc.c */
4683 #line 1564 "lang11d"
4684 { (yyval) = zzval; ;}
4685 break;
4686
4687 case 278:
4688
4689 /* Line 1455 of yacc.c */
4690 #line 1567 "lang11d"
4691 { (yyval) = zzval; ;}
4692 break;
4693
4694 case 279:
4695
4696 /* Line 1455 of yacc.c */
4697 #line 1570 "lang11d"
4698 { (yyval) = zzval; ;}
4699 break;
4700
4701 case 280:
4702
4703 /* Line 1455 of yacc.c */
4704 #line 1573 "lang11d"
4705 { (yyval) = zzval; ;}
4706 break;
4707
4708 case 281:
4709
4710 /* Line 1455 of yacc.c */
4711 #line 1576 "lang11d"
4712 { (yyval) = zzval; ;}
4713 break;
4714
4715 case 282:
4716
4717 /* Line 1455 of yacc.c */
4718 #line 1579 "lang11d"
4719 { (yyval) = zzval; ;}
4720 break;
4721
4722 case 283:
4723
4724 /* Line 1455 of yacc.c */
4725 #line 1582 "lang11d"
4726 { (yyval) = zzval; ;}
4727 break;
4728
4729 case 284:
4730
4731 /* Line 1455 of yacc.c */
4732 #line 1585 "lang11d"
4733 { (yyval) = zzval; ;}
4734 break;
4735
4736 case 285:
4737
4738 /* Line 1455 of yacc.c */
4739 #line 1586 "lang11d"
4740 { (yyval) = zzval; ;}
4741 break;
4742
4743 case 286:
4744
4745 /* Line 1455 of yacc.c */
4746 #line 1587 "lang11d"
4747 { (yyval) = zzval; ;}
4748 break;
4749
4750 case 287:
4751
4752 /* Line 1455 of yacc.c */
4753 #line 1588 "lang11d"
4754 { (yyval) = zzval; ;}
4755 break;
4756
4757 case 288:
4758
4759 /* Line 1455 of yacc.c */
4760 #line 1589 "lang11d"
4761 { (yyval) = zzval; ;}
4762 break;
4763
4764 case 289:
4765
4766 /* Line 1455 of yacc.c */
4767 #line 1590 "lang11d"
4768 { (yyval) = zzval; ;}
4769 break;
4770
4771 case 290:
4772
4773 /* Line 1455 of yacc.c */
4774 #line 1591 "lang11d"
4775 { (yyval) = zzval; ;}
4776 break;
4777
4778 case 291:
4779
4780 /* Line 1455 of yacc.c */
4781 #line 1592 "lang11d"
4782 { (yyval) = zzval; ;}
4783 break;
4784
4785 case 292:
4786
4787 /* Line 1455 of yacc.c */
4788 #line 1595 "lang11d"
4789 { (yyval) = zzval; ;}
4790 break;
4791
4792 case 295:
4793
4794 /* Line 1455 of yacc.c */
4795 #line 1602 "lang11d"
4796 { (yyval) = zzval; ;}
4797 break;
4798
4799
4800
4801 /* Line 1455 of yacc.c */
4802 #line 4803 "lang11d_tab.cpp"
4803 default: break;
4804 }
4805 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
4806
4807 YYPOPSTACK (yylen);
4808 yylen = 0;
4809 YY_STACK_PRINT (yyss, yyssp);
4810
4811 *++yyvsp = yyval;
4812
4813 /* Now `shift' the result of the reduction. Determine what state
4814 that goes to, based on the state we popped back to and the rule
4815 number reduced by. */
4816
4817 yyn = yyr1[yyn];
4818
4819 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
4820 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
4821 yystate = yytable[yystate];
4822 else
4823 yystate = yydefgoto[yyn - YYNTOKENS];
4824
4825 goto yynewstate;
4826
4827
4828 /*------------------------------------.
4829 | yyerrlab -- here on detecting error |
4830 `------------------------------------*/
4831 yyerrlab:
4832 /* If not already recovering from an error, report this error. */
4833 if (!yyerrstatus)
4834 {
4835 ++yynerrs;
4836 #if ! YYERROR_VERBOSE
4837 yyerror (YY_("syntax error"));
4838 #else
4839 {
4840 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
4841 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
4842 {
4843 YYSIZE_T yyalloc = 2 * yysize;
4844 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
4845 yyalloc = YYSTACK_ALLOC_MAXIMUM;
4846 if (yymsg != yymsgbuf)
4847 YYSTACK_FREE (yymsg);
4848 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
4849 if (yymsg)
4850 yymsg_alloc = yyalloc;
4851 else
4852 {
4853 yymsg = yymsgbuf;
4854 yymsg_alloc = sizeof yymsgbuf;
4855 }
4856 }
4857
4858 if (0 < yysize && yysize <= yymsg_alloc)
4859 {
4860 (void) yysyntax_error (yymsg, yystate, yychar);
4861 yyerror (yymsg);
4862 }
4863 else
4864 {
4865 yyerror (YY_("syntax error"));
4866 if (yysize != 0)
4867 goto yyexhaustedlab;
4868 }
4869 }
4870 #endif
4871 }
4872
4873
4874
4875 if (yyerrstatus == 3)
4876 {
4877 /* If just tried and failed to reuse lookahead token after an
4878 error, discard it. */
4879
4880 if (yychar <= YYEOF)
4881 {
4882 /* Return failure if at end of input. */
4883 if (yychar == YYEOF)
4884 YYABORT;
4885 }
4886 else
4887 {
4888 yydestruct ("Error: discarding",
4889 yytoken, &yylval);
4890 yychar = YYEMPTY;
4891 }
4892 }
4893
4894 /* Else will try to reuse lookahead token after shifting the error
4895 token. */
4896 goto yyerrlab1;
4897
4898
4899 /*---------------------------------------------------.
4900 | yyerrorlab -- error raised explicitly by YYERROR. |
4901 `---------------------------------------------------*/
4902 yyerrorlab:
4903
4904 /* Pacify compilers like GCC when the user code never invokes
4905 YYERROR and the label yyerrorlab therefore never appears in user
4906 code. */
4907 if (/*CONSTCOND*/ 0)
4908 goto yyerrorlab;
4909
4910 /* Do not reclaim the symbols of the rule which action triggered
4911 this YYERROR. */
4912 YYPOPSTACK (yylen);
4913 yylen = 0;
4914 YY_STACK_PRINT (yyss, yyssp);
4915 yystate = *yyssp;
4916 goto yyerrlab1;
4917
4918
4919 /*-------------------------------------------------------------.
4920 | yyerrlab1 -- common code for both syntax error and YYERROR. |
4921 `-------------------------------------------------------------*/
4922 yyerrlab1:
4923 yyerrstatus = 3; /* Each real token shifted decrements this. */
4924
4925 for (;;)
4926 {
4927 yyn = yypact[yystate];
4928 if (yyn != YYPACT_NINF)
4929 {
4930 yyn += YYTERROR;
4931 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
4932 {
4933 yyn = yytable[yyn];
4934 if (0 < yyn)
4935 break;
4936 }
4937 }
4938
4939 /* Pop the current state because it cannot handle the error token. */
4940 if (yyssp == yyss)
4941 YYABORT;
4942
4943
4944 yydestruct ("Error: popping",
4945 yystos[yystate], yyvsp);
4946 YYPOPSTACK (1);
4947 yystate = *yyssp;
4948 YY_STACK_PRINT (yyss, yyssp);
4949 }
4950
4951 *++yyvsp = yylval;
4952
4953
4954 /* Shift the error token. */
4955 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
4956
4957 yystate = yyn;
4958 goto yynewstate;
4959
4960
4961 /*-------------------------------------.
4962 | yyacceptlab -- YYACCEPT comes here. |
4963 `-------------------------------------*/
4964 yyacceptlab:
4965 yyresult = 0;
4966 goto yyreturn;
4967
4968 /*-----------------------------------.
4969 | yyabortlab -- YYABORT comes here. |
4970 `-----------------------------------*/
4971 yyabortlab:
4972 yyresult = 1;
4973 goto yyreturn;
4974
4975 #if !defined(yyoverflow) || YYERROR_VERBOSE
4976 /*-------------------------------------------------.
4977 | yyexhaustedlab -- memory exhaustion comes here. |
4978 `-------------------------------------------------*/
4979 yyexhaustedlab:
4980 yyerror (YY_("memory exhausted"));
4981 yyresult = 2;
4982 /* Fall through. */
4983 #endif
4984
4985 yyreturn:
4986 if (yychar != YYEMPTY)
4987 yydestruct ("Cleanup: discarding lookahead",
4988 yytoken, &yylval);
4989 /* Do not reclaim the symbols of the rule which action triggered
4990 this YYABORT or YYACCEPT. */
4991 YYPOPSTACK (yylen);
4992 YY_STACK_PRINT (yyss, yyssp);
4993 while (yyssp != yyss)
4994 {
4995 yydestruct ("Cleanup: popping",
4996 yystos[*yyssp], yyvsp);
4997 YYPOPSTACK (1);
4998 }
4999 #ifndef yyoverflow
5000 if (yyss != yyssa)
5001 YYSTACK_FREE (yyss);
5002 #endif
5003 #if YYERROR_VERBOSE
5004 if (yymsg != yymsgbuf)
5005 YYSTACK_FREE (yymsg);
5006 #endif
5007 /* Make sure YYID is used. */
5008 return YYID (yyresult);
5009 }
5010
5011
5012