1 /* A Bison parser, made by GNU Bison 3.3.2. */
2
3 /* Bison implementation for Yacc-like parsers in C
4
5 Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2019 Free Software Foundation,
6 Inc.
7
8 This program is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20
21 /* As a special exception, you may create a larger work that contains
22 part or all of the Bison parser skeleton and distribute that work
23 under terms of your choice, so long as that work isn't itself a
24 parser generator using the skeleton or a modified version thereof
25 as a parser skeleton. Alternatively, if you modify or redistribute
26 the parser skeleton itself, you may (at your option) remove this
27 special exception, which will cause the skeleton and the resulting
28 Bison output files to be licensed under the GNU General Public
29 License without this special exception.
30
31 This special exception was added by the Free Software Foundation in
32 version 2.2 of Bison. */
33
34 /* C LALR(1) parser skeleton written by Richard Stallman, by
35 simplifying the original so-called "semantic" parser. */
36
37 /* All symbols defined below should begin with yy or YY, to avoid
38 infringing on user name space. This should be done even for local
39 variables, as they might otherwise be expanded by user macros.
40 There are some unavoidable exceptions within include files to
41 define necessary library symbols; they are noted "INFRINGES ON
42 USER NAME SPACE" below. */
43
44 /* Undocumented macros, especially those whose name start with YY_,
45 are private implementation details. Do not rely on them. */
46
47 /* Identify Bison output. */
48 #define YYBISON 1
49
50 /* Bison version. */
51 #define YYBISON_VERSION "3.3.2"
52
53 /* Skeleton name. */
54 #define YYSKELETON_NAME "yacc.c"
55
56 /* Pure parsers. */
57 #define YYPURE 0
58
59 /* Push parsers. */
60 #define YYPUSH 0
61
62 /* Pull parsers. */
63 #define YYPULL 1
64
65
66
67
68 /* First part of user prologue. */
69 #line 30 "parser.y" /* yacc.c:337 */
70
71 #include "config.h"
72 #include <stdio.h>
73 #include <stdlib.h>
74 #include "sizes.h"
75 #include "ick.h"
76 #include "feh.h"
77 #include "ick_lose.h"
78
79 extern int yyerror(const char*);
80
81 /* Intervene our ick_first-stage lexer. */
82 extern int lexer(void);
83 #define yylex() lexer()
84
85 static node *rlist; /* pointer to current right-hand node list */
86 /*static node *llist;*/ /* pointer to current left-hand node list */
87 static node *np; /* variable for building node lists */
88
89 extern int stbeginline; /* line number of last seen preamble */
90 static int thisline; /* line number of beginning of current statement */
91
92 extern int mark112; /* AIS: Mark the tuple for W112 when it's created. */
93 static int lineuid=65537; /* AIS: a line number not used anywhere else */
94 static int cacsofar=0; /* AIS: Number of args in a CREATE statement */
95
96 static tuple *splat(int);
97
98 static tuple *prevtuple = NULL;
99
100 #define GETLINENO \
101 {if (stbeginline < 0) thisline = -stbeginline; \
102 else {thisline = stbeginline; stbeginline = 0;}}
103
104 #define ACTION(x, nt, nn) \
105 {x = newtuple(); x->type = nt; x->ick_lineno = thisline; x->u.node = nn;}
106 #define TARGET(x, nt, nn) \
107 {x = newtuple(); x->type = nt; x->ick_lineno = thisline; x->u.target = nn;}
108 #define ACTARGET(x, nt, nn, nn2)\
109 {x = newtuple(); x->type = nt; x->ick_lineno = thisline;\
110 x->u.node = nn; x->u.target = nn2;}
111 /* AIS : The macro above was added for ABSTAIN expr FROM. */
112 #define NEWFANGLED mark112 = 1; /* AIS: Added the mention of mark112 */ \
113 if (ick_traditional) ick_lose(IE111,iyylineno,(char*)NULL); else
114
115 #define DESTACKSE1 sparkearsstack[sparkearslev--/32] >>= 1
116 #define DESTACKSPARKEARS DESTACKSE1; DESTACKSE1
117
118
119 #line 120 "src/parser.c" /* yacc.c:337 */
120 # ifndef YY_NULLPTR
121 # if defined __cplusplus
122 # if 201103L <= __cplusplus
123 # define YY_NULLPTR nullptr
124 # else
125 # define YY_NULLPTR 0
126 # endif
127 # else
128 # define YY_NULLPTR ((void*)0)
129 # endif
130 # endif
131
132 /* Enabling verbose error messages. */
133 #ifdef YYERROR_VERBOSE
134 # undef YYERROR_VERBOSE
135 # define YYERROR_VERBOSE 1
136 #else
137 # define YYERROR_VERBOSE 0
138 #endif
139
140 /* In a future release of Bison, this section will be replaced
141 by #include "y.tab.h". */
142 #ifndef YY_YY_Y_TAB_H_INCLUDED
143 # define YY_YY_Y_TAB_H_INCLUDED
144 /* Debug traces. */
145 #ifndef YYDEBUG
146 # define YYDEBUG 0
147 #endif
148 #if YYDEBUG
149 extern int yydebug;
150 #endif
151
152 /* Token type. */
153 #ifndef YYTOKENTYPE
154 # define YYTOKENTYPE
155 enum yytokentype
156 {
157 UNKNOWN = 258,
158 GETS = 259,
159 RESIZE = 260,
160 NEXT = 261,
161 GO_AHEAD = 262,
162 GO_BACK = 263,
163 FORGET = 264,
164 RESUME = 265,
165 STASH = 266,
166 RETRIEVE = 267,
167 IGNORE = 268,
168 REMEMBER = 269,
169 ABSTAIN = 270,
170 REINSTATE = 271,
171 DISABLE = 272,
172 ENABLE = 273,
173 MANYFROM = 274,
174 GIVE_UP = 275,
175 READ_OUT = 276,
176 WRITE_IN = 277,
177 PIN = 278,
178 COME_FROM = 279,
179 NEXTFROMLABEL = 280,
180 NEXTFROMEXPR = 281,
181 NEXTFROMGERUND = 282,
182 COMPUCOME = 283,
183 GERUCOME = 284,
184 PREPROC = 285,
185 WHILE = 286,
186 TRY_AGAIN = 287,
187 CREATE = 288,
188 COMPUCREATE = 289,
189 FROM = 290,
190 MAYBE = 291,
191 DO = 292,
192 PLEASE = 293,
193 NOT = 294,
194 ONCE = 295,
195 AGAIN = 296,
196 MESH = 297,
197 NOSPOT = 298,
198 ick_ONESPOT = 299,
199 ick_TWOSPOT = 300,
200 ick_TAIL = 301,
201 ick_HYBRID = 302,
202 MINGLE = 303,
203 SELECT = 304,
204 UNKNOWNOP = 305,
205 SUB = 306,
206 BY = 307,
207 SLAT = 308,
208 BACKSLAT = 309,
209 NUMBER = 310,
210 UNARY = 311,
211 OHOHSEVEN = 312,
212 GERUND = 313,
213 LABEL = 314,
214 BADCHAR = 315,
215 INTERSECTION = 316,
216 SPLATTERED = 317,
217 MESH32 = 318,
218 C_AND = 319,
219 C_OR = 320,
220 C_XOR = 321,
221 C_NOT = 322,
222 C_LOGICALNOT = 323,
223 C_LSHIFTBY = 324,
224 C_RSHIFTBY = 325,
225 C_NOTEQUAL = 326,
226 C_A = 327,
227 C_PLUS = 328,
228 C_MINUS = 329,
229 C_TIMES = 330,
230 C_DIVIDEBY = 331,
231 C_MODULUS = 332,
232 C_GREATER = 333,
233 C_LESS = 334,
234 C_ISEQUAL = 335,
235 C_LOGICALAND = 336,
236 C_LOGICALOR = 337,
237 AND = 338,
238 OR = 339,
239 XOR = 340,
240 FIN = 341,
241 WHIRL = 342,
242 WHIRL2 = 343,
243 WHIRL3 = 344,
244 WHIRL4 = 345,
245 WHIRL5 = 346,
246 REV_AND = 347,
247 REV_OR = 348,
248 REV_XOR = 349,
249 REV_FIN = 350,
250 REV_WHIRL = 351,
251 REV_WHIRL2 = 352,
252 REV_WHIRL3 = 353,
253 REV_WHIRL4 = 354,
254 REV_WHIRL5 = 355,
255 UNKNOWNID = 356,
256 US_ID = 357,
257 US_SCALAR = 358,
258 US_ARRVAR = 359,
259 US_ELEM = 360,
260 US_EXPR = 361,
261 OPENEARS = 362,
262 OPENSPARK = 363,
263 CLOSEEARS = 364,
264 CLOSESPARK = 365,
265 HIGHPREC = 366,
266 UNARYPREC = 367,
267 LOWPREC = 368
268 };
269 #endif
270 /* Tokens. */
271 #define UNKNOWN 258
272 #define GETS 259
273 #define RESIZE 260
274 #define NEXT 261
275 #define GO_AHEAD 262
276 #define GO_BACK 263
277 #define FORGET 264
278 #define RESUME 265
279 #define STASH 266
280 #define RETRIEVE 267
281 #define IGNORE 268
282 #define REMEMBER 269
283 #define ABSTAIN 270
284 #define REINSTATE 271
285 #define DISABLE 272
286 #define ENABLE 273
287 #define MANYFROM 274
288 #define GIVE_UP 275
289 #define READ_OUT 276
290 #define WRITE_IN 277
291 #define PIN 278
292 #define COME_FROM 279
293 #define NEXTFROMLABEL 280
294 #define NEXTFROMEXPR 281
295 #define NEXTFROMGERUND 282
296 #define COMPUCOME 283
297 #define GERUCOME 284
298 #define PREPROC 285
299 #define WHILE 286
300 #define TRY_AGAIN 287
301 #define CREATE 288
302 #define COMPUCREATE 289
303 #define FROM 290
304 #define MAYBE 291
305 #define DO 292
306 #define PLEASE 293
307 #define NOT 294
308 #define ONCE 295
309 #define AGAIN 296
310 #define MESH 297
311 #define NOSPOT 298
312 #define ick_ONESPOT 299
313 #define ick_TWOSPOT 300
314 #define ick_TAIL 301
315 #define ick_HYBRID 302
316 #define MINGLE 303
317 #define SELECT 304
318 #define UNKNOWNOP 305
319 #define SUB 306
320 #define BY 307
321 #define SLAT 308
322 #define BACKSLAT 309
323 #define NUMBER 310
324 #define UNARY 311
325 #define OHOHSEVEN 312
326 #define GERUND 313
327 #define LABEL 314
328 #define BADCHAR 315
329 #define INTERSECTION 316
330 #define SPLATTERED 317
331 #define MESH32 318
332 #define C_AND 319
333 #define C_OR 320
334 #define C_XOR 321
335 #define C_NOT 322
336 #define C_LOGICALNOT 323
337 #define C_LSHIFTBY 324
338 #define C_RSHIFTBY 325
339 #define C_NOTEQUAL 326
340 #define C_A 327
341 #define C_PLUS 328
342 #define C_MINUS 329
343 #define C_TIMES 330
344 #define C_DIVIDEBY 331
345 #define C_MODULUS 332
346 #define C_GREATER 333
347 #define C_LESS 334
348 #define C_ISEQUAL 335
349 #define C_LOGICALAND 336
350 #define C_LOGICALOR 337
351 #define AND 338
352 #define OR 339
353 #define XOR 340
354 #define FIN 341
355 #define WHIRL 342
356 #define WHIRL2 343
357 #define WHIRL3 344
358 #define WHIRL4 345
359 #define WHIRL5 346
360 #define REV_AND 347
361 #define REV_OR 348
362 #define REV_XOR 349
363 #define REV_FIN 350
364 #define REV_WHIRL 351
365 #define REV_WHIRL2 352
366 #define REV_WHIRL3 353
367 #define REV_WHIRL4 354
368 #define REV_WHIRL5 355
369 #define UNKNOWNID 356
370 #define US_ID 357
371 #define US_SCALAR 358
372 #define US_ARRVAR 359
373 #define US_ELEM 360
374 #define US_EXPR 361
375 #define OPENEARS 362
376 #define OPENSPARK 363
377 #define CLOSEEARS 364
378 #define CLOSESPARK 365
379 #define HIGHPREC 366
380 #define UNARYPREC 367
381 #define LOWPREC 368
382
383 /* Value type. */
384 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
385
386 union YYSTYPE
387 {
388 #line 83 "parser.y" /* yacc.c:352 */
389
390 int numval; /* a numeric value */
391 tuple *tuple; /* a code tuple */
392 node *node; /* an expression-tree node */
393
394 #line 395 "src/parser.c" /* yacc.c:352 */
395 };
396
397 typedef union YYSTYPE YYSTYPE;
398 # define YYSTYPE_IS_TRIVIAL 1
399 # define YYSTYPE_IS_DECLARED 1
400 #endif
401
402
403 extern YYSTYPE yylval;
404
405 int yyparse (void);
406
407 #endif /* !YY_YY_Y_TAB_H_INCLUDED */
408
409
410
411 #ifdef short
412 # undef short
413 #endif
414
415 #ifdef YYTYPE_UINT8
416 typedef YYTYPE_UINT8 yytype_uint8;
417 #else
418 typedef unsigned char yytype_uint8;
419 #endif
420
421 #ifdef YYTYPE_INT8
422 typedef YYTYPE_INT8 yytype_int8;
423 #else
424 typedef signed char yytype_int8;
425 #endif
426
427 #ifdef YYTYPE_UINT16
428 typedef YYTYPE_UINT16 yytype_uint16;
429 #else
430 typedef unsigned short yytype_uint16;
431 #endif
432
433 #ifdef YYTYPE_INT16
434 typedef YYTYPE_INT16 yytype_int16;
435 #else
436 typedef short yytype_int16;
437 #endif
438
439 #ifndef YYSIZE_T
440 # ifdef __SIZE_TYPE__
441 # define YYSIZE_T __SIZE_TYPE__
442 # elif defined size_t
443 # define YYSIZE_T size_t
444 # elif ! defined YYSIZE_T
445 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
446 # define YYSIZE_T size_t
447 # else
448 # define YYSIZE_T unsigned
449 # endif
450 #endif
451
452 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
453
454 #ifndef YY_
455 # if defined YYENABLE_NLS && YYENABLE_NLS
456 # if ENABLE_NLS
457 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
458 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
459 # endif
460 # endif
461 # ifndef YY_
462 # define YY_(Msgid) Msgid
463 # endif
464 #endif
465
466 #ifndef YY_ATTRIBUTE
467 # if (defined __GNUC__ \
468 && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
469 || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
470 # define YY_ATTRIBUTE(Spec) __attribute__(Spec)
471 # else
472 # define YY_ATTRIBUTE(Spec) /* empty */
473 # endif
474 #endif
475
476 #ifndef YY_ATTRIBUTE_PURE
477 # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
478 #endif
479
480 #ifndef YY_ATTRIBUTE_UNUSED
481 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
482 #endif
483
484 /* Suppress unused-variable warnings by "using" E. */
485 #if ! defined lint || defined __GNUC__
486 # define YYUSE(E) ((void) (E))
487 #else
488 # define YYUSE(E) /* empty */
489 #endif
490
491 #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
492 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
493 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
494 _Pragma ("GCC diagnostic push") \
495 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
496 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
497 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
498 _Pragma ("GCC diagnostic pop")
499 #else
500 # define YY_INITIAL_VALUE(Value) Value
501 #endif
502 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
503 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
504 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
505 #endif
506 #ifndef YY_INITIAL_VALUE
507 # define YY_INITIAL_VALUE(Value) /* Nothing. */
508 #endif
509
510
511 #if ! defined yyoverflow || YYERROR_VERBOSE
512
513 /* The parser invokes alloca or malloc; define the necessary symbols. */
514
515 # ifdef YYSTACK_USE_ALLOCA
516 # if YYSTACK_USE_ALLOCA
517 # ifdef __GNUC__
518 # define YYSTACK_ALLOC __builtin_alloca
519 # elif defined __BUILTIN_VA_ARG_INCR
520 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
521 # elif defined _AIX
522 # define YYSTACK_ALLOC __alloca
523 # elif defined _MSC_VER
524 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
525 # define alloca _alloca
526 # else
527 # define YYSTACK_ALLOC alloca
528 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
529 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
530 /* Use EXIT_SUCCESS as a witness for stdlib.h. */
531 # ifndef EXIT_SUCCESS
532 # define EXIT_SUCCESS 0
533 # endif
534 # endif
535 # endif
536 # endif
537 # endif
538
539 # ifdef YYSTACK_ALLOC
540 /* Pacify GCC's 'empty if-body' warning. */
541 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
542 # ifndef YYSTACK_ALLOC_MAXIMUM
543 /* The OS might guarantee only one guard page at the bottom of the stack,
544 and a page size can be as small as 4096 bytes. So we cannot safely
545 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
546 to allow for a few compiler-allocated temporary stack slots. */
547 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
548 # endif
549 # else
550 # define YYSTACK_ALLOC YYMALLOC
551 # define YYSTACK_FREE YYFREE
552 # ifndef YYSTACK_ALLOC_MAXIMUM
553 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
554 # endif
555 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
556 && ! ((defined YYMALLOC || defined malloc) \
557 && (defined YYFREE || defined free)))
558 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
559 # ifndef EXIT_SUCCESS
560 # define EXIT_SUCCESS 0
561 # endif
562 # endif
563 # ifndef YYMALLOC
564 # define YYMALLOC malloc
565 # if ! defined malloc && ! defined EXIT_SUCCESS
566 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
567 # endif
568 # endif
569 # ifndef YYFREE
570 # define YYFREE free
571 # if ! defined free && ! defined EXIT_SUCCESS
572 void free (void *); /* INFRINGES ON USER NAME SPACE */
573 # endif
574 # endif
575 # endif
576 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
577
578
579 #if (! defined yyoverflow \
580 && (! defined __cplusplus \
581 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
582
583 /* A type that is properly aligned for any stack member. */
584 union yyalloc
585 {
586 yytype_int16 yyss_alloc;
587 YYSTYPE yyvs_alloc;
588 };
589
590 /* The size of the maximum gap between one aligned stack and the next. */
591 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
592
593 /* The size of an array large to enough to hold all stacks, each with
594 N elements. */
595 # define YYSTACK_BYTES(N) \
596 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
597 + YYSTACK_GAP_MAXIMUM)
598
599 # define YYCOPY_NEEDED 1
600
601 /* Relocate STACK from its old location to the new one. The
602 local variables YYSIZE and YYSTACKSIZE give the old and new number of
603 elements in the stack, and YYPTR gives the new location of the
604 stack. Advance YYPTR to a properly aligned location for the next
605 stack. */
606 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
607 do \
608 { \
609 YYSIZE_T yynewbytes; \
610 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
611 Stack = &yyptr->Stack_alloc; \
612 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
613 yyptr += yynewbytes / sizeof (*yyptr); \
614 } \
615 while (0)
616
617 #endif
618
619 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
620 /* Copy COUNT objects from SRC to DST. The source and destination do
621 not overlap. */
622 # ifndef YYCOPY
623 # if defined __GNUC__ && 1 < __GNUC__
624 # define YYCOPY(Dst, Src, Count) \
625 __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
626 # else
627 # define YYCOPY(Dst, Src, Count) \
628 do \
629 { \
630 YYSIZE_T yyi; \
631 for (yyi = 0; yyi < (Count); yyi++) \
632 (Dst)[yyi] = (Src)[yyi]; \
633 } \
634 while (0)
635 # endif
636 # endif
637 #endif /* !YYCOPY_NEEDED */
638
639 /* YYFINAL -- State number of the termination state. */
640 #define YYFINAL 2
641 /* YYLAST -- Last index in YYTABLE. */
642 #define YYLAST 663
643
644 /* YYNTOKENS -- Number of terminals. */
645 #define YYNTOKENS 114
646 /* YYNNTS -- Number of nonterminals. */
647 #define YYNNTS 43
648 /* YYNRULES -- Number of rules. */
649 #define YYNRULES 145
650 /* YYNSTATES -- Number of states. */
651 #define YYNSTATES 230
652
653 #define YYUNDEFTOK 2
654 #define YYMAXUTOK 368
655
656 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
657 as returned by yylex, with out-of-bounds checking. */
658 #define YYTRANSLATE(YYX) \
659 ((unsigned) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
660
661 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
662 as returned by yylex. */
663 static const yytype_uint8 yytranslate[] =
664 {
665 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
666 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
667 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
668 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
669 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
670 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
671 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
672 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
673 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
674 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
675 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
676 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
677 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
678 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
679 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
680 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
681 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
682 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
683 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
684 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
685 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
686 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
687 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
688 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
689 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
690 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
691 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
692 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
693 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
694 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
695 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
696 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
697 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
698 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
699 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
700 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
701 105, 106, 107, 108, 109, 110, 111, 112, 113
702 };
703
704 #if YYDEBUG
705 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
706 static const yytype_uint16 yyrline[] =
707 {
708 0, 168, 168, 169, 181, 183, 185, 187, 189, 204,
709 206, 209, 226, 227, 266, 267, 268, 269, 273, 274,
710 275, 279, 280, 281, 282, 283, 284, 285, 286, 287,
711 288, 289, 291, 292, 293, 294, 295, 296, 297, 298,
712 299, 300, 301, 304, 307, 309, 312, 315, 316, 319,
713 321, 325, 327, 328, 333, 334, 336, 339, 340, 342,
714 343, 348, 355, 362, 369, 372, 376, 378, 387, 387,
715 389, 389, 391, 397, 403, 411, 417, 427, 435, 446,
716 461, 462, 468, 468, 468, 469, 470, 475, 475, 475,
717 475, 476, 477, 483, 484, 488, 489, 491, 493, 494,
718 496, 497, 498, 502, 503, 506, 511, 516, 519, 520,
719 521, 532, 537, 538, 542, 543, 544, 545, 546, 556,
720 564, 565, 566, 567, 577, 582, 583, 587, 587, 587,
721 592, 594, 616, 623, 632, 633, 636, 637, 640, 641,
722 651, 652, 656, 657, 660, 661
723 };
724 #endif
725
726 #if YYDEBUG || YYERROR_VERBOSE || 0
727 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
728 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
729 static const char *const yytname[] =
730 {
731 "$end", "error", "$undefined", "UNKNOWN", "GETS", "RESIZE", "NEXT",
732 "GO_AHEAD", "GO_BACK", "FORGET", "RESUME", "STASH", "RETRIEVE", "IGNORE",
733 "REMEMBER", "ABSTAIN", "REINSTATE", "DISABLE", "ENABLE", "MANYFROM",
734 "GIVE_UP", "READ_OUT", "WRITE_IN", "PIN", "COME_FROM", "NEXTFROMLABEL",
735 "NEXTFROMEXPR", "NEXTFROMGERUND", "COMPUCOME", "GERUCOME", "PREPROC",
736 "WHILE", "TRY_AGAIN", "CREATE", "COMPUCREATE", "FROM", "MAYBE", "DO",
737 "PLEASE", "NOT", "ONCE", "AGAIN", "MESH", "NOSPOT", "ick_ONESPOT",
738 "ick_TWOSPOT", "ick_TAIL", "ick_HYBRID", "MINGLE", "SELECT", "UNKNOWNOP",
739 "SUB", "BY", "SLAT", "BACKSLAT", "NUMBER", "UNARY", "OHOHSEVEN",
740 "GERUND", "LABEL", "BADCHAR", "INTERSECTION", "SPLATTERED", "MESH32",
741 "C_AND", "C_OR", "C_XOR", "C_NOT", "C_LOGICALNOT", "C_LSHIFTBY",
742 "C_RSHIFTBY", "C_NOTEQUAL", "C_A", "C_PLUS", "C_MINUS", "C_TIMES",
743 "C_DIVIDEBY", "C_MODULUS", "C_GREATER", "C_LESS", "C_ISEQUAL",
744 "C_LOGICALAND", "C_LOGICALOR", "AND", "OR", "XOR", "FIN", "WHIRL",
745 "WHIRL2", "WHIRL3", "WHIRL4", "WHIRL5", "REV_AND", "REV_OR", "REV_XOR",
746 "REV_FIN", "REV_WHIRL", "REV_WHIRL2", "REV_WHIRL3", "REV_WHIRL4",
747 "REV_WHIRL5", "UNKNOWNID", "US_ID", "US_SCALAR", "US_ARRVAR", "US_ELEM",
748 "US_EXPR", "OPENEARS", "OPENSPARK", "CLOSEEARS", "CLOSESPARK",
749 "HIGHPREC", "UNARYPREC", "LOWPREC", "$accept", "program", "command",
750 "mtperform", "preproc", "please", "perform", "unknownstatement",
751 "unknownsif", "unknownsin", "unknownatom", "unknownaid", "gerunds",
752 "variable", "lvalue", "scalar2s", "scalar", "ick_array", "oparray",
753 "constant", "varlist", "initem", "inlist", "outitem", "outlist",
754 "byexpr", "subscr", "subscr1", "sublist", "sublist1", "osubscr",
755 "osubscr1", "unop", "expr", "notanlvalue", "limexpr", "preftype",
756 "lunambig", "limunambig", "nlunambig", "unambig", "eitherspark",
757 "eitherears", YY_NULLPTR
758 };
759 #endif
760
761 # ifdef YYPRINT
762 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
763 (internal) symbol number NUM (which must be that of a token). */
764 static const yytype_uint16 yytoknum[] =
765 {
766 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
767 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
768 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
769 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
770 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
771 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
772 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
773 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
774 335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
775 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
776 355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
777 365, 366, 367, 368
778 };
779 # endif
780
781 #define YYPACT_NINF -140
782
783 #define yypact_value_is_default(Yystate) \
784 (!!((Yystate) == (-140)))
785
786 #define YYTABLE_NINF -142
787
788 #define yytable_value_is_error(Yytable_value) \
789 0
790
791 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
792 STATE-NUM. */
793 static const yytype_int16 yypact[] =
794 {
795 -140, 129, -140, -140, -31, -25, 6, -140, 290, -140,
796 -140, 362, -140, -140, -140, 438, 438, 248, 248, 248,
797 248, 152, 102, -140, 283, 248, -27, -140, -140, 457,
798 457, -140, 451, 438, -34, -32, -29, 84, 128, -17,
799 432, 24, -140, -140, -140, -140, -140, -140, -140, 149,
800 5, -51, 478, -140, -140, 48, 203, 9, 14, -140,
801 66, -140, -140, -140, 69, 33, 8, -140, -140, 74,
802 547, 553, 432, -140, -17, 41, 49, -140, -140, -140,
803 -140, 94, -140, -32, -29, 43, 53, -140, -140, -140,
804 52, 52, 52, 52, 147, 83, -140, -140, 55, -34,
805 -140, 49, -140, 59, -140, -140, -140, 49, 67, -140,
806 -140, 77, -140, 55, -140, 55, -140, -140, -51, -15,
807 49, -140, -140, -140, -51, 94, -140, -140, -140, -140,
808 89, -140, 91, -140, 193, -140, -140, -140, -140, 432,
809 -140, -140, 438, 438, 438, 438, 438, 438, 95, 438,
810 438, 438, 438, 71, -140, -140, 26, 226, 438, 60,
811 -140, -140, 438, 438, 438, 438, 248, -140, 55, 162,
812 99, 283, 248, -140, -140, 472, 438, -140, -140, -140,
813 -140, -140, -140, 100, 111, 125, -140, -140, -140, -140,
814 171, -140, -140, -140, -140, -140, -140, -140, 75, 438,
815 -140, 438, 438, 438, 72, -140, -140, -140, -140, -140,
816 -140, -140, 55, -140, -140, -140, -51, 438, 438, 438,
817 -140, -140, -140, -140, -140, -140, -140, -140, -140, -140
818 };
819
820 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
821 Performed when YYTABLE does not specify something else to do. Zero
822 means the default is an error. */
823 static const yytype_uint8 yydefact[] =
824 {
825 2, 0, 1, 8, 16, 14, 0, 3, 0, 17,
826 15, 0, 53, 38, 39, 0, 0, 0, 0, 0,
827 0, 0, 0, 37, 0, 0, 0, 41, 44, 0,
828 0, 40, 0, 0, 127, 128, 129, 0, 0, 0,
829 0, 0, 52, 65, 144, 142, 145, 143, 4, 9,
830 12, 51, 56, 54, 59, 0, 62, 64, 0, 130,
831 61, 95, 115, 103, 63, 0, 138, 140, 114, 0,
832 0, 0, 0, 6, 0, 137, 0, 112, 113, 22,
833 136, 107, 23, 0, 0, 0, 0, 80, 68, 69,
834 24, 25, 26, 27, 0, 0, 66, 32, 33, 0,
835 87, 90, 89, 92, 35, 88, 82, 84, 86, 34,
836 83, 0, 36, 45, 46, 42, 43, 106, 47, 62,
837 64, 61, 49, 63, 0, 107, 79, 73, 74, 75,
838 0, 76, 0, 137, 139, 5, 21, 10, 11, 0,
839 60, 55, 0, 0, 0, 0, 0, 0, 0, 0,
840 0, 0, 0, 137, 125, 126, 0, 120, 0, 0,
841 7, 141, 0, 0, 0, 0, 0, 28, 29, 0,
842 0, 0, 0, 72, 48, 57, 50, 77, 78, 13,
843 18, 119, 19, 94, 0, 0, 100, 96, 97, 101,
844 102, 104, 105, 20, 131, 117, 116, 118, 0, 0,
845 134, 0, 0, 0, 0, 135, 111, 109, 108, 110,
846 81, 30, 31, 67, 91, 85, 58, 0, 0, 0,
847 98, 99, 132, 124, 122, 121, 123, 133, 93, 102
848 };
849
850 /* YYPGOTO[NTERM-NUM]. */
851 static const yytype_int16 yypgoto[] =
852 {
853 -140, -140, -140, -5, -140, 185, 64, -28, -140, -140,
854 157, -46, -10, 46, -140, -140, -8, 29, -63, -23,
855 57, -140, 42, -140, 54, 19, 101, -41, -139, -131,
856 218, -39, -40, 81, -30, 178, -140, 63, 164, -140,
857 47, -140, -140
858 };
859
860 /* YYDEFGOTO[NTERM-NUM]. */
861 static const yytype_int16 yydefgoto[] =
862 {
863 -1, 1, 7, 48, 49, 8, 50, 51, 174, 52,
864 53, 54, 98, 87, 55, 112, 75, 76, 58, 59,
865 90, 108, 109, 103, 104, 182, 77, 61, 187, 188,
866 78, 63, 122, 183, 64, 156, 65, 80, 67, 68,
867 81, 70, 71
868 };
869
870 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
871 positive, shift that token. If negative, reduce the rule whose
872 number is the opposite. If YYTABLE_NINF, syntax error. */
873 static const yytype_int16 yytable[] =
874 {
875 56, 102, 123, 56, 118, 140, 73, 191, 9, 88,
876 88, 88, 88, 144, 10, 192, 100, 106, 111, 113,
877 115, 126, 123, 127, 119, 34, 128, 35, 36, 151,
878 136, 133, 56, -137, -137, 135, 139, 57, 143, 74,
879 57, 165, 4, 5, 119, -137, 89, 89, 89, 89,
880 43, 220, 142, 101, 107, 69, -136, -136, 69, 221,
881 145, 120, 153, 153, 56, 146, 133, 160, -136, 57,
882 -71, 66, 140, 147, 66, 91, 92, 93, 175, 69,
883 125, 120, 185, 185, 168, 176, 134, 69, 192, 148,
884 44, 45, 46, 47, 162, 66, 79, 82, 129, 69,
885 145, 57, 95, 66, 186, 186, 189, 189, 131, 60,
886 114, 116, 60, 166, 124, 66, 170, 203, 169, 69,
887 171, 161, 149, 150, 199, 105, 110, 185, 172, 2,
888 3, 56, 173, 121, 117, 66, 200, 133, 133, 129,
889 130, 60, 163, 164, 177, 123, 178, 216, 102, 186,
890 194, 189, 217, 121, 117, 185, 185, 213, 88, 212,
891 96, 97, 218, 100, 106, 4, 5, 119, 57, 205,
892 140, 154, 154, 60, 184, 184, 219, 186, 186, 189,
893 189, 227, 133, 131, 132, 222, 69, 94, 6, 137,
894 138, 11, 190, 190, 34, 89, 35, 36, 37, 38,
895 101, 107, 66, 179, 120, 96, 167, -70, 74, 141,
896 133, 133, 210, 34, 215, 35, 36, 37, 38, 184,
897 96, 211, 69, 180, 181, 214, 62, 74, 193, 62,
898 195, 196, 197, 198, 157, 157, 228, 190, 66, 204,
899 60, -141, -141, 206, 207, 208, 209, 184, 184, 159,
900 62, -137, -137, -141, 0, 0, 143, 209, 62, 44,
901 45, 46, 47, -137, 0, 229, 229, 0, 0, 0,
902 62, 0, 105, 110, 201, 202, 121, 0, 44, 45,
903 223, 0, 224, 225, 226, 0, 117, 0, 155, 155,
904 62, 12, 83, 84, 85, 86, 0, 13, 14, 15,
905 16, 17, 18, 19, 20, 21, 22, 0, 0, 0,
906 23, 24, 25, 26, 27, 28, 29, 0, 30, 0,
907 0, 0, 31, 32, 33, 99, 0, 83, 84, 85,
908 86, 0, 34, 0, 35, 36, 37, 38, 0, 0,
909 0, 0, 0, 0, 0, 0, 39, 40, 0, 41,
910 42, 0, 0, 0, 0, 0, 0, 62, 0, 0,
911 0, 0, 0, 12, 0, 0, 0, 0, 0, 13,
912 14, 15, 16, 17, 18, 19, 20, 21, 22, 0,
913 0, 0, 23, 24, 25, 26, 27, 28, 29, 0,
914 30, 43, 0, 62, 31, 32, 33, 44, 45, 46,
915 47, 0, 0, 0, 34, 0, 35, 36, 37, 38,
916 0, 0, 0, 0, 0, 0, 0, 0, 39, 72,
917 0, 41, 42, 0, 0, 0, 0, 0, 0, 0,
918 0, 0, 0, 12, 0, 0, 0, 0, 0, 13,
919 14, 15, 16, 17, 18, 19, 20, 21, 22, 0,
920 0, 0, 23, 24, 25, 26, 27, 28, 29, 0,
921 30, 0, 0, 43, 31, 32, 33, 0, 0, 44,
922 45, 46, 47, 0, 34, 0, 35, 36, 37, 38,
923 34, 0, 35, 36, 37, 38, 0, 0, 39, 0,
924 0, 41, 42, 34, 74, 35, 36, 37, 38, 34,
925 0, 35, 36, 37, 38, 0, 0, 39, 0, 0,
926 0, 117, 0, 74, 34, 96, 35, 36, 37, 38,
927 34, 0, 35, 36, 37, 38, 0, 0, 39, 0,
928 0, 0, 0, 43, 39, 0, 0, 0, 0, 44,
929 45, 46, 47, 0, 0, 44, 45, 46, 47, 0,
930 0, 0, 43, 0, 0, 0, 0, 0, 44, 45,
931 46, 47, 0, 0, 44, 45, 46, 47, 0, 0,
932 0, 0, 0, 43, 0, 0, 0, 0, 0, 44,
933 45, 46, 47, 0, 0, 44, 45, 46, 47, 34,
934 0, 35, 36, 37, 38, 34, 0, 35, 36, 37,
935 38, 0, 0, 152, 0, 0, 0, 0, 0, 158,
936 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
937 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
938 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
939 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
940 0, 0, 0, 0, 44, 45, 46, 47, 0, 0,
941 44, 45, 46, 47
942 };
943
944 static const yytype_int16 yycheck[] =
945 {
946 8, 24, 32, 11, 32, 51, 11, 146, 39, 17,
947 18, 19, 20, 4, 39, 146, 24, 25, 45, 29,
948 30, 55, 52, 55, 32, 42, 55, 44, 45, 69,
949 6, 39, 40, 48, 49, 40, 31, 8, 53, 56,
950 11, 81, 36, 37, 52, 60, 17, 18, 19, 20,
951 101, 190, 4, 24, 25, 8, 48, 49, 11, 190,
952 51, 32, 70, 71, 72, 51, 74, 72, 60, 40,
953 4, 8, 118, 4, 11, 18, 19, 20, 124, 32,
954 33, 52, 145, 146, 94, 125, 39, 40, 219, 56,
955 107, 108, 109, 110, 53, 32, 15, 16, 55, 52,
956 51, 72, 21, 40, 145, 146, 145, 146, 55, 8,
957 29, 30, 11, 61, 33, 52, 61, 157, 35, 72,
958 61, 74, 48, 49, 53, 24, 25, 190, 61, 0,
959 1, 139, 55, 32, 60, 72, 110, 145, 146, 55,
960 56, 40, 48, 49, 55, 175, 55, 175, 171, 190,
961 55, 190, 52, 52, 60, 218, 219, 58, 166, 169,
962 58, 59, 51, 171, 172, 36, 37, 175, 139, 109,
963 216, 70, 71, 72, 145, 146, 51, 218, 219, 218,
964 219, 109, 190, 55, 56, 110, 139, 35, 59, 40,
965 41, 6, 145, 146, 42, 166, 44, 45, 46, 47,
966 171, 172, 139, 139, 175, 58, 59, 4, 56, 52,
967 218, 219, 166, 42, 172, 44, 45, 46, 47, 190,
968 58, 59, 175, 142, 143, 171, 8, 56, 147, 11,
969 149, 150, 151, 152, 70, 71, 217, 190, 175, 158,
970 139, 48, 49, 162, 163, 164, 165, 218, 219, 71,
971 32, 48, 49, 60, -1, -1, 53, 176, 40, 107,
972 108, 109, 110, 60, -1, 218, 219, -1, -1, -1,
973 52, -1, 171, 172, 48, 49, 175, -1, 107, 108,
974 199, -1, 201, 202, 203, -1, 60, -1, 70, 71,
975 72, 1, 44, 45, 46, 47, -1, 7, 8, 9,
976 10, 11, 12, 13, 14, 15, 16, -1, -1, -1,
977 20, 21, 22, 23, 24, 25, 26, -1, 28, -1,
978 -1, -1, 32, 33, 34, 42, -1, 44, 45, 46,
979 47, -1, 42, -1, 44, 45, 46, 47, -1, -1,
980 -1, -1, -1, -1, -1, -1, 56, 57, -1, 59,
981 60, -1, -1, -1, -1, -1, -1, 139, -1, -1,
982 -1, -1, -1, 1, -1, -1, -1, -1, -1, 7,
983 8, 9, 10, 11, 12, 13, 14, 15, 16, -1,
984 -1, -1, 20, 21, 22, 23, 24, 25, 26, -1,
985 28, 101, -1, 175, 32, 33, 34, 107, 108, 109,
986 110, -1, -1, -1, 42, -1, 44, 45, 46, 47,
987 -1, -1, -1, -1, -1, -1, -1, -1, 56, 57,
988 -1, 59, 60, -1, -1, -1, -1, -1, -1, -1,
989 -1, -1, -1, 1, -1, -1, -1, -1, -1, 7,
990 8, 9, 10, 11, 12, 13, 14, 15, 16, -1,
991 -1, -1, 20, 21, 22, 23, 24, 25, 26, -1,
992 28, -1, -1, 101, 32, 33, 34, -1, -1, 107,
993 108, 109, 110, -1, 42, -1, 44, 45, 46, 47,
994 42, -1, 44, 45, 46, 47, -1, -1, 56, -1,
995 -1, 59, 60, 42, 56, 44, 45, 46, 47, 42,
996 -1, 44, 45, 46, 47, -1, -1, 56, -1, -1,
997 -1, 60, -1, 56, 42, 58, 44, 45, 46, 47,
998 42, -1, 44, 45, 46, 47, -1, -1, 56, -1,
999 -1, -1, -1, 101, 56, -1, -1, -1, -1, 107,
1000 108, 109, 110, -1, -1, 107, 108, 109, 110, -1,
1001 -1, -1, 101, -1, -1, -1, -1, -1, 107, 108,
1002 109, 110, -1, -1, 107, 108, 109, 110, -1, -1,
1003 -1, -1, -1, 101, -1, -1, -1, -1, -1, 107,
1004 108, 109, 110, -1, -1, 107, 108, 109, 110, 42,
1005 -1, 44, 45, 46, 47, 42, -1, 44, 45, 46,
1006 47, -1, -1, 56, -1, -1, -1, -1, -1, 56,
1007 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1008 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1009 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1010 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1011 -1, -1, -1, -1, 107, 108, 109, 110, -1, -1,
1012 107, 108, 109, 110
1013 };
1014
1015 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1016 symbol of state STATE-NUM. */
1017 static const yytype_uint8 yystos[] =
1018 {
1019 0, 115, 0, 1, 36, 37, 59, 116, 119, 39,
1020 39, 119, 1, 7, 8, 9, 10, 11, 12, 13,
1021 14, 15, 16, 20, 21, 22, 23, 24, 25, 26,
1022 28, 32, 33, 34, 42, 44, 45, 46, 47, 56,
1023 57, 59, 60, 101, 107, 108, 109, 110, 117, 118,
1024 120, 121, 123, 124, 125, 128, 130, 131, 132, 133,
1025 140, 141, 144, 145, 148, 150, 151, 152, 153, 154,
1026 155, 156, 57, 117, 56, 130, 131, 140, 144, 147,
1027 151, 154, 147, 44, 45, 46, 47, 127, 130, 131,
1028 134, 134, 134, 134, 35, 147, 58, 59, 126, 42,
1029 130, 131, 133, 137, 138, 140, 130, 131, 135, 136,
1030 140, 45, 129, 126, 147, 126, 147, 60, 121, 130,
1031 131, 140, 146, 148, 147, 154, 55, 55, 55, 55,
1032 56, 55, 56, 130, 154, 117, 6, 40, 41, 31,
1033 125, 124, 4, 53, 4, 51, 51, 4, 56, 48,
1034 49, 146, 56, 130, 140, 144, 149, 152, 56, 149,
1035 117, 154, 53, 48, 49, 146, 61, 59, 126, 35,
1036 61, 61, 61, 55, 122, 125, 146, 55, 55, 120,
1037 147, 147, 139, 147, 131, 132, 141, 142, 143, 145,
1038 154, 142, 143, 147, 55, 147, 147, 147, 147, 53,
1039 110, 48, 49, 146, 147, 109, 147, 147, 147, 147,
1040 127, 59, 126, 58, 138, 136, 121, 52, 51, 51,
1041 142, 143, 110, 147, 147, 147, 147, 109, 139, 154
1042 };
1043
1044 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1045 static const yytype_uint8 yyr1[] =
1046 {
1047 0, 114, 115, 115, 116, 116, 116, 116, 116, 117,
1048 117, 117, 118, 118, 119, 119, 119, 119, 120, 120,
1049 120, 120, 120, 120, 120, 120, 120, 120, 120, 120,
1050 120, 120, 120, 120, 120, 120, 120, 120, 120, 120,
1051 120, 120, 120, 120, 120, 120, 120, 120, 120, 120,
1052 120, 120, 120, 120, 121, 121, 121, 122, 122, 123,
1053 123, 124, 124, 124, 124, 125, 126, 126, 127, 127,
1054 128, 128, 129, 130, 130, 131, 131, 132, 132, 133,
1055 134, 134, 135, 135, 135, 136, 136, 137, 137, 137,
1056 137, 138, 138, 139, 139, 140, 140, 141, 142, 142,
1057 143, 143, 143, 144, 144, 145, 146, 147, 147, 147,
1058 147, 147, 147, 147, 148, 148, 148, 148, 148, 148,
1059 149, 149, 149, 149, 149, 149, 149, 150, 150, 150,
1060 151, 151, 151, 151, 151, 151, 152, 152, 153, 153,
1061 154, 154, 155, 155, 156, 156
1062 };
1063
1064 /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
1065 static const yytype_uint8 yyr2[] =
1066 {
1067 0, 2, 0, 2, 2, 3, 3, 4, 1, 1,
1068 2, 2, 1, 3, 1, 2, 1, 2, 3, 3,
1069 3, 2, 2, 2, 2, 2, 2, 2, 3, 3,
1070 4, 4, 2, 2, 2, 2, 2, 1, 1, 1,
1071 1, 1, 2, 2, 1, 2, 2, 2, 3, 2,
1072 3, 1, 1, 1, 1, 2, 1, 1, 2, 1,
1073 2, 1, 1, 1, 1, 1, 1, 3, 1, 1,
1074 1, 1, 2, 2, 2, 2, 2, 3, 3, 2,
1075 1, 3, 1, 1, 1, 3, 1, 1, 1, 1,
1076 1, 3, 1, 3, 1, 1, 3, 3, 2, 2,
1077 1, 1, 1, 1, 3, 3, 1, 1, 3, 3,
1078 3, 3, 1, 1, 1, 1, 3, 3, 3, 3,
1079 1, 3, 3, 3, 3, 1, 1, 1, 1, 1,
1080 1, 3, 4, 4, 3, 3, 1, 1, 1, 2,
1081 1, 2, 1, 1, 1, 1
1082 };
1083
1084
1085 #define yyerrok (yyerrstatus = 0)
1086 #define yyclearin (yychar = YYEMPTY)
1087 #define YYEMPTY (-2)
1088 #define YYEOF 0
1089
1090 #define YYACCEPT goto yyacceptlab
1091 #define YYABORT goto yyabortlab
1092 #define YYERROR goto yyerrorlab
1093
1094
1095 #define YYRECOVERING() (!!yyerrstatus)
1096
1097 #define YYBACKUP(Token, Value) \
1098 do \
1099 if (yychar == YYEMPTY) \
1100 { \
1101 yychar = (Token); \
1102 yylval = (Value); \
1103 YYPOPSTACK (yylen); \
1104 yystate = *yyssp; \
1105 goto yybackup; \
1106 } \
1107 else \
1108 { \
1109 yyerror (YY_("syntax error: cannot back up")); \
1110 YYERROR; \
1111 } \
1112 while (0)
1113
1114 /* Error token number */
1115 #define YYTERROR 1
1116 #define YYERRCODE 256
1117
1118
1119
1120 /* Enable debugging if requested. */
1121 #if YYDEBUG
1122
1123 # ifndef YYFPRINTF
1124 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1125 # define YYFPRINTF fprintf
1126 # endif
1127
1128 # define YYDPRINTF(Args) \
1129 do { \
1130 if (yydebug) \
1131 YYFPRINTF Args; \
1132 } while (0)
1133
1134 /* This macro is provided for backward compatibility. */
1135 #ifndef YY_LOCATION_PRINT
1136 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1137 #endif
1138
1139
1140 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1141 do { \
1142 if (yydebug) \
1143 { \
1144 YYFPRINTF (stderr, "%s ", Title); \
1145 yy_symbol_print (stderr, \
1146 Type, Value); \
1147 YYFPRINTF (stderr, "\n"); \
1148 } \
1149 } while (0)
1150
1151
1152 /*-----------------------------------.
1153 | Print this symbol's value on YYO. |
1154 `-----------------------------------*/
1155
1156 static void
yy_symbol_value_print(FILE * yyo,int yytype,YYSTYPE const * const yyvaluep)1157 yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep)
1158 {
1159 FILE *yyoutput = yyo;
1160 YYUSE (yyoutput);
1161 if (!yyvaluep)
1162 return;
1163 # ifdef YYPRINT
1164 if (yytype < YYNTOKENS)
1165 YYPRINT (yyo, yytoknum[yytype], *yyvaluep);
1166 # endif
1167 YYUSE (yytype);
1168 }
1169
1170
1171 /*---------------------------.
1172 | Print this symbol on YYO. |
1173 `---------------------------*/
1174
1175 static void
yy_symbol_print(FILE * yyo,int yytype,YYSTYPE const * const yyvaluep)1176 yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep)
1177 {
1178 YYFPRINTF (yyo, "%s %s (",
1179 yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
1180
1181 yy_symbol_value_print (yyo, yytype, yyvaluep);
1182 YYFPRINTF (yyo, ")");
1183 }
1184
1185 /*------------------------------------------------------------------.
1186 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1187 | TOP (included). |
1188 `------------------------------------------------------------------*/
1189
1190 static void
yy_stack_print(yytype_int16 * yybottom,yytype_int16 * yytop)1191 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1192 {
1193 YYFPRINTF (stderr, "Stack now");
1194 for (; yybottom <= yytop; yybottom++)
1195 {
1196 int yybot = *yybottom;
1197 YYFPRINTF (stderr, " %d", yybot);
1198 }
1199 YYFPRINTF (stderr, "\n");
1200 }
1201
1202 # define YY_STACK_PRINT(Bottom, Top) \
1203 do { \
1204 if (yydebug) \
1205 yy_stack_print ((Bottom), (Top)); \
1206 } while (0)
1207
1208
1209 /*------------------------------------------------.
1210 | Report that the YYRULE is going to be reduced. |
1211 `------------------------------------------------*/
1212
1213 static void
yy_reduce_print(yytype_int16 * yyssp,YYSTYPE * yyvsp,int yyrule)1214 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule)
1215 {
1216 unsigned long yylno = yyrline[yyrule];
1217 int yynrhs = yyr2[yyrule];
1218 int yyi;
1219 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1220 yyrule - 1, yylno);
1221 /* The symbols being reduced. */
1222 for (yyi = 0; yyi < yynrhs; yyi++)
1223 {
1224 YYFPRINTF (stderr, " $%d = ", yyi + 1);
1225 yy_symbol_print (stderr,
1226 yystos[yyssp[yyi + 1 - yynrhs]],
1227 &yyvsp[(yyi + 1) - (yynrhs)]
1228 );
1229 YYFPRINTF (stderr, "\n");
1230 }
1231 }
1232
1233 # define YY_REDUCE_PRINT(Rule) \
1234 do { \
1235 if (yydebug) \
1236 yy_reduce_print (yyssp, yyvsp, Rule); \
1237 } while (0)
1238
1239 /* Nonzero means print parse trace. It is left uninitialized so that
1240 multiple parsers can coexist. */
1241 int yydebug;
1242 #else /* !YYDEBUG */
1243 # define YYDPRINTF(Args)
1244 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1245 # define YY_STACK_PRINT(Bottom, Top)
1246 # define YY_REDUCE_PRINT(Rule)
1247 #endif /* !YYDEBUG */
1248
1249
1250 /* YYINITDEPTH -- initial size of the parser's stacks. */
1251 #ifndef YYINITDEPTH
1252 # define YYINITDEPTH 200
1253 #endif
1254
1255 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1256 if the built-in stack extension method is used).
1257
1258 Do not make this value too large; the results are undefined if
1259 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1260 evaluated with infinite-precision integer arithmetic. */
1261
1262 #ifndef YYMAXDEPTH
1263 # define YYMAXDEPTH 10000
1264 #endif
1265
1266
1267 #if YYERROR_VERBOSE
1268
1269 # ifndef yystrlen
1270 # if defined __GLIBC__ && defined _STRING_H
1271 # define yystrlen strlen
1272 # else
1273 /* Return the length of YYSTR. */
1274 static YYSIZE_T
yystrlen(const char * yystr)1275 yystrlen (const char *yystr)
1276 {
1277 YYSIZE_T yylen;
1278 for (yylen = 0; yystr[yylen]; yylen++)
1279 continue;
1280 return yylen;
1281 }
1282 # endif
1283 # endif
1284
1285 # ifndef yystpcpy
1286 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1287 # define yystpcpy stpcpy
1288 # else
1289 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1290 YYDEST. */
1291 static char *
yystpcpy(char * yydest,const char * yysrc)1292 yystpcpy (char *yydest, const char *yysrc)
1293 {
1294 char *yyd = yydest;
1295 const char *yys = yysrc;
1296
1297 while ((*yyd++ = *yys++) != '\0')
1298 continue;
1299
1300 return yyd - 1;
1301 }
1302 # endif
1303 # endif
1304
1305 # ifndef yytnamerr
1306 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1307 quotes and backslashes, so that it's suitable for yyerror. The
1308 heuristic is that double-quoting is unnecessary unless the string
1309 contains an apostrophe, a comma, or backslash (other than
1310 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1311 null, do not copy; instead, return the length of what the result
1312 would have been. */
1313 static YYSIZE_T
yytnamerr(char * yyres,const char * yystr)1314 yytnamerr (char *yyres, const char *yystr)
1315 {
1316 if (*yystr == '"')
1317 {
1318 YYSIZE_T yyn = 0;
1319 char const *yyp = yystr;
1320
1321 for (;;)
1322 switch (*++yyp)
1323 {
1324 case '\'':
1325 case ',':
1326 goto do_not_strip_quotes;
1327
1328 case '\\':
1329 if (*++yyp != '\\')
1330 goto do_not_strip_quotes;
1331 else
1332 goto append;
1333
1334 append:
1335 default:
1336 if (yyres)
1337 yyres[yyn] = *yyp;
1338 yyn++;
1339 break;
1340
1341 case '"':
1342 if (yyres)
1343 yyres[yyn] = '\0';
1344 return yyn;
1345 }
1346 do_not_strip_quotes: ;
1347 }
1348
1349 if (! yyres)
1350 return yystrlen (yystr);
1351
1352 return (YYSIZE_T) (yystpcpy (yyres, yystr) - yyres);
1353 }
1354 # endif
1355
1356 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1357 about the unexpected token YYTOKEN for the state stack whose top is
1358 YYSSP.
1359
1360 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
1361 not large enough to hold the message. In that case, also set
1362 *YYMSG_ALLOC to the required number of bytes. Return 2 if the
1363 required number of bytes is too large to store. */
1364 static int
yysyntax_error(YYSIZE_T * yymsg_alloc,char ** yymsg,yytype_int16 * yyssp,int yytoken)1365 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1366 yytype_int16 *yyssp, int yytoken)
1367 {
1368 YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
1369 YYSIZE_T yysize = yysize0;
1370 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1371 /* Internationalized format string. */
1372 const char *yyformat = YY_NULLPTR;
1373 /* Arguments of yyformat. */
1374 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1375 /* Number of reported tokens (one for the "unexpected", one per
1376 "expected"). */
1377 int yycount = 0;
1378
1379 /* There are many possibilities here to consider:
1380 - If this state is a consistent state with a default action, then
1381 the only way this function was invoked is if the default action
1382 is an error action. In that case, don't check for expected
1383 tokens because there are none.
1384 - The only way there can be no lookahead present (in yychar) is if
1385 this state is a consistent state with a default action. Thus,
1386 detecting the absence of a lookahead is sufficient to determine
1387 that there is no unexpected or expected token to report. In that
1388 case, just report a simple "syntax error".
1389 - Don't assume there isn't a lookahead just because this state is a
1390 consistent state with a default action. There might have been a
1391 previous inconsistent state, consistent state with a non-default
1392 action, or user semantic action that manipulated yychar.
1393 - Of course, the expected token list depends on states to have
1394 correct lookahead information, and it depends on the parser not
1395 to perform extra reductions after fetching a lookahead from the
1396 scanner and before detecting a syntax error. Thus, state merging
1397 (from LALR or IELR) and default reductions corrupt the expected
1398 token list. However, the list is correct for canonical LR with
1399 one exception: it will still contain any token that will not be
1400 accepted due to an error action in a later state.
1401 */
1402 if (yytoken != YYEMPTY)
1403 {
1404 int yyn = yypact[*yyssp];
1405 yyarg[yycount++] = yytname[yytoken];
1406 if (!yypact_value_is_default (yyn))
1407 {
1408 /* Start YYX at -YYN if negative to avoid negative indexes in
1409 YYCHECK. In other words, skip the first -YYN actions for
1410 this state because they are default actions. */
1411 int yyxbegin = yyn < 0 ? -yyn : 0;
1412 /* Stay within bounds of both yycheck and yytname. */
1413 int yychecklim = YYLAST - yyn + 1;
1414 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1415 int yyx;
1416
1417 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1418 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1419 && !yytable_value_is_error (yytable[yyx + yyn]))
1420 {
1421 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1422 {
1423 yycount = 1;
1424 yysize = yysize0;
1425 break;
1426 }
1427 yyarg[yycount++] = yytname[yyx];
1428 {
1429 YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
1430 if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
1431 yysize = yysize1;
1432 else
1433 return 2;
1434 }
1435 }
1436 }
1437 }
1438
1439 switch (yycount)
1440 {
1441 # define YYCASE_(N, S) \
1442 case N: \
1443 yyformat = S; \
1444 break
1445 default: /* Avoid compiler warnings. */
1446 YYCASE_(0, YY_("syntax error"));
1447 YYCASE_(1, YY_("syntax error, unexpected %s"));
1448 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1449 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1450 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1451 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1452 # undef YYCASE_
1453 }
1454
1455 {
1456 YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
1457 if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
1458 yysize = yysize1;
1459 else
1460 return 2;
1461 }
1462
1463 if (*yymsg_alloc < yysize)
1464 {
1465 *yymsg_alloc = 2 * yysize;
1466 if (! (yysize <= *yymsg_alloc
1467 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1468 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1469 return 1;
1470 }
1471
1472 /* Avoid sprintf, as that infringes on the user's name space.
1473 Don't have undefined behavior even if the translation
1474 produced a string with the wrong number of "%s"s. */
1475 {
1476 char *yyp = *yymsg;
1477 int yyi = 0;
1478 while ((*yyp = *yyformat) != '\0')
1479 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1480 {
1481 yyp += yytnamerr (yyp, yyarg[yyi++]);
1482 yyformat += 2;
1483 }
1484 else
1485 {
1486 yyp++;
1487 yyformat++;
1488 }
1489 }
1490 return 0;
1491 }
1492 #endif /* YYERROR_VERBOSE */
1493
1494 /*-----------------------------------------------.
1495 | Release the memory associated to this symbol. |
1496 `-----------------------------------------------*/
1497
1498 static void
yydestruct(const char * yymsg,int yytype,YYSTYPE * yyvaluep)1499 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1500 {
1501 YYUSE (yyvaluep);
1502 if (!yymsg)
1503 yymsg = "Deleting";
1504 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1505
1506 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1507 YYUSE (yytype);
1508 YY_IGNORE_MAYBE_UNINITIALIZED_END
1509 }
1510
1511
1512
1513
1514 /* The lookahead symbol. */
1515 int yychar;
1516
1517 /* The semantic value of the lookahead symbol. */
1518 YYSTYPE yylval;
1519 /* Number of syntax errors so far. */
1520 int yynerrs;
1521
1522
1523 /*----------.
1524 | yyparse. |
1525 `----------*/
1526
1527 int
yyparse(void)1528 yyparse (void)
1529 {
1530 int yystate;
1531 /* Number of tokens to shift before error messages enabled. */
1532 int yyerrstatus;
1533
1534 /* The stacks and their tools:
1535 'yyss': related to states.
1536 'yyvs': related to semantic values.
1537
1538 Refer to the stacks through separate pointers, to allow yyoverflow
1539 to reallocate them elsewhere. */
1540
1541 /* The state stack. */
1542 yytype_int16 yyssa[YYINITDEPTH];
1543 yytype_int16 *yyss;
1544 yytype_int16 *yyssp;
1545
1546 /* The semantic value stack. */
1547 YYSTYPE yyvsa[YYINITDEPTH];
1548 YYSTYPE *yyvs;
1549 YYSTYPE *yyvsp;
1550
1551 YYSIZE_T yystacksize;
1552
1553 int yyn;
1554 int yyresult;
1555 /* Lookahead token as an internal (translated) token number. */
1556 int yytoken = 0;
1557 /* The variables used to return semantic value and location from the
1558 action routines. */
1559 YYSTYPE yyval;
1560
1561 #if YYERROR_VERBOSE
1562 /* Buffer for error messages, and its allocated size. */
1563 char yymsgbuf[128];
1564 char *yymsg = yymsgbuf;
1565 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1566 #endif
1567
1568 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1569
1570 /* The number of symbols on the RHS of the reduced rule.
1571 Keep to zero when no symbol should be popped. */
1572 int yylen = 0;
1573
1574 yyssp = yyss = yyssa;
1575 yyvsp = yyvs = yyvsa;
1576 yystacksize = YYINITDEPTH;
1577
1578 YYDPRINTF ((stderr, "Starting parse\n"));
1579
1580 yystate = 0;
1581 yyerrstatus = 0;
1582 yynerrs = 0;
1583 yychar = YYEMPTY; /* Cause a token to be read. */
1584 goto yysetstate;
1585
1586
1587 /*------------------------------------------------------------.
1588 | yynewstate -- push a new state, which is found in yystate. |
1589 `------------------------------------------------------------*/
1590 yynewstate:
1591 /* In all cases, when you get here, the value and location stacks
1592 have just been pushed. So pushing a state here evens the stacks. */
1593 yyssp++;
1594
1595
1596 /*--------------------------------------------------------------------.
1597 | yynewstate -- set current state (the top of the stack) to yystate. |
1598 `--------------------------------------------------------------------*/
1599 yysetstate:
1600 *yyssp = (yytype_int16) yystate;
1601
1602 if (yyss + yystacksize - 1 <= yyssp)
1603 #if !defined yyoverflow && !defined YYSTACK_RELOCATE
1604 goto yyexhaustedlab;
1605 #else
1606 {
1607 /* Get the current used size of the three stacks, in elements. */
1608 YYSIZE_T yysize = (YYSIZE_T) (yyssp - yyss + 1);
1609
1610 # if defined yyoverflow
1611 {
1612 /* Give user a chance to reallocate the stack. Use copies of
1613 these so that the &'s don't force the real ones into
1614 memory. */
1615 YYSTYPE *yyvs1 = yyvs;
1616 yytype_int16 *yyss1 = yyss;
1617
1618 /* Each stack pointer address is followed by the size of the
1619 data in use in that stack, in bytes. This used to be a
1620 conditional around just the two extra args, but that might
1621 be undefined if yyoverflow is a macro. */
1622 yyoverflow (YY_("memory exhausted"),
1623 &yyss1, yysize * sizeof (*yyssp),
1624 &yyvs1, yysize * sizeof (*yyvsp),
1625 &yystacksize);
1626 yyss = yyss1;
1627 yyvs = yyvs1;
1628 }
1629 # else /* defined YYSTACK_RELOCATE */
1630 /* Extend the stack our own way. */
1631 if (YYMAXDEPTH <= yystacksize)
1632 goto yyexhaustedlab;
1633 yystacksize *= 2;
1634 if (YYMAXDEPTH < yystacksize)
1635 yystacksize = YYMAXDEPTH;
1636
1637 {
1638 yytype_int16 *yyss1 = yyss;
1639 union yyalloc *yyptr =
1640 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1641 if (! yyptr)
1642 goto yyexhaustedlab;
1643 YYSTACK_RELOCATE (yyss_alloc, yyss);
1644 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1645 # undef YYSTACK_RELOCATE
1646 if (yyss1 != yyssa)
1647 YYSTACK_FREE (yyss1);
1648 }
1649 # endif
1650
1651 yyssp = yyss + yysize - 1;
1652 yyvsp = yyvs + yysize - 1;
1653
1654 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1655 (unsigned long) yystacksize));
1656
1657 if (yyss + yystacksize - 1 <= yyssp)
1658 YYABORT;
1659 }
1660 #endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
1661
1662 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1663
1664 if (yystate == YYFINAL)
1665 YYACCEPT;
1666
1667 goto yybackup;
1668
1669
1670 /*-----------.
1671 | yybackup. |
1672 `-----------*/
1673 yybackup:
1674 /* Do appropriate processing given the current state. Read a
1675 lookahead token if we need one and don't already have one. */
1676
1677 /* First try to decide what to do without reference to lookahead token. */
1678 yyn = yypact[yystate];
1679 if (yypact_value_is_default (yyn))
1680 goto yydefault;
1681
1682 /* Not known => get a lookahead token if don't already have one. */
1683
1684 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1685 if (yychar == YYEMPTY)
1686 {
1687 YYDPRINTF ((stderr, "Reading a token: "));
1688 yychar = yylex ();
1689 }
1690
1691 if (yychar <= YYEOF)
1692 {
1693 yychar = yytoken = YYEOF;
1694 YYDPRINTF ((stderr, "Now at end of input.\n"));
1695 }
1696 else
1697 {
1698 yytoken = YYTRANSLATE (yychar);
1699 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1700 }
1701
1702 /* If the proper action on seeing token YYTOKEN is to reduce or to
1703 detect an error, take that action. */
1704 yyn += yytoken;
1705 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1706 goto yydefault;
1707 yyn = yytable[yyn];
1708 if (yyn <= 0)
1709 {
1710 if (yytable_value_is_error (yyn))
1711 goto yyerrlab;
1712 yyn = -yyn;
1713 goto yyreduce;
1714 }
1715
1716 /* Count tokens shifted since error; after three, turn off error
1717 status. */
1718 if (yyerrstatus)
1719 yyerrstatus--;
1720
1721 /* Shift the lookahead token. */
1722 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1723
1724 /* Discard the shifted token. */
1725 yychar = YYEMPTY;
1726
1727 yystate = yyn;
1728 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1729 *++yyvsp = yylval;
1730 YY_IGNORE_MAYBE_UNINITIALIZED_END
1731
1732 goto yynewstate;
1733
1734
1735 /*-----------------------------------------------------------.
1736 | yydefault -- do the default action for the current state. |
1737 `-----------------------------------------------------------*/
1738 yydefault:
1739 yyn = yydefact[yystate];
1740 if (yyn == 0)
1741 goto yyerrlab;
1742 goto yyreduce;
1743
1744
1745 /*-----------------------------.
1746 | yyreduce -- do a reduction. |
1747 `-----------------------------*/
1748 yyreduce:
1749 /* yyn is the number of a rule to reduce with. */
1750 yylen = yyr2[yyn];
1751
1752 /* If YYLEN is nonzero, implement the default value of the action:
1753 '$$ = $1'.
1754
1755 Otherwise, the following line sets YYVAL to garbage.
1756 This behavior is undocumented and Bison
1757 users should not rely upon it. Assigning to YYVAL
1758 unconditionally makes the parser a bit smaller, and it avoids a
1759 GCC warning that YYVAL may be used uninitialized. */
1760 yyval = yyvsp[1-yylen];
1761
1762
1763 YY_REDUCE_PRINT (yyn);
1764 switch (yyn)
1765 {
1766 case 4:
1767 #line 182 "parser.y" /* yacc.c:1652 */
1768 {(yyvsp[0].tuple)->label = 0; (yyvsp[0].tuple)->exechance = (yyvsp[-1].numval) * 100;}
1769 #line 1770 "src/parser.c" /* yacc.c:1652 */
1770 break;
1771
1772 case 5:
1773 #line 184 "parser.y" /* yacc.c:1652 */
1774 {(yyvsp[0].tuple)->label = 0; (yyvsp[0].tuple)->exechance = (yyvsp[-2].numval) * (yyvsp[-1].numval);}
1775 #line 1776 "src/parser.c" /* yacc.c:1652 */
1776 break;
1777
1778 case 6:
1779 #line 186 "parser.y" /* yacc.c:1652 */
1780 {checklabel((yyvsp[-2].numval)); (yyvsp[0].tuple)->label = (yyvsp[-2].numval); (yyvsp[0].tuple)->exechance = (yyvsp[-1].numval) * 100;}
1781 #line 1782 "src/parser.c" /* yacc.c:1652 */
1782 break;
1783
1784 case 7:
1785 #line 188 "parser.y" /* yacc.c:1652 */
1786 {checklabel((yyvsp[-3].numval)); (yyvsp[0].tuple)->label = (yyvsp[-3].numval); (yyvsp[0].tuple)->exechance = (yyvsp[-2].numval) * (yyvsp[-1].numval);}
1787 #line 1788 "src/parser.c" /* yacc.c:1652 */
1788 break;
1789
1790 case 8:
1791 #line 190 "parser.y" /* yacc.c:1652 */
1792 {/* AIS: catch errors which occur after the end of a statement
1793 (highly likely when comments are being written, as the
1794 start of them will be parsed as an UNKNOWN) */
1795 yyerrok; yyclearin; cacsofar=0;
1796 if(prevtuple) {prevtuple->type=SPLATTERED; splat(0);}
1797 else splat(1); /* this is the first statement */
1798 }
1799 #line 1800 "src/parser.c" /* yacc.c:1652 */
1800 break;
1801
1802 case 9:
1803 #line 205 "parser.y" /* yacc.c:1652 */
1804 {(yyvsp[0].tuple)->onceagainflag = onceagain_NORMAL; prevtuple = (yyval.tuple) = (yyvsp[0].tuple);}
1805 #line 1806 "src/parser.c" /* yacc.c:1652 */
1806 break;
1807
1808 case 10:
1809 #line 207 "parser.y" /* yacc.c:1652 */
1810 {NEWFANGLED {(yyvsp[-1].tuple)->onceagainflag = onceagain_ONCE;
1811 prevtuple = (yyval.tuple) = (yyvsp[-1].tuple);}}
1812 #line 1813 "src/parser.c" /* yacc.c:1652 */
1813 break;
1814
1815 case 11:
1816 #line 210 "parser.y" /* yacc.c:1652 */
1817 {NEWFANGLED {(yyvsp[-1].tuple)->onceagainflag = onceagain_AGAIN;
1818 prevtuple = (yyval.tuple) = (yyvsp[-1].tuple);}}
1819 #line 1820 "src/parser.c" /* yacc.c:1652 */
1820 break;
1821
1822 case 12:
1823 #line 226 "parser.y" /* yacc.c:1652 */
1824 {(yyval.tuple) = (yyvsp[0].tuple);}
1825 #line 1826 "src/parser.c" /* yacc.c:1652 */
1826 break;
1827
1828 case 13:
1829 #line 228 "parser.y" /* yacc.c:1652 */
1830 {
1831 if(!multithread) ick_lose(IE405, iyylineno, (char*)NULL);
1832 NEWFANGLED{
1833 /* (x) DO a WHILE b
1834 is equivalent to
1835 #11 (l0) DO REINSTATE (l3) <weave on>
1836 #10 (l1) DO COME FROM (l2) AGAIN
1837 #9 DO b
1838 #8 DO COME FROM (l0)
1839 #7 DO NOTHING
1840 #6 DO NOTHING
1841 #5 (l2) DO NOTHING
1842 #4 DO GIVE UP
1843 #3 DO COME FROM (l0)
1844 #2 (x) DO a
1845 #1 (l3) DON'T ABSTAIN FROM (l1) AGAIN <weave off> */
1846 tuple* temptuple;
1847 TARGET(temptuple, COME_FROM, lineuid+2);
1848 temptuple->label=lineuid+1; temptuple->preproc=1; /* #10 */
1849 TARGET(temptuple, COME_FROM, lineuid+0); temptuple->preproc=1; /* #8 */
1850 ACTION(temptuple, PREPROC, 0); temptuple->preproc=1; /* #7 */
1851 ACTION(temptuple, PREPROC, 0); temptuple->preproc=1; /* #6 */
1852 ACTION(temptuple, PREPROC, 0);
1853 temptuple->label=lineuid+2; temptuple->preproc=1; /* #5 */
1854 ACTION(temptuple, GIVE_UP, 0); temptuple->preproc=1; /* #4 */
1855 TARGET(temptuple, COME_FROM, lineuid+0); temptuple->preproc=1; /* #3 */
1856 TARGET(temptuple, REINSTATE, lineuid+3); temptuple->setweave=1;
1857 temptuple->label=lineuid+0; temptuple->preproc=1; /* #11 */
1858 TARGET(temptuple, ABSTAIN, lineuid+1); temptuple->label=lineuid+3; /* #1 */
1859 temptuple->preproc=1; temptuple->setweave=-1; temptuple->exechance=-100;
1860 politesse += 3; /* Keep the politeness checker happy */
1861 ppinit(11); tupleswap(10,9); tupleswap(11,2); lineuid+=4; /* #2, #9 */
1862 tuples[ick_lineno-10].onceagainflag=onceagain_AGAIN;
1863 tuples[ick_lineno-1].onceagainflag=onceagain_AGAIN;
1864 (yyval.tuple)=&(tuples[ick_lineno-2]);
1865 }}
1866 #line 1867 "src/parser.c" /* yacc.c:1652 */
1867 break;
1868
1869 case 14:
1870 #line 266 "parser.y" /* yacc.c:1652 */
1871 {GETLINENO; (yyval.numval) = 1;}
1872 #line 1873 "src/parser.c" /* yacc.c:1652 */
1873 break;
1874
1875 case 15:
1876 #line 267 "parser.y" /* yacc.c:1652 */
1877 {GETLINENO; (yyval.numval) = -1;}
1878 #line 1879 "src/parser.c" /* yacc.c:1652 */
1879 break;
1880
1881 case 16:
1882 #line 268 "parser.y" /* yacc.c:1652 */
1883 {NEWFANGLED {GETLINENO; (yyval.numval) = 101;}}
1884 #line 1885 "src/parser.c" /* yacc.c:1652 */
1885 break;
1886
1887 case 17:
1888 #line 269 "parser.y" /* yacc.c:1652 */
1889 {NEWFANGLED {GETLINENO; (yyval.numval) = -101;}}
1890 #line 1891 "src/parser.c" /* yacc.c:1652 */
1891 break;
1892
1893 case 18:
1894 #line 273 "parser.y" /* yacc.c:1652 */
1895 {ACTION((yyval.tuple), GETS, cons(GETS,(yyvsp[-2].node),(yyvsp[0].node)));}
1896 #line 1897 "src/parser.c" /* yacc.c:1652 */
1897 break;
1898
1899 case 19:
1900 #line 274 "parser.y" /* yacc.c:1652 */
1901 {ACTION((yyval.tuple), RESIZE, cons(RESIZE,(yyvsp[-2].node),(yyvsp[0].node)));}
1902 #line 1903 "src/parser.c" /* yacc.c:1652 */
1903 break;
1904
1905 case 20:
1906 #line 276 "parser.y" /* yacc.c:1652 */
1907 {/* AIS: This is for variableconstants, and an error otherwise.*/
1908 if(variableconstants) ACTION((yyval.tuple), GETS, cons(GETS,(yyvsp[-2].node),(yyvsp[0].node)))
1909 else {yyerrok; yyclearin; (yyval.tuple)=splat(1);}}
1910 #line 1911 "src/parser.c" /* yacc.c:1652 */
1911 break;
1912
1913 case 21:
1914 #line 279 "parser.y" /* yacc.c:1652 */
1915 {TARGET((yyval.tuple), NEXT, (yyvsp[-1].numval));}
1916 #line 1917 "src/parser.c" /* yacc.c:1652 */
1917 break;
1918
1919 case 22:
1920 #line 280 "parser.y" /* yacc.c:1652 */
1921 {ACTION((yyval.tuple), FORGET, (yyvsp[0].node));}
1922 #line 1923 "src/parser.c" /* yacc.c:1652 */
1923 break;
1924
1925 case 23:
1926 #line 281 "parser.y" /* yacc.c:1652 */
1927 {ACTION((yyval.tuple), RESUME, (yyvsp[0].node));}
1928 #line 1929 "src/parser.c" /* yacc.c:1652 */
1929 break;
1930
1931 case 24:
1932 #line 282 "parser.y" /* yacc.c:1652 */
1933 {ACTION((yyval.tuple), STASH, rlist);}
1934 #line 1935 "src/parser.c" /* yacc.c:1652 */
1935 break;
1936
1937 case 25:
1938 #line 283 "parser.y" /* yacc.c:1652 */
1939 {ACTION((yyval.tuple), RETRIEVE, rlist);}
1940 #line 1941 "src/parser.c" /* yacc.c:1652 */
1941 break;
1942
1943 case 26:
1944 #line 284 "parser.y" /* yacc.c:1652 */
1945 {ACTION((yyval.tuple), IGNORE, rlist);}
1946 #line 1947 "src/parser.c" /* yacc.c:1652 */
1947 break;
1948
1949 case 27:
1950 #line 285 "parser.y" /* yacc.c:1652 */
1951 {ACTION((yyval.tuple), REMEMBER, rlist);}
1952 #line 1953 "src/parser.c" /* yacc.c:1652 */
1953 break;
1954
1955 case 28:
1956 #line 286 "parser.y" /* yacc.c:1652 */
1957 {stbeginline=0; TARGET((yyval.tuple), ABSTAIN, (yyvsp[0].numval));}
1958 #line 1959 "src/parser.c" /* yacc.c:1652 */
1959 break;
1960
1961 case 29:
1962 #line 287 "parser.y" /* yacc.c:1652 */
1963 {ACTION((yyval.tuple), DISABLE, rlist);}
1964 #line 1965 "src/parser.c" /* yacc.c:1652 */
1965 break;
1966
1967 case 30:
1968 #line 288 "parser.y" /* yacc.c:1652 */
1969 {/* AIS */ NEWFANGLED {stbeginline=0; ACTARGET((yyval.tuple), FROM, (yyvsp[-2].node), (yyvsp[0].numval));}}
1970 #line 1971 "src/parser.c" /* yacc.c:1652 */
1971 break;
1972
1973 case 31:
1974 #line 289 "parser.y" /* yacc.c:1652 */
1975 {/* AIS */ NEWFANGLED {(yyval.tuple) = newtuple(); (yyval.tuple)->type = MANYFROM; (yyval.tuple)->ick_lineno = thisline; \
1976 {node* tempnode=newnode(); (yyval.tuple)->u.node = tempnode; tempnode->lval=(yyvsp[-2].node); tempnode->rval=rlist; tempnode->opcode=MANYFROM;}}}
1977 #line 1978 "src/parser.c" /* yacc.c:1652 */
1978 break;
1979
1980 case 32:
1981 #line 291 "parser.y" /* yacc.c:1652 */
1982 {stbeginline=0; TARGET((yyval.tuple), REINSTATE, (yyvsp[0].numval));}
1983 #line 1984 "src/parser.c" /* yacc.c:1652 */
1984 break;
1985
1986 case 33:
1987 #line 292 "parser.y" /* yacc.c:1652 */
1988 {ACTION((yyval.tuple), ENABLE, rlist);}
1989 #line 1990 "src/parser.c" /* yacc.c:1652 */
1990 break;
1991
1992 case 34:
1993 #line 293 "parser.y" /* yacc.c:1652 */
1994 {ACTION((yyval.tuple), WRITE_IN, (yyvsp[0].node));}
1995 #line 1996 "src/parser.c" /* yacc.c:1652 */
1996 break;
1997
1998 case 35:
1999 #line 294 "parser.y" /* yacc.c:1652 */
2000 {ACTION((yyval.tuple), READ_OUT, (yyvsp[0].node));}
2001 #line 2002 "src/parser.c" /* yacc.c:1652 */
2002 break;
2003
2004 case 36:
2005 #line 295 "parser.y" /* yacc.c:1652 */
2006 {ACTION((yyval.tuple), PIN, (yyvsp[0].node));}
2007 #line 2008 "src/parser.c" /* yacc.c:1652 */
2008 break;
2009
2010 case 37:
2011 #line 296 "parser.y" /* yacc.c:1652 */
2012 {ACTION((yyval.tuple), GIVE_UP, 0);}
2013 #line 2014 "src/parser.c" /* yacc.c:1652 */
2014 break;
2015
2016 case 38:
2017 #line 297 "parser.y" /* yacc.c:1652 */
2018 {/* AIS */ NEWFANGLED {ACTION((yyval.tuple), GO_AHEAD, 0);}}
2019 #line 2020 "src/parser.c" /* yacc.c:1652 */
2020 break;
2021
2022 case 39:
2023 #line 298 "parser.y" /* yacc.c:1652 */
2024 {/* AIS */ NEWFANGLED {ACTION((yyval.tuple), GO_BACK, 0);}}
2025 #line 2026 "src/parser.c" /* yacc.c:1652 */
2026 break;
2027
2028 case 40:
2029 #line 299 "parser.y" /* yacc.c:1652 */
2030 {/* AIS */ NEWFANGLED {ACTION((yyval.tuple),TRY_AGAIN,0);}}
2031 #line 2032 "src/parser.c" /* yacc.c:1652 */
2032 break;
2033
2034 case 41:
2035 #line 300 "parser.y" /* yacc.c:1652 */
2036 {/* AIS: Modified */ NEWFANGLED {TARGET((yyval.tuple),COME_FROM,(yyvsp[0].numval));}}
2037 #line 2038 "src/parser.c" /* yacc.c:1652 */
2038 break;
2039
2040 case 42:
2041 #line 301 "parser.y" /* yacc.c:1652 */
2042 {/* AIS: COME FROM gerund */
2043 NEWFANGLED{ACTION((yyval.tuple),GERUCOME,rlist);
2044 compucomesused=1; gerucomesused=1;}}
2045 #line 2046 "src/parser.c" /* yacc.c:1652 */
2046 break;
2047
2048 case 43:
2049 #line 304 "parser.y" /* yacc.c:1652 */
2050 {/* AIS */NEWFANGLED {ACTION((yyval.tuple),COMPUCOME,(yyvsp[0].node));
2051 compucomesused=1;}}
2052 #line 2053 "src/parser.c" /* yacc.c:1652 */
2053 break;
2054
2055 case 44:
2056 #line 307 "parser.y" /* yacc.c:1652 */
2057 {NEWFANGLED {TARGET((yyval.tuple),NEXTFROMLABEL,(yyvsp[0].numval));}
2058 nextfromsused=1;}
2059 #line 2060 "src/parser.c" /* yacc.c:1652 */
2060 break;
2061
2062 case 45:
2063 #line 309 "parser.y" /* yacc.c:1652 */
2064 {NEWFANGLED{ACTION((yyval.tuple),NEXTFROMGERUND,rlist);
2065 compucomesused=1; gerucomesused=1;}
2066 nextfromsused=1;}
2067 #line 2068 "src/parser.c" /* yacc.c:1652 */
2068 break;
2069
2070 case 46:
2071 #line 312 "parser.y" /* yacc.c:1652 */
2072 {NEWFANGLED {ACTION((yyval.tuple),NEXTFROMEXPR,(yyvsp[0].node));
2073 compucomesused=1; nextfromsused=1;}}
2074 #line 2075 "src/parser.c" /* yacc.c:1652 */
2075 break;
2076
2077 case 47:
2078 #line 315 "parser.y" /* yacc.c:1652 */
2079 {NEWFANGLED{ACTARGET((yyval.tuple),CREATE,(yyvsp[0].node),(yyvsp[-1].numval)); cacsofar=0;}}
2080 #line 2081 "src/parser.c" /* yacc.c:1652 */
2081 break;
2082
2083 case 48:
2084 #line 316 "parser.y" /* yacc.c:1652 */
2085 {NEWFANGLED{ACTION((yyval.tuple),COMPUCREATE,
2086 cons(INTERSECTION,(yyvsp[-1].node),(yyvsp[0].node))); cacsofar=0;}}
2087 #line 2088 "src/parser.c" /* yacc.c:1652 */
2088 break;
2089
2090 case 49:
2091 #line 319 "parser.y" /* yacc.c:1652 */
2092 {NEWFANGLED{ACTARGET((yyval.tuple),CREATE,(yyvsp[0].node),(yyvsp[-1].numval));
2093 cacsofar=0;}}
2094 #line 2095 "src/parser.c" /* yacc.c:1652 */
2095 break;
2096
2097 case 50:
2098 #line 322 "parser.y" /* yacc.c:1652 */
2099 {NEWFANGLED{ACTION((yyval.tuple),COMPUCREATE,
2100 cons(INTERSECTION,(yyvsp[-1].node),(yyvsp[0].node))); cacsofar=0;}}
2101 #line 2102 "src/parser.c" /* yacc.c:1652 */
2102 break;
2103
2104 case 51:
2105 #line 325 "parser.y" /* yacc.c:1652 */
2106 {NEWFANGLED {ACTION((yyval.tuple),UNKNOWN,(yyvsp[0].node)); cacsofar=0;}}
2107 #line 2108 "src/parser.c" /* yacc.c:1652 */
2108 break;
2109
2110 case 52:
2111 #line 327 "parser.y" /* yacc.c:1652 */
2112 {yyclearin; yyerrok; (yyval.tuple) = splat(1); cacsofar=0;}
2113 #line 2114 "src/parser.c" /* yacc.c:1652 */
2114 break;
2115
2116 case 53:
2117 #line 328 "parser.y" /* yacc.c:1652 */
2118 {yyclearin; yyerrok; (yyval.tuple) = splat(1); cacsofar=0;}
2119 #line 2120 "src/parser.c" /* yacc.c:1652 */
2120 break;
2121
2122 case 54:
2123 #line 333 "parser.y" /* yacc.c:1652 */
2124 {(yyval.node) = (yyvsp[0].node); intern(ick_TWOSPOT,cacsofar+++1601);}
2125 #line 2126 "src/parser.c" /* yacc.c:1652 */
2126 break;
2127
2128 case 55:
2129 #line 334 "parser.y" /* yacc.c:1652 */
2130 {(yyval.node)=cons(INTERSECTION,(yyvsp[-1].node),(yyvsp[0].node));
2131 intern(ick_TWOSPOT,cacsofar+++1601);}
2132 #line 2133 "src/parser.c" /* yacc.c:1652 */
2133 break;
2134
2135 case 56:
2136 #line 336 "parser.y" /* yacc.c:1652 */
2137 {(yyval.node) = (yyvsp[0].node);}
2138 #line 2139 "src/parser.c" /* yacc.c:1652 */
2139 break;
2140
2141 case 57:
2142 #line 339 "parser.y" /* yacc.c:1652 */
2143 {(yyval.node) = (yyvsp[0].node);}
2144 #line 2145 "src/parser.c" /* yacc.c:1652 */
2145 break;
2146
2147 case 58:
2148 #line 340 "parser.y" /* yacc.c:1652 */
2149 {(yyval.node)=cons(INTERSECTION,(yyvsp[-1].node),(yyvsp[0].node));}
2150 #line 2151 "src/parser.c" /* yacc.c:1652 */
2151 break;
2152
2153 case 59:
2154 #line 342 "parser.y" /* yacc.c:1652 */
2155 {(yyval.node) = (yyvsp[0].node);}
2156 #line 2157 "src/parser.c" /* yacc.c:1652 */
2157 break;
2158
2159 case 60:
2160 #line 343 "parser.y" /* yacc.c:1652 */
2161 {(yyval.node)=cons(INTERSECTION,(yyvsp[-1].node),(yyvsp[0].node));}
2162 #line 2163 "src/parser.c" /* yacc.c:1652 */
2163 break;
2164
2165 case 61:
2166 #line 348 "parser.y" /* yacc.c:1652 */
2167 {(yyval.node)=cons(US_ELEM,0,(yyvsp[0].node));
2168 if(createsused){
2169 opoverused=1; if(!firstslat)
2170 firstslat=(yyvsp[0].node); else
2171 prevslat->nextslat=(yyvsp[0].node);
2172 prevslat=(yyvsp[0].node);
2173 (yyvsp[0].node)->nextslat=0;}}
2174 #line 2175 "src/parser.c" /* yacc.c:1652 */
2175 break;
2176
2177 case 62:
2178 #line 355 "parser.y" /* yacc.c:1652 */
2179 {(yyval.node)=cons(US_SCALAR,0,(yyvsp[0].node));
2180 if(createsused){
2181 opoverused=1; if(!firstslat)
2182 firstslat=(yyvsp[0].node); else
2183 prevslat->nextslat=(yyvsp[0].node);
2184 prevslat=(yyvsp[0].node);
2185 (yyvsp[0].node)->nextslat=0;}}
2186 #line 2187 "src/parser.c" /* yacc.c:1652 */
2187 break;
2188
2189 case 63:
2190 #line 362 "parser.y" /* yacc.c:1652 */
2191 {(yyval.node)=cons(US_EXPR,0,(yyvsp[0].node));
2192 if(createsused){
2193 opoverused=1; if(!firstslat)
2194 firstslat=(yyvsp[0].node); else
2195 prevslat->nextslat=(yyvsp[0].node);
2196 prevslat=(yyvsp[0].node);
2197 (yyvsp[0].node)->nextslat=0;}}
2198 #line 2199 "src/parser.c" /* yacc.c:1652 */
2199 break;
2200
2201 case 64:
2202 #line 369 "parser.y" /* yacc.c:1652 */
2203 {(yyval.node)=cons(US_ARRVAR,0,(yyvsp[0].node));}
2204 #line 2205 "src/parser.c" /* yacc.c:1652 */
2205 break;
2206
2207 case 65:
2208 #line 372 "parser.y" /* yacc.c:1652 */
2209 {(yyval.node)=newnode(); (yyval.node)->opcode=US_ID; (yyval.node)->constant=(yyvsp[0].numval);}
2210 #line 2211 "src/parser.c" /* yacc.c:1652 */
2211 break;
2212
2213 case 66:
2214 #line 377 "parser.y" /* yacc.c:1652 */
2215 {rlist = np = newnode(); np->constant = (yyvsp[0].numval);}
2216 #line 2217 "src/parser.c" /* yacc.c:1652 */
2217 break;
2218
2219 case 67:
2220 #line 379 "parser.y" /* yacc.c:1652 */
2221 {
2222 np->rval = newnode();
2223 np = np->rval;
2224 np->constant = (yyvsp[0].numval);
2225 }
2226 #line 2227 "src/parser.c" /* yacc.c:1652 */
2227 break;
2228
2229 case 72:
2230 #line 392 "parser.y" /* yacc.c:1652 */
2231 {
2232 (yyval.node) = newnode();
2233 (yyval.node)->opcode = ick_TWOSPOT;
2234 (yyval.node)->constant = intern(ick_TWOSPOT, (yyvsp[0].numval));
2235 }
2236 #line 2237 "src/parser.c" /* yacc.c:1652 */
2237 break;
2238
2239 case 73:
2240 #line 398 "parser.y" /* yacc.c:1652 */
2241 {
2242 (yyval.node) = newnode();
2243 (yyval.node)->opcode = ick_ONESPOT;
2244 (yyval.node)->constant = intern(ick_ONESPOT, (yyvsp[0].numval));
2245 }
2246 #line 2247 "src/parser.c" /* yacc.c:1652 */
2247 break;
2248
2249 case 74:
2250 #line 404 "parser.y" /* yacc.c:1652 */
2251 {
2252 (yyval.node) = newnode();
2253 (yyval.node)->opcode = ick_TWOSPOT;
2254 (yyval.node)->constant = intern(ick_TWOSPOT, (yyvsp[0].numval));
2255 }
2256 #line 2257 "src/parser.c" /* yacc.c:1652 */
2257 break;
2258
2259 case 75:
2260 #line 412 "parser.y" /* yacc.c:1652 */
2261 {
2262 (yyval.node) = newnode();
2263 (yyval.node)->opcode = ick_TAIL;
2264 (yyval.node)->constant = intern(ick_TAIL, (yyvsp[0].numval));
2265 }
2266 #line 2267 "src/parser.c" /* yacc.c:1652 */
2267 break;
2268
2269 case 76:
2270 #line 418 "parser.y" /* yacc.c:1652 */
2271 {
2272 (yyval.node) = newnode();
2273 (yyval.node)->opcode = ick_HYBRID;
2274 (yyval.node)->constant = intern(ick_HYBRID, (yyvsp[0].numval));
2275 }
2276 #line 2277 "src/parser.c" /* yacc.c:1652 */
2277 break;
2278
2279 case 77:
2280 #line 428 "parser.y" /* yacc.c:1652 */
2281 {
2282 (yyval.node) = newnode();
2283 (yyval.node)->opcode = (yyvsp[-1].numval);
2284 (yyval.node)->rval = newnode();
2285 (yyval.node)->rval->opcode = ick_TAIL;
2286 (yyval.node)->rval->constant = intern(ick_TAIL, (yyvsp[0].numval));
2287 }
2288 #line 2289 "src/parser.c" /* yacc.c:1652 */
2289 break;
2290
2291 case 78:
2292 #line 436 "parser.y" /* yacc.c:1652 */
2293 {
2294 (yyval.node) = newnode();
2295 (yyval.node)->opcode = (yyvsp[-1].numval);
2296 (yyval.node)->rval = newnode();
2297 (yyval.node)->rval->opcode = ick_HYBRID;
2298 (yyval.node)->rval->constant = intern(ick_HYBRID, (yyvsp[0].numval));
2299 }
2300 #line 2301 "src/parser.c" /* yacc.c:1652 */
2301 break;
2302
2303 case 79:
2304 #line 447 "parser.y" /* yacc.c:1652 */
2305 {
2306 /* enforce the 16-bit constant constraint */
2307 if ((unsigned int)(yyvsp[0].numval) > ick_Max_small)
2308 ick_lose(IE017, iyylineno, (char *)NULL);
2309 (yyval.node) = newnode();
2310 (yyval.node)->opcode = MESH;
2311 if(variableconstants) /* AIS */
2312 (yyval.node)->constant = intern(MESH, (yyvsp[0].numval));
2313 else
2314 (yyval.node)->constant = (yyvsp[0].numval);
2315 }
2316 #line 2317 "src/parser.c" /* yacc.c:1652 */
2317 break;
2318
2319 case 80:
2320 #line 461 "parser.y" /* yacc.c:1652 */
2321 {rlist = np = (yyvsp[0].node);}
2322 #line 2323 "src/parser.c" /* yacc.c:1652 */
2323 break;
2324
2325 case 81:
2326 #line 462 "parser.y" /* yacc.c:1652 */
2327 {np = np->rval = (yyvsp[0].node);
2328 /* newnode(); */ }
2329 #line 2330 "src/parser.c" /* yacc.c:1652 */
2330 break;
2331
2332 case 85:
2333 #line 469 "parser.y" /* yacc.c:1652 */
2334 {(yyval.node)=cons(INTERSECTION,(yyvsp[-2].node),(yyvsp[0].node));}
2335 #line 2336 "src/parser.c" /* yacc.c:1652 */
2336 break;
2337
2338 case 86:
2339 #line 470 "parser.y" /* yacc.c:1652 */
2340 {(yyval.node)=cons(INTERSECTION,(yyvsp[0].node),0);}
2341 #line 2342 "src/parser.c" /* yacc.c:1652 */
2342 break;
2343
2344 case 91:
2345 #line 476 "parser.y" /* yacc.c:1652 */
2346 {(yyval.node)=cons(INTERSECTION,(yyvsp[-2].node),(yyvsp[0].node));}
2347 #line 2348 "src/parser.c" /* yacc.c:1652 */
2348 break;
2349
2350 case 92:
2351 #line 477 "parser.y" /* yacc.c:1652 */
2352 {(yyval.node)=cons(INTERSECTION,(yyvsp[0].node),0);}
2353 #line 2354 "src/parser.c" /* yacc.c:1652 */
2354 break;
2355
2356 case 93:
2357 #line 483 "parser.y" /* yacc.c:1652 */
2358 {(yyval.node) = cons(BY, (yyvsp[-2].node), (yyvsp[0].node));}
2359 #line 2360 "src/parser.c" /* yacc.c:1652 */
2360 break;
2361
2362 case 94:
2363 #line 484 "parser.y" /* yacc.c:1652 */
2364 {(yyval.node) = cons(BY, (yyvsp[0].node), 0);}
2365 #line 2366 "src/parser.c" /* yacc.c:1652 */
2366 break;
2367
2368 case 95:
2369 #line 488 "parser.y" /* yacc.c:1652 */
2370 {(yyval.node) = (yyvsp[0].node);}
2371 #line 2372 "src/parser.c" /* yacc.c:1652 */
2372 break;
2373
2374 case 96:
2375 #line 489 "parser.y" /* yacc.c:1652 */
2376 {(yyval.node) = cons(SUB, (yyvsp[-2].node), (yyvsp[0].node));}
2377 #line 2378 "src/parser.c" /* yacc.c:1652 */
2378 break;
2379
2380 case 97:
2381 #line 491 "parser.y" /* yacc.c:1652 */
2382 {(yyval.node) = cons(SUB, (yyvsp[-2].node), (yyvsp[0].node));}
2383 #line 2384 "src/parser.c" /* yacc.c:1652 */
2384 break;
2385
2386 case 98:
2387 #line 493 "parser.y" /* yacc.c:1652 */
2388 {(yyval.node) = cons(INTERSECTION, (yyvsp[-1].node), (yyvsp[0].node));}
2389 #line 2390 "src/parser.c" /* yacc.c:1652 */
2390 break;
2391
2392 case 99:
2393 #line 494 "parser.y" /* yacc.c:1652 */
2394 {(yyval.node) = cons(INTERSECTION, (yyvsp[-1].node), (yyvsp[0].node));}
2395 #line 2396 "src/parser.c" /* yacc.c:1652 */
2396 break;
2397
2398 case 100:
2399 #line 496 "parser.y" /* yacc.c:1652 */
2400 {(yyval.node) = cons(INTERSECTION, (yyvsp[0].node), 0);}
2401 #line 2402 "src/parser.c" /* yacc.c:1652 */
2402 break;
2403
2404 case 101:
2405 #line 497 "parser.y" /* yacc.c:1652 */
2406 {(yyval.node) = cons(INTERSECTION, (yyvsp[0].node), 0);}
2407 #line 2408 "src/parser.c" /* yacc.c:1652 */
2408 break;
2409
2410 case 102:
2411 #line 498 "parser.y" /* yacc.c:1652 */
2412 {(yyval.node) = cons(INTERSECTION, (yyvsp[0].node), 0);}
2413 #line 2414 "src/parser.c" /* yacc.c:1652 */
2414 break;
2415
2416 case 103:
2417 #line 502 "parser.y" /* yacc.c:1652 */
2418 {(yyval.node) = (yyvsp[0].node);}
2419 #line 2420 "src/parser.c" /* yacc.c:1652 */
2420 break;
2421
2422 case 104:
2423 #line 504 "parser.y" /* yacc.c:1652 */
2424 {(yyval.node) = (yyvsp[-2].node); (yyval.node)->rval = cons(SUB, (yyval.node)->rval, (yyvsp[0].node));}
2425 #line 2426 "src/parser.c" /* yacc.c:1652 */
2426 break;
2427
2428 case 105:
2429 #line 507 "parser.y" /* yacc.c:1652 */
2430 {(yyval.node) = (yyvsp[-2].node); (yyval.node)->rval = cons(SUB, (yyval.node)->rval, (yyvsp[0].node));}
2431 #line 2432 "src/parser.c" /* yacc.c:1652 */
2432 break;
2433
2434 case 106:
2435 #line 511 "parser.y" /* yacc.c:1652 */
2436 {(yyval.node) = newnode(); (yyval.node)->opcode = BADCHAR;
2437 (yyval.node)->constant = (yyvsp[0].numval);}
2438 #line 2439 "src/parser.c" /* yacc.c:1652 */
2439 break;
2440
2441 case 107:
2442 #line 516 "parser.y" /* yacc.c:1652 */
2443 {(yyval.node) = (yyvsp[0].node);}
2444 #line 2445 "src/parser.c" /* yacc.c:1652 */
2445 break;
2446
2447 case 108:
2448 #line 519 "parser.y" /* yacc.c:1652 */
2449 {(yyval.node) = cons(SELECT, (yyvsp[-2].node), (yyvsp[0].node));}
2450 #line 2451 "src/parser.c" /* yacc.c:1652 */
2451 break;
2452
2453 case 109:
2454 #line 520 "parser.y" /* yacc.c:1652 */
2455 {(yyval.node) = cons(MINGLE, (yyvsp[-2].node), (yyvsp[0].node));}
2456 #line 2457 "src/parser.c" /* yacc.c:1652 */
2457 break;
2458
2459 case 110:
2460 #line 521 "parser.y" /* yacc.c:1652 */
2461 {(yyval.node) = cons(UNKNOWNOP, (yyvsp[-1].node),
2462 cons(INTERSECTION, (yyvsp[-2].node), (yyvsp[0].node)));
2463 if(useickec && createsused) {
2464 if(!firstslat) firstslat=(yyvsp[-2].node);
2465 else prevslat->nextslat=(yyvsp[-2].node);
2466 (yyvsp[-2].node)->nextslat=(yyvsp[0].node); prevslat=(yyvsp[0].node);
2467 (yyvsp[0].node)->nextslat=0; opoverused=1;
2468 intern(ick_TWOSPOT, 1601);
2469 intern(ick_TWOSPOT, 1602);
2470 intern(ick_TWOSPOT, 1603);}}
2471 #line 2472 "src/parser.c" /* yacc.c:1652 */
2472 break;
2473
2474 case 111:
2475 #line 532 "parser.y" /* yacc.c:1652 */
2476 {NEWFANGLED{(yyval.node) = cons(SLAT, (yyvsp[-2].node), (yyvsp[0].node));
2477 opoverused=1; if(!firstslat)
2478 firstslat=(yyvsp[0].node); else
2479 prevslat->nextslat=(yyvsp[0].node); prevslat=(yyvsp[0].node);
2480 (yyvsp[0].node)->nextslat=0;}}
2481 #line 2482 "src/parser.c" /* yacc.c:1652 */
2482 break;
2483
2484 case 112:
2485 #line 537 "parser.y" /* yacc.c:1652 */
2486 {(yyval.node) = (yyvsp[0].node);}
2487 #line 2488 "src/parser.c" /* yacc.c:1652 */
2488 break;
2489
2490 case 113:
2491 #line 538 "parser.y" /* yacc.c:1652 */
2492 {(yyval.node) = (yyvsp[0].node);}
2493 #line 2494 "src/parser.c" /* yacc.c:1652 */
2494 break;
2495
2496 case 114:
2497 #line 542 "parser.y" /* yacc.c:1652 */
2498 {(yyval.node) = (yyvsp[0].node);}
2499 #line 2500 "src/parser.c" /* yacc.c:1652 */
2500 break;
2501
2502 case 115:
2503 #line 543 "parser.y" /* yacc.c:1652 */
2504 {(yyval.node) = (yyvsp[0].node);}
2505 #line 2506 "src/parser.c" /* yacc.c:1652 */
2506 break;
2507
2508 case 116:
2509 #line 544 "parser.y" /* yacc.c:1652 */
2510 {(yyval.node) = cons(SELECT, (yyvsp[-2].node), (yyvsp[0].node));}
2511 #line 2512 "src/parser.c" /* yacc.c:1652 */
2512 break;
2513
2514 case 117:
2515 #line 545 "parser.y" /* yacc.c:1652 */
2516 {(yyval.node) = cons(MINGLE, (yyvsp[-2].node), (yyvsp[0].node));}
2517 #line 2518 "src/parser.c" /* yacc.c:1652 */
2518 break;
2519
2520 case 118:
2521 #line 546 "parser.y" /* yacc.c:1652 */
2522 {(yyval.node) = cons(UNKNOWNOP, (yyvsp[-1].node),
2523 cons(INTERSECTION, (yyvsp[-2].node), (yyvsp[0].node)));
2524 if(useickec && createsused) {
2525 if(!firstslat) firstslat=(yyvsp[-2].node);
2526 else prevslat->nextslat=(yyvsp[-2].node);
2527 (yyvsp[-2].node)->nextslat=(yyvsp[0].node); prevslat=(yyvsp[0].node);
2528 (yyvsp[0].node)->nextslat=0; opoverused=1;
2529 intern(ick_TWOSPOT, 1601);
2530 intern(ick_TWOSPOT, 1602);
2531 intern(ick_TWOSPOT, 1603);}}
2532 #line 2533 "src/parser.c" /* yacc.c:1652 */
2533 break;
2534
2535 case 119:
2536 #line 556 "parser.y" /* yacc.c:1652 */
2537 {NEWFANGLED{(yyval.node) = cons(SLAT, (yyvsp[-2].node), (yyvsp[0].node));
2538 opoverused=1; if(!firstslat)
2539 firstslat=(yyvsp[0].node); else
2540 prevslat->nextslat=(yyvsp[0].node); prevslat=(yyvsp[0].node);
2541 (yyvsp[0].node)->nextslat=0;}}
2542 #line 2543 "src/parser.c" /* yacc.c:1652 */
2543 break;
2544
2545 case 120:
2546 #line 564 "parser.y" /* yacc.c:1652 */
2547 {(yyval.node) = (yyvsp[0].node);}
2548 #line 2549 "src/parser.c" /* yacc.c:1652 */
2549 break;
2550
2551 case 121:
2552 #line 565 "parser.y" /* yacc.c:1652 */
2553 {(yyval.node) = cons(SELECT, (yyvsp[-2].node), (yyvsp[0].node));}
2554 #line 2555 "src/parser.c" /* yacc.c:1652 */
2555 break;
2556
2557 case 122:
2558 #line 566 "parser.y" /* yacc.c:1652 */
2559 {(yyval.node) = cons(MINGLE, (yyvsp[-2].node), (yyvsp[0].node));}
2560 #line 2561 "src/parser.c" /* yacc.c:1652 */
2561 break;
2562
2563 case 123:
2564 #line 567 "parser.y" /* yacc.c:1652 */
2565 {(yyval.node) = cons(UNKNOWNOP, (yyvsp[-1].node),
2566 cons(INTERSECTION, (yyvsp[-2].node), (yyvsp[0].node)));
2567 if(useickec && createsused) {
2568 if(!firstslat) firstslat=(yyvsp[-2].node);
2569 else prevslat->nextslat=(yyvsp[-2].node);
2570 (yyvsp[-2].node)->nextslat=(yyvsp[0].node); prevslat=(yyvsp[0].node);
2571 (yyvsp[0].node)->nextslat=0; opoverused=1;
2572 intern(ick_TWOSPOT, 1601);
2573 intern(ick_TWOSPOT, 1602);
2574 intern(ick_TWOSPOT, 1603);}}
2575 #line 2576 "src/parser.c" /* yacc.c:1652 */
2576 break;
2577
2578 case 124:
2579 #line 577 "parser.y" /* yacc.c:1652 */
2580 {NEWFANGLED{(yyval.node) = cons(SLAT, (yyvsp[-2].node), (yyvsp[0].node));
2581 opoverused=1; if(!firstslat)
2582 firstslat=(yyvsp[0].node); else
2583 prevslat->nextslat=(yyvsp[0].node); prevslat=(yyvsp[0].node);
2584 (yyvsp[0].node)->nextslat=0;}}
2585 #line 2586 "src/parser.c" /* yacc.c:1652 */
2586 break;
2587
2588 case 125:
2589 #line 582 "parser.y" /* yacc.c:1652 */
2590 {(yyval.node) = (yyvsp[0].node);}
2591 #line 2592 "src/parser.c" /* yacc.c:1652 */
2592 break;
2593
2594 case 126:
2595 #line 583 "parser.y" /* yacc.c:1652 */
2596 {(yyval.node) = (yyvsp[0].node);}
2597 #line 2598 "src/parser.c" /* yacc.c:1652 */
2598 break;
2599
2600 case 127:
2601 #line 587 "parser.y" /* yacc.c:1652 */
2602 {(yyval.numval)=MESH; }
2603 #line 2604 "src/parser.c" /* yacc.c:1652 */
2604 break;
2605
2606 case 128:
2607 #line 587 "parser.y" /* yacc.c:1652 */
2608 {(yyval.numval)=ick_ONESPOT;}
2609 #line 2610 "src/parser.c" /* yacc.c:1652 */
2610 break;
2611
2612 case 129:
2613 #line 587 "parser.y" /* yacc.c:1652 */
2614 {(yyval.numval)=ick_TWOSPOT;}
2615 #line 2616 "src/parser.c" /* yacc.c:1652 */
2616 break;
2617
2618 case 130:
2619 #line 592 "parser.y" /* yacc.c:1652 */
2620 {(yyval.node) = (yyvsp[0].node);}
2621 #line 2622 "src/parser.c" /* yacc.c:1652 */
2622 break;
2623
2624 case 131:
2625 #line 595 "parser.y" /* yacc.c:1652 */
2626 {
2627 (yyval.node) = newnode();
2628 (yyval.node)->opcode = (yyvsp[-1].numval);
2629 (yyval.node)->rval = newnode();
2630 (yyval.node)->rval->opcode = (yyvsp[-2].numval);
2631 if((yyvsp[-2].numval) == MESH) {
2632 /* enforce the 16-bit constant constraint */
2633 if ((unsigned int)(yyvsp[0].numval) > ick_Max_small)
2634 ick_lose(IE017, iyylineno, (char *)NULL);
2635 if(variableconstants) /* AIS, patched by JH */
2636 (yyval.node)->rval->constant = intern(MESH, (yyvsp[0].numval));
2637 else
2638 (yyval.node)->rval->constant = (yyvsp[0].numval);
2639 }
2640 else {
2641 (yyval.node)->rval->constant = intern((yyvsp[-2].numval), (yyvsp[0].numval));
2642 }
2643 }
2644 #line 2645 "src/parser.c" /* yacc.c:1652 */
2645 break;
2646
2647 case 132:
2648 #line 617 "parser.y" /* yacc.c:1652 */
2649 {
2650 (yyval.node) = newnode();
2651 (yyval.node)->opcode = (yyvsp[-2].numval);
2652 (yyval.node)->rval = (yyvsp[-1].node);
2653 DESTACKSPARKEARS;
2654 }
2655 #line 2656 "src/parser.c" /* yacc.c:1652 */
2656 break;
2657
2658 case 133:
2659 #line 624 "parser.y" /* yacc.c:1652 */
2660 {
2661 (yyval.node) = newnode();
2662 (yyval.node)->opcode = (yyvsp[-2].numval);
2663 (yyval.node)->rval = (yyvsp[-1].node);
2664 DESTACKSPARKEARS;
2665 }
2666 #line 2667 "src/parser.c" /* yacc.c:1652 */
2667 break;
2668
2669 case 134:
2670 #line 632 "parser.y" /* yacc.c:1652 */
2671 {(yyval.node) = (yyvsp[-1].node); DESTACKSPARKEARS;}
2672 #line 2673 "src/parser.c" /* yacc.c:1652 */
2673 break;
2674
2675 case 135:
2676 #line 633 "parser.y" /* yacc.c:1652 */
2677 {(yyval.node) = (yyvsp[-1].node); DESTACKSPARKEARS;}
2678 #line 2679 "src/parser.c" /* yacc.c:1652 */
2679 break;
2680
2681 case 136:
2682 #line 636 "parser.y" /* yacc.c:1652 */
2683 {(yyval.node) = (yyvsp[0].node);}
2684 #line 2685 "src/parser.c" /* yacc.c:1652 */
2685 break;
2686
2687 case 137:
2688 #line 637 "parser.y" /* yacc.c:1652 */
2689 {(yyval.node) = (yyvsp[0].node);}
2690 #line 2691 "src/parser.c" /* yacc.c:1652 */
2691 break;
2692
2693 case 138:
2694 #line 640 "parser.y" /* yacc.c:1652 */
2695 {(yyval.node) = (yyvsp[0].node);}
2696 #line 2697 "src/parser.c" /* yacc.c:1652 */
2697 break;
2698
2699 case 139:
2700 #line 642 "parser.y" /* yacc.c:1652 */
2701 {(yyval.node)=newnode(); (yyval.node)->opcode = (yyvsp[-1].numval); (yyval.node)->rval = (yyvsp[0].node);}
2702 #line 2703 "src/parser.c" /* yacc.c:1652 */
2703 break;
2704
2705 case 140:
2706 #line 651 "parser.y" /* yacc.c:1652 */
2707 {(yyval.node) = (yyvsp[0].node);}
2708 #line 2709 "src/parser.c" /* yacc.c:1652 */
2709 break;
2710
2711 case 141:
2712 #line 653 "parser.y" /* yacc.c:1652 */
2713 {(yyval.node)=newnode(); (yyval.node)->opcode = (yyvsp[-1].numval); (yyval.node)->rval = (yyvsp[0].node);}
2714 #line 2715 "src/parser.c" /* yacc.c:1652 */
2715 break;
2716
2717
2718 #line 2719 "src/parser.c" /* yacc.c:1652 */
2719 default: break;
2720 }
2721 /* User semantic actions sometimes alter yychar, and that requires
2722 that yytoken be updated with the new translation. We take the
2723 approach of translating immediately before every use of yytoken.
2724 One alternative is translating here after every semantic action,
2725 but that translation would be missed if the semantic action invokes
2726 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
2727 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
2728 incorrect destructor might then be invoked immediately. In the
2729 case of YYERROR or YYBACKUP, subsequent parser actions might lead
2730 to an incorrect destructor call or verbose syntax error message
2731 before the lookahead is translated. */
2732 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
2733
2734 YYPOPSTACK (yylen);
2735 yylen = 0;
2736 YY_STACK_PRINT (yyss, yyssp);
2737
2738 *++yyvsp = yyval;
2739
2740 /* Now 'shift' the result of the reduction. Determine what state
2741 that goes to, based on the state we popped back to and the rule
2742 number reduced by. */
2743 {
2744 const int yylhs = yyr1[yyn] - YYNTOKENS;
2745 const int yyi = yypgoto[yylhs] + *yyssp;
2746 yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
2747 ? yytable[yyi]
2748 : yydefgoto[yylhs]);
2749 }
2750
2751 goto yynewstate;
2752
2753
2754 /*--------------------------------------.
2755 | yyerrlab -- here on detecting error. |
2756 `--------------------------------------*/
2757 yyerrlab:
2758 /* Make sure we have latest lookahead translation. See comments at
2759 user semantic actions for why this is necessary. */
2760 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
2761
2762 /* If not already recovering from an error, report this error. */
2763 if (!yyerrstatus)
2764 {
2765 ++yynerrs;
2766 #if ! YYERROR_VERBOSE
2767 yyerror (YY_("syntax error"));
2768 #else
2769 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
2770 yyssp, yytoken)
2771 {
2772 char const *yymsgp = YY_("syntax error");
2773 int yysyntax_error_status;
2774 yysyntax_error_status = YYSYNTAX_ERROR;
2775 if (yysyntax_error_status == 0)
2776 yymsgp = yymsg;
2777 else if (yysyntax_error_status == 1)
2778 {
2779 if (yymsg != yymsgbuf)
2780 YYSTACK_FREE (yymsg);
2781 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
2782 if (!yymsg)
2783 {
2784 yymsg = yymsgbuf;
2785 yymsg_alloc = sizeof yymsgbuf;
2786 yysyntax_error_status = 2;
2787 }
2788 else
2789 {
2790 yysyntax_error_status = YYSYNTAX_ERROR;
2791 yymsgp = yymsg;
2792 }
2793 }
2794 yyerror (yymsgp);
2795 if (yysyntax_error_status == 2)
2796 goto yyexhaustedlab;
2797 }
2798 # undef YYSYNTAX_ERROR
2799 #endif
2800 }
2801
2802
2803
2804 if (yyerrstatus == 3)
2805 {
2806 /* If just tried and failed to reuse lookahead token after an
2807 error, discard it. */
2808
2809 if (yychar <= YYEOF)
2810 {
2811 /* Return failure if at end of input. */
2812 if (yychar == YYEOF)
2813 YYABORT;
2814 }
2815 else
2816 {
2817 yydestruct ("Error: discarding",
2818 yytoken, &yylval);
2819 yychar = YYEMPTY;
2820 }
2821 }
2822
2823 /* Else will try to reuse lookahead token after shifting the error
2824 token. */
2825 goto yyerrlab1;
2826
2827
2828 /*---------------------------------------------------.
2829 | yyerrorlab -- error raised explicitly by YYERROR. |
2830 `---------------------------------------------------*/
2831 yyerrorlab:
2832 /* Pacify compilers when the user code never invokes YYERROR and the
2833 label yyerrorlab therefore never appears in user code. */
2834 if (0)
2835 YYERROR;
2836
2837 /* Do not reclaim the symbols of the rule whose action triggered
2838 this YYERROR. */
2839 YYPOPSTACK (yylen);
2840 yylen = 0;
2841 YY_STACK_PRINT (yyss, yyssp);
2842 yystate = *yyssp;
2843 goto yyerrlab1;
2844
2845
2846 /*-------------------------------------------------------------.
2847 | yyerrlab1 -- common code for both syntax error and YYERROR. |
2848 `-------------------------------------------------------------*/
2849 yyerrlab1:
2850 yyerrstatus = 3; /* Each real token shifted decrements this. */
2851
2852 for (;;)
2853 {
2854 yyn = yypact[yystate];
2855 if (!yypact_value_is_default (yyn))
2856 {
2857 yyn += YYTERROR;
2858 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
2859 {
2860 yyn = yytable[yyn];
2861 if (0 < yyn)
2862 break;
2863 }
2864 }
2865
2866 /* Pop the current state because it cannot handle the error token. */
2867 if (yyssp == yyss)
2868 YYABORT;
2869
2870
2871 yydestruct ("Error: popping",
2872 yystos[yystate], yyvsp);
2873 YYPOPSTACK (1);
2874 yystate = *yyssp;
2875 YY_STACK_PRINT (yyss, yyssp);
2876 }
2877
2878 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2879 *++yyvsp = yylval;
2880 YY_IGNORE_MAYBE_UNINITIALIZED_END
2881
2882
2883 /* Shift the error token. */
2884 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
2885
2886 yystate = yyn;
2887 goto yynewstate;
2888
2889
2890 /*-------------------------------------.
2891 | yyacceptlab -- YYACCEPT comes here. |
2892 `-------------------------------------*/
2893 yyacceptlab:
2894 yyresult = 0;
2895 goto yyreturn;
2896
2897
2898 /*-----------------------------------.
2899 | yyabortlab -- YYABORT comes here. |
2900 `-----------------------------------*/
2901 yyabortlab:
2902 yyresult = 1;
2903 goto yyreturn;
2904
2905
2906 #if !defined yyoverflow || YYERROR_VERBOSE
2907 /*-------------------------------------------------.
2908 | yyexhaustedlab -- memory exhaustion comes here. |
2909 `-------------------------------------------------*/
2910 yyexhaustedlab:
2911 yyerror (YY_("memory exhausted"));
2912 yyresult = 2;
2913 /* Fall through. */
2914 #endif
2915
2916
2917 /*-----------------------------------------------------.
2918 | yyreturn -- parsing is finished, return the result. |
2919 `-----------------------------------------------------*/
2920 yyreturn:
2921 if (yychar != YYEMPTY)
2922 {
2923 /* Make sure we have latest lookahead translation. See comments at
2924 user semantic actions for why this is necessary. */
2925 yytoken = YYTRANSLATE (yychar);
2926 yydestruct ("Cleanup: discarding lookahead",
2927 yytoken, &yylval);
2928 }
2929 /* Do not reclaim the symbols of the rule whose action triggered
2930 this YYABORT or YYACCEPT. */
2931 YYPOPSTACK (yylen);
2932 YY_STACK_PRINT (yyss, yyssp);
2933 while (yyssp != yyss)
2934 {
2935 yydestruct ("Cleanup: popping",
2936 yystos[*yyssp], yyvsp);
2937 YYPOPSTACK (1);
2938 }
2939 #ifndef yyoverflow
2940 if (yyss != yyssa)
2941 YYSTACK_FREE (yyss);
2942 #endif
2943 #if YYERROR_VERBOSE
2944 if (yymsg != yymsgbuf)
2945 YYSTACK_FREE (yymsg);
2946 #endif
2947 return yyresult;
2948 }
2949 #line 664 "parser.y" /* yacc.c:1918 */
2950
2951
splat(int gentuple)2952 static tuple *splat(int gentuple)
2953 /* try to recover from an invalid statement. */
2954 {
2955 tuple *sp;
2956 int tok, i;
2957 extern bool re_send_token;
2958
2959 /*
2960 * The idea
2961 * here is to skip to the ick_next DO, PLEASE or label, then unget that token.
2962 * which we can do with a tricky flag on the lexer (re_send_token).
2963 */
2964
2965 if(re_send_token == true) /* By AIS */
2966 {
2967 /* We're still cleaning up from the previous error. */
2968 return prevtuple;
2969 }
2970
2971 /* fprintf(stderr,"attempting to splat at line %d....\n",iyylineno); */
2972 /* AIS: Set the flag to true the first time round, false for subsequent
2973 iterations. That way, if the error was triggered on a DO or label,
2974 we use that token as the start of the next statement. */
2975 for(i = 0,re_send_token = true;;i++,re_send_token = false) {
2976 tok = lexer();
2977 if (!tok)
2978 {
2979 re_send_token = true;
2980 tok = ' '; /* scanner must not see a NUL */
2981 break;
2982 }
2983 else if (tok == DO || tok == PLEASE || tok == LABEL
2984 /* AIS */ || tok == MAYBE) {
2985 re_send_token = true;
2986 break;
2987 }
2988 }
2989 /*
2990 fprintf(stderr,"found %d on line %d after %d other tokens.\n",
2991 tok,iyylineno,i);
2992 */
2993
2994 /* generate a placeholder tuple for the text line */
2995 if(gentuple /* AIS */) {TARGET(sp, SPLATTERED, 0); prevtuple=sp;}
2996 else sp=NULL;
2997
2998 return(sp);
2999 }
3000
3001 /* parser.y ends here */
3002