1 /* A Bison parser, made by GNU Bison 3.0.5. */
2
3 /* Bison implementation for Yacc-like parsers in C
4
5 Copyright (C) 1984, 1989-1990, 2000-2015, 2018 Free Software Foundation, Inc.
6
7 This program is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20 /* As a special exception, you may create a larger work that contains
21 part or all of the Bison parser skeleton and distribute that work
22 under terms of your choice, so long as that work isn't itself a
23 parser generator using the skeleton or a modified version thereof
24 as a parser skeleton. Alternatively, if you modify or redistribute
25 the parser skeleton itself, you may (at your option) remove this
26 special exception, which will cause the skeleton and the resulting
27 Bison output files to be licensed under the GNU General Public
28 License without this special exception.
29
30 This special exception was added by the Free Software Foundation in
31 version 2.2 of Bison. */
32
33 /* C LALR(1) parser skeleton written by Richard Stallman, by
34 simplifying the original so-called "semantic" parser. */
35
36 /* All symbols defined below should begin with yy or YY, to avoid
37 infringing on user name space. This should be done even for local
38 variables, as they might otherwise be expanded by user macros.
39 There are some unavoidable exceptions within include files to
40 define necessary library symbols; they are noted "INFRINGES ON
41 USER NAME SPACE" below. */
42
43 /* Identify Bison output. */
44 #define YYBISON 1
45
46 /* Bison version. */
47 #define YYBISON_VERSION "3.0.5"
48
49 /* Skeleton name. */
50 #define YYSKELETON_NAME "yacc.c"
51
52 /* Pure parsers. */
53 #define YYPURE 0
54
55 /* Push parsers. */
56 #define YYPUSH 0
57
58 /* Pull parsers. */
59 #define YYPULL 1
60
61
62
63
64 /* Copy the first part of user declarations. */
65
66 // -*- C++ -*-
67 /*
68 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
69 * Copyright (C) 2008-2010 - DIGITEO - Bruno JOFRET
70 *
71 * Copyright (C) 2012 - 2016 - Scilab Enterprises
72 *
73 * This file is hereby licensed under the terms of the GNU GPL v2.0,
74 * pursuant to article 5.3.4 of the CeCILL v.2.1.
75 * This file was originally licensed under the terms of the CeCILL v2.1,
76 * and continues to be available under such terms.
77 * For more information, see the COPYING file which you should have received
78 * along with this program.
79 *
80 */
81 #define YYERROR_VERBOSE 1
82
83 #define YYDEBUG 1
84
85 #define YYLTYPE Location
86
87 /*
88 ** This build the tree in verbose mode
89 ** for instance adding CommentExp
90 ** where nothing is needed.
91 */
92 //#define BUILD_DEBUG_AST
93
94 #include <string>
95 #include <sstream>
96 #include <list>
97 #include "all.hxx"
98 #include "parse.hxx"
99 #include "parser_private.hxx"
100 #include "location.hxx"
101 #include "symbol.hxx"
102 #include "charEncoding.h"
103 #include "sci_malloc.h"
104
105 //#define DEBUG_RULES
106 #ifdef DEBUG_RULES
107 #include <iomanip>
108 #endif
109
print_rules(const std::string & _parent,const std::string & _rules)110 static void print_rules(const std::string& _parent, const std::string& _rules)
111 {
112 #ifdef DEBUG_RULES
113 static std::list<std::pair<std::string, std::string> > rules;
114 // add a space to perform a find as whole word of _parent in _rules
115 rules.emplace_front(_parent+" ", _rules+" ");
116
117 if(_parent == "program")
118 {
119 std::list<std::pair<std::string, std::string> > last;
120 int spaces = 5; // 5 is the size of "|_./ "
121
122 std::cout << "--- RULES ---" << std::endl;
123 std::cout << "|_./ " << _parent << " : " << _rules << std::endl;
124
125 last.emplace_back(rules.front());
126 rules.pop_front();
127 for(auto r : rules)
128 {
129 size_t pos = last.back().second.find(r.first);
130 while(pos == std::string::npos)
131 {
132 spaces -= 2;
133 last.pop_back();
134 if(last.empty())
135 {
136 break;
137 }
138 pos = last.back().second.find(r.first);
139 }
140
141 if(last.empty() == false)
142 {
143 last.back().second.erase(pos, r.first.length());
144 }
145
146 spaces += 2;
147 last.emplace_back(r);
148
149 std::setfill(" ");
150 std::cout << std::setw(spaces) << "|_./ " << r.first << ": " << r.second << std::endl;
151 }
152
153 rules.clear();
154 }
155 #endif
156 }
157
print_rules(const std::string & _parent,const double _value)158 static void print_rules(const std::string& _parent, const double _value)
159 {
160 #ifdef DEBUG_RULES
161 std::stringstream ostr;
162 ostr << _value;
163 print_rules(_parent, ostr.str());
164 #endif
165 }
166
167 #define StopOnError() \
168 { \
169 if(ParserSingleInstance::stopOnFirstError()) \
170 { \
171 ParserSingleInstance::setExitStatus(Parser::ParserStatus::Failed); \
172 } \
173 }
174
175 #define SetTree(PTR) \
176 { \
177 if(ParserSingleInstance::getExitStatus() == Parser::Failed) \
178 { \
179 delete PTR; \
180 ParserSingleInstance::setTree(nullptr); \
181 } \
182 else \
183 { \
184 ParserSingleInstance::setTree(PTR); \
185 } \
186 }
187
188
189
190
191
192 # ifndef YY_NULLPTR
193 # if defined __cplusplus && 201103L <= __cplusplus
194 # define YY_NULLPTR nullptr
195 # else
196 # define YY_NULLPTR 0
197 # endif
198 # endif
199
200 /* Enabling verbose error messages. */
201 #ifdef YYERROR_VERBOSE
202 # undef YYERROR_VERBOSE
203 # define YYERROR_VERBOSE 1
204 #else
205 # define YYERROR_VERBOSE 0
206 #endif
207
208 /* In a future release of Bison, this section will be replaced
209 by #include "y.tab.h". */
210 #ifndef YY_YY_Y_TAB_H_INCLUDED
211 # define YY_YY_Y_TAB_H_INCLUDED
212 /* Debug traces. */
213 #ifndef YYDEBUG
214 # define YYDEBUG 1
215 #endif
216 #if YYDEBUG
217 extern int yydebug;
218 #endif
219
220 /* Token type. */
221 #ifndef YYTOKENTYPE
222 # define YYTOKENTYPE
223 enum yytokentype
224 {
225 YYEOF = 0,
226 DOTS = 258,
227 EOL = 259,
228 SPACES = 260,
229 BOOLTRUE = 261,
230 BOOLFALSE = 262,
231 QUOTE = 263,
232 NOT = 264,
233 DOLLAR = 265,
234 COMMA = 266,
235 COLON = 267,
236 SEMI = 268,
237 LPAREN = 269,
238 RPAREN = 270,
239 LBRACK = 271,
240 RBRACK = 272,
241 LBRACE = 273,
242 RBRACE = 274,
243 DOT = 275,
244 DOTQUOTE = 276,
245 PLUS = 277,
246 MINUS = 278,
247 TIMES = 279,
248 DOTTIMES = 280,
249 KRONTIMES = 281,
250 CONTROLTIMES = 282,
251 RDIVIDE = 283,
252 DOTRDIVIDE = 284,
253 CONTROLRDIVIDE = 285,
254 KRONRDIVIDE = 286,
255 LDIVIDE = 287,
256 DOTLDIVIDE = 288,
257 CONTROLLDIVIDE = 289,
258 KRONLDIVIDE = 290,
259 POWER = 291,
260 DOTPOWER = 292,
261 EQ = 293,
262 NE = 294,
263 LT = 295,
264 LE = 296,
265 GT = 297,
266 GE = 298,
267 AND = 299,
268 ANDAND = 300,
269 OR = 301,
270 OROR = 302,
271 ASSIGN = 303,
272 IF = 304,
273 THEN = 305,
274 ELSE = 306,
275 ELSEIF = 307,
276 END = 308,
277 SELECT = 309,
278 SWITCH = 310,
279 CASE = 311,
280 OTHERWISE = 312,
281 FUNCTION = 313,
282 ENDFUNCTION = 314,
283 FOR = 315,
284 WHILE = 316,
285 DO = 317,
286 BREAK = 318,
287 CONTINUE = 319,
288 TRY = 320,
289 CATCH = 321,
290 RETURN = 322,
291 FLEX_ERROR = 323,
292 STR = 324,
293 ID = 325,
294 VARINT = 326,
295 VARFLOAT = 327,
296 NUM = 328,
297 PATH = 329,
298 COMMENT = 330,
299 BLOCKCOMMENT = 331,
300 TOPLEVEL = 332,
301 HIGHLEVEL = 333,
302 UPLEVEL = 334,
303 LISTABLE = 335,
304 CONTROLBREAK = 336,
305 UMINUS = 337,
306 UPLUS = 338,
307 FUNCTIONCALL = 339
308 };
309 #endif
310 /* Tokens. */
311 #define YYEOF 0
312 #define DOTS 258
313 #define EOL 259
314 #define SPACES 260
315 #define BOOLTRUE 261
316 #define BOOLFALSE 262
317 #define QUOTE 263
318 #define NOT 264
319 #define DOLLAR 265
320 #define COMMA 266
321 #define COLON 267
322 #define SEMI 268
323 #define LPAREN 269
324 #define RPAREN 270
325 #define LBRACK 271
326 #define RBRACK 272
327 #define LBRACE 273
328 #define RBRACE 274
329 #define DOT 275
330 #define DOTQUOTE 276
331 #define PLUS 277
332 #define MINUS 278
333 #define TIMES 279
334 #define DOTTIMES 280
335 #define KRONTIMES 281
336 #define CONTROLTIMES 282
337 #define RDIVIDE 283
338 #define DOTRDIVIDE 284
339 #define CONTROLRDIVIDE 285
340 #define KRONRDIVIDE 286
341 #define LDIVIDE 287
342 #define DOTLDIVIDE 288
343 #define CONTROLLDIVIDE 289
344 #define KRONLDIVIDE 290
345 #define POWER 291
346 #define DOTPOWER 292
347 #define EQ 293
348 #define NE 294
349 #define LT 295
350 #define LE 296
351 #define GT 297
352 #define GE 298
353 #define AND 299
354 #define ANDAND 300
355 #define OR 301
356 #define OROR 302
357 #define ASSIGN 303
358 #define IF 304
359 #define THEN 305
360 #define ELSE 306
361 #define ELSEIF 307
362 #define END 308
363 #define SELECT 309
364 #define SWITCH 310
365 #define CASE 311
366 #define OTHERWISE 312
367 #define FUNCTION 313
368 #define ENDFUNCTION 314
369 #define FOR 315
370 #define WHILE 316
371 #define DO 317
372 #define BREAK 318
373 #define CONTINUE 319
374 #define TRY 320
375 #define CATCH 321
376 #define RETURN 322
377 #define FLEX_ERROR 323
378 #define STR 324
379 #define ID 325
380 #define VARINT 326
381 #define VARFLOAT 327
382 #define NUM 328
383 #define PATH 329
384 #define COMMENT 330
385 #define BLOCKCOMMENT 331
386 #define TOPLEVEL 332
387 #define HIGHLEVEL 333
388 #define UPLEVEL 334
389 #define LISTABLE 335
390 #define CONTROLBREAK 336
391 #define UMINUS 337
392 #define UPLUS 338
393 #define FUNCTIONCALL 339
394
395 /* Value type. */
396 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
397
398 union YYSTYPE
399 {
400
401
402 /* Tokens. */
403 double number;
404 std::wstring* str;
405 std::wstring* path;
406 std::wstring* comment;
407
408 LineBreakStr* mute;
409
410 ast::exps_t* t_list_var;
411 ast::exps_t* t_list_exp;
412 ast::Exp* t_exp;
413
414 ast::SeqExp* t_seq_exp;
415 ast::ReturnExp* t_return_exp;
416
417 ast::IfExp* t_if_exp;
418 ast::WhileExp* t_while_exp;
419 ast::ForExp* t_for_exp;
420 ast::TryCatchExp* t_try_exp;
421 ast::SelectExp* t_select_exp;
422 ast::CaseExp* t_case_exp;
423 ast::exps_t* t_list_case;
424
425 ast::CallExp* t_call_exp;
426
427 ast::MathExp* t_math_exp;
428
429 ast::OpExp* t_op_exp;
430 ast::OpExp::Oper t_op_exp_oper;
431 ast::LogicalOpExp::Oper t_lop_exp_oper;
432
433 ast::AssignExp* t_assign_exp;
434
435 ast::StringExp* t_string_exp;
436
437 ast::ListExp* t_implicit_list;
438
439 ast::MatrixExp* t_matrix_exp;
440 ast::MatrixLineExp* t_matrixline_exp;
441 ast::exps_t* t_list_mline;
442
443 ast::CellExp* t_cell_exp;
444
445 ast::CellCallExp* t_cell_call_exp;
446
447 ast::FunctionDec* t_function_dec;
448
449 ast::ArrayListExp* t_arraylist_exp;
450 ast::AssignListExp* t_assignlist_exp;
451 ast::ArrayListVar* t_arraylist_var;
452
453 ast::SimpleVar* t_simple_var;
454
455
456 };
457
458 typedef union YYSTYPE YYSTYPE;
459 # define YYSTYPE_IS_TRIVIAL 1
460 # define YYSTYPE_IS_DECLARED 1
461 #endif
462
463 /* Location type. */
464 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
465 typedef struct YYLTYPE YYLTYPE;
466 struct YYLTYPE
467 {
468 int first_line;
469 int first_column;
470 int last_line;
471 int last_column;
472 };
473 # define YYLTYPE_IS_DECLARED 1
474 # define YYLTYPE_IS_TRIVIAL 1
475 #endif
476
477
478 extern YYSTYPE yylval;
479 extern YYLTYPE yylloc;
480 int yyparse (void);
481
482 #endif /* !YY_YY_Y_TAB_H_INCLUDED */
483
484 /* Copy the second part of user declarations. */
485
486
487
488 #ifdef short
489 # undef short
490 #endif
491
492 #ifdef YYTYPE_UINT8
493 typedef YYTYPE_UINT8 yytype_uint8;
494 #else
495 typedef unsigned char yytype_uint8;
496 #endif
497
498 #ifdef YYTYPE_INT8
499 typedef YYTYPE_INT8 yytype_int8;
500 #else
501 typedef signed char yytype_int8;
502 #endif
503
504 #ifdef YYTYPE_UINT16
505 typedef YYTYPE_UINT16 yytype_uint16;
506 #else
507 typedef unsigned short int yytype_uint16;
508 #endif
509
510 #ifdef YYTYPE_INT16
511 typedef YYTYPE_INT16 yytype_int16;
512 #else
513 typedef short int yytype_int16;
514 #endif
515
516 #ifndef YYSIZE_T
517 # ifdef __SIZE_TYPE__
518 # define YYSIZE_T __SIZE_TYPE__
519 # elif defined size_t
520 # define YYSIZE_T size_t
521 # elif ! defined YYSIZE_T
522 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
523 # define YYSIZE_T size_t
524 # else
525 # define YYSIZE_T unsigned int
526 # endif
527 #endif
528
529 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
530
531 #ifndef YY_
532 # if defined YYENABLE_NLS && YYENABLE_NLS
533 # if ENABLE_NLS
534 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
535 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
536 # endif
537 # endif
538 # ifndef YY_
539 # define YY_(Msgid) Msgid
540 # endif
541 #endif
542
543 #ifndef YY_ATTRIBUTE
544 # if (defined __GNUC__ \
545 && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
546 || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
547 # define YY_ATTRIBUTE(Spec) __attribute__(Spec)
548 # else
549 # define YY_ATTRIBUTE(Spec) /* empty */
550 # endif
551 #endif
552
553 #ifndef YY_ATTRIBUTE_PURE
554 # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
555 #endif
556
557 #ifndef YY_ATTRIBUTE_UNUSED
558 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
559 #endif
560
561 #if !defined _Noreturn \
562 && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
563 # if defined _MSC_VER && 1200 <= _MSC_VER
564 # define _Noreturn __declspec (noreturn)
565 # else
566 # define _Noreturn YY_ATTRIBUTE ((__noreturn__))
567 # endif
568 #endif
569
570 /* Suppress unused-variable warnings by "using" E. */
571 #if ! defined lint || defined __GNUC__
572 # define YYUSE(E) ((void) (E))
573 #else
574 # define YYUSE(E) /* empty */
575 #endif
576
577 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
578 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
579 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
580 _Pragma ("GCC diagnostic push") \
581 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
582 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
583 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
584 _Pragma ("GCC diagnostic pop")
585 #else
586 # define YY_INITIAL_VALUE(Value) Value
587 #endif
588 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
589 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
590 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
591 #endif
592 #ifndef YY_INITIAL_VALUE
593 # define YY_INITIAL_VALUE(Value) /* Nothing. */
594 #endif
595
596
597 #if ! defined yyoverflow || YYERROR_VERBOSE
598
599 /* The parser invokes alloca or malloc; define the necessary symbols. */
600
601 # ifdef YYSTACK_USE_ALLOCA
602 # if YYSTACK_USE_ALLOCA
603 # ifdef __GNUC__
604 # define YYSTACK_ALLOC __builtin_alloca
605 # elif defined __BUILTIN_VA_ARG_INCR
606 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
607 # elif defined _AIX
608 # define YYSTACK_ALLOC __alloca
609 # elif defined _MSC_VER
610 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
611 # define alloca _alloca
612 # else
613 # define YYSTACK_ALLOC alloca
614 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
615 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
616 /* Use EXIT_SUCCESS as a witness for stdlib.h. */
617 # ifndef EXIT_SUCCESS
618 # define EXIT_SUCCESS 0
619 # endif
620 # endif
621 # endif
622 # endif
623 # endif
624
625 # ifdef YYSTACK_ALLOC
626 /* Pacify GCC's 'empty if-body' warning. */
627 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
628 # ifndef YYSTACK_ALLOC_MAXIMUM
629 /* The OS might guarantee only one guard page at the bottom of the stack,
630 and a page size can be as small as 4096 bytes. So we cannot safely
631 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
632 to allow for a few compiler-allocated temporary stack slots. */
633 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
634 # endif
635 # else
636 # define YYSTACK_ALLOC YYMALLOC
637 # define YYSTACK_FREE YYFREE
638 # ifndef YYSTACK_ALLOC_MAXIMUM
639 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
640 # endif
641 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
642 && ! ((defined YYMALLOC || defined malloc) \
643 && (defined YYFREE || defined free)))
644 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
645 # ifndef EXIT_SUCCESS
646 # define EXIT_SUCCESS 0
647 # endif
648 # endif
649 # ifndef YYMALLOC
650 # define YYMALLOC malloc
651 # if ! defined malloc && ! defined EXIT_SUCCESS
652 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
653 # endif
654 # endif
655 # ifndef YYFREE
656 # define YYFREE free
657 # if ! defined free && ! defined EXIT_SUCCESS
658 void free (void *); /* INFRINGES ON USER NAME SPACE */
659 # endif
660 # endif
661 # endif
662 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
663
664
665 #if (! defined yyoverflow \
666 && (! defined __cplusplus \
667 || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
668 && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
669
670 /* A type that is properly aligned for any stack member. */
671 union yyalloc
672 {
673 yytype_int16 yyss_alloc;
674 YYSTYPE yyvs_alloc;
675 YYLTYPE yyls_alloc;
676 };
677
678 /* The size of the maximum gap between one aligned stack and the next. */
679 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
680
681 /* The size of an array large to enough to hold all stacks, each with
682 N elements. */
683 # define YYSTACK_BYTES(N) \
684 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
685 + 2 * YYSTACK_GAP_MAXIMUM)
686
687 # define YYCOPY_NEEDED 1
688
689 /* Relocate STACK from its old location to the new one. The
690 local variables YYSIZE and YYSTACKSIZE give the old and new number of
691 elements in the stack, and YYPTR gives the new location of the
692 stack. Advance YYPTR to a properly aligned location for the next
693 stack. */
694 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
695 do \
696 { \
697 YYSIZE_T yynewbytes; \
698 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
699 Stack = &yyptr->Stack_alloc; \
700 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
701 yyptr += yynewbytes / sizeof (*yyptr); \
702 } \
703 while (0)
704
705 #endif
706
707 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
708 /* Copy COUNT objects from SRC to DST. The source and destination do
709 not overlap. */
710 # ifndef YYCOPY
711 # if defined __GNUC__ && 1 < __GNUC__
712 # define YYCOPY(Dst, Src, Count) \
713 __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
714 # else
715 # define YYCOPY(Dst, Src, Count) \
716 do \
717 { \
718 YYSIZE_T yyi; \
719 for (yyi = 0; yyi < (Count); yyi++) \
720 (Dst)[yyi] = (Src)[yyi]; \
721 } \
722 while (0)
723 # endif
724 # endif
725 #endif /* !YYCOPY_NEEDED */
726
727 /* YYFINAL -- State number of the termination state. */
728 #define YYFINAL 105
729 /* YYLAST -- Last index in YYTABLE. */
730 #define YYLAST 3501
731
732 /* YYNTOKENS -- Number of terminals. */
733 #define YYNTOKENS 85
734 /* YYNNTS -- Number of nonterminals. */
735 #define YYNNTS 64
736 /* YYNRULES -- Number of rules. */
737 #define YYNRULES 392
738 /* YYNSTATES -- Number of states. */
739 #define YYNSTATES 558
740
741 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
742 by yylex, with out-of-bounds checking. */
743 #define YYUNDEFTOK 2
744 #define YYMAXUTOK 339
745
746 #define YYTRANSLATE(YYX) \
747 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
748
749 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
750 as returned by yylex, without out-of-bounds checking. */
751 static const yytype_uint8 yytranslate[] =
752 {
753 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
754 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
755 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
756 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
757 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
758 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
759 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
760 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
761 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
762 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
763 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
764 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
765 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
766 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
767 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
768 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
769 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
770 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
771 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
772 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
773 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
774 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
775 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
776 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
777 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
778 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
779 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
780 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
781 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
782 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
783 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
784 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
785 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
786 75, 76, 77, 78, 79, 80, 81, 82, 83, 84
787 };
788
789 #if YYDEBUG
790 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
791 static const yytype_uint16 yyrline[] =
792 {
793 0, 403, 403, 404, 405, 414, 429, 433, 439, 446,
794 453, 468, 479, 488, 498, 517, 518, 519, 520, 521,
795 522, 530, 531, 532, 533, 534, 535, 536, 537, 538,
796 539, 540, 541, 542, 543, 544, 558, 564, 580, 581,
797 587, 593, 599, 600, 601, 602, 603, 610, 618, 620,
798 631, 632, 633, 634, 657, 658, 659, 660, 661, 662,
799 663, 664, 665, 666, 667, 668, 669, 670, 686, 698,
800 707, 717, 727, 739, 748, 758, 775, 783, 784, 785,
801 793, 799, 812, 813, 814, 815, 816, 824, 830, 845,
802 846, 854, 861, 876, 877, 878, 880, 881, 882, 884,
803 885, 886, 888, 889, 890, 892, 893, 894, 896, 897,
804 898, 900, 901, 902, 904, 905, 906, 908, 909, 910,
805 912, 913, 914, 922, 929, 936, 937, 938, 939, 940,
806 941, 942, 943, 944, 945, 946, 947, 948, 949, 950,
807 951, 960, 961, 963, 964, 966, 967, 968, 969, 970,
808 971, 972, 973, 975, 976, 977, 978, 979, 980, 981,
809 982, 984, 985, 986, 987, 988, 989, 990, 991, 999,
810 1000, 1008, 1009, 1010, 1018, 1019, 1020, 1021, 1022, 1028,
811 1029, 1030, 1035, 1040, 1041, 1042, 1043, 1044, 1045, 1046,
812 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, 1063,
813 1068, 1073, 1079, 1085, 1091, 1103, 1104, 1105, 1110, 1115,
814 1121, 1127, 1128, 1137, 1138, 1139, 1140, 1141, 1142, 1143,
815 1144, 1152, 1153, 1163, 1164, 1165, 1166, 1174, 1175, 1183,
816 1184, 1185, 1186, 1187, 1188, 1189, 1190, 1191, 1199, 1200,
817 1208, 1209, 1210, 1211, 1213, 1214, 1216, 1217, 1226, 1227,
818 1228, 1229, 1230, 1231, 1232, 1233, 1234, 1241, 1250, 1251,
819 1262, 1270, 1276, 1291, 1297, 1314, 1315, 1316, 1317, 1318,
820 1326, 1327, 1328, 1329, 1330, 1331, 1339, 1340, 1341, 1342,
821 1343, 1344, 1352, 1358, 1372, 1388, 1389, 1400, 1401, 1420,
822 1421, 1429, 1430, 1431, 1432, 1433, 1434, 1435, 1443, 1444,
823 1452, 1453, 1454, 1455, 1456, 1464, 1465, 1466, 1467, 1468,
824 1469, 1473, 1479, 1494, 1495, 1496, 1497, 1498, 1499, 1500,
825 1501, 1502, 1503, 1504, 1505, 1513, 1514, 1522, 1523, 1532,
826 1533, 1534, 1535, 1536, 1537, 1538, 1539, 1543, 1549, 1564,
827 1572, 1578, 1593, 1594, 1595, 1596, 1597, 1598, 1599, 1600,
828 1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 1609, 1610,
829 1618, 1619, 1634, 1640, 1646, 1652, 1658, 1666, 1681, 1682,
830 1683, 1690, 1691, 1699, 1700, 1708, 1709, 1710, 1711, 1712,
831 1713, 1714, 1715, 1716, 1717, 1718, 1719, 1720, 1721, 1722,
832 1723, 1724, 1725
833 };
834 #endif
835
836 #if YYDEBUG || YYERROR_VERBOSE || 0
837 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
838 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
839 static const char *const yytname[] =
840 {
841 "\"end of file\"", "error", "$undefined", "\"line break\"",
842 "\"end of line\"", "\"spaces\"", "\"%t or %T\"", "\"%f or %F\"", "\"'\"",
843 "\"~ or @\"", "\"$\"", "\",\"", "\":\"", "\";\"", "\"(\"", "\")\"",
844 "\"[\"", "\"]\"", "\"{\"", "\"}\"", "\".\"", "\".'\"", "\"+\"", "\"-\"",
845 "\"*\"", "\".*\"", "\".*.\"", "\"*.\"", "\"/\"", "\"./\"", "\"/.\"",
846 "\"./.\"", "\"\\\\\"", "\".\\\\\"", "\"\\\\.\"", "\".\\\\.\"",
847 "\"** or ^\"", "\".^\"", "\"==\"", "\"<> or ~=\"", "\"<\"", "\"<=\"",
848 "\">\"", "\">=\"", "\"&\"", "\"&&\"", "\"|\"", "\"||\"", "\"=\"",
849 "\"if\"", "\"then\"", "\"else\"", "\"elseif\"", "\"end\"", "\"select\"",
850 "\"switch\"", "\"case\"", "\"otherwise\"", "\"function\"",
851 "\"endfunction\"", "\"for\"", "\"while\"", "\"do\"", "\"break\"",
852 "\"continue\"", "\"try\"", "\"catch\"", "\"return\"", "FLEX_ERROR",
853 "\"string\"", "\"identifier\"", "\"integer\"", "\"float\"", "\"number\"",
854 "\"path\"", "\"line comment\"", "\"block comment\"", "TOPLEVEL",
855 "HIGHLEVEL", "UPLEVEL", "LISTABLE", "CONTROLBREAK", "UMINUS", "UPLUS",
856 "FUNCTIONCALL", "$accept", "program", "expressions",
857 "recursiveExpression", "expressionLineBreak", "expression",
858 "implicitFunctionCall", "implicitCallable", "functionCall",
859 "simpleFunctionCall", "functionArgs", "functionDeclaration",
860 "functionDeclarationReturns", "functionDeclarationArguments", "idList",
861 "functionDeclarationBreak", "functionBody", "condition", "comparison",
862 "rightComparable", "operation", "rightOperand", "listableBegin",
863 "listableEnd", "variable", "variableFields", "cell", "matrix",
864 "matrixOrCellLines", "matrixOrCellLineBreak", "matrixOrCellLine",
865 "matrixOrCellColumns", "matrixOrCellColumnsBreak", "variableDeclaration",
866 "assignable", "multipleResults", "ifControl", "thenBody", "elseBody",
867 "ifConditionBreak", "then", "else", "elseIfControl", "selectControl",
868 "select", "defaultCase", "selectable", "selectConditionBreak",
869 "casesControl", "caseBody", "caseControlBreak", "forControl",
870 "forIterator", "forConditionBreak", "forBody", "whileControl",
871 "whileBody", "whileConditionBreak", "tryControl", "catchBody",
872 "returnControl", "comments", "lineEnd", "keywords", YY_NULLPTR
873 };
874 #endif
875
876 # ifdef YYPRINT
877 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
878 (internal) symbol number NUM (which must be that of a token). */
879 static const yytype_uint16 yytoknum[] =
880 {
881 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
882 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
883 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
884 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
885 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
886 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
887 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
888 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
889 335, 336, 337, 338, 339
890 };
891 # endif
892
893 #define YYPACT_NINF -461
894
895 #define yypact_value_is_default(Yystate) \
896 (!!((Yystate) == (-461)))
897
898 #define YYTABLE_NINF -368
899
900 #define yytable_value_is_error(Yytable_value) \
901 0
902
903 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
904 STATE-NUM. */
905 static const yytype_int16 yypact[] =
906 {
907 273, -461, 665, -461, -461, 2743, -461, -461, -461, 2743,
908 418, 1995, 2743, 2743, 2743, -461, -461, 25, 4, 2743,
909 -461, -461, 1120, 2743, -461, 287, -461, -461, -461, -461,
910 33, -461, 192, 97, 24, 406, 2881, -461, -461, -461,
911 -461, 3002, -461, -461, -461, 22, -461, -461, -461, 2743,
912 -461, -461, -461, -461, -461, 418, 147, 3, 171, 2922,
913 2962, 216, 514, -461, -461, 3042, 3082, 626, -461, 302,
914 2013, -461, 2031, 392, 672, 733, 672, 733, 3042, 96,
915 3082, 13, 131, 21, 50, 163, 1484, 1705, 1705, -461,
916 128, 3042, 3082, -461, -461, -461, 2137, 2205, -461, -461,
917 -461, -461, -461, -461, 83, -461, 27, -461, -461, -461,
918 -461, 215, 97, 83, -461, 2743, 2223, 3409, -461, 2743,
919 2743, 2743, 2743, 2743, 2743, 2743, 2743, 2743, 2743, 2743,
920 2743, 2743, 2743, 2743, 2743, 2327, 2345, 2413, 2431, 2449,
921 2517, 2535, 2553, 2621, 2639, 2241, -461, -461, 94, -461,
922 -461, 2223, 1050, -461, 2743, 2743, -461, -461, -461, 2309,
923 3042, 3082, 39, 1148, 2223, 3431, 2223, 2719, 2743, -461,
924 2743, -461, 2743, -461, -461, 2101, 1303, -461, -461, 1775,
925 -461, -461, -461, 65, -461, 3042, 3082, 40, 1925, -461,
926 2119, 1795, -461, 1815, -461, -461, 166, 169, 229, 154,
927 750, 149, -461, 195, 198, 6, 150, 69, 174, 2743,
928 -461, 213, 230, 265, 277, 266, 1582, -461, -461, -461,
929 -461, 1333, 2657, -461, -461, 189, 2881, 224, 3002, -461,
930 -461, 38, 232, 215, 97, 97, 3330, 3360, 257, -461,
931 -461, -461, -461, -461, -461, -461, -461, -461, -461, -461,
932 -461, -461, -461, -461, -461, -461, -461, 252, 259, 3390,
933 3420, 3390, 3420, 672, 733, 672, 733, 672, 733, 672,
934 733, 672, 733, 672, 733, 672, 733, 672, 733, 672,
935 733, 672, 733, 672, 733, 672, 733, 672, 733, 672,
936 733, -461, 3270, 3300, -461, 3270, 3300, -461, 3270, 3300,
937 -461, 3270, 3300, -461, 3270, 3300, -461, 3270, 3300, -461,
938 3198, 3234, -461, 3198, 3234, -461, 3122, 3160, -461, 3122,
939 3160, -461, 3042, 3082, -461, 2743, 260, 15, 218, 269,
940 281, 672, 733, 672, 733, -461, 3042, 3082, -461, -461,
941 328, 359, 365, -43, -461, 288, -461, -461, 299, 147,
942 -461, -461, 3042, 3082, 3042, 3082, 3042, 3082, -461, 1885,
943 -461, -461, -461, -461, -461, -461, 3042, 3082, 40, -461,
944 1905, -461, -461, -461, -461, -461, 361, -461, 298, 300,
945 332, 312, -461, 315, 367, -461, 381, 390, 391, 1509,
946 -461, 2743, 3042, 3082, 43, -461, -461, -461, 393, 396,
947 -461, 400, 405, -461, -461, 364, 370, -461, 2881, 3002,
948 -461, 2725, -461, -461, -461, 97, 372, 3330, 3360, 378,
949 147, 403, -461, -461, -43, 2743, 425, 311, -14, -461,
950 -461, -461, -461, -461, 375, 2743, -461, 1607, 377, 367,
951 363, -461, -461, 69, -461, -461, -461, -461, 137, 423,
952 -461, 435, 439, 440, 1680, -461, -461, -461, -461, -461,
953 -461, -461, 2881, 3002, -461, 402, 2797, 2841, -461, -461,
954 2743, 379, -461, 1607, 2743, 441, -461, 448, 453, 96,
955 -461, 415, -461, 69, 367, 1509, -461, -461, 43, -461,
956 -461, -461, -461, 416, -461, 1607, -461, 467, 468, 380,
957 1409, 1409, 2797, 2841, -461, 470, 477, 429, 2797, 2841,
958 -461, -461, -461, 750, -461, 1509, 69, 201, 1680, -461,
959 430, -461, -461, -461, 480, 490, -461, -461, -461, 1409,
960 1409, -461, -461, -461, 1409, 1409, 102, 239, 1509, -461,
961 -461, 443, -461, -461, -461, -461, -461, -461, -461, 1607,
962 -461, -461, -461, 294, -461, -461, -461, -461
963 };
964
965 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
966 Performed when YYTABLE does not specify something else to do. Zero
967 means the default is an error. */
968 static const yytype_uint16 yydefact[] =
969 {
970 0, 35, 0, 192, 193, 0, 191, 16, 15, 0,
971 0, 0, 0, 0, 0, 289, 290, 0, 0, 0,
972 31, 32, 0, 368, 190, 186, 187, 189, 188, 34,
973 0, 2, 0, 4, 9, 30, 22, 48, 21, 196,
974 185, 29, 184, 183, 23, 0, 254, 24, 25, 0,
975 26, 27, 28, 33, 3, 0, 186, 175, 174, 0,
976 0, 0, 0, 220, 237, 236, 235, 0, 222, 0,
977 0, 212, 0, 0, 128, 127, 126, 125, 89, 275,
978 90, 0, 79, 0, 0, 0, 0, 0, 0, 362,
979 0, 370, 369, 44, 45, 43, 0, 0, 42, 38,
980 39, 41, 40, 47, 37, 1, 7, 20, 19, 18,
981 17, 10, 14, 36, 139, 0, 0, 0, 140, 0,
982 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
983 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
984 0, 0, 0, 0, 0, 0, 92, 124, 173, 182,
985 137, 0, 0, 138, 0, 0, 91, 123, 181, 0,
986 299, 298, 0, 0, 0, 0, 0, 0, 0, 49,
987 0, 194, 0, 195, 219, 0, 0, 213, 221, 0,
988 224, 239, 223, 217, 233, 232, 231, 227, 0, 211,
989 0, 0, 205, 0, 209, 269, 267, 265, 270, 274,
990 0, 0, 81, 0, 76, 0, 0, 0, 0, 0,
991 351, 342, 343, 347, 344, 0, 0, 363, 365, 364,
992 361, 0, 58, 56, 52, 186, 55, 0, 54, 57,
993 53, 0, 0, 8, 11, 13, 170, 169, 0, 375,
994 376, 377, 378, 379, 380, 381, 383, 382, 384, 385,
995 386, 387, 388, 389, 390, 391, 392, 179, 180, 142,
996 141, 144, 143, 146, 145, 148, 147, 150, 149, 152,
997 151, 154, 153, 156, 155, 160, 159, 158, 157, 162,
998 161, 164, 163, 168, 167, 166, 165, 132, 131, 136,
999 135, 107, 106, 105, 110, 109, 108, 116, 115, 114,
1000 122, 121, 120, 113, 112, 111, 119, 118, 117, 95,
1001 94, 93, 98, 97, 96, 101, 100, 99, 104, 103,
1002 102, 245, 243, 242, 247, 0, 0, 0, 176, 178,
1003 177, 130, 129, 134, 133, 244, 241, 240, 246, 300,
1004 303, 304, 0, 0, 217, 0, 179, 180, 0, 176,
1005 178, 177, 202, 203, 204, 201, 200, 199, 214, 0,
1006 218, 215, 225, 226, 238, 234, 230, 229, 228, 206,
1007 0, 210, 207, 268, 266, 273, 271, 261, 0, 0,
1008 0, 0, 78, 0, 79, 373, 85, 83, 0, 0,
1009 82, 0, 327, 328, 336, 352, 353, 357, 348, 349,
1010 354, 345, 346, 350, 340, 0, 0, 61, 60, 59,
1011 62, 63, 50, 51, 46, 12, 198, 172, 171, 197,
1012 0, 0, 301, 302, 0, 0, 0, 0, 0, 198,
1013 197, 216, 208, 272, 276, 0, 258, 0, 0, 79,
1014 0, 80, 77, 0, 86, 84, 374, 87, 0, 0,
1015 329, 332, 330, 334, 0, 358, 359, 355, 356, 339,
1016 360, 66, 65, 64, 67, 0, 324, 324, 371, 285,
1017 0, 292, 291, 0, 0, 0, 279, 277, 278, 275,
1018 263, 0, 260, 0, 79, 0, 75, 71, 336, 333,
1019 331, 335, 337, 0, 287, 0, 316, 314, 315, 313,
1020 0, 0, 324, 324, 295, 293, 294, 0, 324, 324,
1021 372, 280, 281, 0, 259, 0, 0, 0, 0, 325,
1022 0, 318, 319, 317, 320, 322, 311, 306, 305, 0,
1023 0, 296, 297, 286, 0, 0, 282, 0, 0, 72,
1024 68, 0, 288, 321, 323, 310, 309, 308, 307, 0,
1025 284, 74, 70, 0, 326, 283, 73, 69
1026 };
1027
1028 /* YYPGOTO[NTERM-NUM]. */
1029 static const yytype_int16 yypgoto[] =
1030 {
1031 -461, -461, 0, -461, -22, 465, -461, 463, -4, -461,
1032 188, -461, -461, -380, 295, -419, -460, -16, -461, 581,
1033 -461, 705, -461, 974, 437, -461, -461, -461, 9, 313,
1034 -33, 5, -461, -70, -461, -461, -461, -11, -459, 305,
1035 26, -367, -28, -461, -461, 46, -461, 170, 90, -352,
1036 -279, -461, 125, 29, 1, -461, -461, -461, -461, 301,
1037 -97, -461, -461, -9
1038 };
1039
1040 /* YYDEFGOTO[NTERM-NUM]. */
1041 static const yytype_int16 yydefgoto[] =
1042 {
1043 -1, 30, 526, 32, 33, 34, 35, 104, 36, 37,
1044 227, 38, 203, 207, 204, 389, 448, 79, 39, 146,
1045 40, 147, 148, 149, 41, 61, 42, 43, 67, 187,
1046 68, 69, 188, 44, 45, 46, 47, 378, 481, 199,
1047 200, 472, 438, 48, 49, 473, 162, 343, 427, 527,
1048 500, 50, 394, 454, 493, 51, 405, 216, 52, 90,
1049 53, 428, 390, 258
1050 };
1051
1052 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
1053 positive, shift that token. If negative, reduce the rule whose
1054 number is the opposite. If YYTABLE_NINF, syntax error. */
1055 static const yytype_int16 yytable[] =
1056 {
1057 31, 57, 54, 85, 443, 59, 65, 65, 74, 76,
1058 78, 437, 112, 425, 507, 78, 73, 164, 83, 91,
1059 72, 382, 89, 165, 485, 517, 229, 229, 110, 327,
1060 201, 110, 426, 105, 178, 7, 520, 8, 7, 178,
1061 8, 81, 474, 339, 362, 160, 229, 450, 324, 411,
1062 340, 65, 341, 363, 451, 537, 452, 413, 65, 483,
1063 163, 475, 338, 65, 515, 185, 65, 176, 65, 185,
1064 159, 175, 179, 385, 84, 191, 202, 193, 553, 190,
1065 386, 229, 387, 202, 234, 420, 217, 218, 219, 235,
1066 555, 208, 226, 226, 229, 82, 229, 538, 209, 111,
1067 195, 107, 233, 232, 516, 453, 325, 196, 108, 197,
1068 109, 236, 226, -257, 342, 259, 261, 263, 265, 267,
1069 269, 271, 273, 275, 277, 279, 281, 283, 285, 287,
1070 289, 292, 295, 298, 301, 304, 307, 310, 313, 316,
1071 319, 322, 178, 330, 388, 205, 198, 226, 329, 528,
1072 331, 333, 410, 434, 435, 336, 347, 178, 351, 185,
1073 226, 96, 226, 350, 352, 97, 354, 210, 356, 549,
1074 373, 65, 185, 374, 211, 185, 212, 545, 546, 206,
1075 359, 220, 547, 548, 366, 166, 65, 185, 501, 185,
1076 486, 167, -6, 1, 221, 370, 487, 379, 3, 4,
1077 377, 5, 6, 96, 376, 392, 9, 97, 10, 381,
1078 11, 415, 380, 213, 12, 13, 404, 395, 408, 110,
1079 384, 89, 391, 529, 530, 214, 7, 172, 8, 534,
1080 535, 173, 96, 195, 396, 411, 97, -253, 215, 412,
1081 196, 14, 197, -6, -6, -6, 15, 16, -6, -6,
1082 17, -6, 18, 19, 539, 20, 21, 22, -6, 23,
1083 540, 24, 25, 26, 27, 28, -248, 29, 411, 397,
1084 403, 411, 416, -5, 1, 419, 398, 2, 399, 3,
1085 4, 400, 5, 6, 7, 231, 8, 9, 401, 10,
1086 402, 11, 551, 93, 94, 12, 13, 95, 552, 411,
1087 -251, 96, 414, 429, 238, 97, 180, -252, 3, 4,
1088 411, 5, 6, 181, 430, 182, 9, -250, 55, 183,
1089 11, 417, 14, 421, 12, 13, 381, 15, 16, -249,
1090 442, 17, 422, 18, 19, -253, 20, 21, 22, 326,
1091 23, 464, 24, 25, 26, 27, 28, 556, 29, 434,
1092 435, 436, 345, 557, 348, 185, 98, 99, 100, 101,
1093 102, 103, 434, 423, 469, 433, 185, 470, 471, 339,
1094 439, 24, 56, 26, 27, 28, 340, 184, 341, 476,
1095 440, 205, 441, 504, 523, 444, 477, 392, 478, 447,
1096 505, 524, 506, 525, 445, 446, 180, 455, 3, 4,
1097 456, 5, 6, 181, 457, 182, 9, 462, 55, 458,
1098 11, 194, 93, 94, 12, 13, 95, 459, 169, 479,
1099 -256, 466, 62, 460, 3, 4, -255, 5, 6, 468,
1100 482, 78, 9, 484, 55, 63, 11, 480, 488, 489,
1101 12, 13, 58, 490, 491, 510, 60, 66, 66, 75,
1102 77, 80, 511, 434, 492, 494, 80, 512, 470, 471,
1103 92, 24, 56, 26, 27, 28, 502, 184, 514, 519,
1104 508, 521, 522, 480, 531, 98, 99, 100, 101, 102,
1105 103, 532, 533, 542, 543, 447, 161, 24, 56, 26,
1106 27, 28, 66, 64, 544, 480, 554, 106, 113, 66,
1107 383, 368, 536, 375, 66, 513, 186, 66, 550, 66,
1108 186, 495, 424, 377, 465, 447, 449, 518, 492, 541,
1109 3, 4, 406, 5, 6, 0, 0, 0, 9, 0,
1110 55, 174, 11, 228, 228, 0, 12, 13, 447, 0,
1111 0, 0, 0, 0, 0, 0, 0, 0, 0, 480,
1112 0, 0, 237, 228, 0, 0, 260, 262, 264, 266,
1113 268, 270, 272, 274, 276, 278, 280, 282, 284, 286,
1114 288, 290, 293, 296, 299, 302, 305, 308, 311, 314,
1115 317, 320, 323, 24, 56, 26, 27, 28, 228, 64,
1116 0, 332, 334, 0, 0, 0, 337, 0, 0, 0,
1117 186, 228, 0, 228, 0, 353, 0, 355, 0, 357,
1118 0, 0, 66, 186, 0, 0, 186, 0, 0, 0,
1119 0, 0, 156, 0, 0, 367, 0, 66, 186, 0,
1120 186, 0, 3, 4, 0, 5, 6, 0, 0, 156,
1121 9, 156, 55, 177, 11, 0, 393, 156, 12, 13,
1122 0, 0, 0, 0, 0, 0, 156, 0, 156, 409,
1123 0, 156, 0, 0, 0, -17, 1, 0, 0, -17,
1124 0, 3, 4, 156, 5, 6, -17, 0, -17, 9,
1125 114, 10, 0, 11, 0, 0, 164, 12, 13, 0,
1126 0, 0, 165, 118, 0, 24, 56, 26, 27, 28,
1127 0, 64, 0, 0, 0, 0, 0, 0, 133, 134,
1128 0, 0, 0, 0, 14, 0, 0, 0, 0, 15,
1129 16, 0, 0, 17, 0, 18, 19, 0, 20, 21,
1130 22, 0, 23, 0, 24, 25, 26, 27, 28, 0,
1131 29, 150, 156, 0, 0, 0, 157, 166, 0, 0,
1132 0, 1, 0, 167, 153, 0, 3, 4, 0, 5,
1133 6, 0, 418, 157, 9, 157, 10, 156, 11, 154,
1134 155, 157, 12, 13, 0, 0, 0, 0, 0, 0,
1135 157, 0, 157, 0, 0, 157, 0, 0, 0, 0,
1136 0, 0, 0, 0, 0, 0, 186, 157, 0, 14,
1137 0, -262, -262, -262, 15, 16, 0, 186, 17, 156,
1138 18, 19, 0, 20, 21, 22, 0, 23, 156, 24,
1139 25, 26, 27, 28, 0, 29, 0, 0, 393, 0,
1140 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1141 0, 156, 0, 156, 0, 156, 0, 156, 463, 156,
1142 0, 156, 0, 156, 0, 156, 0, 156, 0, 156,
1143 0, 156, 467, 156, 0, 156, 157, 156, 0, 156,
1144 0, 156, 80, 0, 156, 0, 0, 156, 0, 0,
1145 156, 0, 0, 156, 0, 0, 156, 0, 0, 156,
1146 0, 157, 156, 0, 0, 156, 0, 0, 156, 0,
1147 0, 156, 0, 0, 156, 0, 0, 503, 0, 0,
1148 0, 509, 0, 156, 0, 156, 0, 0, 156, 0,
1149 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1150 0, 0, 0, 157, 156, 0, 156, 0, 156, 0,
1151 0, 0, 157, 0, 0, 0, 0, 0, 156, 0,
1152 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1153 0, 0, 0, 0, 0, 157, 0, 157, 0, 157,
1154 0, 157, 0, 157, 156, 157, 0, 157, 0, 157,
1155 0, 157, 0, 157, 0, 157, 0, 157, 0, 157,
1156 156, 157, 0, 157, 0, 157, 0, 0, 157, 156,
1157 0, 157, 0, 0, 157, 0, 0, 157, 0, 0,
1158 157, 0, 0, 157, 0, 158, 157, 0, 0, 157,
1159 0, 0, 157, 0, 0, 157, 0, 0, 157, 0,
1160 0, 0, 158, 0, 158, 0, 0, 157, 0, 157,
1161 158, 0, 157, 0, 156, 0, 0, 0, 156, 158,
1162 0, 158, 0, 0, 158, 0, 0, 0, 157, 0,
1163 157, 0, 157, 0, 327, 0, 158, 0, 0, 0,
1164 0, 0, 157, 0, 0, 0, 0, 0, 0, 0,
1165 0, 0, 0, 0, 156, 0, 0, 0, 0, 0,
1166 156, 0, 0, 0, 0, 0, 0, 0, 157, 239,
1167 240, 241, 242, 243, 244, 245, 246, 247, 248, 249,
1168 250, 251, 252, 253, 157, 254, 255, 256, 0, 0,
1169 328, 1, 0, 157, 86, 0, 3, 4, 0, 5,
1170 6, 87, 0, 88, 9, 158, 10, 0, 11, 0,
1171 0, 0, 12, 13, 0, 0, 0, 0, 0, 0,
1172 0, 0, 180, 0, 3, 4, 0, 5, 6, 181,
1173 158, 182, 9, 0, 55, 344, 11, 0, 157, 14,
1174 12, 13, 157, -367, 15, 16, 0, 0, 17, 0,
1175 18, 19, 0, 20, 21, 22, -367, 23, 0, 24,
1176 25, 26, 27, 28, 0, 29, 0, 0, 0, 0,
1177 0, 0, 158, 0, 0, 0, 0, 0, 157, 0,
1178 0, 158, 0, 0, 157, 0, 0, 24, 56, 26,
1179 27, 28, 0, 184, 0, 0, 0, 0, 0, 0,
1180 0, 0, 0, 0, 158, 0, 158, 0, 158, 0,
1181 158, 0, 158, 0, 158, 0, 158, 0, 158, 0,
1182 158, 0, 158, 0, 158, 0, 158, 0, 158, 0,
1183 158, 0, 158, 0, 158, 0, 0, 158, 0, 0,
1184 158, 0, 0, 158, 0, 0, 158, 0, 0, 158,
1185 0, 0, 158, 0, 0, 158, 0, 0, 158, 0,
1186 0, 158, 0, 0, 158, 0, 0, 158, 0, 0,
1187 0, 0, 0, 0, 0, 0, 158, 180, 158, 3,
1188 4, 158, 5, 6, 181, 0, 182, 9, 0, 55,
1189 360, 11, 0, 0, 0, 12, 13, 158, 0, 158,
1190 0, 158, 0, 0, 1, 0, 0, 86, 0, 3,
1191 4, 158, 5, 6, 87, 0, 88, 9, 0, 10,
1192 0, 11, 0, 0, 0, 12, 13, 0, 0, 0,
1193 0, 0, 0, 0, 0, 0, 0, 158, 0, 0,
1194 0, 0, 24, 56, 26, 27, 28, 0, 184, 0,
1195 0, 0, 14, 158, 0, 0, -367, 15, 16, 0,
1196 0, 17, 158, 18, 19, 0, 20, 21, 22, 0,
1197 23, 0, 24, 25, 26, 27, 28, 0, 29, 0,
1198 1, 0, 0, 0, 0, 3, 4, 0, 5, 6,
1199 0, 0, 0, 9, 0, 10, 0, 11, 0, 0,
1200 0, 12, 13, 0, 0, 0, 0, 158, 0, 0,
1201 0, 158, 0, 0, 0, 0, 0, 0, 0, 0,
1202 0, 0, 0, 0, 0, 0, 0, 0, 14, 0,
1203 -312, 0, -312, 15, 16, -312, -312, 17, 0, 18,
1204 19, 0, 20, 21, 22, 0, 23, 158, 24, 25,
1205 26, 27, 28, 158, 29, 1, 0, 0, 0, 0,
1206 3, 4, 0, 5, 6, 0, 0, 0, 9, 0,
1207 10, 0, 11, 0, 0, 0, 12, 13, 0, 0,
1208 1, 0, 0, 0, 0, 3, 4, 0, 5, 6,
1209 0, 0, 0, 9, 0, 10, 0, 11, 0, 0,
1210 0, 12, 13, 14, 0, 0, 0, -366, 15, 16,
1211 0, 0, 17, 0, 18, 19, 0, 20, 21, 22,
1212 -366, 23, 0, 24, 25, 26, 27, 28, 14, 29,
1213 0, 0, -88, 15, 16, 0, 0, 17, -88, 18,
1214 19, 0, 20, 21, 22, 0, 23, 0, 24, 25,
1215 26, 27, 28, 1, 29, 0, 0, 0, 3, 4,
1216 0, 5, 6, 0, 0, 0, 9, 0, 10, 0,
1217 11, 0, 0, 0, 12, 13, 0, 0, 1, 0,
1218 0, 0, 0, 3, 4, 0, 5, 6, 0, 0,
1219 0, 9, 0, 10, 0, 11, 0, 0, 0, 12,
1220 13, 14, 0, 0, 0, -341, 15, 16, 0, 0,
1221 17, 0, 18, 19, 0, 20, 21, 22, 0, 23,
1222 0, 24, 25, 26, 27, 28, 14, 29, 0, 0,
1223 -264, 15, 16, 0, 0, 17, 0, 18, 19, 0,
1224 20, 21, 22, 0, 23, 0, 24, 25, 26, 27,
1225 28, 1, 29, 0, 0, 0, 3, 4, 0, 5,
1226 6, 0, 0, 0, 9, 0, 10, 0, 11, 0,
1227 0, 0, 12, 13, 0, 0, 1, 0, 0, 0,
1228 0, 3, 4, 0, 5, 6, 0, 0, 0, 9,
1229 0, 10, 0, 11, 0, 0, 0, 12, 13, 14,
1230 0, 0, 0, -338, 15, 16, 0, 0, 17, 0,
1231 18, 19, 0, 20, 21, 22, 0, 23, 0, 24,
1232 25, 26, 27, 28, 14, 29, 0, 0, 0, 15,
1233 16, 0, 0, 17, 0, 18, 19, 0, 20, 21,
1234 22, 0, 23, 0, 24, 25, 26, 27, 28, 180,
1235 29, 3, 4, 0, 5, 6, 181, 0, 182, 9,
1236 0, 55, 361, 11, 0, 0, 0, 12, 13, 180,
1237 0, 3, 4, 0, 5, 6, 181, 0, 182, 9,
1238 0, 55, 0, 11, 371, 0, 0, 12, 13, 180,
1239 0, 3, 4, 0, 5, 6, 181, 0, 182, 9,
1240 0, 55, 0, 11, 372, 0, 0, 12, 13, 0,
1241 0, 0, 0, 0, 24, 56, 26, 27, 28, 0,
1242 184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1243 0, 0, 0, 0, 24, 56, 26, 27, 28, 0,
1244 184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1245 0, 0, 0, 0, 24, 56, 26, 27, 28, 180,
1246 184, 3, 4, 0, 5, 6, 181, 0, 182, 9,
1247 0, 55, 431, 11, 0, 0, 0, 12, 13, 180,
1248 0, 3, 4, 0, 5, 6, 181, 0, 182, 9,
1249 0, 55, 0, 11, 432, 0, 0, 12, 13, 180,
1250 0, 3, 4, 0, 5, 6, 364, 0, 182, 9,
1251 0, 55, 0, 11, 0, 0, 0, 12, 13, 0,
1252 0, 0, 0, 0, 24, 56, 26, 27, 28, 0,
1253 184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1254 0, 0, 0, 0, 24, 56, 26, 27, 28, 0,
1255 184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1256 0, 0, 0, 0, 24, 56, 26, 27, 28, 70,
1257 365, 3, 4, 0, 5, 6, 0, 0, 0, 9,
1258 0, 55, 0, 11, 71, 0, 0, 12, 13, 3,
1259 4, 0, 5, 6, 0, 0, 0, 9, 0, 55,
1260 0, 11, 189, 0, 0, 12, 13, 3, 4, 0,
1261 5, 6, 0, 0, 0, 9, 0, 55, 0, 11,
1262 192, 0, 0, 12, 13, 0, 0, 0, 0, 0,
1263 0, 0, 0, 0, 24, 56, 26, 27, 28, 0,
1264 64, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1265 0, 0, 24, 56, 26, 27, 28, 0, 64, 0,
1266 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1267 24, 56, 26, 27, 28, 0, 64, 3, 4, 0,
1268 5, 6, 0, 0, 0, 9, 0, 55, 358, 11,
1269 0, 0, 0, 12, 13, 3, 4, 0, 5, 6,
1270 0, 0, 0, 9, 0, 55, 0, 11, 369, 0,
1271 0, 12, 13, 3, 4, 0, 5, 6, 222, 223,
1272 0, 9, 224, 10, 0, 11, 0, 0, 0, 12,
1273 13, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1274 24, 56, 26, 27, 28, 0, 64, 0, 0, 0,
1275 0, 0, 0, 0, 0, 0, 0, 0, 24, 56,
1276 26, 27, 28, 0, 64, 0, 0, 0, 0, 0,
1277 0, 0, 0, 0, 0, 0, 24, 225, 26, 27,
1278 28, 3, 4, 0, 5, 6, 222, 223, 0, 9,
1279 0, 10, 0, 11, 230, 0, 0, 12, 13, 3,
1280 4, 0, 5, 6, 222, 223, 0, 9, 0, 10,
1281 0, 11, 0, 0, 0, 12, 13, 3, 4, 0,
1282 5, 6, 0, 321, 0, 9, 0, 55, 0, 11,
1283 0, 0, 0, 12, 13, 0, 0, 0, 0, 0,
1284 0, 0, 0, 0, 24, 225, 26, 27, 28, 0,
1285 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1286 0, 0, 24, 225, 26, 27, 28, 0, 0, 0,
1287 0, 0, 0, 0, 0, 0, 0, 0, 23, 0,
1288 24, 56, 26, 27, 28, 3, 4, 0, 5, 6,
1289 0, 335, 0, 9, 0, 55, 0, 11, 0, 0,
1290 0, 12, 13, 3, 4, 0, 5, 6, 0, 291,
1291 0, 9, 0, 55, 0, 11, 0, 0, 0, 12,
1292 13, 3, 4, 0, 5, 6, 0, 294, 0, 9,
1293 0, 55, 0, 11, 0, 0, 0, 12, 13, 0,
1294 0, 0, 0, 0, 0, 0, 23, 0, 24, 56,
1295 26, 27, 28, 0, 0, 0, 0, 0, 0, 0,
1296 0, 0, 0, 0, 0, 0, 24, 56, 26, 27,
1297 28, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1298 0, 0, 0, 0, 24, 56, 26, 27, 28, 3,
1299 4, 0, 5, 6, 0, 297, 0, 9, 0, 55,
1300 0, 11, 0, 0, 0, 12, 13, 3, 4, 0,
1301 5, 6, 0, 300, 0, 9, 0, 55, 0, 11,
1302 0, 0, 0, 12, 13, 3, 4, 0, 5, 6,
1303 0, 303, 0, 9, 0, 55, 0, 11, 0, 0,
1304 0, 12, 13, 0, 0, 0, 0, 0, 0, 0,
1305 0, 0, 24, 56, 26, 27, 28, 0, 0, 0,
1306 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1307 24, 56, 26, 27, 28, 0, 0, 0, 0, 0,
1308 0, 0, 0, 0, 0, 0, 0, 0, 24, 56,
1309 26, 27, 28, 3, 4, 0, 5, 6, 0, 306,
1310 0, 9, 0, 55, 0, 11, 0, 0, 0, 12,
1311 13, 3, 4, 0, 5, 6, 0, 309, 0, 9,
1312 0, 55, 0, 11, 0, 0, 0, 12, 13, 3,
1313 4, 0, 5, 6, 0, 312, 0, 9, 0, 55,
1314 0, 11, 0, 0, 0, 12, 13, 0, 0, 0,
1315 0, 0, 0, 0, 0, 0, 24, 56, 26, 27,
1316 28, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1317 0, 0, 0, 0, 24, 56, 26, 27, 28, 0,
1318 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1319 0, 0, 24, 56, 26, 27, 28, 3, 4, 0,
1320 5, 6, 0, 315, 0, 9, 0, 55, 0, 11,
1321 0, 0, 0, 12, 13, 3, 4, 0, 5, 6,
1322 0, 318, 0, 9, 0, 55, 0, 11, 0, 0,
1323 0, 12, 13, 3, 4, 0, 5, 6, 0, 407,
1324 0, 9, 0, 10, 0, 11, 0, 0, 0, 12,
1325 13, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1326 24, 56, 26, 27, 28, 0, 0, 0, 0, 0,
1327 0, 0, 0, 0, 0, 0, 0, 0, 24, 56,
1328 26, 27, 28, 0, 0, 0, 0, 0, 0, 0,
1329 0, 0, 0, 0, 0, 0, 24, 225, 26, 27,
1330 28, 3, 4, 327, 5, 6, 0, 461, 0, 9,
1331 0, 10, 0, 11, 0, 0, 0, 12, 13, 3,
1332 4, 0, 5, 6, 0, 0, 0, 9, 0, 55,
1333 0, 11, 0, 0, 0, 12, 13, 0, 239, 240,
1334 241, 242, 243, 244, 245, 246, 247, 248, 249, 250,
1335 251, 252, 253, 0, 254, 255, 256, 0, 0, 349,
1336 0, 0, 0, 0, 24, 225, 26, 27, 28, 0,
1337 0, 496, 0, 0, 0, 114, 0, 0, 497, 115,
1338 498, 164, 24, 56, 26, 27, 28, 165, 118, 119,
1339 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
1340 130, 131, 132, 133, 134, 135, 136, 137, 138, 139,
1341 140, 141, 142, 143, 144, 496, 0, 499, 0, 150,
1342 0, 0, 497, 115, 498, 166, 0, 0, 0, 0,
1343 0, 167, 153, 119, 120, 121, 122, 123, 124, 125,
1344 126, 127, 128, 129, 130, 131, 132, 154, 155, 135,
1345 136, 137, 138, 139, 140, 141, 142, 143, 144, 114,
1346 0, 499, 0, 115, 0, 116, 0, 0, 0, 0,
1347 0, 117, 118, 119, 120, 121, 122, 123, 124, 125,
1348 126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
1349 136, 137, 138, 139, 140, 141, 142, 143, 144, 145,
1350 114, 0, 0, 168, 115, 0, 164, 169, 0, 0,
1351 0, 0, 165, 118, 119, 120, 121, 122, 123, 124,
1352 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
1353 135, 136, 137, 138, 139, 140, 141, 142, 143, 144,
1354 150, 0, 0, 170, 115, 0, 166, 171, 0, 0,
1355 0, 0, 167, 153, 119, 120, 121, 122, 123, 124,
1356 125, 126, 127, 128, 129, 130, 131, 132, 154, 155,
1357 135, 136, 137, 138, 139, 140, 141, 142, 143, 144,
1358 150, 0, 0, 0, 115, 0, 151, 0, 0, 0,
1359 0, 0, 152, 153, 119, 120, 121, 122, 123, 124,
1360 125, 126, 127, 128, 129, 130, 131, 132, 154, 155,
1361 135, 136, 137, 138, 139, 140, 141, 142, 143, 144,
1362 114, 0, 0, 0, 115, 0, 164, 0, 0, 0,
1363 0, 0, 165, 118, 119, 120, 121, 122, 123, 124,
1364 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
1365 135, 136, 137, 138, 139, 140, 141, 142, 143, 144,
1366 150, 0, 0, 0, 115, 0, 166, 0, 0, 0,
1367 0, 0, 167, 153, 119, 120, 121, 122, 123, 124,
1368 125, 126, 127, 128, 129, 130, 131, 132, 154, 155,
1369 135, 136, 137, 138, 139, 140, 141, 142, 143, 144,
1370 114, 0, 0, 0, 115, 0, 164, 0, 0, 0,
1371 0, 0, 165, 118, 119, 120, 121, 122, 123, 124,
1372 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
1373 135, 136, 137, 138, 139, 140, 141, 142, 150, 0,
1374 0, 0, 115, 0, 166, 0, 0, 0, 0, 0,
1375 167, 153, 119, 120, 121, 122, 123, 124, 125, 126,
1376 127, 128, 129, 130, 131, 132, 154, 155, 135, 136,
1377 137, 138, 139, 140, 141, 142, 114, 0, 0, 0,
1378 115, 0, 164, 0, 0, 0, 0, 0, 165, 118,
1379 119, 120, 121, 122, 123, 124, 125, 126, 127, 128,
1380 129, 130, 131, 132, 133, 134, 135, 136, 137, 138,
1381 139, 140, 150, 0, 0, 0, 115, 0, 166, 0,
1382 0, 0, 0, 0, 167, 153, 119, 120, 121, 122,
1383 123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
1384 154, 155, 135, 136, 137, 138, 139, 140, 114, 0,
1385 0, 0, 115, 0, 164, 0, 0, 0, 0, 0,
1386 165, 118, 119, 120, 121, 122, 123, 124, 125, 126,
1387 127, 128, 129, 130, 131, 132, 133, 134, 150, 0,
1388 0, 0, 115, 0, 166, 0, 0, 0, 0, 0,
1389 167, 153, 119, 120, 121, 122, 123, 124, 125, 126,
1390 127, 128, 129, 130, 131, 132, 154, 155, 114, 0,
1391 0, 0, 0, 0, 164, 0, 0, 0, 0, 0,
1392 165, 118, 119, 120, 121, 122, 123, 124, 125, 126,
1393 127, 128, 129, 130, 131, 132, 133, 134, 150, 0,
1394 0, 0, 0, 0, 166, 0, 0, 0, 0, 0,
1395 167, 153, 119, 120, 121, 122, 123, 124, 125, 126,
1396 127, 128, 129, 130, 131, 132, 154, 155, 114, 0,
1397 0, 0, 0, 0, 164, 0, 0, 0, 0, 0,
1398 165, 118, 0, 0, 121, 122, 123, 124, 125, 126,
1399 127, 128, 129, 130, 131, 132, 133, 134, 150, 0,
1400 0, 0, 0, 0, 166, 0, 0, 0, 0, 0,
1401 167, 153, 0, 0, 121, 122, 123, 124, 125, 126,
1402 127, 128, 129, 130, 131, 132, 154, 155, 239, 240,
1403 241, 242, 243, 244, 245, 246, 247, 248, 249, 250,
1404 251, 252, 253, 0, 254, 255, 256, 0, 0, 257,
1405 239, 240, 241, 242, 243, 244, 245, 246, 247, 248,
1406 249, 250, 251, 252, 253, 0, 254, 255, 256, 0,
1407 0, 346
1408 };
1409
1410 static const yytype_int16 yycheck[] =
1411 {
1412 0, 5, 2, 19, 384, 9, 10, 11, 12, 13,
1413 14, 378, 34, 56, 473, 19, 11, 14, 14, 23,
1414 11, 15, 22, 20, 443, 485, 96, 97, 4, 14,
1415 17, 4, 75, 0, 67, 11, 495, 13, 11, 72,
1416 13, 16, 56, 4, 4, 49, 116, 4, 145, 11,
1417 11, 55, 13, 13, 11, 515, 13, 19, 62, 439,
1418 55, 75, 159, 67, 483, 69, 70, 62, 72, 73,
1419 48, 62, 67, 4, 70, 70, 70, 72, 538, 70,
1420 11, 151, 13, 70, 106, 70, 86, 87, 88, 111,
1421 549, 70, 96, 97, 164, 70, 166, 516, 48, 75,
1422 4, 4, 75, 20, 484, 62, 12, 11, 11, 13,
1423 13, 115, 116, 48, 75, 119, 120, 121, 122, 123,
1424 124, 125, 126, 127, 128, 129, 130, 131, 132, 133,
1425 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
1426 144, 145, 175, 152, 75, 14, 50, 151, 152, 501,
1427 154, 155, 222, 51, 52, 159, 165, 190, 167, 163,
1428 164, 14, 166, 167, 168, 18, 170, 4, 172, 536,
1429 4, 175, 176, 4, 11, 179, 13, 529, 530, 48,
1430 175, 53, 534, 535, 188, 14, 190, 191, 467, 193,
1431 53, 20, 0, 1, 66, 190, 59, 48, 6, 7,
1432 200, 9, 10, 14, 50, 209, 14, 18, 16, 11,
1433 18, 233, 17, 50, 22, 23, 216, 4, 222, 4,
1434 70, 221, 48, 502, 503, 62, 11, 11, 13, 508,
1435 509, 15, 14, 4, 4, 11, 18, 48, 75, 15,
1436 11, 49, 13, 51, 52, 53, 54, 55, 56, 57,
1437 58, 59, 60, 61, 53, 63, 64, 65, 66, 67,
1438 59, 69, 70, 71, 72, 73, 48, 75, 11, 4,
1439 4, 11, 15, 0, 1, 15, 11, 4, 13, 6,
1440 7, 4, 9, 10, 11, 97, 13, 14, 11, 16,
1441 13, 18, 53, 6, 7, 22, 23, 10, 59, 11,
1442 48, 14, 70, 15, 116, 18, 4, 48, 6, 7,
1443 11, 9, 10, 11, 15, 13, 14, 48, 16, 17,
1444 18, 325, 49, 327, 22, 23, 11, 54, 55, 48,
1445 15, 58, 4, 60, 61, 48, 63, 64, 65, 151,
1446 67, 411, 69, 70, 71, 72, 73, 53, 75, 51,
1447 52, 53, 164, 59, 166, 359, 69, 70, 71, 72,
1448 73, 74, 51, 4, 53, 4, 370, 56, 57, 4,
1449 70, 69, 70, 71, 72, 73, 11, 75, 13, 4,
1450 48, 14, 70, 4, 4, 4, 11, 391, 13, 389,
1451 11, 11, 13, 13, 4, 4, 4, 4, 6, 7,
1452 4, 9, 10, 11, 4, 13, 14, 411, 16, 4,
1453 18, 19, 6, 7, 22, 23, 10, 53, 15, 435,
1454 48, 425, 4, 53, 6, 7, 48, 9, 10, 4,
1455 53, 435, 14, 70, 16, 17, 18, 437, 15, 4,
1456 22, 23, 5, 4, 4, 4, 9, 10, 11, 12,
1457 13, 14, 4, 51, 454, 53, 19, 4, 56, 57,
1458 23, 69, 70, 71, 72, 73, 470, 75, 53, 53,
1459 474, 4, 4, 473, 4, 69, 70, 71, 72, 73,
1460 74, 4, 53, 53, 4, 485, 49, 69, 70, 71,
1461 72, 73, 55, 75, 4, 495, 53, 32, 35, 62,
1462 205, 188, 513, 198, 67, 479, 69, 70, 536, 72,
1463 73, 465, 342, 513, 424, 515, 391, 488, 518, 518,
1464 6, 7, 221, 9, 10, -1, -1, -1, 14, -1,
1465 16, 17, 18, 96, 97, -1, 22, 23, 538, -1,
1466 -1, -1, -1, -1, -1, -1, -1, -1, -1, 549,
1467 -1, -1, 115, 116, -1, -1, 119, 120, 121, 122,
1468 123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
1469 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
1470 143, 144, 145, 69, 70, 71, 72, 73, 151, 75,
1471 -1, 154, 155, -1, -1, -1, 159, -1, -1, -1,
1472 163, 164, -1, 166, -1, 168, -1, 170, -1, 172,
1473 -1, -1, 175, 176, -1, -1, 179, -1, -1, -1,
1474 -1, -1, 41, -1, -1, 188, -1, 190, 191, -1,
1475 193, -1, 6, 7, -1, 9, 10, -1, -1, 58,
1476 14, 60, 16, 17, 18, -1, 209, 66, 22, 23,
1477 -1, -1, -1, -1, -1, -1, 75, -1, 77, 222,
1478 -1, 80, -1, -1, -1, 0, 1, -1, -1, 4,
1479 -1, 6, 7, 92, 9, 10, 11, -1, 13, 14,
1480 8, 16, -1, 18, -1, -1, 14, 22, 23, -1,
1481 -1, -1, 20, 21, -1, 69, 70, 71, 72, 73,
1482 -1, 75, -1, -1, -1, -1, -1, -1, 36, 37,
1483 -1, -1, -1, -1, 49, -1, -1, -1, -1, 54,
1484 55, -1, -1, 58, -1, 60, 61, -1, 63, 64,
1485 65, -1, 67, -1, 69, 70, 71, 72, 73, -1,
1486 75, 8, 161, -1, -1, -1, 41, 14, -1, -1,
1487 -1, 1, -1, 20, 21, -1, 6, 7, -1, 9,
1488 10, -1, 325, 58, 14, 60, 16, 186, 18, 36,
1489 37, 66, 22, 23, -1, -1, -1, -1, -1, -1,
1490 75, -1, 77, -1, -1, 80, -1, -1, -1, -1,
1491 -1, -1, -1, -1, -1, -1, 359, 92, -1, 49,
1492 -1, 51, 52, 53, 54, 55, -1, 370, 58, 228,
1493 60, 61, -1, 63, 64, 65, -1, 67, 237, 69,
1494 70, 71, 72, 73, -1, 75, -1, -1, 391, -1,
1495 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1496 -1, 260, -1, 262, -1, 264, -1, 266, 411, 268,
1497 -1, 270, -1, 272, -1, 274, -1, 276, -1, 278,
1498 -1, 280, 425, 282, -1, 284, 161, 286, -1, 288,
1499 -1, 290, 435, -1, 293, -1, -1, 296, -1, -1,
1500 299, -1, -1, 302, -1, -1, 305, -1, -1, 308,
1501 -1, 186, 311, -1, -1, 314, -1, -1, 317, -1,
1502 -1, 320, -1, -1, 323, -1, -1, 470, -1, -1,
1503 -1, 474, -1, 332, -1, 334, -1, -1, 337, -1,
1504 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1505 -1, -1, -1, 228, 353, -1, 355, -1, 357, -1,
1506 -1, -1, 237, -1, -1, -1, -1, -1, 367, -1,
1507 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1508 -1, -1, -1, -1, -1, 260, -1, 262, -1, 264,
1509 -1, 266, -1, 268, 393, 270, -1, 272, -1, 274,
1510 -1, 276, -1, 278, -1, 280, -1, 282, -1, 284,
1511 409, 286, -1, 288, -1, 290, -1, -1, 293, 418,
1512 -1, 296, -1, -1, 299, -1, -1, 302, -1, -1,
1513 305, -1, -1, 308, -1, 41, 311, -1, -1, 314,
1514 -1, -1, 317, -1, -1, 320, -1, -1, 323, -1,
1515 -1, -1, 58, -1, 60, -1, -1, 332, -1, 334,
1516 66, -1, 337, -1, 463, -1, -1, -1, 467, 75,
1517 -1, 77, -1, -1, 80, -1, -1, -1, 353, -1,
1518 355, -1, 357, -1, 14, -1, 92, -1, -1, -1,
1519 -1, -1, 367, -1, -1, -1, -1, -1, -1, -1,
1520 -1, -1, -1, -1, 503, -1, -1, -1, -1, -1,
1521 509, -1, -1, -1, -1, -1, -1, -1, 393, 49,
1522 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
1523 60, 61, 62, 63, 409, 65, 66, 67, -1, -1,
1524 70, 1, -1, 418, 4, -1, 6, 7, -1, 9,
1525 10, 11, -1, 13, 14, 161, 16, -1, 18, -1,
1526 -1, -1, 22, 23, -1, -1, -1, -1, -1, -1,
1527 -1, -1, 4, -1, 6, 7, -1, 9, 10, 11,
1528 186, 13, 14, -1, 16, 17, 18, -1, 463, 49,
1529 22, 23, 467, 53, 54, 55, -1, -1, 58, -1,
1530 60, 61, -1, 63, 64, 65, 66, 67, -1, 69,
1531 70, 71, 72, 73, -1, 75, -1, -1, -1, -1,
1532 -1, -1, 228, -1, -1, -1, -1, -1, 503, -1,
1533 -1, 237, -1, -1, 509, -1, -1, 69, 70, 71,
1534 72, 73, -1, 75, -1, -1, -1, -1, -1, -1,
1535 -1, -1, -1, -1, 260, -1, 262, -1, 264, -1,
1536 266, -1, 268, -1, 270, -1, 272, -1, 274, -1,
1537 276, -1, 278, -1, 280, -1, 282, -1, 284, -1,
1538 286, -1, 288, -1, 290, -1, -1, 293, -1, -1,
1539 296, -1, -1, 299, -1, -1, 302, -1, -1, 305,
1540 -1, -1, 308, -1, -1, 311, -1, -1, 314, -1,
1541 -1, 317, -1, -1, 320, -1, -1, 323, -1, -1,
1542 -1, -1, -1, -1, -1, -1, 332, 4, 334, 6,
1543 7, 337, 9, 10, 11, -1, 13, 14, -1, 16,
1544 17, 18, -1, -1, -1, 22, 23, 353, -1, 355,
1545 -1, 357, -1, -1, 1, -1, -1, 4, -1, 6,
1546 7, 367, 9, 10, 11, -1, 13, 14, -1, 16,
1547 -1, 18, -1, -1, -1, 22, 23, -1, -1, -1,
1548 -1, -1, -1, -1, -1, -1, -1, 393, -1, -1,
1549 -1, -1, 69, 70, 71, 72, 73, -1, 75, -1,
1550 -1, -1, 49, 409, -1, -1, 53, 54, 55, -1,
1551 -1, 58, 418, 60, 61, -1, 63, 64, 65, -1,
1552 67, -1, 69, 70, 71, 72, 73, -1, 75, -1,
1553 1, -1, -1, -1, -1, 6, 7, -1, 9, 10,
1554 -1, -1, -1, 14, -1, 16, -1, 18, -1, -1,
1555 -1, 22, 23, -1, -1, -1, -1, 463, -1, -1,
1556 -1, 467, -1, -1, -1, -1, -1, -1, -1, -1,
1557 -1, -1, -1, -1, -1, -1, -1, -1, 49, -1,
1558 51, -1, 53, 54, 55, 56, 57, 58, -1, 60,
1559 61, -1, 63, 64, 65, -1, 67, 503, 69, 70,
1560 71, 72, 73, 509, 75, 1, -1, -1, -1, -1,
1561 6, 7, -1, 9, 10, -1, -1, -1, 14, -1,
1562 16, -1, 18, -1, -1, -1, 22, 23, -1, -1,
1563 1, -1, -1, -1, -1, 6, 7, -1, 9, 10,
1564 -1, -1, -1, 14, -1, 16, -1, 18, -1, -1,
1565 -1, 22, 23, 49, -1, -1, -1, 53, 54, 55,
1566 -1, -1, 58, -1, 60, 61, -1, 63, 64, 65,
1567 66, 67, -1, 69, 70, 71, 72, 73, 49, 75,
1568 -1, -1, 53, 54, 55, -1, -1, 58, 59, 60,
1569 61, -1, 63, 64, 65, -1, 67, -1, 69, 70,
1570 71, 72, 73, 1, 75, -1, -1, -1, 6, 7,
1571 -1, 9, 10, -1, -1, -1, 14, -1, 16, -1,
1572 18, -1, -1, -1, 22, 23, -1, -1, 1, -1,
1573 -1, -1, -1, 6, 7, -1, 9, 10, -1, -1,
1574 -1, 14, -1, 16, -1, 18, -1, -1, -1, 22,
1575 23, 49, -1, -1, -1, 53, 54, 55, -1, -1,
1576 58, -1, 60, 61, -1, 63, 64, 65, -1, 67,
1577 -1, 69, 70, 71, 72, 73, 49, 75, -1, -1,
1578 53, 54, 55, -1, -1, 58, -1, 60, 61, -1,
1579 63, 64, 65, -1, 67, -1, 69, 70, 71, 72,
1580 73, 1, 75, -1, -1, -1, 6, 7, -1, 9,
1581 10, -1, -1, -1, 14, -1, 16, -1, 18, -1,
1582 -1, -1, 22, 23, -1, -1, 1, -1, -1, -1,
1583 -1, 6, 7, -1, 9, 10, -1, -1, -1, 14,
1584 -1, 16, -1, 18, -1, -1, -1, 22, 23, 49,
1585 -1, -1, -1, 53, 54, 55, -1, -1, 58, -1,
1586 60, 61, -1, 63, 64, 65, -1, 67, -1, 69,
1587 70, 71, 72, 73, 49, 75, -1, -1, -1, 54,
1588 55, -1, -1, 58, -1, 60, 61, -1, 63, 64,
1589 65, -1, 67, -1, 69, 70, 71, 72, 73, 4,
1590 75, 6, 7, -1, 9, 10, 11, -1, 13, 14,
1591 -1, 16, 17, 18, -1, -1, -1, 22, 23, 4,
1592 -1, 6, 7, -1, 9, 10, 11, -1, 13, 14,
1593 -1, 16, -1, 18, 19, -1, -1, 22, 23, 4,
1594 -1, 6, 7, -1, 9, 10, 11, -1, 13, 14,
1595 -1, 16, -1, 18, 19, -1, -1, 22, 23, -1,
1596 -1, -1, -1, -1, 69, 70, 71, 72, 73, -1,
1597 75, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1598 -1, -1, -1, -1, 69, 70, 71, 72, 73, -1,
1599 75, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1600 -1, -1, -1, -1, 69, 70, 71, 72, 73, 4,
1601 75, 6, 7, -1, 9, 10, 11, -1, 13, 14,
1602 -1, 16, 17, 18, -1, -1, -1, 22, 23, 4,
1603 -1, 6, 7, -1, 9, 10, 11, -1, 13, 14,
1604 -1, 16, -1, 18, 19, -1, -1, 22, 23, 4,
1605 -1, 6, 7, -1, 9, 10, 11, -1, 13, 14,
1606 -1, 16, -1, 18, -1, -1, -1, 22, 23, -1,
1607 -1, -1, -1, -1, 69, 70, 71, 72, 73, -1,
1608 75, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1609 -1, -1, -1, -1, 69, 70, 71, 72, 73, -1,
1610 75, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1611 -1, -1, -1, -1, 69, 70, 71, 72, 73, 4,
1612 75, 6, 7, -1, 9, 10, -1, -1, -1, 14,
1613 -1, 16, -1, 18, 19, -1, -1, 22, 23, 6,
1614 7, -1, 9, 10, -1, -1, -1, 14, -1, 16,
1615 -1, 18, 19, -1, -1, 22, 23, 6, 7, -1,
1616 9, 10, -1, -1, -1, 14, -1, 16, -1, 18,
1617 19, -1, -1, 22, 23, -1, -1, -1, -1, -1,
1618 -1, -1, -1, -1, 69, 70, 71, 72, 73, -1,
1619 75, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1620 -1, -1, 69, 70, 71, 72, 73, -1, 75, -1,
1621 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1622 69, 70, 71, 72, 73, -1, 75, 6, 7, -1,
1623 9, 10, -1, -1, -1, 14, -1, 16, 17, 18,
1624 -1, -1, -1, 22, 23, 6, 7, -1, 9, 10,
1625 -1, -1, -1, 14, -1, 16, -1, 18, 19, -1,
1626 -1, 22, 23, 6, 7, -1, 9, 10, 11, 12,
1627 -1, 14, 15, 16, -1, 18, -1, -1, -1, 22,
1628 23, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1629 69, 70, 71, 72, 73, -1, 75, -1, -1, -1,
1630 -1, -1, -1, -1, -1, -1, -1, -1, 69, 70,
1631 71, 72, 73, -1, 75, -1, -1, -1, -1, -1,
1632 -1, -1, -1, -1, -1, -1, 69, 70, 71, 72,
1633 73, 6, 7, -1, 9, 10, 11, 12, -1, 14,
1634 -1, 16, -1, 18, 19, -1, -1, 22, 23, 6,
1635 7, -1, 9, 10, 11, 12, -1, 14, -1, 16,
1636 -1, 18, -1, -1, -1, 22, 23, 6, 7, -1,
1637 9, 10, -1, 12, -1, 14, -1, 16, -1, 18,
1638 -1, -1, -1, 22, 23, -1, -1, -1, -1, -1,
1639 -1, -1, -1, -1, 69, 70, 71, 72, 73, -1,
1640 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1641 -1, -1, 69, 70, 71, 72, 73, -1, -1, -1,
1642 -1, -1, -1, -1, -1, -1, -1, -1, 67, -1,
1643 69, 70, 71, 72, 73, 6, 7, -1, 9, 10,
1644 -1, 12, -1, 14, -1, 16, -1, 18, -1, -1,
1645 -1, 22, 23, 6, 7, -1, 9, 10, -1, 12,
1646 -1, 14, -1, 16, -1, 18, -1, -1, -1, 22,
1647 23, 6, 7, -1, 9, 10, -1, 12, -1, 14,
1648 -1, 16, -1, 18, -1, -1, -1, 22, 23, -1,
1649 -1, -1, -1, -1, -1, -1, 67, -1, 69, 70,
1650 71, 72, 73, -1, -1, -1, -1, -1, -1, -1,
1651 -1, -1, -1, -1, -1, -1, 69, 70, 71, 72,
1652 73, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1653 -1, -1, -1, -1, 69, 70, 71, 72, 73, 6,
1654 7, -1, 9, 10, -1, 12, -1, 14, -1, 16,
1655 -1, 18, -1, -1, -1, 22, 23, 6, 7, -1,
1656 9, 10, -1, 12, -1, 14, -1, 16, -1, 18,
1657 -1, -1, -1, 22, 23, 6, 7, -1, 9, 10,
1658 -1, 12, -1, 14, -1, 16, -1, 18, -1, -1,
1659 -1, 22, 23, -1, -1, -1, -1, -1, -1, -1,
1660 -1, -1, 69, 70, 71, 72, 73, -1, -1, -1,
1661 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1662 69, 70, 71, 72, 73, -1, -1, -1, -1, -1,
1663 -1, -1, -1, -1, -1, -1, -1, -1, 69, 70,
1664 71, 72, 73, 6, 7, -1, 9, 10, -1, 12,
1665 -1, 14, -1, 16, -1, 18, -1, -1, -1, 22,
1666 23, 6, 7, -1, 9, 10, -1, 12, -1, 14,
1667 -1, 16, -1, 18, -1, -1, -1, 22, 23, 6,
1668 7, -1, 9, 10, -1, 12, -1, 14, -1, 16,
1669 -1, 18, -1, -1, -1, 22, 23, -1, -1, -1,
1670 -1, -1, -1, -1, -1, -1, 69, 70, 71, 72,
1671 73, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1672 -1, -1, -1, -1, 69, 70, 71, 72, 73, -1,
1673 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1674 -1, -1, 69, 70, 71, 72, 73, 6, 7, -1,
1675 9, 10, -1, 12, -1, 14, -1, 16, -1, 18,
1676 -1, -1, -1, 22, 23, 6, 7, -1, 9, 10,
1677 -1, 12, -1, 14, -1, 16, -1, 18, -1, -1,
1678 -1, 22, 23, 6, 7, -1, 9, 10, -1, 12,
1679 -1, 14, -1, 16, -1, 18, -1, -1, -1, 22,
1680 23, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1681 69, 70, 71, 72, 73, -1, -1, -1, -1, -1,
1682 -1, -1, -1, -1, -1, -1, -1, -1, 69, 70,
1683 71, 72, 73, -1, -1, -1, -1, -1, -1, -1,
1684 -1, -1, -1, -1, -1, -1, 69, 70, 71, 72,
1685 73, 6, 7, 14, 9, 10, -1, 12, -1, 14,
1686 -1, 16, -1, 18, -1, -1, -1, 22, 23, 6,
1687 7, -1, 9, 10, -1, -1, -1, 14, -1, 16,
1688 -1, 18, -1, -1, -1, 22, 23, -1, 49, 50,
1689 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
1690 61, 62, 63, -1, 65, 66, 67, -1, -1, 70,
1691 -1, -1, -1, -1, 69, 70, 71, 72, 73, -1,
1692 -1, 4, -1, -1, -1, 8, -1, -1, 11, 12,
1693 13, 14, 69, 70, 71, 72, 73, 20, 21, 22,
1694 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
1695 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
1696 43, 44, 45, 46, 47, 4, -1, 50, -1, 8,
1697 -1, -1, 11, 12, 13, 14, -1, -1, -1, -1,
1698 -1, 20, 21, 22, 23, 24, 25, 26, 27, 28,
1699 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
1700 39, 40, 41, 42, 43, 44, 45, 46, 47, 8,
1701 -1, 50, -1, 12, -1, 14, -1, -1, -1, -1,
1702 -1, 20, 21, 22, 23, 24, 25, 26, 27, 28,
1703 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
1704 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
1705 8, -1, -1, 11, 12, -1, 14, 15, -1, -1,
1706 -1, -1, 20, 21, 22, 23, 24, 25, 26, 27,
1707 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
1708 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1709 8, -1, -1, 11, 12, -1, 14, 15, -1, -1,
1710 -1, -1, 20, 21, 22, 23, 24, 25, 26, 27,
1711 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
1712 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1713 8, -1, -1, -1, 12, -1, 14, -1, -1, -1,
1714 -1, -1, 20, 21, 22, 23, 24, 25, 26, 27,
1715 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
1716 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1717 8, -1, -1, -1, 12, -1, 14, -1, -1, -1,
1718 -1, -1, 20, 21, 22, 23, 24, 25, 26, 27,
1719 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
1720 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1721 8, -1, -1, -1, 12, -1, 14, -1, -1, -1,
1722 -1, -1, 20, 21, 22, 23, 24, 25, 26, 27,
1723 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
1724 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1725 8, -1, -1, -1, 12, -1, 14, -1, -1, -1,
1726 -1, -1, 20, 21, 22, 23, 24, 25, 26, 27,
1727 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
1728 38, 39, 40, 41, 42, 43, 44, 45, 8, -1,
1729 -1, -1, 12, -1, 14, -1, -1, -1, -1, -1,
1730 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
1731 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
1732 40, 41, 42, 43, 44, 45, 8, -1, -1, -1,
1733 12, -1, 14, -1, -1, -1, -1, -1, 20, 21,
1734 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1735 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
1736 42, 43, 8, -1, -1, -1, 12, -1, 14, -1,
1737 -1, -1, -1, -1, 20, 21, 22, 23, 24, 25,
1738 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
1739 36, 37, 38, 39, 40, 41, 42, 43, 8, -1,
1740 -1, -1, 12, -1, 14, -1, -1, -1, -1, -1,
1741 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
1742 30, 31, 32, 33, 34, 35, 36, 37, 8, -1,
1743 -1, -1, 12, -1, 14, -1, -1, -1, -1, -1,
1744 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
1745 30, 31, 32, 33, 34, 35, 36, 37, 8, -1,
1746 -1, -1, -1, -1, 14, -1, -1, -1, -1, -1,
1747 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
1748 30, 31, 32, 33, 34, 35, 36, 37, 8, -1,
1749 -1, -1, -1, -1, 14, -1, -1, -1, -1, -1,
1750 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
1751 30, 31, 32, 33, 34, 35, 36, 37, 8, -1,
1752 -1, -1, -1, -1, 14, -1, -1, -1, -1, -1,
1753 20, 21, -1, -1, 24, 25, 26, 27, 28, 29,
1754 30, 31, 32, 33, 34, 35, 36, 37, 8, -1,
1755 -1, -1, -1, -1, 14, -1, -1, -1, -1, -1,
1756 20, 21, -1, -1, 24, 25, 26, 27, 28, 29,
1757 30, 31, 32, 33, 34, 35, 36, 37, 49, 50,
1758 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
1759 61, 62, 63, -1, 65, 66, 67, -1, -1, 70,
1760 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
1761 59, 60, 61, 62, 63, -1, 65, 66, 67, -1,
1762 -1, 70
1763 };
1764
1765 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1766 symbol of state STATE-NUM. */
1767 static const yytype_uint8 yystos[] =
1768 {
1769 0, 1, 4, 6, 7, 9, 10, 11, 13, 14,
1770 16, 18, 22, 23, 49, 54, 55, 58, 60, 61,
1771 63, 64, 65, 67, 69, 70, 71, 72, 73, 75,
1772 86, 87, 88, 89, 90, 91, 93, 94, 96, 103,
1773 105, 109, 111, 112, 118, 119, 120, 121, 128, 129,
1774 136, 140, 143, 145, 87, 16, 70, 93, 109, 93,
1775 109, 110, 4, 17, 75, 93, 109, 113, 115, 116,
1776 4, 19, 113, 116, 93, 109, 93, 109, 93, 102,
1777 109, 16, 70, 14, 70, 102, 4, 11, 13, 87,
1778 144, 93, 109, 6, 7, 10, 14, 18, 69, 70,
1779 71, 72, 73, 74, 92, 0, 90, 4, 11, 13,
1780 4, 75, 89, 92, 8, 12, 14, 20, 21, 22,
1781 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
1782 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
1783 43, 44, 45, 46, 47, 48, 104, 106, 107, 108,
1784 8, 14, 20, 21, 36, 37, 104, 106, 108, 48,
1785 93, 109, 131, 116, 14, 20, 14, 20, 11, 15,
1786 11, 15, 11, 15, 17, 113, 116, 17, 115, 116,
1787 4, 11, 13, 17, 75, 93, 109, 114, 117, 19,
1788 113, 116, 19, 116, 19, 4, 11, 13, 50, 124,
1789 125, 17, 70, 97, 99, 14, 48, 98, 70, 48,
1790 4, 11, 13, 50, 62, 75, 142, 87, 87, 87,
1791 53, 66, 11, 12, 15, 70, 93, 95, 109, 118,
1792 19, 95, 20, 75, 89, 89, 93, 109, 95, 49,
1793 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
1794 60, 61, 62, 63, 65, 66, 67, 70, 148, 93,
1795 109, 93, 109, 93, 109, 93, 109, 93, 109, 93,
1796 109, 93, 109, 93, 109, 93, 109, 93, 109, 93,
1797 109, 93, 109, 93, 109, 93, 109, 93, 109, 93,
1798 109, 12, 93, 109, 12, 93, 109, 12, 93, 109,
1799 12, 93, 109, 12, 93, 109, 12, 93, 109, 12,
1800 93, 109, 12, 93, 109, 12, 93, 109, 12, 93,
1801 109, 12, 93, 109, 145, 12, 95, 14, 70, 93,
1802 148, 93, 109, 93, 109, 12, 93, 109, 145, 4,
1803 11, 13, 75, 132, 17, 95, 70, 148, 95, 70,
1804 93, 148, 93, 109, 93, 109, 93, 109, 17, 116,
1805 17, 17, 4, 13, 11, 75, 93, 109, 114, 19,
1806 116, 19, 19, 4, 4, 124, 50, 87, 122, 48,
1807 17, 11, 15, 99, 70, 4, 11, 13, 75, 100,
1808 147, 48, 93, 109, 137, 4, 4, 4, 11, 13,
1809 4, 11, 13, 4, 87, 141, 144, 12, 93, 109,
1810 118, 11, 15, 19, 70, 89, 15, 93, 109, 15,
1811 70, 93, 4, 4, 132, 56, 75, 133, 146, 15,
1812 15, 17, 19, 4, 51, 52, 53, 126, 127, 70,
1813 48, 70, 15, 98, 4, 4, 4, 87, 101, 137,
1814 4, 11, 13, 62, 138, 4, 4, 4, 4, 53,
1815 53, 12, 93, 109, 118, 133, 93, 109, 4, 53,
1816 56, 57, 126, 130, 56, 75, 4, 11, 13, 102,
1817 87, 123, 53, 98, 70, 100, 53, 59, 15, 4,
1818 4, 4, 87, 139, 53, 130, 4, 11, 13, 50,
1819 135, 135, 93, 109, 4, 11, 13, 123, 93, 109,
1820 4, 4, 4, 125, 53, 100, 98, 101, 138, 53,
1821 123, 4, 4, 4, 11, 13, 87, 134, 134, 135,
1822 135, 4, 4, 53, 135, 135, 122, 101, 100, 53,
1823 59, 139, 53, 4, 4, 134, 134, 134, 134, 126,
1824 127, 53, 59, 101, 53, 123, 53, 59
1825 };
1826
1827 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1828 static const yytype_uint8 yyr1[] =
1829 {
1830 0, 85, 86, 86, 86, 86, 87, 87, 87, 87,
1831 87, 88, 88, 88, 88, 89, 89, 89, 89, 89,
1832 89, 90, 90, 90, 90, 90, 90, 90, 90, 90,
1833 90, 90, 90, 90, 90, 90, 91, 91, 92, 92,
1834 92, 92, 92, 92, 92, 92, 92, 92, 93, 93,
1835 94, 94, 94, 94, 95, 95, 95, 95, 95, 95,
1836 95, 95, 95, 95, 95, 95, 95, 95, 96, 96,
1837 96, 96, 96, 96, 96, 96, 97, 98, 98, 98,
1838 99, 99, 100, 100, 100, 100, 100, 101, 101, 102,
1839 102, 103, 103, 104, 104, 104, 104, 104, 104, 104,
1840 104, 104, 104, 104, 104, 104, 104, 104, 104, 104,
1841 104, 104, 104, 104, 104, 104, 104, 104, 104, 104,
1842 104, 104, 104, 105, 105, 105, 105, 105, 105, 105,
1843 105, 105, 105, 105, 105, 105, 105, 105, 105, 105,
1844 105, 106, 106, 106, 106, 106, 106, 106, 106, 106,
1845 106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
1846 106, 106, 106, 106, 106, 106, 106, 106, 106, 107,
1847 107, 108, 108, 108, 109, 109, 109, 109, 109, 109,
1848 109, 109, 109, 109, 109, 109, 109, 109, 109, 109,
1849 109, 109, 109, 109, 109, 109, 109, 109, 109, 110,
1850 110, 110, 110, 110, 110, 111, 111, 111, 111, 111,
1851 111, 111, 111, 112, 112, 112, 112, 112, 112, 112,
1852 112, 113, 113, 114, 114, 114, 114, 115, 115, 116,
1853 116, 116, 116, 116, 116, 116, 116, 116, 117, 117,
1854 118, 118, 118, 118, 118, 118, 118, 118, 119, 119,
1855 119, 119, 119, 119, 119, 119, 119, 120, 121, 121,
1856 121, 122, 122, 123, 123, 124, 124, 124, 124, 124,
1857 125, 125, 125, 125, 125, 125, 126, 126, 126, 126,
1858 126, 126, 127, 127, 127, 128, 128, 128, 128, 129,
1859 129, 130, 130, 130, 130, 130, 130, 130, 131, 131,
1860 132, 132, 132, 132, 132, 133, 133, 133, 133, 133,
1861 133, 134, 134, 135, 135, 135, 135, 135, 135, 135,
1862 135, 135, 135, 135, 135, 136, 136, 137, 137, 138,
1863 138, 138, 138, 138, 138, 138, 138, 139, 139, 140,
1864 141, 141, 142, 142, 142, 142, 142, 142, 142, 142,
1865 142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
1866 143, 143, 144, 144, 144, 144, 144, 144, 145, 145,
1867 145, 146, 146, 147, 147, 148, 148, 148, 148, 148,
1868 148, 148, 148, 148, 148, 148, 148, 148, 148, 148,
1869 148, 148, 148
1870 };
1871
1872 /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
1873 static const yytype_uint8 yyr2[] =
1874 {
1875 0, 2, 1, 2, 1, 0, 1, 2, 3, 1,
1876 2, 3, 4, 3, 2, 1, 1, 1, 2, 2,
1877 2, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1878 1, 1, 1, 1, 1, 1, 2, 2, 1, 1,
1879 1, 1, 1, 1, 1, 1, 3, 1, 1, 3,
1880 4, 4, 3, 3, 1, 1, 1, 1, 1, 2,
1881 2, 2, 2, 2, 3, 3, 3, 3, 8, 10,
1882 9, 6, 8, 10, 9, 6, 1, 3, 2, 0,
1883 3, 1, 1, 1, 2, 1, 2, 1, 0, 1,
1884 1, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1885 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1886 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1887 2, 2, 2, 2, 2, 2, 2, 2, 2, 3,
1888 3, 3, 3, 3, 3, 3, 3, 2, 2, 2,
1889 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1890 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1891 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1892 2, 3, 3, 1, 2, 2, 3, 3, 3, 3,
1893 3, 2, 2, 1, 1, 1, 1, 1, 1, 1,
1894 1, 1, 1, 1, 3, 3, 1, 4, 4, 3,
1895 3, 3, 3, 3, 3, 3, 4, 4, 5, 3,
1896 4, 3, 2, 3, 4, 4, 5, 3, 4, 3,
1897 2, 2, 1, 1, 1, 2, 2, 2, 3, 3,
1898 3, 2, 2, 2, 3, 1, 1, 1, 2, 1,
1899 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1900 3, 3, 3, 1, 1, 4, 4, 3, 5, 7,
1901 6, 1, 0, 1, 0, 1, 2, 1, 2, 1,
1902 1, 2, 3, 2, 1, 0, 1, 2, 2, 2,
1903 3, 3, 4, 6, 5, 5, 7, 6, 8, 1,
1904 1, 1, 1, 2, 2, 2, 3, 3, 1, 1,
1905 1, 2, 2, 1, 1, 4, 4, 5, 5, 5,
1906 5, 1, 0, 1, 1, 1, 1, 2, 2, 2,
1907 2, 3, 2, 3, 0, 7, 9, 1, 1, 1,
1908 1, 2, 1, 2, 1, 2, 0, 1, 0, 5,
1909 1, 0, 1, 1, 1, 2, 2, 1, 2, 2,
1910 2, 1, 2, 2, 2, 3, 3, 2, 3, 3,
1911 5, 3, 1, 2, 2, 2, 1, 0, 1, 2,
1912 2, 2, 3, 1, 2, 1, 1, 1, 1, 1,
1913 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1914 1, 1, 1
1915 };
1916
1917
1918 #define yyerrok (yyerrstatus = 0)
1919 #define yyclearin (yychar = YYEMPTY)
1920 #define YYEMPTY (-2)
1921 #define YYEOF 0
1922
1923 #define YYACCEPT goto yyacceptlab
1924 #define YYABORT goto yyabortlab
1925 #define YYERROR goto yyerrorlab
1926
1927
1928 #define YYRECOVERING() (!!yyerrstatus)
1929
1930 #define YYBACKUP(Token, Value) \
1931 do \
1932 if (yychar == YYEMPTY) \
1933 { \
1934 yychar = (Token); \
1935 yylval = (Value); \
1936 YYPOPSTACK (yylen); \
1937 yystate = *yyssp; \
1938 goto yybackup; \
1939 } \
1940 else \
1941 { \
1942 yyerror (YY_("syntax error: cannot back up")); \
1943 YYERROR; \
1944 } \
1945 while (0)
1946
1947 /* Error token number */
1948 #define YYTERROR 1
1949 #define YYERRCODE 256
1950
1951
1952 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
1953 If N is 0, then set CURRENT to the empty location which ends
1954 the previous symbol: RHS[0] (always defined). */
1955
1956 #ifndef YYLLOC_DEFAULT
1957 # define YYLLOC_DEFAULT(Current, Rhs, N) \
1958 do \
1959 if (N) \
1960 { \
1961 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
1962 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
1963 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
1964 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
1965 } \
1966 else \
1967 { \
1968 (Current).first_line = (Current).last_line = \
1969 YYRHSLOC (Rhs, 0).last_line; \
1970 (Current).first_column = (Current).last_column = \
1971 YYRHSLOC (Rhs, 0).last_column; \
1972 } \
1973 while (0)
1974 #endif
1975
1976 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
1977
1978
1979 /* Enable debugging if requested. */
1980 #if YYDEBUG
1981
1982 # ifndef YYFPRINTF
1983 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1984 # define YYFPRINTF fprintf
1985 # endif
1986
1987 # define YYDPRINTF(Args) \
1988 do { \
1989 if (yydebug) \
1990 YYFPRINTF Args; \
1991 } while (0)
1992
1993
1994 /* YY_LOCATION_PRINT -- Print the location on the stream.
1995 This macro was not mandated originally: define only if we know
1996 we won't break user code: when these are the locations we know. */
1997
1998 #ifndef YY_LOCATION_PRINT
1999 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
2000
2001 /* Print *YYLOCP on YYO. Private, do not rely on its existence. */
2002
2003 YY_ATTRIBUTE_UNUSED
2004 static unsigned
yy_location_print_(FILE * yyo,YYLTYPE const * const yylocp)2005 yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp)
2006 {
2007 unsigned res = 0;
2008 int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;
2009 if (0 <= yylocp->first_line)
2010 {
2011 res += YYFPRINTF (yyo, "%d", yylocp->first_line);
2012 if (0 <= yylocp->first_column)
2013 res += YYFPRINTF (yyo, ".%d", yylocp->first_column);
2014 }
2015 if (0 <= yylocp->last_line)
2016 {
2017 if (yylocp->first_line < yylocp->last_line)
2018 {
2019 res += YYFPRINTF (yyo, "-%d", yylocp->last_line);
2020 if (0 <= end_col)
2021 res += YYFPRINTF (yyo, ".%d", end_col);
2022 }
2023 else if (0 <= end_col && yylocp->first_column < end_col)
2024 res += YYFPRINTF (yyo, "-%d", end_col);
2025 }
2026 return res;
2027 }
2028
2029 # define YY_LOCATION_PRINT(File, Loc) \
2030 yy_location_print_ (File, &(Loc))
2031
2032 # else
2033 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
2034 # endif
2035 #endif
2036
2037
2038 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
2039 do { \
2040 if (yydebug) \
2041 { \
2042 YYFPRINTF (stderr, "%s ", Title); \
2043 yy_symbol_print (stderr, \
2044 Type, Value, Location); \
2045 YYFPRINTF (stderr, "\n"); \
2046 } \
2047 } while (0)
2048
2049
2050 /*----------------------------------------.
2051 | Print this symbol's value on YYOUTPUT. |
2052 `----------------------------------------*/
2053
2054 static void
yy_symbol_value_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep,YYLTYPE const * const yylocationp)2055 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp)
2056 {
2057 FILE *yyo = yyoutput;
2058 YYUSE (yyo);
2059 YYUSE (yylocationp);
2060 if (!yyvaluep)
2061 return;
2062 # ifdef YYPRINT
2063 if (yytype < YYNTOKENS)
2064 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
2065 # endif
2066 YYUSE (yytype);
2067 }
2068
2069
2070 /*--------------------------------.
2071 | Print this symbol on YYOUTPUT. |
2072 `--------------------------------*/
2073
2074 static void
yy_symbol_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep,YYLTYPE const * const yylocationp)2075 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp)
2076 {
2077 YYFPRINTF (yyoutput, "%s %s (",
2078 yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
2079
2080 YY_LOCATION_PRINT (yyoutput, *yylocationp);
2081 YYFPRINTF (yyoutput, ": ");
2082 yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp);
2083 YYFPRINTF (yyoutput, ")");
2084 }
2085
2086 /*------------------------------------------------------------------.
2087 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
2088 | TOP (included). |
2089 `------------------------------------------------------------------*/
2090
2091 static void
yy_stack_print(yytype_int16 * yybottom,yytype_int16 * yytop)2092 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
2093 {
2094 YYFPRINTF (stderr, "Stack now");
2095 for (; yybottom <= yytop; yybottom++)
2096 {
2097 int yybot = *yybottom;
2098 YYFPRINTF (stderr, " %d", yybot);
2099 }
2100 YYFPRINTF (stderr, "\n");
2101 }
2102
2103 # define YY_STACK_PRINT(Bottom, Top) \
2104 do { \
2105 if (yydebug) \
2106 yy_stack_print ((Bottom), (Top)); \
2107 } while (0)
2108
2109
2110 /*------------------------------------------------.
2111 | Report that the YYRULE is going to be reduced. |
2112 `------------------------------------------------*/
2113
2114 static void
yy_reduce_print(yytype_int16 * yyssp,YYSTYPE * yyvsp,YYLTYPE * yylsp,int yyrule)2115 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule)
2116 {
2117 unsigned long int yylno = yyrline[yyrule];
2118 int yynrhs = yyr2[yyrule];
2119 int yyi;
2120 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
2121 yyrule - 1, yylno);
2122 /* The symbols being reduced. */
2123 for (yyi = 0; yyi < yynrhs; yyi++)
2124 {
2125 YYFPRINTF (stderr, " $%d = ", yyi + 1);
2126 yy_symbol_print (stderr,
2127 yystos[yyssp[yyi + 1 - yynrhs]],
2128 &(yyvsp[(yyi + 1) - (yynrhs)])
2129 , &(yylsp[(yyi + 1) - (yynrhs)]) );
2130 YYFPRINTF (stderr, "\n");
2131 }
2132 }
2133
2134 # define YY_REDUCE_PRINT(Rule) \
2135 do { \
2136 if (yydebug) \
2137 yy_reduce_print (yyssp, yyvsp, yylsp, Rule); \
2138 } while (0)
2139
2140 /* Nonzero means print parse trace. It is left uninitialized so that
2141 multiple parsers can coexist. */
2142 int yydebug;
2143 #else /* !YYDEBUG */
2144 # define YYDPRINTF(Args)
2145 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
2146 # define YY_STACK_PRINT(Bottom, Top)
2147 # define YY_REDUCE_PRINT(Rule)
2148 #endif /* !YYDEBUG */
2149
2150
2151 /* YYINITDEPTH -- initial size of the parser's stacks. */
2152 #ifndef YYINITDEPTH
2153 # define YYINITDEPTH 200
2154 #endif
2155
2156 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
2157 if the built-in stack extension method is used).
2158
2159 Do not make this value too large; the results are undefined if
2160 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
2161 evaluated with infinite-precision integer arithmetic. */
2162
2163 #ifndef YYMAXDEPTH
2164 # define YYMAXDEPTH 10000
2165 #endif
2166
2167
2168 #if YYERROR_VERBOSE
2169
2170 # ifndef yystrlen
2171 # if defined __GLIBC__ && defined _STRING_H
2172 # define yystrlen strlen
2173 # else
2174 /* Return the length of YYSTR. */
2175 static YYSIZE_T
yystrlen(const char * yystr)2176 yystrlen (const char *yystr)
2177 {
2178 YYSIZE_T yylen;
2179 for (yylen = 0; yystr[yylen]; yylen++)
2180 continue;
2181 return yylen;
2182 }
2183 # endif
2184 # endif
2185
2186 # ifndef yystpcpy
2187 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
2188 # define yystpcpy stpcpy
2189 # else
2190 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
2191 YYDEST. */
2192 static char *
yystpcpy(char * yydest,const char * yysrc)2193 yystpcpy (char *yydest, const char *yysrc)
2194 {
2195 char *yyd = yydest;
2196 const char *yys = yysrc;
2197
2198 while ((*yyd++ = *yys++) != '\0')
2199 continue;
2200
2201 return yyd - 1;
2202 }
2203 # endif
2204 # endif
2205
2206 # ifndef yytnamerr
2207 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
2208 quotes and backslashes, so that it's suitable for yyerror. The
2209 heuristic is that double-quoting is unnecessary unless the string
2210 contains an apostrophe, a comma, or backslash (other than
2211 backslash-backslash). YYSTR is taken from yytname. If YYRES is
2212 null, do not copy; instead, return the length of what the result
2213 would have been. */
2214 static YYSIZE_T
yytnamerr(char * yyres,const char * yystr)2215 yytnamerr (char *yyres, const char *yystr)
2216 {
2217 if (*yystr == '"')
2218 {
2219 YYSIZE_T yyn = 0;
2220 char const *yyp = yystr;
2221
2222 for (;;)
2223 switch (*++yyp)
2224 {
2225 case '\'':
2226 case ',':
2227 goto do_not_strip_quotes;
2228
2229 case '\\':
2230 if (*++yyp != '\\')
2231 goto do_not_strip_quotes;
2232 /* Fall through. */
2233 default:
2234 if (yyres)
2235 yyres[yyn] = *yyp;
2236 yyn++;
2237 break;
2238
2239 case '"':
2240 if (yyres)
2241 yyres[yyn] = '\0';
2242 return yyn;
2243 }
2244 do_not_strip_quotes: ;
2245 }
2246
2247 if (! yyres)
2248 return yystrlen (yystr);
2249
2250 return yystpcpy (yyres, yystr) - yyres;
2251 }
2252 # endif
2253
2254 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
2255 about the unexpected token YYTOKEN for the state stack whose top is
2256 YYSSP.
2257
2258 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
2259 not large enough to hold the message. In that case, also set
2260 *YYMSG_ALLOC to the required number of bytes. Return 2 if the
2261 required number of bytes is too large to store. */
2262 static int
yysyntax_error(YYSIZE_T * yymsg_alloc,char ** yymsg,yytype_int16 * yyssp,int yytoken)2263 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
2264 yytype_int16 *yyssp, int yytoken)
2265 {
2266 YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
2267 YYSIZE_T yysize = yysize0;
2268 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
2269 /* Internationalized format string. */
2270 const char *yyformat = YY_NULLPTR;
2271 /* Arguments of yyformat. */
2272 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
2273 /* Number of reported tokens (one for the "unexpected", one per
2274 "expected"). */
2275 int yycount = 0;
2276
2277 /* There are many possibilities here to consider:
2278 - If this state is a consistent state with a default action, then
2279 the only way this function was invoked is if the default action
2280 is an error action. In that case, don't check for expected
2281 tokens because there are none.
2282 - The only way there can be no lookahead present (in yychar) is if
2283 this state is a consistent state with a default action. Thus,
2284 detecting the absence of a lookahead is sufficient to determine
2285 that there is no unexpected or expected token to report. In that
2286 case, just report a simple "syntax error".
2287 - Don't assume there isn't a lookahead just because this state is a
2288 consistent state with a default action. There might have been a
2289 previous inconsistent state, consistent state with a non-default
2290 action, or user semantic action that manipulated yychar.
2291 - Of course, the expected token list depends on states to have
2292 correct lookahead information, and it depends on the parser not
2293 to perform extra reductions after fetching a lookahead from the
2294 scanner and before detecting a syntax error. Thus, state merging
2295 (from LALR or IELR) and default reductions corrupt the expected
2296 token list. However, the list is correct for canonical LR with
2297 one exception: it will still contain any token that will not be
2298 accepted due to an error action in a later state.
2299 */
2300 if (yytoken != YYEMPTY)
2301 {
2302 int yyn = yypact[*yyssp];
2303 yyarg[yycount++] = yytname[yytoken];
2304 if (!yypact_value_is_default (yyn))
2305 {
2306 /* Start YYX at -YYN if negative to avoid negative indexes in
2307 YYCHECK. In other words, skip the first -YYN actions for
2308 this state because they are default actions. */
2309 int yyxbegin = yyn < 0 ? -yyn : 0;
2310 /* Stay within bounds of both yycheck and yytname. */
2311 int yychecklim = YYLAST - yyn + 1;
2312 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
2313 int yyx;
2314
2315 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
2316 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
2317 && !yytable_value_is_error (yytable[yyx + yyn]))
2318 {
2319 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
2320 {
2321 yycount = 1;
2322 yysize = yysize0;
2323 break;
2324 }
2325 yyarg[yycount++] = yytname[yyx];
2326 {
2327 YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
2328 if (! (yysize <= yysize1
2329 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
2330 return 2;
2331 yysize = yysize1;
2332 }
2333 }
2334 }
2335 }
2336
2337 switch (yycount)
2338 {
2339 # define YYCASE_(N, S) \
2340 case N: \
2341 yyformat = S; \
2342 break
2343 default: /* Avoid compiler warnings. */
2344 YYCASE_(0, YY_("syntax error"));
2345 YYCASE_(1, YY_("syntax error, unexpected %s"));
2346 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
2347 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
2348 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
2349 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
2350 # undef YYCASE_
2351 }
2352
2353 {
2354 YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
2355 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
2356 return 2;
2357 yysize = yysize1;
2358 }
2359
2360 if (*yymsg_alloc < yysize)
2361 {
2362 *yymsg_alloc = 2 * yysize;
2363 if (! (yysize <= *yymsg_alloc
2364 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
2365 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
2366 return 1;
2367 }
2368
2369 /* Avoid sprintf, as that infringes on the user's name space.
2370 Don't have undefined behavior even if the translation
2371 produced a string with the wrong number of "%s"s. */
2372 {
2373 char *yyp = *yymsg;
2374 int yyi = 0;
2375 while ((*yyp = *yyformat) != '\0')
2376 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
2377 {
2378 yyp += yytnamerr (yyp, yyarg[yyi++]);
2379 yyformat += 2;
2380 }
2381 else
2382 {
2383 yyp++;
2384 yyformat++;
2385 }
2386 }
2387 return 0;
2388 }
2389 #endif /* YYERROR_VERBOSE */
2390
2391 /*-----------------------------------------------.
2392 | Release the memory associated to this symbol. |
2393 `-----------------------------------------------*/
2394
2395 static void
yydestruct(const char * yymsg,int yytype,YYSTYPE * yyvaluep,YYLTYPE * yylocationp)2396 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp)
2397 {
2398 YYUSE (yyvaluep);
2399 YYUSE (yylocationp);
2400 if (!yymsg)
2401 yymsg = "Deleting";
2402 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
2403
2404 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2405 switch (yytype)
2406 {
2407 case 69: /* "string" */
2408
2409 { delete ((*yyvaluep).str); }
2410
2411 break;
2412
2413 case 70: /* "identifier" */
2414
2415 { delete ((*yyvaluep).str); }
2416
2417 break;
2418
2419 case 71: /* "integer" */
2420
2421 { }
2422
2423 break;
2424
2425 case 72: /* "float" */
2426
2427 { }
2428
2429 break;
2430
2431 case 73: /* "number" */
2432
2433 { }
2434
2435 break;
2436
2437 case 74: /* "path" */
2438
2439 { delete ((*yyvaluep).path); }
2440
2441 break;
2442
2443 case 75: /* "line comment" */
2444
2445 { delete ((*yyvaluep).comment); }
2446
2447 break;
2448
2449 case 76: /* "block comment" */
2450
2451 { delete ((*yyvaluep).comment); }
2452
2453 break;
2454
2455 case 87: /* expressions */
2456
2457 { delete ((*yyvaluep).t_seq_exp); }
2458
2459 break;
2460
2461 case 88: /* recursiveExpression */
2462
2463 { for (auto e : *((*yyvaluep).t_list_exp)) delete e; delete ((*yyvaluep).t_list_exp); }
2464
2465 break;
2466
2467 case 89: /* expressionLineBreak */
2468
2469 { delete ((*yyvaluep).mute); }
2470
2471 break;
2472
2473 case 90: /* expression */
2474
2475 { delete ((*yyvaluep).t_exp); }
2476
2477 break;
2478
2479 case 91: /* implicitFunctionCall */
2480
2481 { delete ((*yyvaluep).t_call_exp); }
2482
2483 break;
2484
2485 case 92: /* implicitCallable */
2486
2487 { delete ((*yyvaluep).t_string_exp); }
2488
2489 break;
2490
2491 case 93: /* functionCall */
2492
2493 { delete ((*yyvaluep).t_call_exp); }
2494
2495 break;
2496
2497 case 94: /* simpleFunctionCall */
2498
2499 { delete ((*yyvaluep).t_call_exp); }
2500
2501 break;
2502
2503 case 95: /* functionArgs */
2504
2505 { for (auto e : *((*yyvaluep).t_list_exp)) delete e; delete ((*yyvaluep).t_list_exp); }
2506
2507 break;
2508
2509 case 96: /* functionDeclaration */
2510
2511 { delete ((*yyvaluep).t_function_dec); }
2512
2513 break;
2514
2515 case 97: /* functionDeclarationReturns */
2516
2517 { for (auto e : *((*yyvaluep).t_list_var)) delete e; delete ((*yyvaluep).t_list_var); }
2518
2519 break;
2520
2521 case 98: /* functionDeclarationArguments */
2522
2523 { for (auto e : *((*yyvaluep).t_list_var)) delete e; delete ((*yyvaluep).t_list_var); }
2524
2525 break;
2526
2527 case 99: /* idList */
2528
2529 { for (auto e : *((*yyvaluep).t_list_var)) delete e; delete ((*yyvaluep).t_list_var); }
2530
2531 break;
2532
2533 case 101: /* functionBody */
2534
2535 { delete ((*yyvaluep).t_seq_exp); }
2536
2537 break;
2538
2539 case 102: /* condition */
2540
2541 { delete ((*yyvaluep).t_exp); }
2542
2543 break;
2544
2545 case 103: /* comparison */
2546
2547 { delete ((*yyvaluep).t_op_exp); }
2548
2549 break;
2550
2551 case 104: /* rightComparable */
2552
2553 { delete ((*yyvaluep).t_op_exp); }
2554
2555 break;
2556
2557 case 105: /* operation */
2558
2559 { delete ((*yyvaluep).t_exp); }
2560
2561 break;
2562
2563 case 106: /* rightOperand */
2564
2565 { delete ((*yyvaluep).t_op_exp); }
2566
2567 break;
2568
2569 case 107: /* listableBegin */
2570
2571 { delete ((*yyvaluep).t_exp); }
2572
2573 break;
2574
2575 case 108: /* listableEnd */
2576
2577 { delete ((*yyvaluep).t_implicit_list); }
2578
2579 break;
2580
2581 case 109: /* variable */
2582
2583 { delete ((*yyvaluep).t_exp); }
2584
2585 break;
2586
2587 case 110: /* variableFields */
2588
2589 { for (auto e : *((*yyvaluep).t_list_exp)) delete e; delete ((*yyvaluep).t_list_exp); }
2590
2591 break;
2592
2593 case 111: /* cell */
2594
2595 { delete ((*yyvaluep).t_cell_exp); }
2596
2597 break;
2598
2599 case 112: /* matrix */
2600
2601 { delete ((*yyvaluep).t_matrix_exp); }
2602
2603 break;
2604
2605 case 113: /* matrixOrCellLines */
2606
2607 { for (auto e : *((*yyvaluep).t_list_mline)) delete e; delete ((*yyvaluep).t_list_mline); }
2608
2609 break;
2610
2611 case 115: /* matrixOrCellLine */
2612
2613 { delete ((*yyvaluep).t_matrixline_exp); }
2614
2615 break;
2616
2617 case 116: /* matrixOrCellColumns */
2618
2619 { for (auto e : *((*yyvaluep).t_list_exp)) delete e; delete ((*yyvaluep).t_list_exp); }
2620
2621 break;
2622
2623 case 118: /* variableDeclaration */
2624
2625 { delete ((*yyvaluep).t_assign_exp); }
2626
2627 break;
2628
2629 case 119: /* assignable */
2630
2631 { delete ((*yyvaluep).t_exp); }
2632
2633 break;
2634
2635 case 120: /* multipleResults */
2636
2637 { delete ((*yyvaluep).t_assignlist_exp); }
2638
2639 break;
2640
2641 case 121: /* ifControl */
2642
2643 { delete ((*yyvaluep).t_if_exp); }
2644
2645 break;
2646
2647 case 122: /* thenBody */
2648
2649 { delete ((*yyvaluep).t_seq_exp); }
2650
2651 break;
2652
2653 case 123: /* elseBody */
2654
2655 { delete ((*yyvaluep).t_seq_exp); }
2656
2657 break;
2658
2659 case 127: /* elseIfControl */
2660
2661 { delete ((*yyvaluep).t_seq_exp); }
2662
2663 break;
2664
2665 case 128: /* selectControl */
2666
2667 { delete ((*yyvaluep).t_select_exp); }
2668
2669 break;
2670
2671 case 131: /* selectable */
2672
2673 { delete ((*yyvaluep).t_exp); }
2674
2675 break;
2676
2677 case 133: /* casesControl */
2678
2679 { for (auto e : *((*yyvaluep).t_list_case)) delete e; delete ((*yyvaluep).t_list_case); }
2680
2681 break;
2682
2683 case 134: /* caseBody */
2684
2685 { delete ((*yyvaluep).t_seq_exp); }
2686
2687 break;
2688
2689 case 136: /* forControl */
2690
2691 { delete ((*yyvaluep).t_for_exp); }
2692
2693 break;
2694
2695 case 137: /* forIterator */
2696
2697 { delete ((*yyvaluep).t_exp); }
2698
2699 break;
2700
2701 case 139: /* forBody */
2702
2703 { delete ((*yyvaluep).t_seq_exp); }
2704
2705 break;
2706
2707 case 140: /* whileControl */
2708
2709 { delete ((*yyvaluep).t_while_exp); }
2710
2711 break;
2712
2713 case 141: /* whileBody */
2714
2715 { delete ((*yyvaluep).t_seq_exp); }
2716
2717 break;
2718
2719 case 143: /* tryControl */
2720
2721 { delete ((*yyvaluep).t_try_exp); }
2722
2723 break;
2724
2725 case 144: /* catchBody */
2726
2727 { delete ((*yyvaluep).t_seq_exp); }
2728
2729 break;
2730
2731 case 145: /* returnControl */
2732
2733 { delete ((*yyvaluep).t_return_exp); }
2734
2735 break;
2736
2737 case 148: /* keywords */
2738
2739 { delete ((*yyvaluep).t_simple_var); }
2740
2741 break;
2742
2743
2744 default:
2745 break;
2746 }
2747 YY_IGNORE_MAYBE_UNINITIALIZED_END
2748 }
2749
2750
2751
2752
2753 /* The lookahead symbol. */
2754 int yychar;
2755
2756 /* The semantic value of the lookahead symbol. */
2757 YYSTYPE yylval;
2758 /* Location data for the lookahead symbol. */
2759 YYLTYPE yylloc
2760 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
2761 = { 1, 1, 1, 1 }
2762 # endif
2763 ;
2764 /* Number of syntax errors so far. */
2765 int yynerrs;
2766
2767
2768 /*----------.
2769 | yyparse. |
2770 `----------*/
2771
2772 int
yyparse(void)2773 yyparse (void)
2774 {
2775 int yystate;
2776 /* Number of tokens to shift before error messages enabled. */
2777 int yyerrstatus;
2778
2779 /* The stacks and their tools:
2780 'yyss': related to states.
2781 'yyvs': related to semantic values.
2782 'yyls': related to locations.
2783
2784 Refer to the stacks through separate pointers, to allow yyoverflow
2785 to reallocate them elsewhere. */
2786
2787 /* The state stack. */
2788 yytype_int16 yyssa[YYINITDEPTH];
2789 yytype_int16 *yyss;
2790 yytype_int16 *yyssp;
2791
2792 /* The semantic value stack. */
2793 YYSTYPE yyvsa[YYINITDEPTH];
2794 YYSTYPE *yyvs;
2795 YYSTYPE *yyvsp;
2796
2797 /* The location stack. */
2798 YYLTYPE yylsa[YYINITDEPTH];
2799 YYLTYPE *yyls;
2800 YYLTYPE *yylsp;
2801
2802 /* The locations where the error started and ended. */
2803 YYLTYPE yyerror_range[3];
2804
2805 YYSIZE_T yystacksize;
2806
2807 int yyn;
2808 int yyresult;
2809 /* Lookahead token as an internal (translated) token number. */
2810 int yytoken = 0;
2811 /* The variables used to return semantic value and location from the
2812 action routines. */
2813 YYSTYPE yyval;
2814 YYLTYPE yyloc;
2815
2816 #if YYERROR_VERBOSE
2817 /* Buffer for error messages, and its allocated size. */
2818 char yymsgbuf[128];
2819 char *yymsg = yymsgbuf;
2820 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
2821 #endif
2822
2823 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
2824
2825 /* The number of symbols on the RHS of the reduced rule.
2826 Keep to zero when no symbol should be popped. */
2827 int yylen = 0;
2828
2829 yyssp = yyss = yyssa;
2830 yyvsp = yyvs = yyvsa;
2831 yylsp = yyls = yylsa;
2832 yystacksize = YYINITDEPTH;
2833
2834 YYDPRINTF ((stderr, "Starting parse\n"));
2835
2836 yystate = 0;
2837 yyerrstatus = 0;
2838 yynerrs = 0;
2839 yychar = YYEMPTY; /* Cause a token to be read. */
2840 yylsp[0] = yylloc;
2841 goto yysetstate;
2842
2843 /*------------------------------------------------------------.
2844 | yynewstate -- Push a new state, which is found in yystate. |
2845 `------------------------------------------------------------*/
2846 yynewstate:
2847 /* In all cases, when you get here, the value and location stacks
2848 have just been pushed. So pushing a state here evens the stacks. */
2849 yyssp++;
2850
2851 yysetstate:
2852 *yyssp = yystate;
2853
2854 if (yyss + yystacksize - 1 <= yyssp)
2855 {
2856 /* Get the current used size of the three stacks, in elements. */
2857 YYSIZE_T yysize = yyssp - yyss + 1;
2858
2859 #ifdef yyoverflow
2860 {
2861 /* Give user a chance to reallocate the stack. Use copies of
2862 these so that the &'s don't force the real ones into
2863 memory. */
2864 YYSTYPE *yyvs1 = yyvs;
2865 yytype_int16 *yyss1 = yyss;
2866 YYLTYPE *yyls1 = yyls;
2867
2868 /* Each stack pointer address is followed by the size of the
2869 data in use in that stack, in bytes. This used to be a
2870 conditional around just the two extra args, but that might
2871 be undefined if yyoverflow is a macro. */
2872 yyoverflow (YY_("memory exhausted"),
2873 &yyss1, yysize * sizeof (*yyssp),
2874 &yyvs1, yysize * sizeof (*yyvsp),
2875 &yyls1, yysize * sizeof (*yylsp),
2876 &yystacksize);
2877
2878 yyls = yyls1;
2879 yyss = yyss1;
2880 yyvs = yyvs1;
2881 }
2882 #else /* no yyoverflow */
2883 # ifndef YYSTACK_RELOCATE
2884 goto yyexhaustedlab;
2885 # else
2886 /* Extend the stack our own way. */
2887 if (YYMAXDEPTH <= yystacksize)
2888 goto yyexhaustedlab;
2889 yystacksize *= 2;
2890 if (YYMAXDEPTH < yystacksize)
2891 yystacksize = YYMAXDEPTH;
2892
2893 {
2894 yytype_int16 *yyss1 = yyss;
2895 union yyalloc *yyptr =
2896 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
2897 if (! yyptr)
2898 goto yyexhaustedlab;
2899 YYSTACK_RELOCATE (yyss_alloc, yyss);
2900 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
2901 YYSTACK_RELOCATE (yyls_alloc, yyls);
2902 # undef YYSTACK_RELOCATE
2903 if (yyss1 != yyssa)
2904 YYSTACK_FREE (yyss1);
2905 }
2906 # endif
2907 #endif /* no yyoverflow */
2908
2909 yyssp = yyss + yysize - 1;
2910 yyvsp = yyvs + yysize - 1;
2911 yylsp = yyls + yysize - 1;
2912
2913 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2914 (unsigned long int) yystacksize));
2915
2916 if (yyss + yystacksize - 1 <= yyssp)
2917 YYABORT;
2918 }
2919
2920 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2921
2922 if (yystate == YYFINAL)
2923 YYACCEPT;
2924
2925 goto yybackup;
2926
2927 /*-----------.
2928 | yybackup. |
2929 `-----------*/
2930 yybackup:
2931
2932 /* Do appropriate processing given the current state. Read a
2933 lookahead token if we need one and don't already have one. */
2934
2935 /* First try to decide what to do without reference to lookahead token. */
2936 yyn = yypact[yystate];
2937 if (yypact_value_is_default (yyn))
2938 goto yydefault;
2939
2940 /* Not known => get a lookahead token if don't already have one. */
2941
2942 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
2943 if (yychar == YYEMPTY)
2944 {
2945 YYDPRINTF ((stderr, "Reading a token: "));
2946 yychar = yylex ();
2947 }
2948
2949 if (yychar <= YYEOF)
2950 {
2951 yychar = yytoken = YYEOF;
2952 YYDPRINTF ((stderr, "Now at end of input.\n"));
2953 }
2954 else
2955 {
2956 yytoken = YYTRANSLATE (yychar);
2957 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2958 }
2959
2960 /* If the proper action on seeing token YYTOKEN is to reduce or to
2961 detect an error, take that action. */
2962 yyn += yytoken;
2963 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2964 goto yydefault;
2965 yyn = yytable[yyn];
2966 if (yyn <= 0)
2967 {
2968 if (yytable_value_is_error (yyn))
2969 goto yyerrlab;
2970 yyn = -yyn;
2971 goto yyreduce;
2972 }
2973
2974 /* Count tokens shifted since error; after three, turn off error
2975 status. */
2976 if (yyerrstatus)
2977 yyerrstatus--;
2978
2979 /* Shift the lookahead token. */
2980 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2981
2982 /* Discard the shifted token. */
2983 yychar = YYEMPTY;
2984
2985 yystate = yyn;
2986 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2987 *++yyvsp = yylval;
2988 YY_IGNORE_MAYBE_UNINITIALIZED_END
2989 *++yylsp = yylloc;
2990 goto yynewstate;
2991
2992
2993 /*-----------------------------------------------------------.
2994 | yydefault -- do the default action for the current state. |
2995 `-----------------------------------------------------------*/
2996 yydefault:
2997 yyn = yydefact[yystate];
2998 if (yyn == 0)
2999 goto yyerrlab;
3000 goto yyreduce;
3001
3002
3003 /*-----------------------------.
3004 | yyreduce -- Do a reduction. |
3005 `-----------------------------*/
3006 yyreduce:
3007 /* yyn is the number of a rule to reduce with. */
3008 yylen = yyr2[yyn];
3009
3010 /* If YYLEN is nonzero, implement the default value of the action:
3011 '$$ = $1'.
3012
3013 Otherwise, the following line sets YYVAL to garbage.
3014 This behavior is undocumented and Bison
3015 users should not rely upon it. Assigning to YYVAL
3016 unconditionally makes the parser a bit smaller, and it avoids a
3017 GCC warning that YYVAL may be used uninitialized. */
3018 yyval = yyvsp[1-yylen];
3019
3020 /* Default location. */
3021 YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
3022 yyerror_range[1] = yyloc;
3023 YY_REDUCE_PRINT (yyn);
3024 switch (yyn)
3025 {
3026 case 2:
3027
3028 { SetTree((yyvsp[0].t_seq_exp)); print_rules("program", "expressions");}
3029
3030 break;
3031
3032 case 3:
3033
3034 { SetTree((yyvsp[0].t_seq_exp)); print_rules("program", "EOL expressions");}
3035
3036 break;
3037
3038 case 4:
3039
3040 {
3041 print_rules("program", "expressionLineBreak");
3042 ast::exps_t* tmp = new ast::exps_t;
3043 #ifdef BUILD_DEBUG_AST
3044 tmp->push_back(new ast::CommentExp((yyloc), new std::wstring(L"Empty body")));
3045 #endif
3046 SetTree(new ast::SeqExp((yyloc), *tmp));
3047 delete (yyvsp[0].mute);
3048 }
3049
3050 break;
3051
3052 case 5:
3053
3054 {
3055 print_rules("program", "Epsilon");
3056 ast::exps_t* tmp = new ast::exps_t;
3057 #ifdef BUILD_DEBUG_AST
3058 tmp->push_back(new ast::CommentExp((yyloc), new std::wstring(L"Empty body")));
3059 #endif
3060 SetTree(new ast::SeqExp((yyloc), *tmp));
3061 }
3062
3063 break;
3064
3065 case 6:
3066
3067 {
3068 print_rules("expressions", "recursiveExpression");
3069 (yyval.t_seq_exp) = new ast::SeqExp((yyloc), *(yyvsp[0].t_list_exp));
3070 }
3071
3072 break;
3073
3074 case 7:
3075
3076 {
3077 print_rules("expressions", "recursiveExpression expression");
3078 (yyvsp[0].t_exp)->setVerbose(true);
3079 (yyvsp[-1].t_list_exp)->push_back((yyvsp[0].t_exp));
3080 (yyval.t_seq_exp) = new ast::SeqExp((yyloc), *(yyvsp[-1].t_list_exp));
3081 }
3082
3083 break;
3084
3085 case 8:
3086
3087 {
3088 print_rules("expressions", "recursiveExpression expression COMMENT");
3089 (yyvsp[-1].t_exp)->setVerbose(true);
3090 (yyvsp[-2].t_list_exp)->push_back((yyvsp[-1].t_exp));
3091 (yyvsp[-2].t_list_exp)->push_back(new ast::CommentExp((yylsp[0]), (yyvsp[0].comment)));
3092 (yyval.t_seq_exp) = new ast::SeqExp((yyloc), *(yyvsp[-2].t_list_exp));
3093 }
3094
3095 break;
3096
3097 case 9:
3098
3099 {
3100 print_rules("expressions", "expression");
3101 ast::exps_t* tmp = new ast::exps_t;
3102 (yyvsp[0].t_exp)->setVerbose(true);
3103 tmp->push_back((yyvsp[0].t_exp));
3104 (yyval.t_seq_exp) = new ast::SeqExp((yyloc), *tmp);
3105 }
3106
3107 break;
3108
3109 case 10:
3110
3111 {
3112 print_rules("expressions", "expression COMMENT");
3113 ast::exps_t* tmp = new ast::exps_t;
3114 (yyvsp[-1].t_exp)->setVerbose(true);
3115 tmp->push_back((yyvsp[-1].t_exp));
3116 tmp->push_back(new ast::CommentExp((yylsp[0]), (yyvsp[0].comment)));
3117 (yyval.t_seq_exp) = new ast::SeqExp((yyloc), *tmp);
3118 }
3119
3120 break;
3121
3122 case 11:
3123
3124 {
3125 print_rules("recursiveExpression", "recursiveExpression expression expressionLineBreak");
3126 (yyvsp[-1].t_exp)->setVerbose((yyvsp[0].mute)->bVerbose);
3127 (yyvsp[-2].t_list_exp)->push_back((yyvsp[-1].t_exp));
3128 (yyval.t_list_exp) = (yyvsp[-2].t_list_exp);
3129 if ((yyvsp[0].mute)->iNbBreaker != 0)
3130 {
3131 (yyvsp[-1].t_exp)->getLocation().last_column = (yyvsp[0].mute)->iNbBreaker;
3132 }
3133 delete (yyvsp[0].mute);
3134 }
3135
3136 break;
3137
3138 case 12:
3139
3140 {
3141 print_rules("recursiveExpression", "recursiveExpression expression COMMENT expressionLineBreak");
3142 (yyvsp[-2].t_exp)->setVerbose((yyvsp[0].mute)->bVerbose);
3143 (yyvsp[-3].t_list_exp)->push_back((yyvsp[-2].t_exp));
3144 (yylsp[-1]).columns((yyvsp[0].mute)->iNbBreaker);
3145 (yyvsp[-3].t_list_exp)->push_back(new ast::CommentExp((yylsp[-1]), (yyvsp[-1].comment)));
3146 (yyval.t_list_exp) = (yyvsp[-3].t_list_exp);
3147 delete (yyvsp[0].mute);
3148 }
3149
3150 break;
3151
3152 case 13:
3153
3154 {
3155 print_rules("recursiveExpression", "expression COMMENT expressionLineBreak");
3156 ast::exps_t* tmp = new ast::exps_t;
3157 (yylsp[-1]).columns((yyvsp[0].mute)->iNbBreaker);
3158 (yyvsp[-2].t_exp)->setVerbose((yyvsp[0].mute)->bVerbose);
3159 tmp->push_back((yyvsp[-2].t_exp));
3160 tmp->push_back(new ast::CommentExp((yylsp[-1]), (yyvsp[-1].comment)));
3161 (yyval.t_list_exp) = tmp;
3162 delete (yyvsp[0].mute);
3163 }
3164
3165 break;
3166
3167 case 14:
3168
3169 {
3170 print_rules("recursiveExpression", "expression expressionLineBreak");
3171 ast::exps_t* tmp = new ast::exps_t;
3172 (yyvsp[-1].t_exp)->setVerbose((yyvsp[0].mute)->bVerbose);
3173 tmp->push_back((yyvsp[-1].t_exp));
3174 (yyval.t_list_exp) = tmp;
3175 if ((yyvsp[0].mute)->iNbBreaker != 0)
3176 {
3177 (yyvsp[-1].t_exp)->getLocation().last_column = (yyvsp[0].mute)->iNbBreaker;
3178 }
3179 delete (yyvsp[0].mute);
3180 }
3181
3182 break;
3183
3184 case 15:
3185
3186 { (yyval.mute) = new LineBreakStr(); (yyval.mute)->bVerbose = false; (yyval.mute)->iNbBreaker = (yylsp[0]).last_column;print_rules("expressionLineBreak", "SEMI"); }
3187
3188 break;
3189
3190 case 16:
3191
3192 { (yyval.mute) = new LineBreakStr(); (yyval.mute)->bVerbose = true; (yyval.mute)->iNbBreaker = (yylsp[0]).last_column;print_rules("expressionLineBreak", "COMMA"); }
3193
3194 break;
3195
3196 case 17:
3197
3198 { (yyval.mute) = new LineBreakStr(); (yyval.mute)->bVerbose = true; (yyval.mute)->iNbBreaker = 0;print_rules("expressionLineBreak", "expressionLineBreak SEMI"); }
3199
3200 break;
3201
3202 case 18:
3203
3204 { (yyval.mute) = (yyvsp[-1].mute); (yyval.mute)->bVerbose = false || (yyvsp[-1].mute)->bVerbose; (yyval.mute)->iNbBreaker = (yylsp[0]).last_column;print_rules("expressionLineBreak", "SEMI"); }
3205
3206 break;
3207
3208 case 19:
3209
3210 { (yyval.mute) = (yyvsp[-1].mute); (yyval.mute)->iNbBreaker = (yylsp[0]).last_column;print_rules("expressionLineBreak", "expressionLineBreak COMMA"); }
3211
3212 break;
3213
3214 case 20:
3215
3216 { (yyval.mute) = (yyvsp[-1].mute);print_rules("expressionLineBreak", "expressionLineBreak EOL"); }
3217
3218 break;
3219
3220 case 21:
3221
3222 { (yyval.t_exp) = (yyvsp[0].t_function_dec); print_rules("expression", "functionDeclaration");}
3223
3224 break;
3225
3226 case 22:
3227
3228 { (yyval.t_exp) = (yyvsp[0].t_call_exp); print_rules("expression", "functionCall");}
3229
3230 break;
3231
3232 case 23:
3233
3234 { (yyval.t_exp) = (yyvsp[0].t_assign_exp); print_rules("expression", "variableDeclaration");}
3235
3236 break;
3237
3238 case 24:
3239
3240 { (yyval.t_exp) = (yyvsp[0].t_if_exp); print_rules("expression", "ifControl");}
3241
3242 break;
3243
3244 case 25:
3245
3246 { (yyval.t_exp) = (yyvsp[0].t_select_exp); print_rules("expression", "selectControl");}
3247
3248 break;
3249
3250 case 26:
3251
3252 { (yyval.t_exp) = (yyvsp[0].t_for_exp); print_rules("expression", "forControl");}
3253
3254 break;
3255
3256 case 27:
3257
3258 { (yyval.t_exp) = (yyvsp[0].t_while_exp); print_rules("expression", "whileControl");}
3259
3260 break;
3261
3262 case 28:
3263
3264 { (yyval.t_exp) = (yyvsp[0].t_try_exp); print_rules("expression", "tryControl");}
3265
3266 break;
3267
3268 case 29:
3269
3270 { (yyval.t_exp) = (yyvsp[0].t_exp); print_rules("expression", "variable");}
3271
3272 break;
3273
3274 case 30:
3275
3276 { (yyval.t_exp) = (yyvsp[0].t_call_exp); print_rules("expression", "implicitFunctionCall");}
3277
3278 break;
3279
3280 case 31:
3281
3282 { (yyval.t_exp) = new ast::BreakExp((yyloc)); print_rules("expression", "BREAK");}
3283
3284 break;
3285
3286 case 32:
3287
3288 { (yyval.t_exp) = new ast::ContinueExp((yyloc)); print_rules("expression", "CONTINUE");}
3289
3290 break;
3291
3292 case 33:
3293
3294 { (yyval.t_exp) = (yyvsp[0].t_return_exp); print_rules("expression", "returnControl");}
3295
3296 break;
3297
3298 case 34:
3299
3300 { (yyval.t_exp) = new ast::CommentExp((yyloc), (yyvsp[0].comment)); print_rules("expression", "COMMENT");}
3301
3302 break;
3303
3304 case 35:
3305
3306 {
3307 print_rules("expression", "error");
3308 (yyval.t_exp) = new ast::CommentExp((yyloc), new std::wstring(L"@@ ERROR RECOVERY @@"));
3309 StopOnError();
3310 }
3311
3312 break;
3313
3314 case 36:
3315
3316 {
3317 print_rules("implicitFunctionCall", "implicitFunctionCall implicitCallable");
3318 (yyvsp[-1].t_call_exp)->addArg((yyvsp[0].t_string_exp));
3319 (yyvsp[-1].t_call_exp)->setLocation((yyloc));
3320 (yyval.t_call_exp) = (yyvsp[-1].t_call_exp);
3321 }
3322
3323 break;
3324
3325 case 37:
3326
3327 {
3328 print_rules("implicitFunctionCall", "ID implicitCallable");
3329 ast::exps_t* tmp = new ast::exps_t;
3330 tmp->push_back((yyvsp[0].t_string_exp));
3331 (yyval.t_call_exp) = new ast::CallExp((yyloc), *new ast::SimpleVar((yylsp[-1]), symbol::Symbol(*(yyvsp[-1].str))), *tmp);
3332 delete (yyvsp[-1].str);
3333 }
3334
3335 break;
3336
3337 case 38:
3338
3339 { (yyval.t_string_exp) = new ast::StringExp((yyloc), *(yyvsp[0].str)); delete (yyvsp[0].str);print_rules("implicitCallable", "ID");}
3340
3341 break;
3342
3343 case 39:
3344
3345 {
3346 print_rules("implicitCallable", (yyvsp[0].number));
3347 std::wstringstream tmp;
3348 tmp << (yyvsp[0].number);
3349 (yyval.t_string_exp) = new ast::StringExp((yyloc), tmp.str());
3350 }
3351
3352 break;
3353
3354 case 40:
3355
3356 {
3357 print_rules("implicitCallable", (yyvsp[0].number));
3358 std::wstringstream tmp;
3359 tmp << (yyvsp[0].number);
3360 (yyval.t_string_exp) = new ast::StringExp((yyloc), tmp.str());
3361 }
3362
3363 break;
3364
3365 case 41:
3366
3367 {
3368 print_rules("implicitCallable", (yyvsp[0].number));
3369 std::wstringstream tmp;
3370 tmp << (yyvsp[0].number);
3371 (yyval.t_string_exp) = new ast::StringExp((yyloc), tmp.str());
3372 }
3373
3374 break;
3375
3376 case 42:
3377
3378 { (yyval.t_string_exp) = new ast::StringExp((yyloc), *(yyvsp[0].str)); delete (yyvsp[0].str);print_rules("implicitCallable", "STR");}
3379
3380 break;
3381
3382 case 43:
3383
3384 { (yyval.t_string_exp) = new ast::StringExp((yyloc), std::wstring(L"$")); print_rules("implicitCallable", "DOLLAR");}
3385
3386 break;
3387
3388 case 44:
3389
3390 { (yyval.t_string_exp) = new ast::StringExp((yyloc), std::wstring(L"%t")); print_rules("implicitCallable", "BOOLTRUE");}
3391
3392 break;
3393
3394 case 45:
3395
3396 { (yyval.t_string_exp) = new ast::StringExp((yyloc), std::wstring(L"%f")); print_rules("implicitCallable", "BOOLFALSE");}
3397
3398 break;
3399
3400 case 46:
3401
3402 {
3403 print_rules("implicitCallable", "implicitCallable DOT ID");
3404 std::wstringstream tmp;
3405 tmp << (yyvsp[-2].t_string_exp)->getValue() << "." << *(yyvsp[0].str);
3406 (yyval.t_string_exp) = new ast::StringExp((yyloc), tmp.str());
3407 delete (yyvsp[0].str);
3408 }
3409
3410 break;
3411
3412 case 47:
3413
3414 { (yyval.t_string_exp) = new ast::StringExp((yyloc), *(yyvsp[0].path)); delete (yyvsp[0].path);print_rules("implicitCallable", "PATH");}
3415
3416 break;
3417
3418 case 48:
3419
3420 { (yyval.t_call_exp) = (yyvsp[0].t_call_exp); print_rules("functionCall", "simpleFunctionCall");}
3421
3422 break;
3423
3424 case 49:
3425
3426 { (yyval.t_call_exp) = (yyvsp[-1].t_call_exp); print_rules("functionCall", "LPAREN functionCall RPAREN");}
3427
3428 break;
3429
3430 case 50:
3431
3432 { (yyval.t_call_exp) = new ast::CallExp((yyloc), *new ast::SimpleVar((yylsp[-3]), symbol::Symbol(*(yyvsp[-3].str))), *(yyvsp[-1].t_list_exp)); delete (yyvsp[-3].str);print_rules("simpleFunctionCall", "ID LPAREN functionArgs RPAREN");}
3433
3434 break;
3435
3436 case 51:
3437
3438 { (yyval.t_call_exp) = new ast::CellCallExp((yyloc), *new ast::SimpleVar((yylsp[-3]), symbol::Symbol(*(yyvsp[-3].str))), *(yyvsp[-1].t_list_exp)); delete (yyvsp[-3].str);print_rules("simpleFunctionCall", "ID LBRACE functionArgs RBRACE");}
3439
3440 break;
3441
3442 case 52:
3443
3444 { (yyval.t_call_exp) = new ast::CallExp((yyloc), *new ast::SimpleVar((yylsp[-2]), symbol::Symbol(*(yyvsp[-2].str))), *new ast::exps_t); delete (yyvsp[-2].str);print_rules("simpleFunctionCall", "ID LPAREN RPAREN");}
3445
3446 break;
3447
3448 case 53:
3449
3450 { (yyval.t_call_exp) = new ast::CellCallExp((yyloc), *new ast::SimpleVar((yylsp[-2]), symbol::Symbol(*(yyvsp[-2].str))), *new ast::exps_t); delete (yyvsp[-2].str);print_rules("simpleFunctionCall", "ID LBRACE RBRACE");}
3451
3452 break;
3453
3454 case 54:
3455
3456 {(yyval.t_list_exp) = new ast::exps_t;(yyval.t_list_exp)->push_back((yyvsp[0].t_exp));print_rules("functionArgs", "variable");}
3457
3458 break;
3459
3460 case 55:
3461
3462 {(yyval.t_list_exp) = new ast::exps_t;(yyval.t_list_exp)->push_back((yyvsp[0].t_call_exp));print_rules("functionArgs", "functionCall");}
3463
3464 break;
3465
3466 case 56:
3467
3468 {(yyval.t_list_exp) = new ast::exps_t;(yyval.t_list_exp)->push_back(new ast::ColonVar((yylsp[0])));print_rules("functionArgs", "COLON");}
3469
3470 break;
3471
3472 case 57:
3473
3474 {(yyval.t_list_exp) = new ast::exps_t;(yyval.t_list_exp)->push_back((yyvsp[0].t_assign_exp));print_rules("functionArgs", "variableDeclaration");}
3475
3476 break;
3477
3478 case 58:
3479
3480 {(yyval.t_list_exp) = new ast::exps_t;(yyval.t_list_exp)->push_back(new ast::NilExp((yylsp[0])));(yyval.t_list_exp)->push_back(new ast::NilExp((yylsp[0])));print_rules("functionArgs", "COMMA");}
3481
3482 break;
3483
3484 case 59:
3485
3486 {(yyval.t_list_exp) = new ast::exps_t;(yyval.t_list_exp)->push_back(new ast::NilExp((yylsp[-1])));(yyval.t_list_exp)->push_back((yyvsp[0].t_exp));print_rules("functionArgs", "COMMA variable");}
3487
3488 break;
3489
3490 case 60:
3491
3492 {(yyval.t_list_exp) = new ast::exps_t;(yyval.t_list_exp)->push_back(new ast::NilExp((yylsp[-1])));(yyval.t_list_exp)->push_back((yyvsp[0].t_call_exp));print_rules("functionArgs", "COMMA functionCall");}
3493
3494 break;
3495
3496 case 61:
3497
3498 {(yyval.t_list_exp) = new ast::exps_t;(yyval.t_list_exp)->push_back(new ast::NilExp((yylsp[-1])));(yyval.t_list_exp)->push_back(new ast::ColonVar((yylsp[0])));print_rules("functionArgs", "COMMA COLON");}
3499
3500 break;
3501
3502 case 62:
3503
3504 {(yyval.t_list_exp) = new ast::exps_t;(yyval.t_list_exp)->push_back(new ast::NilExp((yylsp[-1])));(yyval.t_list_exp)->push_back((yyvsp[0].t_assign_exp));print_rules("functionArgs", "COMMA variableDeclaration");}
3505
3506 break;
3507
3508 case 63:
3509
3510 {(yyvsp[-1].t_list_exp)->push_back(new ast::NilExp((yylsp[0])));(yyval.t_list_exp) = (yyvsp[-1].t_list_exp);print_rules("functionArgs", "functionArgs COMMA");}
3511
3512 break;
3513
3514 case 64:
3515
3516 {(yyvsp[-2].t_list_exp)->push_back((yyvsp[0].t_exp));(yyval.t_list_exp) = (yyvsp[-2].t_list_exp);print_rules("functionArgs", "functionArgs COMMA variable");}
3517
3518 break;
3519
3520 case 65:
3521
3522 {(yyvsp[-2].t_list_exp)->push_back((yyvsp[0].t_call_exp));(yyval.t_list_exp) = (yyvsp[-2].t_list_exp);print_rules("functionArgs", "functionArgs COMMA functionCall");}
3523
3524 break;
3525
3526 case 66:
3527
3528 {(yyvsp[-2].t_list_exp)->push_back(new ast::ColonVar((yylsp[-2])));(yyval.t_list_exp) = (yyvsp[-2].t_list_exp);print_rules("functionArgs", "functionArgs COMMA COLON");}
3529
3530 break;
3531
3532 case 67:
3533
3534 {(yyvsp[-2].t_list_exp)->push_back((yyvsp[0].t_assign_exp));(yyval.t_list_exp) = (yyvsp[-2].t_list_exp);print_rules("functionArgs", "functionArgs COMMA variableDeclaration");}
3535
3536 break;
3537
3538 case 68:
3539
3540 {
3541 print_rules("functionDeclaration", "FUNCTION ID ASSIGN ID functionDeclarationArguments functionDeclarationBreak functionBody ENDFUNCTION");
3542 ast::exps_t* tmp = new ast::exps_t;
3543 tmp->push_back(new ast::SimpleVar((yylsp[-6]), symbol::Symbol(*(yyvsp[-6].str))));
3544 (yyval.t_function_dec) = new ast::FunctionDec((yyloc),
3545 symbol::Symbol(*(yyvsp[-4].str)),
3546 *new ast::ArrayListVar((yylsp[-3]), *(yyvsp[-3].t_list_var)),
3547 *new ast::ArrayListVar((yylsp[-6]), *tmp),
3548 *(yyvsp[-1].t_seq_exp));
3549 delete (yyvsp[-6].str);
3550 delete (yyvsp[-4].str);
3551 }
3552
3553 break;
3554
3555 case 69:
3556
3557 {
3558 print_rules("functionDeclaration", "FUNCTION LBRACK functionDeclarationReturns RBRACK ASSIGN ID functionDeclarationArguments functionDeclarationBreak functionBody ENDFUNCTION");
3559 (yyval.t_function_dec) = new ast::FunctionDec((yyloc),
3560 symbol::Symbol(*(yyvsp[-4].str)),
3561 *new ast::ArrayListVar((yylsp[-3]), *(yyvsp[-3].t_list_var)),
3562 *new ast::ArrayListVar((yylsp[-7]) ,*(yyvsp[-7].t_list_var)),
3563 *(yyvsp[-1].t_seq_exp));
3564 delete (yyvsp[-4].str);
3565 }
3566
3567 break;
3568
3569 case 70:
3570
3571 {
3572 print_rules("functionDeclaration", "FUNCTION LBRACK RBRACK ASSIGN ID functionDeclarationArguments functionDeclarationBreak functionBody ENDFUNCTION");
3573 ast::exps_t* tmp = new ast::exps_t;
3574 (yyval.t_function_dec) = new ast::FunctionDec((yyloc),
3575 symbol::Symbol(*(yyvsp[-4].str)),
3576 *new ast::ArrayListVar((yylsp[-3]), *(yyvsp[-3].t_list_var)),
3577 *new ast::ArrayListVar((yylsp[-7]), *tmp),
3578 *(yyvsp[-1].t_seq_exp));
3579 delete (yyvsp[-4].str);
3580 }
3581
3582 break;
3583
3584 case 71:
3585
3586 {
3587 print_rules("functionDeclaration", "FUNCTION ID functionDeclarationArguments functionDeclarationBreak functionBody ENDFUNCTION");
3588 ast::exps_t* tmp = new ast::exps_t;
3589 (yyval.t_function_dec) = new ast::FunctionDec((yyloc),
3590 symbol::Symbol(*(yyvsp[-4].str)),
3591 *new ast::ArrayListVar((yylsp[-3]), *(yyvsp[-3].t_list_var)),
3592 *new ast::ArrayListVar((yyloc), *tmp),
3593 *(yyvsp[-1].t_seq_exp));
3594 delete (yyvsp[-4].str);
3595 }
3596
3597 break;
3598
3599 case 72:
3600
3601 {
3602 print_rules("functionDeclaration", "FUNCTION ID ASSIGN ID functionDeclarationArguments functionDeclarationBreak functionBody END ");
3603 ast::exps_t* tmp = new ast::exps_t;
3604 tmp->push_back(new ast::SimpleVar((yylsp[-6]), symbol::Symbol(*(yyvsp[-6].str))));
3605 (yyval.t_function_dec) = new ast::FunctionDec((yyloc),
3606 symbol::Symbol(*(yyvsp[-4].str)),
3607 *new ast::ArrayListVar((yylsp[-3]), *(yyvsp[-3].t_list_var)),
3608 *new ast::ArrayListVar((yylsp[-6]), *tmp),
3609 *(yyvsp[-1].t_seq_exp));
3610 delete (yyvsp[-6].str);
3611 delete (yyvsp[-4].str);
3612 }
3613
3614 break;
3615
3616 case 73:
3617
3618 {
3619 print_rules("functionDeclaration", "FUNCTION LBRACK functionDeclarationReturns RBRACK ASSIGN ID functionDeclarationArguments functionDeclarationBreak functionBody END");
3620 (yyval.t_function_dec) = new ast::FunctionDec((yyloc),
3621 symbol::Symbol(*(yyvsp[-4].str)),
3622 *new ast::ArrayListVar((yylsp[-3]), *(yyvsp[-3].t_list_var)),
3623 *new ast::ArrayListVar((yylsp[-7]) ,*(yyvsp[-7].t_list_var)),
3624 *(yyvsp[-1].t_seq_exp));
3625 delete (yyvsp[-4].str);
3626 }
3627
3628 break;
3629
3630 case 74:
3631
3632 {
3633 print_rules("functionDeclaration", "FUNCTION LBRACK RBRACK ASSIGN ID functionDeclarationArguments functionDeclarationBreak functionBody END");
3634 ast::exps_t* tmp = new ast::exps_t;
3635 (yyval.t_function_dec) = new ast::FunctionDec((yyloc),
3636 symbol::Symbol(*(yyvsp[-4].str)),
3637 *new ast::ArrayListVar((yylsp[-3]), *(yyvsp[-3].t_list_var)),
3638 *new ast::ArrayListVar((yylsp[-7]), *tmp),
3639 *(yyvsp[-1].t_seq_exp));
3640 delete (yyvsp[-4].str);
3641 }
3642
3643 break;
3644
3645 case 75:
3646
3647 {
3648 print_rules("functionDeclaration", "FUNCTION ID functionDeclarationArguments functionDeclarationBreak functionBody END");
3649 ast::exps_t* tmp = new ast::exps_t;
3650 (yyval.t_function_dec) = new ast::FunctionDec((yyloc),
3651 symbol::Symbol(*(yyvsp[-4].str)),
3652 *new ast::ArrayListVar((yylsp[-3]), *(yyvsp[-3].t_list_var)),
3653 *new ast::ArrayListVar((yyloc), *tmp),
3654 *(yyvsp[-1].t_seq_exp));
3655 delete (yyvsp[-4].str);
3656 }
3657
3658 break;
3659
3660 case 76:
3661
3662 { (yyval.t_list_var) = (yyvsp[0].t_list_var); print_rules("functionDeclarationReturns", "idList");}
3663
3664 break;
3665
3666 case 77:
3667
3668 { (yyval.t_list_var) = (yyvsp[-1].t_list_var); print_rules("functionDeclarationArguments", "LPAREN idList RPAREN");}
3669
3670 break;
3671
3672 case 78:
3673
3674 { (yyval.t_list_var) = new ast::exps_t; print_rules("functionDeclarationArguments", "LPAREN RPAREN");}
3675
3676 break;
3677
3678 case 79:
3679
3680 { (yyval.t_list_var) = new ast::exps_t; print_rules("functionDeclarationArguments", "Epsilon");}
3681
3682 break;
3683
3684 case 80:
3685
3686 {
3687 print_rules("idList", "idList COMMA ID");
3688 (yyvsp[-2].t_list_var)->push_back(new ast::SimpleVar((yylsp[0]), symbol::Symbol(*(yyvsp[0].str))));
3689 delete (yyvsp[0].str);
3690 (yyval.t_list_var) = (yyvsp[-2].t_list_var);
3691 }
3692
3693 break;
3694
3695 case 81:
3696
3697 {
3698 print_rules("idList", "ID");
3699 (yyval.t_list_var) = new ast::exps_t;
3700 (yyval.t_list_var)->push_back(new ast::SimpleVar((yyloc), symbol::Symbol(*(yyvsp[0].str))));
3701 delete (yyvsp[0].str);
3702 }
3703
3704 break;
3705
3706 case 82:
3707
3708 { /* !! Do Nothing !! */ print_rules("functionDeclarationBreak", "lineEnd");}
3709
3710 break;
3711
3712 case 83:
3713
3714 { /* !! Do Nothing !! */ print_rules("functionDeclarationBreak", "SEMI");}
3715
3716 break;
3717
3718 case 84:
3719
3720 { /* !! Do Nothing !! */ print_rules("functionDeclarationBreak", "SEMI EOL");}
3721
3722 break;
3723
3724 case 85:
3725
3726 { /* !! Do Nothing !! */ print_rules("functionDeclarationBreak", "COMMA");}
3727
3728 break;
3729
3730 case 86:
3731
3732 { /* !! Do Nothing !! */ print_rules("functionDeclarationBreak", "COMMA EOL");}
3733
3734 break;
3735
3736 case 87:
3737
3738 {
3739 print_rules("functionBody", "expressions");
3740 (yyvsp[0].t_seq_exp)->getLocation().last_line = (yyvsp[0].t_seq_exp)->getExps().back()->getLocation().last_line;
3741 (yyvsp[0].t_seq_exp)->getLocation().last_column = (yyvsp[0].t_seq_exp)->getExps().back()->getLocation().last_column;
3742 (yyval.t_seq_exp) = (yyvsp[0].t_seq_exp);
3743 }
3744
3745 break;
3746
3747 case 88:
3748
3749 {
3750 print_rules("functionBody", "Epsilon");
3751 ast::exps_t* tmp = new ast::exps_t;
3752 #ifdef BUILD_DEBUG_AST
3753 tmp->push_back(new ast::CommentExp((yyloc), new std::wstring(L"Empty function body")));
3754 #endif
3755 (yyval.t_seq_exp) = new ast::SeqExp((yyloc), *tmp);
3756 }
3757
3758 break;
3759
3760 case 89:
3761
3762 { (yyval.t_exp) = (yyvsp[0].t_call_exp); print_rules("condition", "functionCall");}
3763
3764 break;
3765
3766 case 90:
3767
3768 { (yyval.t_exp) = (yyvsp[0].t_exp); print_rules("condition", "variable");}
3769
3770 break;
3771
3772 case 91:
3773
3774 {
3775 print_rules("comparison", "variable rightComparable");
3776 delete &((yyvsp[0].t_op_exp)->getLeft());
3777 (yyvsp[0].t_op_exp)->setLeft(*(yyvsp[-1].t_exp));
3778 (yyvsp[0].t_op_exp)->setLocation((yyloc));
3779 (yyval.t_op_exp) = (yyvsp[0].t_op_exp);
3780 }
3781
3782 break;
3783
3784 case 92:
3785
3786 {
3787 print_rules("comparison", "functionCall rightComparable");
3788 delete &((yyvsp[0].t_op_exp)->getLeft());
3789 (yyvsp[0].t_op_exp)->setLeft(*(yyvsp[-1].t_call_exp));
3790 (yyvsp[0].t_op_exp)->setLocation((yyloc));
3791 (yyval.t_op_exp) = (yyvsp[0].t_op_exp);
3792 }
3793
3794 break;
3795
3796 case 93:
3797
3798 { (yyval.t_op_exp) = new ast::LogicalOpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::LogicalOpExp::logicalAnd, *(yyvsp[0].t_exp)); print_rules("rightComparable", "AND variable");}
3799
3800 break;
3801
3802 case 94:
3803
3804 { (yyval.t_op_exp) = new ast::LogicalOpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::LogicalOpExp::logicalAnd, *(yyvsp[0].t_call_exp)); print_rules("rightComparable", "AND functionCall");}
3805
3806 break;
3807
3808 case 95:
3809
3810 { (yyval.t_op_exp) = new ast::LogicalOpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::LogicalOpExp::logicalAnd, * new ast::ColonVar((yyloc))); print_rules("rightComparable", "AND COLON");}
3811
3812 break;
3813
3814 case 96:
3815
3816 { (yyval.t_op_exp) = new ast::LogicalOpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::LogicalOpExp::logicalShortCutAnd, *(yyvsp[0].t_exp)); print_rules("rightComparable", "ANDAND variable");}
3817
3818 break;
3819
3820 case 97:
3821
3822 { (yyval.t_op_exp) = new ast::LogicalOpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::LogicalOpExp::logicalShortCutAnd, *(yyvsp[0].t_call_exp)); print_rules("rightComparable", "ANDAND functionCall");}
3823
3824 break;
3825
3826 case 98:
3827
3828 { (yyval.t_op_exp) = new ast::LogicalOpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::LogicalOpExp::logicalShortCutAnd, * new ast::ColonVar((yyloc))); print_rules("rightComparable", "ANDAND COLON");}
3829
3830 break;
3831
3832 case 99:
3833
3834 { (yyval.t_op_exp) = new ast::LogicalOpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::LogicalOpExp::logicalOr, *(yyvsp[0].t_exp)); print_rules("rightComparable", "OR variable");}
3835
3836 break;
3837
3838 case 100:
3839
3840 { (yyval.t_op_exp) = new ast::LogicalOpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::LogicalOpExp::logicalOr, *(yyvsp[0].t_call_exp)); print_rules("rightComparable", "OR functionCall");}
3841
3842 break;
3843
3844 case 101:
3845
3846 { (yyval.t_op_exp) = new ast::LogicalOpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::LogicalOpExp::logicalOr, * new ast::ColonVar((yyloc))); print_rules("rightComparable", "OR COLON");}
3847
3848 break;
3849
3850 case 102:
3851
3852 { (yyval.t_op_exp) = new ast::LogicalOpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::LogicalOpExp::logicalShortCutOr, *(yyvsp[0].t_exp)); print_rules("rightComparable", "OROR variable");}
3853
3854 break;
3855
3856 case 103:
3857
3858 { (yyval.t_op_exp) = new ast::LogicalOpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::LogicalOpExp::logicalShortCutOr, *(yyvsp[0].t_call_exp)); print_rules("rightComparable", "OROR functionCall");}
3859
3860 break;
3861
3862 case 104:
3863
3864 { (yyval.t_op_exp) = new ast::LogicalOpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::LogicalOpExp::logicalShortCutOr, * new ast::ColonVar((yyloc))); print_rules("rightComparable", "OROR COLON");}
3865
3866 break;
3867
3868 case 105:
3869
3870 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::eq, *(yyvsp[0].t_exp)); print_rules("rightComparable", "EQ variable");}
3871
3872 break;
3873
3874 case 106:
3875
3876 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::eq, *(yyvsp[0].t_call_exp)); print_rules("rightComparable", "EQ functionCall");}
3877
3878 break;
3879
3880 case 107:
3881
3882 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::eq, * new ast::ColonVar((yyloc))); print_rules("rightComparable", "EQ COLON");}
3883
3884 break;
3885
3886 case 108:
3887
3888 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::ne, *(yyvsp[0].t_exp)); print_rules("rightComparable", "NE variable");}
3889
3890 break;
3891
3892 case 109:
3893
3894 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::ne, *(yyvsp[0].t_call_exp)); print_rules("rightComparable", "NE functionCall");}
3895
3896 break;
3897
3898 case 110:
3899
3900 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::ne, * new ast::ColonVar((yyloc))); print_rules("rightComparable", "NE COLON");}
3901
3902 break;
3903
3904 case 111:
3905
3906 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::gt, *(yyvsp[0].t_exp)); print_rules("rightComparable", "GT variable");}
3907
3908 break;
3909
3910 case 112:
3911
3912 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::gt, *(yyvsp[0].t_call_exp)); print_rules("rightComparable", "GT functionCall");}
3913
3914 break;
3915
3916 case 113:
3917
3918 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::gt, * new ast::ColonVar((yyloc))); print_rules("rightComparable", "GT COLON");}
3919
3920 break;
3921
3922 case 114:
3923
3924 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::lt, *(yyvsp[0].t_exp)); print_rules("rightComparable", "LT variable");}
3925
3926 break;
3927
3928 case 115:
3929
3930 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::lt, *(yyvsp[0].t_call_exp)); print_rules("rightComparable", "LT functionCall");}
3931
3932 break;
3933
3934 case 116:
3935
3936 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::lt, * new ast::ColonVar((yyloc))); print_rules("rightComparable", "LT COLON");}
3937
3938 break;
3939
3940 case 117:
3941
3942 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::ge, *(yyvsp[0].t_exp)); print_rules("rightComparable", "GE variable");}
3943
3944 break;
3945
3946 case 118:
3947
3948 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::ge, *(yyvsp[0].t_call_exp)); print_rules("rightComparable", "GE functionCall");}
3949
3950 break;
3951
3952 case 119:
3953
3954 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::ge, * new ast::ColonVar((yyloc))); print_rules("rightComparable", "GE COLON");}
3955
3956 break;
3957
3958 case 120:
3959
3960 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::le, *(yyvsp[0].t_exp)); print_rules("rightComparable", "LE variable");}
3961
3962 break;
3963
3964 case 121:
3965
3966 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::le, *(yyvsp[0].t_call_exp)); print_rules("rightComparable", "LE functionCall");}
3967
3968 break;
3969
3970 case 122:
3971
3972 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::le, * new ast::ColonVar((yyloc))); print_rules("rightComparable", "LE COLON");}
3973
3974 break;
3975
3976 case 123:
3977
3978 {
3979 print_rules("operation", "rightOperand");
3980 delete &((yyvsp[0].t_op_exp)->getLeft());
3981 (yyvsp[0].t_op_exp)->setLeft(*(yyvsp[-1].t_exp));
3982 (yyvsp[0].t_op_exp)->setLocation((yyloc));
3983 (yyval.t_exp) = (yyvsp[0].t_op_exp);
3984 }
3985
3986 break;
3987
3988 case 124:
3989
3990 {
3991 print_rules("operation", "functionCall rightOperand");
3992 delete &((yyvsp[0].t_op_exp)->getLeft());
3993 (yyvsp[0].t_op_exp)->setLeft(*(yyvsp[-1].t_call_exp));
3994 (yyvsp[0].t_op_exp)->setLocation((yyloc));
3995 (yyval.t_exp) = (yyvsp[0].t_op_exp);
3996 }
3997
3998 break;
3999
4000 case 125:
4001
4002 { if ((yyvsp[0].t_exp)->isDoubleExp()) { (yyval.t_exp) = (yyvsp[0].t_exp)->getAs<ast::DoubleExp>()->neg(); (yyvsp[0].t_exp)->setLocation((yyloc));} else { (yyval.t_exp) = new ast::OpExp((yyloc), *new ast::DoubleExp((yyloc), 0.0), ast::OpExp::unaryMinus, *(yyvsp[0].t_exp)); } print_rules("operation", "MINUS variable");}
4003
4004 break;
4005
4006 case 126:
4007
4008 { (yyval.t_exp) = new ast::OpExp((yyloc), *new ast::DoubleExp((yyloc), 0.0), ast::OpExp::unaryMinus, *(yyvsp[0].t_call_exp)); print_rules("operation", "MINUS functionCall");}
4009
4010 break;
4011
4012 case 127:
4013
4014 { if ((yyvsp[0].t_exp)->isDoubleExp()) { (yyval.t_exp) = (yyvsp[0].t_exp);} else { (yyval.t_exp) = new ast::OpExp((yyloc), *new ast::DoubleExp((yyloc), 0.0), ast::OpExp::unaryPlus, *(yyvsp[0].t_exp)); } print_rules("operation", "PLUS variable");}
4015
4016 break;
4017
4018 case 128:
4019
4020 { (yyval.t_exp) = new ast::OpExp((yyloc), *new ast::DoubleExp((yyloc), 0.0), ast::OpExp::unaryPlus, *(yyvsp[0].t_call_exp)); print_rules("operation", "PLUS functionCall");}
4021
4022 break;
4023
4024 case 129:
4025
4026 { (yyval.t_exp) = new ast::OpExp((yyloc), *(yyvsp[-2].t_exp), ast::OpExp::power, *(yyvsp[0].t_exp)); print_rules("operation", "variable POWER variable");}
4027
4028 break;
4029
4030 case 130:
4031
4032 { (yyval.t_exp) = new ast::OpExp((yyloc), *(yyvsp[-2].t_exp), ast::OpExp::power, *(yyvsp[0].t_call_exp)); print_rules("operation", "variable POWER functionCall");}
4033
4034 break;
4035
4036 case 131:
4037
4038 { (yyval.t_exp) = new ast::OpExp((yyloc), *(yyvsp[-2].t_call_exp), ast::OpExp::power, *(yyvsp[0].t_exp)); print_rules("operation", "functionCall POWER variable");}
4039
4040 break;
4041
4042 case 132:
4043
4044 { (yyval.t_exp) = new ast::OpExp((yyloc), *(yyvsp[-2].t_call_exp), ast::OpExp::power, *(yyvsp[0].t_call_exp)); print_rules("operation", "functionCall POWER functionCall");}
4045
4046 break;
4047
4048 case 133:
4049
4050 { (yyval.t_exp) = new ast::OpExp((yyloc), *(yyvsp[-2].t_exp), ast::OpExp::dotpower, *(yyvsp[0].t_exp)); print_rules("operation", "variable DOTPOWER variable");}
4051
4052 break;
4053
4054 case 134:
4055
4056 { (yyval.t_exp) = new ast::OpExp((yyloc), *(yyvsp[-2].t_exp), ast::OpExp::dotpower, *(yyvsp[0].t_call_exp)); print_rules("operation", "variable DOTPOWER functionCall");}
4057
4058 break;
4059
4060 case 135:
4061
4062 { (yyval.t_exp) = new ast::OpExp((yyloc), *(yyvsp[-2].t_call_exp), ast::OpExp::dotpower, *(yyvsp[0].t_exp)); print_rules("operation", "functionCall DOTPOWER variable");}
4063
4064 break;
4065
4066 case 136:
4067
4068 { (yyval.t_exp) = new ast::OpExp((yyloc), *(yyvsp[-2].t_call_exp), ast::OpExp::dotpower, *(yyvsp[0].t_call_exp)); print_rules("operation", "functionCall DOTPOWER functionCall");}
4069
4070 break;
4071
4072 case 137:
4073
4074 { (yyval.t_exp) = new ast::TransposeExp((yyloc), *(yyvsp[-1].t_exp), ast::TransposeExp::_Conjugate_); print_rules("operation", "variable QUOTE");}
4075
4076 break;
4077
4078 case 138:
4079
4080 { (yyval.t_exp) = new ast::TransposeExp((yyloc), *(yyvsp[-1].t_exp), ast::TransposeExp::_NonConjugate_); print_rules("operation", "variable DOTQUOTE");}
4081
4082 break;
4083
4084 case 139:
4085
4086 { (yyval.t_exp) = new ast::TransposeExp((yyloc), *(yyvsp[-1].t_call_exp), ast::TransposeExp::_Conjugate_); print_rules("operation", "functionCall QUOTE");}
4087
4088 break;
4089
4090 case 140:
4091
4092 { (yyval.t_exp) = new ast::TransposeExp((yyloc), *(yyvsp[-1].t_call_exp), ast::TransposeExp::_NonConjugate_); print_rules("operation", "functionCall DOTQUOTE");}
4093
4094 break;
4095
4096 case 141:
4097
4098 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::plus, *(yyvsp[0].t_exp)); print_rules("rightOperand", "PLUS variable");}
4099
4100 break;
4101
4102 case 142:
4103
4104 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::plus, *(yyvsp[0].t_call_exp)); print_rules("rightOperand", "PLUS functionCall");}
4105
4106 break;
4107
4108 case 143:
4109
4110 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::minus, *(yyvsp[0].t_exp)); print_rules("rightOperand", "MINUS variable");}
4111
4112 break;
4113
4114 case 144:
4115
4116 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::minus, *(yyvsp[0].t_call_exp)); print_rules("rightOperand", "MINUS functionCall");}
4117
4118 break;
4119
4120 case 145:
4121
4122 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::times, *(yyvsp[0].t_exp)); print_rules("rightOperand", "TIMES variable");}
4123
4124 break;
4125
4126 case 146:
4127
4128 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::times, *(yyvsp[0].t_call_exp)); print_rules("rightOperand", "TIMES functionCall");}
4129
4130 break;
4131
4132 case 147:
4133
4134 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::dottimes, *(yyvsp[0].t_exp)); print_rules("rightOperand", "DOTTIMES variable");}
4135
4136 break;
4137
4138 case 148:
4139
4140 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::dottimes, *(yyvsp[0].t_call_exp)); print_rules("rightOperand", "DOTTIMES functionCall");}
4141
4142 break;
4143
4144 case 149:
4145
4146 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::krontimes, *(yyvsp[0].t_exp)); print_rules("rightOperand", "KRONTIMES variable");}
4147
4148 break;
4149
4150 case 150:
4151
4152 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::krontimes, *(yyvsp[0].t_call_exp)); print_rules("rightOperand", "KRONTIMES functionCall");}
4153
4154 break;
4155
4156 case 151:
4157
4158 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::controltimes, *(yyvsp[0].t_exp)); print_rules("rightOperand", "CONTROLTIMES variable");}
4159
4160 break;
4161
4162 case 152:
4163
4164 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::controltimes, *(yyvsp[0].t_call_exp)); print_rules("rightOperand", "CONTROLTIMES functionCall ");}
4165
4166 break;
4167
4168 case 153:
4169
4170 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::rdivide, *(yyvsp[0].t_exp)); print_rules("rightOperand", "RDIVIDE variable");}
4171
4172 break;
4173
4174 case 154:
4175
4176 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::rdivide, *(yyvsp[0].t_call_exp)); print_rules("rightOperand", "RDIVIDE functionCall");}
4177
4178 break;
4179
4180 case 155:
4181
4182 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::dotrdivide, *(yyvsp[0].t_exp)); print_rules("rightOperand", "DOTRDIVIDE variable");}
4183
4184 break;
4185
4186 case 156:
4187
4188 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::dotrdivide, *(yyvsp[0].t_call_exp)); print_rules("rightOperand", "DOTRDIVIDE functionCall");}
4189
4190 break;
4191
4192 case 157:
4193
4194 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::kronrdivide, *(yyvsp[0].t_exp)); print_rules("rightOperand", "KRONRDIVIDE variable");}
4195
4196 break;
4197
4198 case 158:
4199
4200 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::kronrdivide, *(yyvsp[0].t_call_exp)); print_rules("rightOperand", "KRONRDIVIDE functionCall");}
4201
4202 break;
4203
4204 case 159:
4205
4206 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::controlrdivide, *(yyvsp[0].t_exp)); print_rules("rightOperand", "CONTROLRDIVIDE variable");}
4207
4208 break;
4209
4210 case 160:
4211
4212 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::controlrdivide, *(yyvsp[0].t_call_exp)); print_rules("rightOperand", "CONTROLRDIVIDE functionCall");}
4213
4214 break;
4215
4216 case 161:
4217
4218 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::ldivide, *(yyvsp[0].t_exp)); print_rules("rightOperand", "LDIVIDE variable");}
4219
4220 break;
4221
4222 case 162:
4223
4224 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::ldivide, *(yyvsp[0].t_call_exp)); print_rules("rightOperand", "LDIVIDE functionCall");}
4225
4226 break;
4227
4228 case 163:
4229
4230 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::dotldivide, *(yyvsp[0].t_exp)); print_rules("rightOperand", "DOTLDIVIDE variable");}
4231
4232 break;
4233
4234 case 164:
4235
4236 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::dotldivide, *(yyvsp[0].t_call_exp)); print_rules("rightOperand", "DOTLDIVIDE functionCall");}
4237
4238 break;
4239
4240 case 165:
4241
4242 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::kronldivide, *(yyvsp[0].t_exp)); print_rules("rightOperand", "KRONLDIVIDE variable");}
4243
4244 break;
4245
4246 case 166:
4247
4248 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::kronldivide, *(yyvsp[0].t_call_exp)); print_rules("rightOperand", "KRONLDIVIDE functionCall");}
4249
4250 break;
4251
4252 case 167:
4253
4254 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::controlldivide, *(yyvsp[0].t_exp)); print_rules("rightOperand", "CONTROLLDIVIDE variable");}
4255
4256 break;
4257
4258 case 168:
4259
4260 { (yyval.t_op_exp) = new ast::OpExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), ast::OpExp::controlldivide, *(yyvsp[0].t_call_exp)); print_rules("rightOperand", "CONTROLLDIVIDE functionCall");}
4261
4262 break;
4263
4264 case 169:
4265
4266 { (yyval.t_exp) = (yyvsp[0].t_exp); print_rules("listableBegin", "COLON variable");}
4267
4268 break;
4269
4270 case 170:
4271
4272 { (yyval.t_exp) = (yyvsp[0].t_call_exp); print_rules("listableBegin", "COLON functionCall");}
4273
4274 break;
4275
4276 case 171:
4277
4278 { (yyval.t_implicit_list) = new ast::ListExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), *(yyvsp[-2].t_exp), *(yyvsp[0].t_exp), true); print_rules("listableEnd", "listableBegin COLON variable");}
4279
4280 break;
4281
4282 case 172:
4283
4284 { (yyval.t_implicit_list) = new ast::ListExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), *(yyvsp[-2].t_exp), *(yyvsp[0].t_call_exp), true); print_rules("listableEnd", "listableBegin COLON functionCall");}
4285
4286 break;
4287
4288 case 173:
4289
4290 { (yyval.t_implicit_list) = new ast::ListExp((yyloc), *new ast::CommentExp((yyloc), new std::wstring(L"Should not stay in that state")), *new ast::DoubleExp((yyloc), 1.0), *(yyvsp[0].t_exp)); print_rules("listableEnd", "listableBegin ");}
4291
4292 break;
4293
4294 case 174:
4295
4296 { (yyval.t_exp) = new ast::NotExp((yyloc), *(yyvsp[0].t_exp)); print_rules("variable", "NOT variable");}
4297
4298 break;
4299
4300 case 175:
4301
4302 { (yyval.t_exp) = new ast::NotExp((yyloc), *(yyvsp[0].t_call_exp)); print_rules("variable", "NOT functionCall");}
4303
4304 break;
4305
4306 case 176:
4307
4308 { (yyval.t_exp) = new ast::FieldExp((yyloc), *(yyvsp[-2].t_exp), *new ast::SimpleVar((yyloc), symbol::Symbol(*(yyvsp[0].str)))); delete (yyvsp[0].str);print_rules("variable", "variable DOT ID");}
4309
4310 break;
4311
4312 case 177:
4313
4314 { (yyval.t_exp) = new ast::FieldExp((yyloc), *(yyvsp[-2].t_exp), *(yyvsp[0].t_simple_var)); print_rules("variable", "variable DOT keywords");}
4315
4316 break;
4317
4318 case 178:
4319
4320 {
4321 print_rules("variable", "variable DOT functionCall");
4322 (yyvsp[0].t_call_exp)->setName(new ast::FieldExp((yyloc), *(yyvsp[-2].t_exp), (yyvsp[0].t_call_exp)->getName()));
4323 (yyvsp[0].t_call_exp)->setLocation((yyloc));
4324 (yyval.t_exp) = (yyvsp[0].t_call_exp);
4325 }
4326
4327 break;
4328
4329 case 179:
4330
4331 { (yyval.t_exp) = new ast::FieldExp((yyloc), *(yyvsp[-2].t_call_exp), *new ast::SimpleVar((yyloc), symbol::Symbol(*(yyvsp[0].str)))); delete (yyvsp[0].str); print_rules("variable", "functionCall DOT ID");}
4332
4333 break;
4334
4335 case 180:
4336
4337 { (yyval.t_exp) = new ast::FieldExp((yyloc), *(yyvsp[-2].t_call_exp), *(yyvsp[0].t_simple_var)); print_rules("variable", "functionCall DOT keywords");}
4338
4339 break;
4340
4341 case 181:
4342
4343 {
4344 print_rules("variable", "variable listableEnd");
4345 (yyval.t_exp) = new ast::ListExp((yyloc), *(yyvsp[-1].t_exp), *((yyvsp[0].t_implicit_list)->getStep().clone()), *((yyvsp[0].t_implicit_list)->getEnd().clone()), (yyvsp[0].t_implicit_list)->hasExplicitStep());
4346 delete((yyvsp[0].t_implicit_list));
4347 }
4348
4349 break;
4350
4351 case 182:
4352
4353 {
4354 print_rules("variable", "functionCall listableEnd");
4355 (yyval.t_exp) = new ast::ListExp((yyloc), *(yyvsp[-1].t_call_exp), *((yyvsp[0].t_implicit_list)->getStep().clone()), *((yyvsp[0].t_implicit_list)->getEnd().clone()), (yyvsp[0].t_implicit_list)->hasExplicitStep());
4356 delete((yyvsp[0].t_implicit_list));
4357 }
4358
4359 break;
4360
4361 case 183:
4362
4363 { (yyval.t_exp) = (yyvsp[0].t_matrix_exp); print_rules("variable", "matrix");}
4364
4365 break;
4366
4367 case 184:
4368
4369 { (yyval.t_exp) = (yyvsp[0].t_cell_exp); print_rules("variable", "cell");}
4370
4371 break;
4372
4373 case 185:
4374
4375 { (yyval.t_exp) = (yyvsp[0].t_exp); print_rules("variable", "operation");}
4376
4377 break;
4378
4379 case 186:
4380
4381 { (yyval.t_exp) = new ast::SimpleVar((yyloc), symbol::Symbol(*(yyvsp[0].str))); delete (yyvsp[0].str);print_rules("variable", "ID");}
4382
4383 break;
4384
4385 case 187:
4386
4387 { (yyval.t_exp) = new ast::DoubleExp((yyloc), (yyvsp[0].number)); print_rules("variable", (yyvsp[0].number));}
4388
4389 break;
4390
4391 case 188:
4392
4393 { (yyval.t_exp) = new ast::DoubleExp((yyloc), (yyvsp[0].number)); print_rules("variable", (yyvsp[0].number));}
4394
4395 break;
4396
4397 case 189:
4398
4399 { (yyval.t_exp) = new ast::DoubleExp((yyloc), (yyvsp[0].number)); print_rules("variable", (yyvsp[0].number));}
4400
4401 break;
4402
4403 case 190:
4404
4405 { (yyval.t_exp) = new ast::StringExp((yyloc), *(yyvsp[0].str)); delete (yyvsp[0].str);print_rules("variable", "STR");}
4406
4407 break;
4408
4409 case 191:
4410
4411 { (yyval.t_exp) = new ast::DollarVar((yyloc)); print_rules("variable", "DOLLAR");}
4412
4413 break;
4414
4415 case 192:
4416
4417 { (yyval.t_exp) = new ast::BoolExp((yyloc), true); print_rules("variable", "BOOLTRUE");}
4418
4419 break;
4420
4421 case 193:
4422
4423 { (yyval.t_exp) = new ast::BoolExp((yyloc), false); print_rules("variable", "BOOLFALSE");}
4424
4425 break;
4426
4427 case 194:
4428
4429 { (yyval.t_exp) = (yyvsp[-1].t_exp); print_rules("variable", "LPAREN variable RPAREN");}
4430
4431 break;
4432
4433 case 195:
4434
4435 { (yyval.t_exp) = new ast::ArrayListExp((yyloc), *(yyvsp[-1].t_list_exp)); print_rules("variable", "LPAREN variableFields RPAREN");}
4436
4437 break;
4438
4439 case 196:
4440
4441 { (yyval.t_exp) = (yyvsp[0].t_op_exp); print_rules("variable", "comparison");}
4442
4443 break;
4444
4445 case 197:
4446
4447 { (yyval.t_exp) = new ast::CallExp((yyloc), *(yyvsp[-3].t_exp), *(yyvsp[-1].t_list_exp)); print_rules("variable", "variable LPAREN functionArgs RPAREN");}
4448
4449 break;
4450
4451 case 198:
4452
4453 { (yyval.t_exp) = new ast::CallExp((yyloc), *(yyvsp[-3].t_call_exp), *(yyvsp[-1].t_list_exp)); print_rules("variable", "functionCall LPAREN functionArgs RPAREN");}
4454
4455 break;
4456
4457 case 199:
4458
4459 {
4460 print_rules("variableFields", "variableFields COMMA variable");
4461 (yyvsp[-2].t_list_exp)->push_back((yyvsp[0].t_exp));
4462 (yyval.t_list_exp) = (yyvsp[-2].t_list_exp);
4463 }
4464
4465 break;
4466
4467 case 200:
4468
4469 {
4470 print_rules("variableFields", "variableFields COMMA functionCall");
4471 (yyvsp[-2].t_list_exp)->push_back((yyvsp[0].t_call_exp));
4472 (yyval.t_list_exp) = (yyvsp[-2].t_list_exp);
4473 }
4474
4475 break;
4476
4477 case 201:
4478
4479 {
4480 print_rules("variableFields", "variable COMMA variable");
4481 (yyval.t_list_exp) = new ast::exps_t;
4482 (yyval.t_list_exp)->push_back((yyvsp[-2].t_exp));
4483 (yyval.t_list_exp)->push_back((yyvsp[0].t_exp));
4484 }
4485
4486 break;
4487
4488 case 202:
4489
4490 {
4491 print_rules("variableFields", "functionCall COMMA functionCall");
4492 (yyval.t_list_exp) = new ast::exps_t;
4493 (yyval.t_list_exp)->push_back((yyvsp[-2].t_call_exp));
4494 (yyval.t_list_exp)->push_back((yyvsp[0].t_call_exp));
4495 }
4496
4497 break;
4498
4499 case 203:
4500
4501 {
4502 print_rules("variableFields", "functionCall COMMA variable");
4503 (yyval.t_list_exp) = new ast::exps_t;
4504 (yyval.t_list_exp)->push_back((yyvsp[-2].t_call_exp));
4505 (yyval.t_list_exp)->push_back((yyvsp[0].t_exp));
4506 }
4507
4508 break;
4509
4510 case 204:
4511
4512 {
4513 print_rules("variableFields", "variable COMMA functionCall");
4514 (yyval.t_list_exp) = new ast::exps_t;
4515 (yyval.t_list_exp)->push_back((yyvsp[-2].t_exp));
4516 (yyval.t_list_exp)->push_back((yyvsp[0].t_call_exp));
4517 }
4518
4519 break;
4520
4521 case 205:
4522
4523 { (yyval.t_cell_exp) = new ast::CellExp((yyloc), *(yyvsp[-1].t_list_mline)); print_rules("cell", "LBRACE matrixOrCellLines RBRACE");}
4524
4525 break;
4526
4527 case 206:
4528
4529 { (yyval.t_cell_exp) = new ast::CellExp((yyloc), *(yyvsp[-1].t_list_mline)); print_rules("cell", "variable COMMA functionCall");}
4530
4531 break;
4532
4533 case 207:
4534
4535 {
4536 print_rules("cell", "LBRACE matrixOrCellLines matrixOrCellColumns RBRACE");
4537 (yyvsp[-2].t_list_mline)->push_back(new ast::MatrixLineExp((yylsp[-1]), *(yyvsp[-1].t_list_exp)));
4538 (yyval.t_cell_exp) = new ast::CellExp((yyloc), *(yyvsp[-2].t_list_mline));
4539 }
4540
4541 break;
4542
4543 case 208:
4544
4545 {
4546 print_rules("cell", "LBRACE EOL matrixOrCellLines matrixOrCellColumns RBRACE");
4547 (yyvsp[-2].t_list_mline)->push_back(new ast::MatrixLineExp((yylsp[-1]), *(yyvsp[-1].t_list_exp)));
4548 (yyval.t_cell_exp) = new ast::CellExp((yyloc), *(yyvsp[-2].t_list_mline));
4549 }
4550
4551 break;
4552
4553 case 209:
4554
4555 {
4556 print_rules("cell", "LBRACE matrixOrCellColumns RBRACE");
4557 ast::exps_t* tmp = new ast::exps_t;
4558 tmp->push_back(new ast::MatrixLineExp((yylsp[-1]), *(yyvsp[-1].t_list_exp)));
4559 (yyval.t_cell_exp) = new ast::CellExp((yyloc), *tmp);
4560 }
4561
4562 break;
4563
4564 case 210:
4565
4566 {
4567 print_rules("cell", "LBRACE EOL matrixOrCellColumns RBRACE");
4568 ast::exps_t* tmp = new ast::exps_t;
4569 tmp->push_back(new ast::MatrixLineExp((yylsp[-1]), *(yyvsp[-1].t_list_exp)));
4570 (yyval.t_cell_exp) = new ast::CellExp((yyloc), *tmp);
4571 }
4572
4573 break;
4574
4575 case 211:
4576
4577 { ast::exps_t* tmp = new ast::exps_t;(yyval.t_cell_exp) = new ast::CellExp((yyloc), *tmp); print_rules("cell", "LBRACE EOL RBRACE");}
4578
4579 break;
4580
4581 case 212:
4582
4583 { ast::exps_t* tmp = new ast::exps_t;(yyval.t_cell_exp) = new ast::CellExp((yyloc), *tmp); print_rules("cell", "LBRACE RBRACE");}
4584
4585 break;
4586
4587 case 213:
4588
4589 {(yyval.t_matrix_exp) = new ast::MatrixExp((yyloc), *(yyvsp[-1].t_list_mline)); print_rules("matrix", "LBRACK matrixOrCellLines RBRACK");}
4590
4591 break;
4592
4593 case 214:
4594
4595 {(yyval.t_matrix_exp) = new ast::MatrixExp((yyloc), *(yyvsp[-1].t_list_mline)); print_rules("matrix", "LBRACK EOL matrixOrCellLines RBRACK");}
4596
4597 break;
4598
4599 case 215:
4600
4601 {(yyvsp[-2].t_list_mline)->push_back(new ast::MatrixLineExp((yylsp[-1]), *(yyvsp[-1].t_list_exp)));(yyval.t_matrix_exp) = new ast::MatrixExp((yyloc), *(yyvsp[-2].t_list_mline));print_rules("matrix", "LBRACK matrixOrCellLines matrixOrCellColumns RBRACK");}
4602
4603 break;
4604
4605 case 216:
4606
4607 {(yyvsp[-2].t_list_mline)->push_back(new ast::MatrixLineExp((yylsp[-1]), *(yyvsp[-1].t_list_exp)));(yyval.t_matrix_exp) = new ast::MatrixExp((yyloc), *(yyvsp[-2].t_list_mline));print_rules("matrix", "BRACK EOL matrixOrCellLines matrixOrCellColumns RBRACK");}
4608
4609 break;
4610
4611 case 217:
4612
4613 {ast::exps_t* tmp = new ast::exps_t;tmp->push_back(new ast::MatrixLineExp((yylsp[-1]), *(yyvsp[-1].t_list_exp)));(yyval.t_matrix_exp) = new ast::MatrixExp((yyloc), *tmp);print_rules("matrix", "LBRACK matrixOrCellColumns RBRACK");}
4614
4615 break;
4616
4617 case 218:
4618
4619 {ast::exps_t* tmp = new ast::exps_t;tmp->push_back(new ast::MatrixLineExp((yylsp[-1]), *(yyvsp[-1].t_list_exp)));(yyval.t_matrix_exp) = new ast::MatrixExp((yyloc), *tmp);print_rules("matrix", "LBRACK EOL matrixOrCellColumns RBRACK");}
4620
4621 break;
4622
4623 case 219:
4624
4625 {ast::exps_t* tmp = new ast::exps_t;(yyval.t_matrix_exp) = new ast::MatrixExp((yyloc), *tmp); print_rules("matrix", "LBRACK EOL RBRACK");}
4626
4627 break;
4628
4629 case 220:
4630
4631 {ast::exps_t* tmp = new ast::exps_t;(yyval.t_matrix_exp) = new ast::MatrixExp((yyloc), *tmp); print_rules("matrix", "LBRACK RBRACK");}
4632
4633 break;
4634
4635 case 221:
4636
4637 {(yyvsp[-1].t_list_mline)->push_back((yyvsp[0].t_matrixline_exp));(yyval.t_list_mline) = (yyvsp[-1].t_list_mline);print_rules("matrixOrCellLines", "matrixOrCellLines matrixOrCellLine");}
4638
4639 break;
4640
4641 case 222:
4642
4643 {(yyval.t_list_mline) = new ast::exps_t;(yyval.t_list_mline)->push_back((yyvsp[0].t_matrixline_exp));print_rules("matrixOrCellLines", "matrixOrCellLine");}
4644
4645 break;
4646
4647 case 223:
4648
4649 { /* !! Do Nothing !! */ print_rules("matrixOrCellLineBreak", "SEMI");}
4650
4651 break;
4652
4653 case 224:
4654
4655 { /* !! Do Nothing !! */ print_rules("matrixOrCellLineBreak", "EOL");}
4656
4657 break;
4658
4659 case 225:
4660
4661 { /* !! Do Nothing !! */ print_rules("matrixOrCellLineBreak", "matrixOrCellLineBreak EOL");}
4662
4663 break;
4664
4665 case 226:
4666
4667 { /* !! Do Nothing !! */ print_rules("matrixOrCellLineBreak", "matrixOrCellLineBreak SEMI");}
4668
4669 break;
4670
4671 case 227:
4672
4673 { (yyval.t_matrixline_exp) = new ast::MatrixLineExp((yyloc), *(yyvsp[-1].t_list_exp)); print_rules("matrixOrCellLine", "matrixOrCellColumns matrixOrCellLineBreak ");}
4674
4675 break;
4676
4677 case 228:
4678
4679 { (yyval.t_matrixline_exp) = new ast::MatrixLineExp((yyloc), *(yyvsp[-2].t_list_exp)); print_rules("matrixOrCellLine", "matrixOrCellColumns matrixOrCellColumnsBreak matrixOrCellLineBreak");}
4680
4681 break;
4682
4683 case 229:
4684
4685 {(yyvsp[-2].t_list_exp)->push_back((yyvsp[0].t_exp));(yyval.t_list_exp) = (yyvsp[-2].t_list_exp);print_rules("matrixOrCellColumns", "matrixOrCellColumns matrixOrCellColumnsBreak variable");}
4686
4687 break;
4688
4689 case 230:
4690
4691 {(yyvsp[-2].t_list_exp)->push_back((yyvsp[0].t_call_exp));(yyval.t_list_exp) = (yyvsp[-2].t_list_exp);print_rules("matrixOrCellColumns", "matrixOrCellColumns matrixOrCellColumnsBreak functionCall");}
4692
4693 break;
4694
4695 case 231:
4696
4697 {(yyvsp[-1].t_list_exp)->push_back((yyvsp[0].t_exp));(yyval.t_list_exp) = (yyvsp[-1].t_list_exp);print_rules("matrixOrCellColumns", "matrixOrCellColumns variable");}
4698
4699 break;
4700
4701 case 232:
4702
4703 {(yyvsp[-1].t_list_exp)->push_back((yyvsp[0].t_call_exp));(yyval.t_list_exp) = (yyvsp[-1].t_list_exp);print_rules("matrixOrCellColumns", "matrixOrCellColumns functionCall");}
4704
4705 break;
4706
4707 case 233:
4708
4709 {(yyvsp[-1].t_list_exp)->push_back(new ast::CommentExp((yylsp[0]), (yyvsp[0].comment)));(yyval.t_list_exp) = (yyvsp[-1].t_list_exp);print_rules("matrixOrCellColumns", "matrixOrCellColumns COMMENT");}
4710
4711 break;
4712
4713 case 234:
4714
4715 {(yyvsp[-2].t_list_exp)->push_back(new ast::CommentExp((yylsp[0]), (yyvsp[0].comment)));(yyval.t_list_exp) = (yyvsp[-2].t_list_exp);print_rules("matrixOrCellColumns", "matrixOrCellColumns matrixOrCellColumnsBreak COMMENT");}
4716
4717 break;
4718
4719 case 235:
4720
4721 {(yyval.t_list_exp) = new ast::exps_t;(yyval.t_list_exp)->push_back((yyvsp[0].t_exp));print_rules("matrixOrCellColumns", "variable");}
4722
4723 break;
4724
4725 case 236:
4726
4727 {(yyval.t_list_exp) = new ast::exps_t;(yyval.t_list_exp)->push_back((yyvsp[0].t_call_exp));print_rules("matrixOrCellColumns", "functionCall");}
4728
4729 break;
4730
4731 case 237:
4732
4733 {(yyval.t_list_exp) = new ast::exps_t;(yyval.t_list_exp)->push_back(new ast::CommentExp((yyloc), (yyvsp[0].comment)));print_rules("matrixOrCellColumns", "COMMENT");}
4734
4735 break;
4736
4737 case 238:
4738
4739 { /* !! Do Nothing !! */ print_rules("matrixOrCellColumnsBreak", "matrixOrCellColumnsBreak COMMA");}
4740
4741 break;
4742
4743 case 239:
4744
4745 { /* !! Do Nothing !! */ print_rules("matrixOrCellColumnsBreak", "COMMA");}
4746
4747 break;
4748
4749 case 240:
4750
4751 { (yyval.t_assign_exp) = new ast::AssignExp((yyloc), *(yyvsp[-2].t_exp), *(yyvsp[0].t_exp)); print_rules("variableDeclaration", "assignable ASSIGN variable");}
4752
4753 break;
4754
4755 case 241:
4756
4757 { (yyval.t_assign_exp) = new ast::AssignExp((yyloc), *(yyvsp[-2].t_exp), *(yyvsp[0].t_call_exp)); print_rules("variableDeclaration", "assignable ASSIGN functionCall");}
4758
4759 break;
4760
4761 case 242:
4762
4763 { (yyval.t_assign_exp) = new ast::AssignExp((yyloc), *(yyvsp[-2].t_call_exp), *(yyvsp[0].t_exp)); print_rules("variableDeclaration", "functionCall ASSIGN variable");}
4764
4765 break;
4766
4767 case 243:
4768
4769 { (yyval.t_assign_exp) = new ast::AssignExp((yyloc), *(yyvsp[-2].t_call_exp), *(yyvsp[0].t_call_exp)); print_rules("variableDeclaration", "functionCall ASSIGN functionCall");}
4770
4771 break;
4772
4773 case 244:
4774
4775 { (yyval.t_assign_exp) = new ast::AssignExp((yyloc), *(yyvsp[-2].t_exp), *new ast::ColonVar((yylsp[0]))); print_rules("variableDeclaration", "assignable ASSIGN COLON");}
4776
4777 break;
4778
4779 case 245:
4780
4781 { (yyval.t_assign_exp) = new ast::AssignExp((yyloc), *(yyvsp[-2].t_call_exp), *new ast::ColonVar((yylsp[0]))); print_rules("variableDeclaration", "functionCall ASSIGN COLON");}
4782
4783 break;
4784
4785 case 246:
4786
4787 { (yyval.t_assign_exp) = new ast::AssignExp((yyloc), *(yyvsp[-2].t_exp), *(yyvsp[0].t_return_exp)); print_rules("variableDeclaration", "assignable ASSIGN returnControl");}
4788
4789 break;
4790
4791 case 247:
4792
4793 { (yyval.t_assign_exp) = new ast::AssignExp((yyloc), *(yyvsp[-2].t_call_exp), *(yyvsp[0].t_return_exp)); print_rules("variableDeclaration", "functionCall ASSIGN returnControl");}
4794
4795 break;
4796
4797 case 248:
4798
4799 { (yyval.t_exp) = new ast::FieldExp((yyloc), *(yyvsp[-2].t_exp), *new ast::SimpleVar((yyloc), symbol::Symbol(*(yyvsp[0].str)))); delete (yyvsp[0].str);print_rules("assignable", "variable DOT ID");}
4800
4801 break;
4802
4803 case 249:
4804
4805 { (yyval.t_exp) = new ast::FieldExp((yyloc), *(yyvsp[-2].t_exp), *(yyvsp[0].t_simple_var)); print_rules("assignable", "variable DOT keywords");}
4806
4807 break;
4808
4809 case 250:
4810
4811 { (yyvsp[0].t_call_exp)->setName(new ast::FieldExp((yyloc), *(yyvsp[-2].t_exp), (yyvsp[0].t_call_exp)->getName()));(yyvsp[0].t_call_exp)->setLocation((yyloc));(yyval.t_exp) = (yyvsp[0].t_call_exp);print_rules("assignable", "variable DOT functionCall");}
4812
4813 break;
4814
4815 case 251:
4816
4817 { (yyval.t_exp) = new ast::FieldExp((yyloc), *(yyvsp[-2].t_call_exp), *new ast::SimpleVar((yyloc), symbol::Symbol(*(yyvsp[0].str)))); delete (yyvsp[0].str); print_rules("assignable", "functionCall DOT ID");}
4818
4819 break;
4820
4821 case 252:
4822
4823 { (yyval.t_exp) = new ast::FieldExp((yyloc), *(yyvsp[-2].t_call_exp), *(yyvsp[0].t_simple_var)); print_rules("assignable", "functionCall DOT keywords");}
4824
4825 break;
4826
4827 case 253:
4828
4829 { (yyval.t_exp) = new ast::SimpleVar((yyloc), symbol::Symbol(*(yyvsp[0].str))); delete (yyvsp[0].str);print_rules("assignable", "ID");}
4830
4831 break;
4832
4833 case 254:
4834
4835 { (yyval.t_exp) = (yyvsp[0].t_assignlist_exp); print_rules("assignable", "multipleResults");}
4836
4837 break;
4838
4839 case 255:
4840
4841 { (yyval.t_exp) = new ast::CallExp((yyloc), *(yyvsp[-3].t_exp), *(yyvsp[-1].t_list_exp)); print_rules("assignable", "ariable LPAREN functionArgs RPAREN");}
4842
4843 break;
4844
4845 case 256:
4846
4847 { (yyval.t_exp) = new ast::CallExp((yyloc), *(yyvsp[-3].t_call_exp), *(yyvsp[-1].t_list_exp)); print_rules("assignable", "functionCall LPAREN functionArgs RPAREN");}
4848
4849 break;
4850
4851 case 257:
4852
4853 { (yyval.t_assignlist_exp) = new ast::AssignListExp((yyloc), *(yyvsp[-1].t_list_exp)); print_rules("multipleResults", "LBRACK matrixOrCellColumns RBRACK");}
4854
4855 break;
4856
4857 case 258:
4858
4859 { (yyval.t_if_exp) = new ast::IfExp((yyloc), *(yyvsp[-3].t_exp), *(yyvsp[-1].t_seq_exp)); print_rules("ifControl", "IF condition then thenBody END");}
4860
4861 break;
4862
4863 case 259:
4864
4865 {
4866 if ((yyvsp[-1].t_seq_exp) != NULL)
4867 {
4868 (yyval.t_if_exp) = new ast::IfExp((yyloc), *(yyvsp[-5].t_exp), *(yyvsp[-3].t_seq_exp), *(yyvsp[-1].t_seq_exp));
4869 }
4870 else
4871 {
4872 (yyval.t_if_exp) = new ast::IfExp((yyloc), *(yyvsp[-5].t_exp), *(yyvsp[-3].t_seq_exp));
4873 }
4874 print_rules("ifControl", "IF condition then thenBody else elseBody END");
4875 }
4876
4877 break;
4878
4879 case 260:
4880
4881 { (yyval.t_if_exp) = new ast::IfExp((yyloc), *(yyvsp[-4].t_exp), *(yyvsp[-2].t_seq_exp), *(yyvsp[-1].t_seq_exp)); print_rules("ifControl", "IF condition then thenBody elseIfControl END");}
4882
4883 break;
4884
4885 case 261:
4886
4887 {
4888 print_rules("thenBody", "expressions");
4889 (yyvsp[0].t_seq_exp)->getLocation().last_line = (yyvsp[0].t_seq_exp)->getExps().back()->getLocation().last_line;
4890 (yyvsp[0].t_seq_exp)->getLocation().last_column = (yyvsp[0].t_seq_exp)->getExps().back()->getLocation().last_column;
4891 (yyval.t_seq_exp) = (yyvsp[0].t_seq_exp);
4892 }
4893
4894 break;
4895
4896 case 262:
4897
4898 {
4899 print_rules("thenBody", "Epsilon");
4900 ast::exps_t* tmp = new ast::exps_t;
4901 #ifdef BUILD_DEBUG_AST
4902 tmp->push_back(new ast::CommentExp((yyloc), new std::wstring(L"Empty then body")));
4903 #endif
4904 (yyval.t_seq_exp) = new ast::SeqExp((yyloc), *tmp);
4905 }
4906
4907 break;
4908
4909 case 263:
4910
4911 {
4912 print_rules("elseBody", "expressions");
4913 (yyvsp[0].t_seq_exp)->getLocation().last_line = (yyvsp[0].t_seq_exp)->getExps().back()->getLocation().last_line;
4914 (yyvsp[0].t_seq_exp)->getLocation().last_column = (yyvsp[0].t_seq_exp)->getExps().back()->getLocation().last_column;
4915 (yyval.t_seq_exp) = (yyvsp[0].t_seq_exp);
4916 }
4917
4918 break;
4919
4920 case 264:
4921
4922 {
4923 #ifdef BUILD_DEBUG_AST
4924 ast::exps_t* tmp = new ast::exps_t;
4925 tmp->push_back(new ast::CommentExp((yyloc), new std::wstring(L"Empty else body")));
4926 (yyval.t_seq_exp) = new ast::SeqExp((yyloc), *tmp);
4927 #else
4928 (yyval.t_seq_exp) = NULL;
4929 #endif
4930 print_rules("elseBody", "Epsilon");
4931 }
4932
4933 break;
4934
4935 case 265:
4936
4937 { /* !! Do Nothing !! */ print_rules("ifConditionBreak", "SEMI");}
4938
4939 break;
4940
4941 case 266:
4942
4943 { /* !! Do Nothing !! */ print_rules("ifConditionBreak", "SEMI EOL");}
4944
4945 break;
4946
4947 case 267:
4948
4949 { /* !! Do Nothing !! */ print_rules("ifConditionBreak", "COMMA");}
4950
4951 break;
4952
4953 case 268:
4954
4955 { /* !! Do Nothing !! */ print_rules("ifConditionBreak", "COMMA EOL");}
4956
4957 break;
4958
4959 case 269:
4960
4961 { /* !! Do Nothing !! */ print_rules("ifConditionBreak", "EOL");}
4962
4963 break;
4964
4965 case 270:
4966
4967 { /* !! Do Nothing !! */ print_rules("then", "THEN");}
4968
4969 break;
4970
4971 case 271:
4972
4973 { /* !! Do Nothing !! */ print_rules("then", "ifConditionBreak THEN");}
4974
4975 break;
4976
4977 case 272:
4978
4979 { /* !! Do Nothing !! */ print_rules("then", "ifConditionBreak THEN EOL");}
4980
4981 break;
4982
4983 case 273:
4984
4985 { /* !! Do Nothing !! */ print_rules("then", "THEN ifConditionBreak");}
4986
4987 break;
4988
4989 case 274:
4990
4991 { /* !! Do Nothing !! */ print_rules("then", "ifConditionBreak");}
4992
4993 break;
4994
4995 case 275:
4996
4997 { /* !! Do Nothing !! */ print_rules("then", "Epsilon");}
4998
4999 break;
5000
5001 case 276:
5002
5003 { /* !! Do Nothing !! */ print_rules("else", "ELSE");}
5004
5005 break;
5006
5007 case 277:
5008
5009 { /* !! Do Nothing !! */ print_rules("else", "ELSE COMMA");}
5010
5011 break;
5012
5013 case 278:
5014
5015 { /* !! Do Nothing !! */ print_rules("else", "ELSE SEMI");}
5016
5017 break;
5018
5019 case 279:
5020
5021 { /* !! Do Nothing !! */ print_rules("else", "ELSE EOL");}
5022
5023 break;
5024
5025 case 280:
5026
5027 { /* !! Do Nothing !! */ print_rules("else", "ELSE COMMA EOL");}
5028
5029 break;
5030
5031 case 281:
5032
5033 { /* !! Do Nothing !! */ print_rules("else", "ELSE SEMI EOL");}
5034
5035 break;
5036
5037 case 282:
5038
5039 {
5040 print_rules("elseIfControl", "ELSEIF condition then thenBody");
5041 ast::exps_t* tmp = new ast::exps_t;
5042 tmp->push_back(new ast::IfExp((yyloc), *(yyvsp[-2].t_exp), *(yyvsp[0].t_seq_exp)));
5043 (yyval.t_seq_exp) = new ast::SeqExp((yyloc), *tmp);
5044 }
5045
5046 break;
5047
5048 case 283:
5049
5050 {
5051 print_rules("elseIfControl", "ELSEIF condition then thenBody else elseBody");
5052 ast::exps_t* tmp = new ast::exps_t;
5053 if( (yyvsp[0].t_seq_exp) == NULL)
5054 {
5055 tmp->push_back(new ast::IfExp((yyloc), *(yyvsp[-4].t_exp), *(yyvsp[-2].t_seq_exp)));
5056 }
5057 else
5058 {
5059 tmp->push_back(new ast::IfExp((yyloc), *(yyvsp[-4].t_exp), *(yyvsp[-2].t_seq_exp), *(yyvsp[0].t_seq_exp)));
5060 }
5061 (yyval.t_seq_exp) = new ast::SeqExp((yyloc), *tmp);
5062
5063 }
5064
5065 break;
5066
5067 case 284:
5068
5069 {
5070 print_rules("elseIfControl", "ELSEIF condition then thenBody elseIfControl");
5071 ast::exps_t* tmp = new ast::exps_t;
5072 tmp->push_back(new ast::IfExp((yyloc), *(yyvsp[-3].t_exp), *(yyvsp[-1].t_seq_exp), *(yyvsp[0].t_seq_exp)));
5073 (yyval.t_seq_exp) = new ast::SeqExp((yyloc), *tmp);
5074 }
5075
5076 break;
5077
5078 case 285:
5079
5080 { (yyval.t_select_exp) = new ast::SelectExp((yyloc), *(yyvsp[-3].t_exp), *(yyvsp[-1].t_list_case)); print_rules("selectControl", "select selectable selectConditionBreak casesControl END");}
5081
5082 break;
5083
5084 case 286:
5085
5086 {
5087 if((yyvsp[-1].t_seq_exp) == NULL)
5088 {
5089 (yyval.t_select_exp) = new ast::SelectExp((yyloc), *(yyvsp[-5].t_exp), *(yyvsp[-3].t_list_case));
5090 }
5091 else
5092 {
5093 (yyval.t_select_exp) = new ast::SelectExp((yyloc), *(yyvsp[-5].t_exp), *(yyvsp[-3].t_list_case), *(yyvsp[-1].t_seq_exp));
5094 }
5095 print_rules("selectControl", "select selectable selectConditionBreak casesControl defaultCase elseBody END");
5096 }
5097
5098 break;
5099
5100 case 287:
5101
5102 { (yyval.t_select_exp) = new ast::SelectExp((yyloc), *(yyvsp[-4].t_exp), *(yyvsp[-1].t_list_case)); delete (yyvsp[-3].comment);print_rules("selectControl", "select selectable COMMENT selectConditionBreak casesControl END");}
5103
5104 break;
5105
5106 case 288:
5107
5108 {
5109 if((yyvsp[-1].t_seq_exp) == NULL)
5110 {
5111 (yyval.t_select_exp) = new ast::SelectExp((yyloc), *(yyvsp[-6].t_exp), *(yyvsp[-3].t_list_case));
5112 }
5113 else
5114 {
5115 (yyval.t_select_exp) = new ast::SelectExp((yyloc), *(yyvsp[-6].t_exp), *(yyvsp[-3].t_list_case), *(yyvsp[-1].t_seq_exp));
5116 }
5117 delete (yyvsp[-5].comment);
5118 print_rules("selectControl", "select selectable COMMENT selectConditionBreak casesControl defaultCase elseBody END");
5119 }
5120
5121 break;
5122
5123 case 289:
5124
5125 { /* !! Do Nothing !! */ print_rules("select", "SELECT");}
5126
5127 break;
5128
5129 case 290:
5130
5131 { /* !! Do Nothing !! */ print_rules("select", "SWITCH");}
5132
5133 break;
5134
5135 case 291:
5136
5137 { /* !! Do Nothing !! */ print_rules("defaultCase", "else");}
5138
5139 break;
5140
5141 case 292:
5142
5143 { /* !! Do Nothing !! */ print_rules("defaultCase", "OTHERWISE");}
5144
5145 break;
5146
5147 case 293:
5148
5149 { /* !! Do Nothing !! */ print_rules("defaultCase", "OTHERWISE COMMA");}
5150
5151 break;
5152
5153 case 294:
5154
5155 { /* !! Do Nothing !! */ print_rules("defaultCase", "OTHERWISE SEMI");}
5156
5157 break;
5158
5159 case 295:
5160
5161 { /* !! Do Nothing !! */ print_rules("defaultCase", "OTHERWISE EOL");}
5162
5163 break;
5164
5165 case 296:
5166
5167 { /* !! Do Nothing !! */ print_rules("defaultCase", "OTHERWISE COMMA EOL");}
5168
5169 break;
5170
5171 case 297:
5172
5173 { /* !! Do Nothing !! */ print_rules("defaultCase", "OTHERWISE SEMI EOL");}
5174
5175 break;
5176
5177 case 298:
5178
5179 { (yyval.t_exp) = (yyvsp[0].t_exp); print_rules("selectable", "variable");}
5180
5181 break;
5182
5183 case 299:
5184
5185 { (yyval.t_exp) = (yyvsp[0].t_call_exp); print_rules("selectable", "functionCall");}
5186
5187 break;
5188
5189 case 300:
5190
5191 { /* !! Do Nothing !! */ print_rules("selectConditionBreak", "EOL");}
5192
5193 break;
5194
5195 case 301:
5196
5197 { /* !! Do Nothing !! */ print_rules("selectConditionBreak", "COMMA EOL");}
5198
5199 break;
5200
5201 case 302:
5202
5203 { /* !! Do Nothing !! */ print_rules("selectConditionBreak", "SEMI EOL");}
5204
5205 break;
5206
5207 case 303:
5208
5209 { /* !! Do Nothing !! */ print_rules("selectConditionBreak", "COMMA");}
5210
5211 break;
5212
5213 case 304:
5214
5215 { /* !! Do Nothing !! */ print_rules("selectConditionBreak", "SEMI");}
5216
5217 break;
5218
5219 case 305:
5220
5221 {(yyval.t_list_case) = new ast::exps_t;(yyval.t_list_case)->push_back(new ast::CaseExp((yyloc), *(yyvsp[-2].t_exp), *(yyvsp[0].t_seq_exp)));print_rules("casesControl", "CASE variable caseControlBreak caseBody");}
5222
5223 break;
5224
5225 case 306:
5226
5227 {(yyval.t_list_case) = new ast::exps_t;(yyval.t_list_case)->push_back(new ast::CaseExp((yyloc), *(yyvsp[-2].t_call_exp), *(yyvsp[0].t_seq_exp)));print_rules("casesControl", "CASE functionCall caseControlBreak caseBody");}
5228
5229 break;
5230
5231 case 307:
5232
5233 {(yyval.t_list_case) = new ast::exps_t;(yyval.t_list_case)->push_back(new ast::CaseExp((yyloc), *(yyvsp[-2].t_exp), *(yyvsp[0].t_seq_exp)));print_rules("casesControl", "comments CASE variable caseControlBreak caseBody");}
5234
5235 break;
5236
5237 case 308:
5238
5239 {(yyval.t_list_case) = new ast::exps_t;(yyval.t_list_case)->push_back(new ast::CaseExp((yyloc), *(yyvsp[-2].t_call_exp), *(yyvsp[0].t_seq_exp)));print_rules("casesControl", "comments CASE functionCall caseControlBreak caseBody");}
5240
5241 break;
5242
5243 case 309:
5244
5245 {(yyvsp[-4].t_list_case)->push_back(new ast::CaseExp((yyloc), *(yyvsp[-2].t_exp), *(yyvsp[0].t_seq_exp)));(yyval.t_list_case) = (yyvsp[-4].t_list_case);print_rules("casesControl", "casesControl CASE variable caseControlBreak caseBody");}
5246
5247 break;
5248
5249 case 310:
5250
5251 {(yyvsp[-4].t_list_case)->push_back(new ast::CaseExp((yyloc), *(yyvsp[-2].t_call_exp), *(yyvsp[0].t_seq_exp)));(yyval.t_list_case) = (yyvsp[-4].t_list_case);print_rules("casesControl", "casesControl CASE functionCall caseControlBreak caseBody");}
5252
5253 break;
5254
5255 case 311:
5256
5257 {
5258 print_rules("caseBody", "expressions");
5259 (yyvsp[0].t_seq_exp)->getLocation().last_line = (yyvsp[0].t_seq_exp)->getExps().back()->getLocation().last_line;
5260 (yyvsp[0].t_seq_exp)->getLocation().last_column = (yyvsp[0].t_seq_exp)->getExps().back()->getLocation().last_column;
5261 (yyval.t_seq_exp) = (yyvsp[0].t_seq_exp);
5262 }
5263
5264 break;
5265
5266 case 312:
5267
5268 {
5269 print_rules("caseBody", "Epsilon");
5270 ast::exps_t* tmp = new ast::exps_t;
5271 #ifdef BUILD_DEBUG_AST
5272 tmp->push_back(new ast::CommentExp((yyloc), new std::wstring(L"Empty case body")));
5273 #endif
5274 (yyval.t_seq_exp) = new ast::SeqExp((yyloc), *tmp);
5275 }
5276
5277 break;
5278
5279 case 313:
5280
5281 { /* !! Do Nothing !! */ print_rules("caseControlBreak", "THEN");}
5282
5283 break;
5284
5285 case 314:
5286
5287 { /* !! Do Nothing !! */ print_rules("caseControlBreak", "COMMA");}
5288
5289 break;
5290
5291 case 315:
5292
5293 { /* !! Do Nothing !! */ print_rules("caseControlBreak", "SEMI");}
5294
5295 break;
5296
5297 case 316:
5298
5299 { /* !! Do Nothing !! */ print_rules("caseControlBreak", "EOL");}
5300
5301 break;
5302
5303 case 317:
5304
5305 { /* !! Do Nothing !! */ print_rules("caseControlBreak", "THEN EOL");}
5306
5307 break;
5308
5309 case 318:
5310
5311 { /* !! Do Nothing !! */ print_rules("caseControlBreak", "COMMA EOL");}
5312
5313 break;
5314
5315 case 319:
5316
5317 { /* !! Do Nothing !! */ print_rules("caseControlBreak", "SEMI EOL");}
5318
5319 break;
5320
5321 case 320:
5322
5323 { /* !! Do Nothing !! */ print_rules("caseControlBreak", "THEN COMMA");}
5324
5325 break;
5326
5327 case 321:
5328
5329 { /* !! Do Nothing !! */ print_rules("caseControlBreak", "THEN COMMA EOL");}
5330
5331 break;
5332
5333 case 322:
5334
5335 { /* !! Do Nothing !! */ print_rules("caseControlBreak", "THEN SEMI");}
5336
5337 break;
5338
5339 case 323:
5340
5341 { /* !! Do Nothing !! */ print_rules("caseControlBreak", "THEN SEMI EOL");}
5342
5343 break;
5344
5345 case 324:
5346
5347 { /* !! Do Nothing !! */ print_rules("caseControlBreak", "Epsilon");}
5348
5349 break;
5350
5351 case 325:
5352
5353 { (yyval.t_for_exp) = new ast::ForExp((yyloc), *new ast::VarDec((yylsp[-4]), symbol::Symbol(*(yyvsp[-5].str)), *(yyvsp[-3].t_exp)), *(yyvsp[-1].t_seq_exp)); delete (yyvsp[-5].str);print_rules("forControl", "FOR ID ASSIGN forIterator forConditionBreak forBody END ");}
5354
5355 break;
5356
5357 case 326:
5358
5359 { (yyval.t_for_exp) = new ast::ForExp((yyloc), *new ast::VarDec((yylsp[-5]), symbol::Symbol(*(yyvsp[-6].str)), *(yyvsp[-4].t_exp)), *(yyvsp[-1].t_seq_exp)); delete (yyvsp[-6].str);print_rules("forControl", "FOR LPAREN ID ASSIGN forIterator RPAREN forConditionBreak forBody END");}
5360
5361 break;
5362
5363 case 327:
5364
5365 { (yyval.t_exp) = (yyvsp[0].t_call_exp); print_rules("forIterator", "functionCall");}
5366
5367 break;
5368
5369 case 328:
5370
5371 { (yyval.t_exp) = (yyvsp[0].t_exp); print_rules("forIterator", "variable");}
5372
5373 break;
5374
5375 case 329:
5376
5377 { /* !! Do Nothing !! */ print_rules("forConditionBreak", "EOL");}
5378
5379 break;
5380
5381 case 330:
5382
5383 { /* !! Do Nothing !! */ print_rules("forConditionBreak", "SEMI");}
5384
5385 break;
5386
5387 case 331:
5388
5389 { /* !! Do Nothing !! */ print_rules("forConditionBreak", "SEMI EOL");}
5390
5391 break;
5392
5393 case 332:
5394
5395 { /* !! Do Nothing !! */ print_rules("forConditionBreak", "COMMA");}
5396
5397 break;
5398
5399 case 333:
5400
5401 { /* !! Do Nothing !! */ print_rules("forConditionBreak", "COMMA EOL");}
5402
5403 break;
5404
5405 case 334:
5406
5407 { /* !! Do Nothing !! */ print_rules("forConditionBreak", "DO");}
5408
5409 break;
5410
5411 case 335:
5412
5413 { /* !! Do Nothing !! */ print_rules("forConditionBreak", "DO EOL");}
5414
5415 break;
5416
5417 case 336:
5418
5419 { /* !! Do Nothing !! */ print_rules("forConditionBreak", "Epsilon");}
5420
5421 break;
5422
5423 case 337:
5424
5425 {
5426 print_rules("forBody", "expressions");
5427 (yyvsp[0].t_seq_exp)->getLocation().last_line = (yyvsp[0].t_seq_exp)->getExps().back()->getLocation().last_line;
5428 (yyvsp[0].t_seq_exp)->getLocation().last_column = (yyvsp[0].t_seq_exp)->getExps().back()->getLocation().last_column;
5429 (yyval.t_seq_exp) = (yyvsp[0].t_seq_exp);
5430 }
5431
5432 break;
5433
5434 case 338:
5435
5436 {
5437 print_rules("forBody", "Epsilon");
5438 ast::exps_t* tmp = new ast::exps_t;
5439 #ifdef BUILD_DEBUG_AST
5440 tmp->push_back(new ast::CommentExp((yyloc), new std::wstring(L"Empty for body")));
5441 #endif
5442 (yyval.t_seq_exp) = new ast::SeqExp((yyloc), *tmp);
5443 }
5444
5445 break;
5446
5447 case 339:
5448
5449 { (yyval.t_while_exp) = new ast::WhileExp((yyloc), *(yyvsp[-3].t_exp), *(yyvsp[-1].t_seq_exp)); print_rules("whileControl", "WHILE condition whileConditionBreak whileBody END");}
5450
5451 break;
5452
5453 case 340:
5454
5455 {
5456 print_rules("whileBody", "expressions");
5457 (yyvsp[0].t_seq_exp)->getLocation().last_line = (yyvsp[0].t_seq_exp)->getExps().back()->getLocation().last_line;
5458 (yyvsp[0].t_seq_exp)->getLocation().last_column = (yyvsp[0].t_seq_exp)->getExps().back()->getLocation().last_column;
5459 (yyval.t_seq_exp) = (yyvsp[0].t_seq_exp);
5460 }
5461
5462 break;
5463
5464 case 341:
5465
5466 {
5467 print_rules("whileBody", "Epsilon");
5468 ast::exps_t* tmp = new ast::exps_t;
5469 #ifdef BUILD_DEBUG_AST
5470 tmp->push_back(new ast::CommentExp((yyloc), new std::wstring(L"Empty while body")));
5471 #endif
5472 (yyval.t_seq_exp) = new ast::SeqExp((yyloc), *tmp);
5473 }
5474
5475 break;
5476
5477 case 342:
5478
5479 { /* !! Do Nothing !! */ print_rules("whileConditionBreak", "COMMA");}
5480
5481 break;
5482
5483 case 343:
5484
5485 { /* !! Do Nothing !! */ print_rules("whileConditionBreak", "SEMI");}
5486
5487 break;
5488
5489 case 344:
5490
5491 { /* !! Do Nothing !! */ print_rules("whileConditionBreak", "DO");}
5492
5493 break;
5494
5495 case 345:
5496
5497 { /* !! Do Nothing !! */ print_rules("whileConditionBreak", "DO COMMA");}
5498
5499 break;
5500
5501 case 346:
5502
5503 { /* !! Do Nothing !! */ print_rules("whileConditionBreak", "DO SEMI");}
5504
5505 break;
5506
5507 case 347:
5508
5509 { /* !! Do Nothing !! */ print_rules("whileConditionBreak", "THEN");}
5510
5511 break;
5512
5513 case 348:
5514
5515 { /* !! Do Nothing !! */ print_rules("whileConditionBreak", "THEN COMMA");}
5516
5517 break;
5518
5519 case 349:
5520
5521 { /* !! Do Nothing !! */ print_rules("whileConditionBreak", "THEN SEMI");}
5522
5523 break;
5524
5525 case 350:
5526
5527 { delete (yyvsp[-1].comment); print_rules("whileConditionBreak", "COMMENT EOL");}
5528
5529 break;
5530
5531 case 351:
5532
5533 { /* !! Do Nothing !! */ print_rules("whileConditionBreak", "EOL");}
5534
5535 break;
5536
5537 case 352:
5538
5539 { /* !! Do Nothing !! */ print_rules("whileConditionBreak", "COMMA EOL");}
5540
5541 break;
5542
5543 case 353:
5544
5545 { /* !! Do Nothing !! */ print_rules("whileConditionBreak", "SEMI EOL");}
5546
5547 break;
5548
5549 case 354:
5550
5551 { /* !! Do Nothing !! */ print_rules("whileConditionBreak", "SEMI EOL");}
5552
5553 break;
5554
5555 case 355:
5556
5557 { /* !! Do Nothing !! */ print_rules("whileConditionBreak", "DO COMMA EOL");}
5558
5559 break;
5560
5561 case 356:
5562
5563 { /* !! Do Nothing !! */ print_rules("whileConditionBreak", "DO SEMI EOL");}
5564
5565 break;
5566
5567 case 357:
5568
5569 { /* !! Do Nothing !! */ print_rules("whileConditionBreak", "THEN EOL");}
5570
5571 break;
5572
5573 case 358:
5574
5575 { /* !! Do Nothing !! */ print_rules("whileConditionBreak", "THEN COMMA EOL");}
5576
5577 break;
5578
5579 case 359:
5580
5581 { /* !! Do Nothing !! */ print_rules("whileConditionBreak", "THEN SEMI EOL");}
5582
5583 break;
5584
5585 case 360:
5586
5587 { (yyval.t_try_exp) =new ast::TryCatchExp((yyloc), *(yyvsp[-3].t_seq_exp), *(yyvsp[-1].t_seq_exp)); print_rules("tryControl", "TRY catchBody CATCH catchBody END");}
5588
5589 break;
5590
5591 case 361:
5592
5593 {
5594 print_rules("tryControl", "TRY catchBody END");
5595 ast::exps_t* tmp = new ast::exps_t;
5596 #ifdef BUILD_DEBUG_AST
5597 tmp->push_back(new ast::CommentExp((yyloc), new std::wstring(L"Empty catch body")));
5598 #endif
5599 (yyval.t_try_exp) = new ast::TryCatchExp((yyloc), *(yyvsp[-1].t_seq_exp), *new ast::SeqExp((yyloc), *tmp));
5600 }
5601
5602 break;
5603
5604 case 362:
5605
5606 {
5607 print_rules("catchBody", "expressions");
5608 (yyvsp[0].t_seq_exp)->getLocation().last_line = (yyvsp[0].t_seq_exp)->getExps().back()->getLocation().last_line;
5609 (yyvsp[0].t_seq_exp)->getLocation().last_column = (yyvsp[0].t_seq_exp)->getExps().back()->getLocation().last_column;
5610 (yyval.t_seq_exp) = (yyvsp[0].t_seq_exp);
5611 }
5612
5613 break;
5614
5615 case 363:
5616
5617 {
5618 print_rules("catchBody", "EOL expressions");
5619 (yyvsp[0].t_seq_exp)->getLocation().last_line = (yyvsp[0].t_seq_exp)->getExps().back()->getLocation().last_line;
5620 (yyvsp[0].t_seq_exp)->getLocation().last_column = (yyvsp[0].t_seq_exp)->getExps().back()->getLocation().last_column;
5621 (yyval.t_seq_exp) = (yyvsp[0].t_seq_exp);
5622 }
5623
5624 break;
5625
5626 case 364:
5627
5628 {
5629 print_rules("catchBody", "SEMI expressions");
5630 (yyvsp[0].t_seq_exp)->getLocation().last_line = (yyvsp[0].t_seq_exp)->getExps().back()->getLocation().last_line;
5631 (yyvsp[0].t_seq_exp)->getLocation().last_column = (yyvsp[0].t_seq_exp)->getExps().back()->getLocation().last_column;
5632 (yyval.t_seq_exp) = (yyvsp[0].t_seq_exp);
5633 }
5634
5635 break;
5636
5637 case 365:
5638
5639 {
5640 print_rules("catchBody", "COMMA expressions");
5641 (yyvsp[0].t_seq_exp)->getLocation().last_line = (yyvsp[0].t_seq_exp)->getExps().back()->getLocation().last_line;
5642 (yyvsp[0].t_seq_exp)->getLocation().last_column = (yyvsp[0].t_seq_exp)->getExps().back()->getLocation().last_column;
5643 (yyval.t_seq_exp) = (yyvsp[0].t_seq_exp);
5644 }
5645
5646 break;
5647
5648 case 366:
5649
5650 {
5651 print_rules("catchBody", "EOL");
5652 ast::exps_t* tmp = new ast::exps_t;
5653 #ifdef BUILD_DEBUG_AST
5654 tmp->push_back(new ast::CommentExp((yyloc), new std::wstring(L"Empty catch body")));
5655 #endif
5656 (yyval.t_seq_exp) = new ast::SeqExp((yyloc), *tmp);
5657 }
5658
5659 break;
5660
5661 case 367:
5662
5663 {
5664 print_rules("catchBody", "Epsilon");
5665 ast::exps_t* tmp = new ast::exps_t;
5666 #ifdef BUILD_DEBUG_AST
5667 tmp->push_back(new ast::CommentExp((yyloc), new std::wstring(L"Empty catch body")));
5668 #endif
5669 (yyval.t_seq_exp) = new ast::SeqExp((yyloc), *tmp);
5670 }
5671
5672 break;
5673
5674 case 368:
5675
5676 { (yyval.t_return_exp) = new ast::ReturnExp((yyloc)); print_rules("returnControl", "RETURN");}
5677
5678 break;
5679
5680 case 369:
5681
5682 { (yyval.t_return_exp) = new ast::ReturnExp((yyloc), (yyvsp[0].t_exp)); print_rules("returnControl", "RETURN variable");}
5683
5684 break;
5685
5686 case 370:
5687
5688 { (yyval.t_return_exp) = new ast::ReturnExp((yyloc), (yyvsp[0].t_call_exp)); print_rules("returnControl", "RETURN functionCall");}
5689
5690 break;
5691
5692 case 371:
5693
5694 { delete (yyvsp[-1].comment); print_rules("comments", "COMMENT EOL");}
5695
5696 break;
5697
5698 case 372:
5699
5700 { delete (yyvsp[-1].comment); print_rules("comments", "comments COMMENT EOL");}
5701
5702 break;
5703
5704 case 373:
5705
5706 { print_rules("lineEnd", "EOL");}
5707
5708 break;
5709
5710 case 374:
5711
5712 { delete (yyvsp[-1].comment); print_rules("lineEnd", "COMMENT EOL");}
5713
5714 break;
5715
5716 case 375:
5717
5718 { (yyval.t_simple_var) = new ast::SimpleVar((yyloc), symbol::Symbol(L"if")); print_rules("keywords", "IF");}
5719
5720 break;
5721
5722 case 376:
5723
5724 { (yyval.t_simple_var) = new ast::SimpleVar((yyloc), symbol::Symbol(L"then")); print_rules("keywords", "THEN");}
5725
5726 break;
5727
5728 case 377:
5729
5730 { (yyval.t_simple_var) = new ast::SimpleVar((yyloc), symbol::Symbol(L"else")); print_rules("keywords", "ELSE");}
5731
5732 break;
5733
5734 case 378:
5735
5736 { (yyval.t_simple_var) = new ast::SimpleVar((yyloc), symbol::Symbol(L"elseif")); print_rules("keywords", "ELSEIF");}
5737
5738 break;
5739
5740 case 379:
5741
5742 { (yyval.t_simple_var) = new ast::SimpleVar((yyloc), symbol::Symbol(L"end")); print_rules("keywords", "END");}
5743
5744 break;
5745
5746 case 380:
5747
5748 { (yyval.t_simple_var) = new ast::SimpleVar((yyloc), symbol::Symbol(L"select")); print_rules("keywords", "SELECT");}
5749
5750 break;
5751
5752 case 381:
5753
5754 { (yyval.t_simple_var) = new ast::SimpleVar((yyloc), symbol::Symbol(L"switch")); print_rules("keywords", "SWITCH");}
5755
5756 break;
5757
5758 case 382:
5759
5760 { (yyval.t_simple_var) = new ast::SimpleVar((yyloc), symbol::Symbol(L"otherwise")); print_rules("keywords", "OTHERWISE");}
5761
5762 break;
5763
5764 case 383:
5765
5766 { (yyval.t_simple_var) = new ast::SimpleVar((yyloc), symbol::Symbol(L"case")); print_rules("keywords", "CASE");}
5767
5768 break;
5769
5770 case 384:
5771
5772 { (yyval.t_simple_var) = new ast::SimpleVar((yyloc), symbol::Symbol(L"function")); print_rules("keywords", "FUNCTION");}
5773
5774 break;
5775
5776 case 385:
5777
5778 { (yyval.t_simple_var) = new ast::SimpleVar((yyloc), symbol::Symbol(L"endfunction")); print_rules("keywords", "ENDFUNCTION");}
5779
5780 break;
5781
5782 case 386:
5783
5784 { (yyval.t_simple_var) = new ast::SimpleVar((yyloc), symbol::Symbol(L"for")); print_rules("keywords", "FOR");}
5785
5786 break;
5787
5788 case 387:
5789
5790 { (yyval.t_simple_var) = new ast::SimpleVar((yyloc), symbol::Symbol(L"while")); print_rules("keywords", "WHILE");}
5791
5792 break;
5793
5794 case 388:
5795
5796 { (yyval.t_simple_var) = new ast::SimpleVar((yyloc), symbol::Symbol(L"do")); print_rules("keywords", "DO");}
5797
5798 break;
5799
5800 case 389:
5801
5802 { (yyval.t_simple_var) = new ast::SimpleVar((yyloc), symbol::Symbol(L"break")); print_rules("keywords", "BREAK");}
5803
5804 break;
5805
5806 case 390:
5807
5808 { (yyval.t_simple_var) = new ast::SimpleVar((yyloc), symbol::Symbol(L"try")); print_rules("keywords", "TRY");}
5809
5810 break;
5811
5812 case 391:
5813
5814 { (yyval.t_simple_var) = new ast::SimpleVar((yyloc), symbol::Symbol(L"catch")); print_rules("keywords", "CATCH");}
5815
5816 break;
5817
5818 case 392:
5819
5820 { (yyval.t_simple_var) = new ast::SimpleVar((yyloc), symbol::Symbol(L"return")); print_rules("keywords", "RETURN");}
5821
5822 break;
5823
5824
5825
5826 default: break;
5827 }
5828 /* User semantic actions sometimes alter yychar, and that requires
5829 that yytoken be updated with the new translation. We take the
5830 approach of translating immediately before every use of yytoken.
5831 One alternative is translating here after every semantic action,
5832 but that translation would be missed if the semantic action invokes
5833 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
5834 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
5835 incorrect destructor might then be invoked immediately. In the
5836 case of YYERROR or YYBACKUP, subsequent parser actions might lead
5837 to an incorrect destructor call or verbose syntax error message
5838 before the lookahead is translated. */
5839 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
5840
5841 YYPOPSTACK (yylen);
5842 yylen = 0;
5843 YY_STACK_PRINT (yyss, yyssp);
5844
5845 *++yyvsp = yyval;
5846 *++yylsp = yyloc;
5847
5848 /* Now 'shift' the result of the reduction. Determine what state
5849 that goes to, based on the state we popped back to and the rule
5850 number reduced by. */
5851
5852 yyn = yyr1[yyn];
5853
5854 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
5855 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
5856 yystate = yytable[yystate];
5857 else
5858 yystate = yydefgoto[yyn - YYNTOKENS];
5859
5860 goto yynewstate;
5861
5862
5863 /*--------------------------------------.
5864 | yyerrlab -- here on detecting error. |
5865 `--------------------------------------*/
5866 yyerrlab:
5867 /* Make sure we have latest lookahead translation. See comments at
5868 user semantic actions for why this is necessary. */
5869 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
5870
5871 /* If not already recovering from an error, report this error. */
5872 if (!yyerrstatus)
5873 {
5874 ++yynerrs;
5875 #if ! YYERROR_VERBOSE
5876 yyerror (YY_("syntax error"));
5877 #else
5878 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
5879 yyssp, yytoken)
5880 {
5881 char const *yymsgp = YY_("syntax error");
5882 int yysyntax_error_status;
5883 yysyntax_error_status = YYSYNTAX_ERROR;
5884 if (yysyntax_error_status == 0)
5885 yymsgp = yymsg;
5886 else if (yysyntax_error_status == 1)
5887 {
5888 if (yymsg != yymsgbuf)
5889 YYSTACK_FREE (yymsg);
5890 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
5891 if (!yymsg)
5892 {
5893 yymsg = yymsgbuf;
5894 yymsg_alloc = sizeof yymsgbuf;
5895 yysyntax_error_status = 2;
5896 }
5897 else
5898 {
5899 yysyntax_error_status = YYSYNTAX_ERROR;
5900 yymsgp = yymsg;
5901 }
5902 }
5903 yyerror (yymsgp);
5904 if (yysyntax_error_status == 2)
5905 goto yyexhaustedlab;
5906 }
5907 # undef YYSYNTAX_ERROR
5908 #endif
5909 }
5910
5911 yyerror_range[1] = yylloc;
5912
5913 if (yyerrstatus == 3)
5914 {
5915 /* If just tried and failed to reuse lookahead token after an
5916 error, discard it. */
5917
5918 if (yychar <= YYEOF)
5919 {
5920 /* Return failure if at end of input. */
5921 if (yychar == YYEOF)
5922 YYABORT;
5923 }
5924 else
5925 {
5926 yydestruct ("Error: discarding",
5927 yytoken, &yylval, &yylloc);
5928 yychar = YYEMPTY;
5929 }
5930 }
5931
5932 /* Else will try to reuse lookahead token after shifting the error
5933 token. */
5934 goto yyerrlab1;
5935
5936
5937 /*---------------------------------------------------.
5938 | yyerrorlab -- error raised explicitly by YYERROR. |
5939 `---------------------------------------------------*/
5940 yyerrorlab:
5941
5942 /* Pacify compilers like GCC when the user code never invokes
5943 YYERROR and the label yyerrorlab therefore never appears in user
5944 code. */
5945 if (/*CONSTCOND*/ 0)
5946 goto yyerrorlab;
5947
5948 /* Do not reclaim the symbols of the rule whose action triggered
5949 this YYERROR. */
5950 YYPOPSTACK (yylen);
5951 yylen = 0;
5952 YY_STACK_PRINT (yyss, yyssp);
5953 yystate = *yyssp;
5954 goto yyerrlab1;
5955
5956
5957 /*-------------------------------------------------------------.
5958 | yyerrlab1 -- common code for both syntax error and YYERROR. |
5959 `-------------------------------------------------------------*/
5960 yyerrlab1:
5961 yyerrstatus = 3; /* Each real token shifted decrements this. */
5962
5963 for (;;)
5964 {
5965 yyn = yypact[yystate];
5966 if (!yypact_value_is_default (yyn))
5967 {
5968 yyn += YYTERROR;
5969 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
5970 {
5971 yyn = yytable[yyn];
5972 if (0 < yyn)
5973 break;
5974 }
5975 }
5976
5977 /* Pop the current state because it cannot handle the error token. */
5978 if (yyssp == yyss)
5979 YYABORT;
5980
5981 yyerror_range[1] = *yylsp;
5982 yydestruct ("Error: popping",
5983 yystos[yystate], yyvsp, yylsp);
5984 YYPOPSTACK (1);
5985 yystate = *yyssp;
5986 YY_STACK_PRINT (yyss, yyssp);
5987 }
5988
5989 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
5990 *++yyvsp = yylval;
5991 YY_IGNORE_MAYBE_UNINITIALIZED_END
5992
5993 yyerror_range[2] = yylloc;
5994 /* Using YYLLOC is tempting, but would change the location of
5995 the lookahead. YYLOC is available though. */
5996 YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
5997 *++yylsp = yyloc;
5998
5999 /* Shift the error token. */
6000 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
6001
6002 yystate = yyn;
6003 goto yynewstate;
6004
6005
6006 /*-------------------------------------.
6007 | yyacceptlab -- YYACCEPT comes here. |
6008 `-------------------------------------*/
6009 yyacceptlab:
6010 yyresult = 0;
6011 goto yyreturn;
6012
6013 /*-----------------------------------.
6014 | yyabortlab -- YYABORT comes here. |
6015 `-----------------------------------*/
6016 yyabortlab:
6017 yyresult = 1;
6018 goto yyreturn;
6019
6020 #if !defined yyoverflow || YYERROR_VERBOSE
6021 /*-------------------------------------------------.
6022 | yyexhaustedlab -- memory exhaustion comes here. |
6023 `-------------------------------------------------*/
6024 yyexhaustedlab:
6025 yyerror (YY_("memory exhausted"));
6026 yyresult = 2;
6027 /* Fall through. */
6028 #endif
6029
6030 yyreturn:
6031 if (yychar != YYEMPTY)
6032 {
6033 /* Make sure we have latest lookahead translation. See comments at
6034 user semantic actions for why this is necessary. */
6035 yytoken = YYTRANSLATE (yychar);
6036 yydestruct ("Cleanup: discarding lookahead",
6037 yytoken, &yylval, &yylloc);
6038 }
6039 /* Do not reclaim the symbols of the rule whose action triggered
6040 this YYABORT or YYACCEPT. */
6041 YYPOPSTACK (yylen);
6042 YY_STACK_PRINT (yyss, yyssp);
6043 while (yyssp != yyss)
6044 {
6045 yydestruct ("Cleanup: popping",
6046 yystos[*yyssp], yyvsp, yylsp);
6047 YYPOPSTACK (1);
6048 }
6049 #ifndef yyoverflow
6050 if (yyss != yyssa)
6051 YYSTACK_FREE (yyss);
6052 #endif
6053 #if YYERROR_VERBOSE
6054 if (yymsg != yymsgbuf)
6055 YYSTACK_FREE (yymsg);
6056 #endif
6057 return yyresult;
6058 }
6059
6060
6061
endsWith(const std::string & str,const std::string & end)6062 bool endsWith(const std::string & str, const std::string & end)
6063 {
6064 if (end.size() > str.size())
6065 {
6066 return false;
6067 }
6068
6069 return std::equal(end.rbegin(), end.rend(), str.rbegin());
6070 }
6071
yyerror(std::string msg)6072 void yyerror(std::string msg) {
6073 if (!endsWith(msg, "FLEX_ERROR") && !ParserSingleInstance::isStrictMode()
6074 || ParserSingleInstance::getExitStatus() == Parser::Succeded)
6075 {
6076 wchar_t* pstMsg = to_wide_string(msg.c_str());
6077 ParserSingleInstance::PrintError(pstMsg);
6078 ParserSingleInstance::setExitStatus(Parser::Failed);
6079 delete ParserSingleInstance::getTree();
6080 FREE(pstMsg);
6081 }
6082 }
6083
6084