cprover
jsil_y.tab.cpp
Go to the documentation of this file.
1 /* A Bison parser, made by GNU Bison 3.6.4. */
2 
3 /* Bison implementation for Yacc-like parsers in C
4 
5  Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation,
6  Inc.
7 
8  This program is free software: you can redistribute it and/or modify
9  it under the terms of the GNU General Public License as published by
10  the Free Software Foundation, either version 3 of the License, or
11  (at your option) any later version.
12 
13  This program is distributed in the hope that it will be useful,
14  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  GNU General Public License for more details.
17 
18  You should have received a copy of the GNU General Public License
19  along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 
21 /* As a special exception, you may create a larger work that contains
22  part or all of the Bison parser skeleton and distribute that work
23  under terms of your choice, so long as that work isn't itself a
24  parser generator using the skeleton or a modified version thereof
25  as a parser skeleton. Alternatively, if you modify or redistribute
26  the parser skeleton itself, you may (at your option) remove this
27  special exception, which will cause the skeleton and the resulting
28  Bison output files to be licensed under the GNU General Public
29  License without this special exception.
30 
31  This special exception was added by the Free Software Foundation in
32  version 2.2 of Bison. */
33 
34 /* C LALR(1) parser skeleton written by Richard Stallman, by
35  simplifying the original so-called "semantic" parser. */
36 
37 /* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
38  especially those whose name start with YY_ or yy_. They are
39  private implementation details that can be changed or removed. */
40 
41 /* All symbols defined below should begin with yy or YY, to avoid
42  infringing on user name space. This should be done even for local
43  variables, as they might otherwise be expanded by user macros.
44  There are some unavoidable exceptions within include files to
45  define necessary library symbols; they are noted "INFRINGES ON
46  USER NAME SPACE" below. */
47 
48 /* Identify Bison output. */
49 #define YYBISON 1
50 
51 /* Bison version. */
52 #define YYBISON_VERSION "3.6.4"
53 
54 /* Skeleton name. */
55 #define YYSKELETON_NAME "yacc.c"
56 
57 /* Pure parsers. */
58 #define YYPURE 0
59 
60 /* Push parsers. */
61 #define YYPUSH 0
62 
63 /* Pull parsers. */
64 #define YYPULL 1
65 
66 
67 /* Substitute the variable and function names. */
68 #define yyparse yyjsilparse
69 #define yylex yyjsillex
70 #define yyerror yyjsilerror
71 #define yydebug yyjsildebug
72 #define yynerrs yyjsilnerrs
73 #define yylval yyjsillval
74 #define yychar yyjsilchar
75 
76 /* First part of user prologue. */
77 #line 1 "parser.y"
78 
79 
80 // #define YYDEBUG 1
81 #define PARSER jsil_parser
82 
83 #include "jsil_parser.h"
84 
85 int yyjsillex();
86 extern char *yyjsiltext;
87 
88 #define YYSTYPE unsigned
89 #define YYSTYPE_IS_TRIVIAL 1
90 
91 #include <util/std_expr.h>
92 #include <util/std_code.h>
93 #include <util/string_constant.h>
94 
95 #include "jsil_y.tab.h"
96 
97 #ifdef _MSC_VER
98 // possible loss of data
99 #pragma warning(disable:4242)
100 // possible loss of data
101 #pragma warning(disable:4244)
102 // signed/unsigned mismatch
103 #pragma warning(disable:4365)
104 // switch with default but no case labels
105 #pragma warning(disable:4065)
106 // unreachable code
107 #pragma warning(disable:4702)
108 #endif
109 
110 /*** token declaration **************************************************/
111 
112 #line 113 "jsil_y.tab.cpp"
113 
114 # ifndef YY_CAST
115 # ifdef __cplusplus
116 # define YY_CAST(Type, Val) static_cast<Type> (Val)
117 # define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
118 # else
119 # define YY_CAST(Type, Val) ((Type) (Val))
120 # define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
121 # endif
122 # endif
123 # ifndef YY_NULLPTR
124 # if defined __cplusplus
125 # if 201103L <= __cplusplus
126 # define YY_NULLPTR nullptr
127 # else
128 # define YY_NULLPTR 0
129 # endif
130 # else
131 # define YY_NULLPTR ((void*)0)
132 # endif
133 # endif
134 
135 /* Use api.header.include to #include this header
136  instead of duplicating it here. */
137 #ifndef YY_YYJSIL_JSIL_Y_TAB_H_INCLUDED
138 # define YY_YYJSIL_JSIL_Y_TAB_H_INCLUDED
139 /* Debug traces. */
140 #ifndef YYDEBUG
141 # define YYDEBUG 0
142 #endif
143 #if YYDEBUG
144 extern int yyjsildebug;
145 #endif
146 
147 /* Token kinds. */
148 #ifndef YYTOKENTYPE
149 # define YYTOKENTYPE
150  enum yytokentype
151  {
152  YYEMPTY = -2,
153  YYEOF = 0, /* "end of file" */
154  YYerror = 256, /* error */
155  YYUNDEF = 257, /* "invalid token" */
156  TOK_SCANNER_ERROR = 258, /* TOK_SCANNER_ERROR */
157  TOK_NEWLINE = 259, /* "<newline>" */
158  TOK_PROCEDURE = 260, /* "procedure" */
159  TOK_RETURNS = 261, /* "returns" */
160  TOK_TO = 262, /* "to" */
161  TOK_THROWS = 263, /* "throws" */
162  TOK_EVAL = 264, /* "eval" */
163  TOK_LABEL = 265, /* "label" */
164  TOK_GOTO = 266, /* "goto" */
165  TOK_SKIP = 267, /* "skip" */
166  TOK_WITH = 268, /* "with" */
167  TOK_NEW = 269, /* "new" */
168  TOK_HAS_FIELD = 270, /* "hasField" */
169  TOK_DELETE = 271, /* "delete" */
170  TOK_PROTO_FIELD = 272, /* "protoField" */
171  TOK_PROTO_OBJ = 273, /* "protoObj" */
172  TOK_REF = 274, /* "ref" */
173  TOK_FIELD = 275, /* "field" */
174  TOK_BASE = 276, /* "base" */
175  TOK_TYPEOF = 277, /* "typeOf" */
176  TOK_NULL = 278, /* "null" */
177  TOK_UNDEFINED = 279, /* "#undefined" */
178  TOK_EMPTY = 280, /* "#empty" */
179  TOK_TRUE = 281, /* "true" */
180  TOK_FALSE = 282, /* "false" */
181  TOK_PROTO = 283, /* "#proto" */
182  TOK_FID = 284, /* "#fid" */
183  TOK_SCOPE = 285, /* "#scope" */
184  TOK_CONSTRUCTID = 286, /* "#constructid" */
185  TOK_PRIMVALUE = 287, /* "#primvalue" */
186  TOK_TARGETFUNCTION = 288, /* "#targetfunction" */
187  TOK_CLASS = 289, /* "#class" */
188  TOK_NUM_TO_STRING = 290, /* "num_to_string" */
189  TOK_STRING_TO_NUM = 291, /* "string_to_num" */
190  TOK_NUM_TO_INT32 = 292, /* "num_to_int32" */
191  TOK_NUM_TO_UINT32 = 293, /* "num_to_uint32" */
192  TOK_MEMBER_REFERENCE = 294, /* "#MemberReference" */
193  TOK_VARIABLE_REFERENCE = 295, /* "#VariableReference" */
194  TOK_T_NULL = 296, /* "#Null" */
195  TOK_T_UNDEFINED = 297, /* "#Undefined" */
196  TOK_T_BOOLEAN = 298, /* "#Boolean" */
197  TOK_T_STRING = 299, /* "#String" */
198  TOK_T_NUMBER = 300, /* "#Number" */
199  TOK_T_BUILTIN_OBJECT = 301, /* "#BuiltinObject" */
200  TOK_T_USER_OBJECT = 302, /* "#UserObject" */
201  TOK_T_OBJECT = 303, /* "#Object" */
202  TOK_T_REFERENCE = 304, /* "#Reference" */
203  TOK_DEFEQ = 305, /* ":=" */
204  TOK_LEQ = 306, /* "<=" */
205  TOK_AND = 307, /* "and" */
206  TOK_OR = 308, /* "or" */
207  TOK_SUBTYPE_OF = 309, /* "<:" */
208  TOK_LEFT_SHIFT = 310, /* "<<" */
209  TOK_SIGNED_RIGHT_SHIFT = 311, /* ">>" */
210  TOK_UNSIGNED_RIGHT_SHIFT = 312, /* ">>>" */
211  TOK_NOT = 313, /* "not" */
212  TOK_IDENTIFIER = 314, /* TOK_IDENTIFIER */
213  TOK_FLOATING = 315, /* TOK_FLOATING */
214  TOK_STRING = 316, /* TOK_STRING */
215  TOK_BUILTIN_LOC = 317, /* TOK_BUILTIN_LOC */
216  TOK_BUILTIN_IDENTIFIER = 318, /* TOK_BUILTIN_IDENTIFIER */
217  TOK_SPEC_IDENTIFIER = 319 /* TOK_SPEC_IDENTIFIER */
218  };
219  typedef enum yytokentype yytoken_kind_t;
220 #endif
221 
222 /* Value type. */
223 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
224 typedef int YYSTYPE;
225 # define YYSTYPE_IS_TRIVIAL 1
226 # define YYSTYPE_IS_DECLARED 1
227 #endif
228 
229 
230 extern YYSTYPE yyjsillval;
231 
232 int yyjsilparse (void);
233 
234 #endif /* !YY_YYJSIL_JSIL_Y_TAB_H_INCLUDED */
235 /* Symbol kind. */
237 {
239  YYSYMBOL_YYEOF = 0, /* "end of file" */
240  YYSYMBOL_YYerror = 1, /* error */
241  YYSYMBOL_YYUNDEF = 2, /* "invalid token" */
242  YYSYMBOL_TOK_SCANNER_ERROR = 3, /* TOK_SCANNER_ERROR */
243  YYSYMBOL_TOK_NEWLINE = 4, /* "<newline>" */
244  YYSYMBOL_TOK_PROCEDURE = 5, /* "procedure" */
245  YYSYMBOL_TOK_RETURNS = 6, /* "returns" */
246  YYSYMBOL_TOK_TO = 7, /* "to" */
247  YYSYMBOL_TOK_THROWS = 8, /* "throws" */
248  YYSYMBOL_TOK_EVAL = 9, /* "eval" */
249  YYSYMBOL_TOK_LABEL = 10, /* "label" */
250  YYSYMBOL_TOK_GOTO = 11, /* "goto" */
251  YYSYMBOL_TOK_SKIP = 12, /* "skip" */
252  YYSYMBOL_TOK_WITH = 13, /* "with" */
253  YYSYMBOL_TOK_NEW = 14, /* "new" */
254  YYSYMBOL_TOK_HAS_FIELD = 15, /* "hasField" */
255  YYSYMBOL_TOK_DELETE = 16, /* "delete" */
256  YYSYMBOL_TOK_PROTO_FIELD = 17, /* "protoField" */
257  YYSYMBOL_TOK_PROTO_OBJ = 18, /* "protoObj" */
258  YYSYMBOL_TOK_REF = 19, /* "ref" */
259  YYSYMBOL_TOK_FIELD = 20, /* "field" */
260  YYSYMBOL_TOK_BASE = 21, /* "base" */
261  YYSYMBOL_TOK_TYPEOF = 22, /* "typeOf" */
262  YYSYMBOL_TOK_NULL = 23, /* "null" */
263  YYSYMBOL_TOK_UNDEFINED = 24, /* "#undefined" */
264  YYSYMBOL_TOK_EMPTY = 25, /* "#empty" */
265  YYSYMBOL_TOK_TRUE = 26, /* "true" */
266  YYSYMBOL_TOK_FALSE = 27, /* "false" */
267  YYSYMBOL_TOK_PROTO = 28, /* "#proto" */
268  YYSYMBOL_TOK_FID = 29, /* "#fid" */
269  YYSYMBOL_TOK_SCOPE = 30, /* "#scope" */
270  YYSYMBOL_TOK_CONSTRUCTID = 31, /* "#constructid" */
271  YYSYMBOL_TOK_PRIMVALUE = 32, /* "#primvalue" */
272  YYSYMBOL_TOK_TARGETFUNCTION = 33, /* "#targetfunction" */
273  YYSYMBOL_TOK_CLASS = 34, /* "#class" */
274  YYSYMBOL_TOK_NUM_TO_STRING = 35, /* "num_to_string" */
275  YYSYMBOL_TOK_STRING_TO_NUM = 36, /* "string_to_num" */
276  YYSYMBOL_TOK_NUM_TO_INT32 = 37, /* "num_to_int32" */
277  YYSYMBOL_TOK_NUM_TO_UINT32 = 38, /* "num_to_uint32" */
278  YYSYMBOL_TOK_MEMBER_REFERENCE = 39, /* "#MemberReference" */
279  YYSYMBOL_TOK_VARIABLE_REFERENCE = 40, /* "#VariableReference" */
280  YYSYMBOL_TOK_T_NULL = 41, /* "#Null" */
281  YYSYMBOL_TOK_T_UNDEFINED = 42, /* "#Undefined" */
282  YYSYMBOL_TOK_T_BOOLEAN = 43, /* "#Boolean" */
283  YYSYMBOL_TOK_T_STRING = 44, /* "#String" */
284  YYSYMBOL_TOK_T_NUMBER = 45, /* "#Number" */
285  YYSYMBOL_TOK_T_BUILTIN_OBJECT = 46, /* "#BuiltinObject" */
286  YYSYMBOL_TOK_T_USER_OBJECT = 47, /* "#UserObject" */
287  YYSYMBOL_TOK_T_OBJECT = 48, /* "#Object" */
288  YYSYMBOL_TOK_T_REFERENCE = 49, /* "#Reference" */
289  YYSYMBOL_TOK_DEFEQ = 50, /* ":=" */
290  YYSYMBOL_TOK_LEQ = 51, /* "<=" */
291  YYSYMBOL_TOK_AND = 52, /* "and" */
292  YYSYMBOL_TOK_OR = 53, /* "or" */
293  YYSYMBOL_TOK_SUBTYPE_OF = 54, /* "<:" */
294  YYSYMBOL_TOK_LEFT_SHIFT = 55, /* "<<" */
297  YYSYMBOL_TOK_NOT = 58, /* "not" */
298  YYSYMBOL_TOK_IDENTIFIER = 59, /* TOK_IDENTIFIER */
299  YYSYMBOL_TOK_FLOATING = 60, /* TOK_FLOATING */
300  YYSYMBOL_TOK_STRING = 61, /* TOK_STRING */
301  YYSYMBOL_TOK_BUILTIN_LOC = 62, /* TOK_BUILTIN_LOC */
302  YYSYMBOL_TOK_BUILTIN_IDENTIFIER = 63, /* TOK_BUILTIN_IDENTIFIER */
303  YYSYMBOL_TOK_SPEC_IDENTIFIER = 64, /* TOK_SPEC_IDENTIFIER */
304  YYSYMBOL_65_ = 65, /* '(' */
305  YYSYMBOL_66_ = 66, /* ')' */
306  YYSYMBOL_67_ = 67, /* '{' */
307  YYSYMBOL_68_ = 68, /* '}' */
308  YYSYMBOL_69_ = 69, /* ',' */
309  YYSYMBOL_70_ = 70, /* '[' */
310  YYSYMBOL_71_ = 71, /* ']' */
311  YYSYMBOL_72_ = 72, /* '=' */
312  YYSYMBOL_73_ = 73, /* '<' */
313  YYSYMBOL_74_ = 74, /* '+' */
314  YYSYMBOL_75_ = 75, /* '-' */
315  YYSYMBOL_76_ = 76, /* '*' */
316  YYSYMBOL_77_ = 77, /* '/' */
317  YYSYMBOL_78_ = 78, /* '%' */
318  YYSYMBOL_79_ = 79, /* ':' */
319  YYSYMBOL_80_ = 80, /* '&' */
320  YYSYMBOL_81_ = 81, /* '|' */
321  YYSYMBOL_82_ = 82, /* '^' */
322  YYSYMBOL_83_ = 83, /* '!' */
323  YYSYMBOL_YYACCEPT = 84, /* $accept */
324  YYSYMBOL_program = 85, /* program */
325  YYSYMBOL_procedure_decls = 86, /* procedure_decls */
326  YYSYMBOL_procedure_decl = 87, /* procedure_decl */
327  YYSYMBOL_proc_ident = 88, /* proc_ident */
328  YYSYMBOL_proc_ident_expr = 89, /* proc_ident_expr */
329  YYSYMBOL_parameters_opt = 90, /* parameters_opt */
330  YYSYMBOL_parameters = 91, /* parameters */
331  YYSYMBOL_statements_opt = 92, /* statements_opt */
332  YYSYMBOL_statements = 93, /* statements */
333  YYSYMBOL_statement = 94, /* statement */
334  YYSYMBOL_instruction = 95, /* instruction */
335  YYSYMBOL_rhs = 96, /* rhs */
336  YYSYMBOL_with_opt = 97, /* with_opt */
337  YYSYMBOL_expressions_opt = 98, /* expressions_opt */
338  YYSYMBOL_expressions = 99, /* expressions */
339  YYSYMBOL_expression = 100, /* expression */
340  YYSYMBOL_atom_expression = 101, /* atom_expression */
341  YYSYMBOL_literal = 102, /* literal */
342  YYSYMBOL_builtin_field = 103, /* builtin_field */
343  YYSYMBOL_binary_op = 104, /* binary_op */
344  YYSYMBOL_compare_op = 105, /* compare_op */
345  YYSYMBOL_arithmetic_op = 106, /* arithmetic_op */
346  YYSYMBOL_boolean_op = 107, /* boolean_op */
347  YYSYMBOL_bitwise_op = 108, /* bitwise_op */
348  YYSYMBOL_unary_op = 109, /* unary_op */
349  YYSYMBOL_jsil_type = 110, /* jsil_type */
350  YYSYMBOL_ref_type = 111 /* ref_type */
351 };
352 typedef enum yysymbol_kind_t yysymbol_kind_t;
353 
354 
355 
356 
357 #ifdef short
358 # undef short
359 #endif
360 
361 /* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
362  <limits.h> and (if available) <stdint.h> are included
363  so that the code can choose integer types of a good width. */
364 
365 #ifndef __PTRDIFF_MAX__
366 # include <limits.h> /* INFRINGES ON USER NAME SPACE */
367 # if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
368 # include <stdint.h> /* INFRINGES ON USER NAME SPACE */
369 # define YY_STDINT_H
370 # endif
371 #endif
372 
373 /* Narrow types that promote to a signed type and that can represent a
374  signed or unsigned integer of at least N bits. In tables they can
375  save space and decrease cache pressure. Promoting to a signed type
376  helps avoid bugs in integer arithmetic. */
377 
378 #ifdef __INT_LEAST8_MAX__
379 typedef __INT_LEAST8_TYPE__ yytype_int8;
380 #elif defined YY_STDINT_H
381 typedef int_least8_t yytype_int8;
382 #else
383 typedef signed char yytype_int8;
384 #endif
385 
386 #ifdef __INT_LEAST16_MAX__
387 typedef __INT_LEAST16_TYPE__ yytype_int16;
388 #elif defined YY_STDINT_H
389 typedef int_least16_t yytype_int16;
390 #else
391 typedef short yytype_int16;
392 #endif
393 
394 #if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
395 typedef __UINT_LEAST8_TYPE__ yytype_uint8;
396 #elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
397  && UINT_LEAST8_MAX <= INT_MAX)
398 typedef uint_least8_t yytype_uint8;
399 #elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
400 typedef unsigned char yytype_uint8;
401 #else
402 typedef short yytype_uint8;
403 #endif
404 
405 #if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
406 typedef __UINT_LEAST16_TYPE__ yytype_uint16;
407 #elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
408  && UINT_LEAST16_MAX <= INT_MAX)
409 typedef uint_least16_t yytype_uint16;
410 #elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
411 typedef unsigned short yytype_uint16;
412 #else
413 typedef int yytype_uint16;
414 #endif
415 
416 #ifndef YYPTRDIFF_T
417 # if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
418 # define YYPTRDIFF_T __PTRDIFF_TYPE__
419 # define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
420 # elif defined PTRDIFF_MAX
421 # ifndef ptrdiff_t
422 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
423 # endif
424 # define YYPTRDIFF_T ptrdiff_t
425 # define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
426 # else
427 # define YYPTRDIFF_T long
428 # define YYPTRDIFF_MAXIMUM LONG_MAX
429 # endif
430 #endif
431 
432 #ifndef YYSIZE_T
433 # ifdef __SIZE_TYPE__
434 # define YYSIZE_T __SIZE_TYPE__
435 # elif defined size_t
436 # define YYSIZE_T size_t
437 # elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
438 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
439 # define YYSIZE_T size_t
440 # else
441 # define YYSIZE_T unsigned
442 # endif
443 #endif
444 
445 #define YYSIZE_MAXIMUM \
446  YY_CAST (YYPTRDIFF_T, \
447  (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
448  ? YYPTRDIFF_MAXIMUM \
449  : YY_CAST (YYSIZE_T, -1)))
450 
451 #define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
452 
453 
454 /* Stored state numbers (used for stacks). */
456 
457 /* State numbers in computations. */
458 typedef int yy_state_fast_t;
459 
460 #ifndef YY_
461 # if defined YYENABLE_NLS && YYENABLE_NLS
462 # if ENABLE_NLS
463 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
464 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
465 # endif
466 # endif
467 # ifndef YY_
468 # define YY_(Msgid) Msgid
469 # endif
470 #endif
471 
472 
473 #ifndef YY_ATTRIBUTE_PURE
474 # if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
475 # define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
476 # else
477 # define YY_ATTRIBUTE_PURE
478 # endif
479 #endif
480 
481 #ifndef YY_ATTRIBUTE_UNUSED
482 # if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
483 # define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
484 # else
485 # define YY_ATTRIBUTE_UNUSED
486 # endif
487 #endif
488 
489 /* Suppress unused-variable warnings by "using" E. */
490 #if ! defined lint || defined __GNUC__
491 # define YYUSE(E) ((void) (E))
492 #else
493 # define YYUSE(E) /* empty */
494 #endif
495 
496 #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
497 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
498 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
499  _Pragma ("GCC diagnostic push") \
500  _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
501  _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
502 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
503  _Pragma ("GCC diagnostic pop")
504 #else
505 # define YY_INITIAL_VALUE(Value) Value
506 #endif
507 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
508 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
509 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
510 #endif
511 #ifndef YY_INITIAL_VALUE
512 # define YY_INITIAL_VALUE(Value) /* Nothing. */
513 #endif
514 
515 #if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
516 # define YY_IGNORE_USELESS_CAST_BEGIN \
517  _Pragma ("GCC diagnostic push") \
518  _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
519 # define YY_IGNORE_USELESS_CAST_END \
520  _Pragma ("GCC diagnostic pop")
521 #endif
522 #ifndef YY_IGNORE_USELESS_CAST_BEGIN
523 # define YY_IGNORE_USELESS_CAST_BEGIN
524 # define YY_IGNORE_USELESS_CAST_END
525 #endif
526 
527 
528 #define YY_ASSERT(E) ((void) (0 && (E)))
529 
530 #if !defined yyoverflow
531 
532 /* The parser invokes alloca or malloc; define the necessary symbols. */
533 
534 # ifdef YYSTACK_USE_ALLOCA
535 # if YYSTACK_USE_ALLOCA
536 # ifdef __GNUC__
537 # define YYSTACK_ALLOC __builtin_alloca
538 # elif defined __BUILTIN_VA_ARG_INCR
539 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
540 # elif defined _AIX
541 # define YYSTACK_ALLOC __alloca
542 # elif defined _MSC_VER
543 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
544 # define alloca _alloca
545 # else
546 # define YYSTACK_ALLOC alloca
547 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
548 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
549  /* Use EXIT_SUCCESS as a witness for stdlib.h. */
550 # ifndef EXIT_SUCCESS
551 # define EXIT_SUCCESS 0
552 # endif
553 # endif
554 # endif
555 # endif
556 # endif
557 
558 # ifdef YYSTACK_ALLOC
559  /* Pacify GCC's 'empty if-body' warning. */
560 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
561 # ifndef YYSTACK_ALLOC_MAXIMUM
562  /* The OS might guarantee only one guard page at the bottom of the stack,
563  and a page size can be as small as 4096 bytes. So we cannot safely
564  invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
565  to allow for a few compiler-allocated temporary stack slots. */
566 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
567 # endif
568 # else
569 # define YYSTACK_ALLOC YYMALLOC
570 # define YYSTACK_FREE YYFREE
571 # ifndef YYSTACK_ALLOC_MAXIMUM
572 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
573 # endif
574 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
575  && ! ((defined YYMALLOC || defined malloc) \
576  && (defined YYFREE || defined free)))
577 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
578 # ifndef EXIT_SUCCESS
579 # define EXIT_SUCCESS 0
580 # endif
581 # endif
582 # ifndef YYMALLOC
583 # define YYMALLOC malloc
584 # if ! defined malloc && ! defined EXIT_SUCCESS
585 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
586 # endif
587 # endif
588 # ifndef YYFREE
589 # define YYFREE free
590 # if ! defined free && ! defined EXIT_SUCCESS
591 void free (void *); /* INFRINGES ON USER NAME SPACE */
592 # endif
593 # endif
594 # endif
595 #endif /* !defined yyoverflow */
596 
597 #if (! defined yyoverflow \
598  && (! defined __cplusplus \
599  || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
600 
601 /* A type that is properly aligned for any stack member. */
602 union yyalloc
603 {
606 };
607 
608 /* The size of the maximum gap between one aligned stack and the next. */
609 # define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
610 
611 /* The size of an array large to enough to hold all stacks, each with
612  N elements. */
613 # define YYSTACK_BYTES(N) \
614  ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
615  + YYSTACK_GAP_MAXIMUM)
616 
617 # define YYCOPY_NEEDED 1
618 
619 /* Relocate STACK from its old location to the new one. The
620  local variables YYSIZE and YYSTACKSIZE give the old and new number of
621  elements in the stack, and YYPTR gives the new location of the
622  stack. Advance YYPTR to a properly aligned location for the next
623  stack. */
624 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
625  do \
626  { \
627  YYPTRDIFF_T yynewbytes; \
628  YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
629  Stack = &yyptr->Stack_alloc; \
630  yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
631  yyptr += yynewbytes / YYSIZEOF (*yyptr); \
632  } \
633  while (0)
634 
635 #endif
636 
637 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
638 /* Copy COUNT objects from SRC to DST. The source and destination do
639  not overlap. */
640 # ifndef YYCOPY
641 # if defined __GNUC__ && 1 < __GNUC__
642 # define YYCOPY(Dst, Src, Count) \
643  __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
644 # else
645 # define YYCOPY(Dst, Src, Count) \
646  do \
647  { \
648  YYPTRDIFF_T yyi; \
649  for (yyi = 0; yyi < (Count); yyi++) \
650  (Dst)[yyi] = (Src)[yyi]; \
651  } \
652  while (0)
653 # endif
654 # endif
655 #endif /* !YYCOPY_NEEDED */
656 
657 /* YYFINAL -- State number of the termination state. */
658 #define YYFINAL 10
659 /* YYLAST -- Last index in YYTABLE. */
660 #define YYLAST 858
661 
662 /* YYNTOKENS -- Number of terminals. */
663 #define YYNTOKENS 84
664 /* YYNNTS -- Number of nonterminals. */
665 #define YYNNTS 28
666 /* YYNRULES -- Number of rules. */
667 #define YYNRULES 109
668 /* YYNSTATES -- Number of states. */
669 #define YYNSTATES 192
670 
671 #define YYMAXUTOK 319
672 
673 
674 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
675  as returned by yylex, with out-of-bounds checking. */
676 #define YYTRANSLATE(YYX) \
677  (0 <= (YYX) && (YYX) <= YYMAXUTOK \
678  ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \
679  : YYSYMBOL_YYUNDEF)
680 
681 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
682  as returned by yylex. */
683 static const yytype_int8 yytranslate[] =
684 {
685  0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
686  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
687  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
688  2, 2, 2, 83, 2, 2, 2, 78, 80, 2,
689  65, 66, 76, 74, 69, 75, 2, 77, 2, 2,
690  2, 2, 2, 2, 2, 2, 2, 2, 79, 2,
691  73, 72, 2, 2, 2, 2, 2, 2, 2, 2,
692  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
693  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
694  2, 70, 2, 71, 82, 2, 2, 2, 2, 2,
695  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
696  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
697  2, 2, 2, 67, 81, 68, 2, 2, 2, 2,
698  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
699  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
700  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
701  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
702  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
703  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
704  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
705  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
706  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
707  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
708  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
709  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
710  2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
711  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
712  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
713  25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
714  35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
715  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
716  55, 56, 57, 58, 59, 60, 61, 62, 63, 64
717 };
718 
719 #if YYDEBUG
720  /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
721 static const yytype_int16 yyrline[] =
722 {
723  0, 121, 121, 124, 125, 128, 161, 162, 167, 171,
724  177, 178, 187, 190, 193, 198, 206, 209, 212, 217,
725  224, 228, 234, 241, 246, 255, 259, 264, 272, 273,
726  287, 292, 299, 304, 311, 318, 328, 331, 338, 341,
727  344, 349, 356, 357, 364, 365, 370, 374, 384, 391,
728  398, 407, 408, 412, 416, 420, 424, 428, 429, 435,
729  436, 437, 440, 444, 448, 452, 456, 460, 464, 470,
730  471, 472, 473, 476, 480, 484, 490, 494, 498, 502,
731  506, 512, 516, 520, 524, 530, 534, 538, 542, 546,
732  550, 556, 560, 564, 568, 572, 576, 580, 586, 590,
733  594, 598, 602, 606, 610, 614, 618, 619, 626, 630
734 };
735 #endif
736 
738 #define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
739 
740 #if YYDEBUG || 0
741 /* The user-facing name of the symbol whose (internal) number is
742  YYSYMBOL. No bounds checking. */
743 static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED;
744 
745 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
746  First, the terminals, then, starting at YYNTOKENS, nonterminals. */
747 static const char *const yytname[] =
748 {
749  "\"end of file\"", "error", "\"invalid token\"", "TOK_SCANNER_ERROR",
750  "\"<newline>\"", "\"procedure\"", "\"returns\"", "\"to\"", "\"throws\"",
751  "\"eval\"", "\"label\"", "\"goto\"", "\"skip\"", "\"with\"", "\"new\"",
752  "\"hasField\"", "\"delete\"", "\"protoField\"", "\"protoObj\"",
753  "\"ref\"", "\"field\"", "\"base\"", "\"typeOf\"", "\"null\"",
754  "\"#undefined\"", "\"#empty\"", "\"true\"", "\"false\"", "\"#proto\"",
755  "\"#fid\"", "\"#scope\"", "\"#constructid\"", "\"#primvalue\"",
756  "\"#targetfunction\"", "\"#class\"", "\"num_to_string\"",
757  "\"string_to_num\"", "\"num_to_int32\"", "\"num_to_uint32\"",
758  "\"#MemberReference\"", "\"#VariableReference\"", "\"#Null\"",
759  "\"#Undefined\"", "\"#Boolean\"", "\"#String\"", "\"#Number\"",
760  "\"#BuiltinObject\"", "\"#UserObject\"", "\"#Object\"", "\"#Reference\"",
761  "\":=\"", "\"<=\"", "\"and\"", "\"or\"", "\"<:\"", "\"<<\"", "\">>\"",
762  "\">>>\"", "\"not\"", "TOK_IDENTIFIER", "TOK_FLOATING", "TOK_STRING",
763  "TOK_BUILTIN_LOC", "TOK_BUILTIN_IDENTIFIER", "TOK_SPEC_IDENTIFIER",
764  "'('", "')'", "'{'", "'}'", "','", "'['", "']'", "'='", "'<'", "'+'",
765  "'-'", "'*'", "'/'", "'%'", "':'", "'&'", "'|'", "'^'", "'!'", "$accept",
766  "program", "procedure_decls", "procedure_decl", "proc_ident",
767  "proc_ident_expr", "parameters_opt", "parameters", "statements_opt",
768  "statements", "statement", "instruction", "rhs", "with_opt",
769  "expressions_opt", "expressions", "expression", "atom_expression",
770  "literal", "builtin_field", "binary_op", "compare_op", "arithmetic_op",
771  "boolean_op", "bitwise_op", "unary_op", "jsil_type", "ref_type", YY_NULLPTR
772 };
773 
774 static const char *
775 yysymbol_name (yysymbol_kind_t yysymbol)
776 {
777  return yytname[yysymbol];
778 }
779 #endif
780 
781 #ifdef YYPRINT
782 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
783  (internal) symbol number NUM (which must be that of a token). */
784 static const yytype_int16 yytoknum[] =
785 {
786  0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
787  265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
788  275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
789  285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
790  295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
791  305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
792  315, 316, 317, 318, 319, 40, 41, 123, 125, 44,
793  91, 93, 61, 60, 43, 45, 42, 47, 37, 58,
794  38, 124, 94, 33
795 };
796 #endif
797 
798 #define YYPACT_NINF (-147)
799 
800 #define yypact_value_is_default(Yyn) \
801  ((Yyn) == YYPACT_NINF)
802 
803 #define YYTABLE_NINF (-12)
804 
805 #define yytable_value_is_error(Yyn) \
806  0
807 
808  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
809  STATE-NUM. */
810 static const yytype_int16 yypact[] =
811 {
812  0, -3, 7, 0, -147, -147, -147, -147, -147, -52,
813  -147, -147, -45, -147, -50, -51, 11, -39, -38, -147,
814  12, -37, 15, -35, 18, -33, -36, -2, -147, -32,
815  -55, -147, -22, 185, -34, -2, -147, 25, -147, -147,
816  185, 120, -30, -29, -26, -25, -147, -147, -147, -147,
817  -147, -147, -147, -147, -147, -147, -147, -147, -147, -147,
818  -147, -147, -147, -147, -147, -147, -147, -147, -147, -147,
819  -147, -147, -147, -147, -147, -147, -147, -147, 185, -147,
820  -147, 31, -147, -147, -147, 185, -147, -147, -147, -147,
821  -147, 200, -24, -23, -21, -20, -18, -17, -16, 185,
822  -147, -15, -147, 776, 185, 185, 185, 185, 232, -147,
823  -147, -147, -147, -147, -147, -147, 185, -147, -147, -147,
824  -147, -147, -147, -147, -147, -147, -147, -147, 185, -147,
825  -147, -147, -147, -147, -27, -14, 185, 185, 185, 185,
826  264, 185, 296, 328, 360, 392, -147, 424, -147, -11,
827  -147, 456, 488, 520, 552, 185, -13, -7, 776, 185,
828  -147, -147, -147, 1, -5, 185, 185, 185, 185, 584,
829  17, 185, 616, 185, -147, 648, 680, 712, 744, -147,
830  -4, -147, 776, -28, 776, -147, -147, -147, -147, -147,
831  3, -147
832 };
833 
834  /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
835  Performed when YYTABLE does not specify something else to do. Zero
836  means the default is an error. */
837 static const yytype_int8 yydefact[] =
838 {
839  0, 0, 0, 2, 3, 7, 6, 8, 9, 0,
840  1, 4, 12, 14, 0, 13, 0, 0, 0, 15,
841  0, 0, 0, 0, 0, 0, 0, 16, 20, 0,
842  0, 25, 0, 0, 0, 17, 18, 0, 22, 23,
843  0, 0, 0, 0, 0, 0, 52, 53, 54, 55,
844  56, 62, 63, 64, 65, 66, 67, 68, 93, 94,
845  95, 96, 108, 109, 98, 99, 100, 101, 102, 103,
846  104, 105, 107, 91, 51, 57, 58, 59, 0, 92,
847  97, 0, 42, 44, 61, 0, 60, 106, 5, 19,
848  21, 0, 0, 0, 0, 0, 0, 51, 58, 0,
849  10, 0, 26, 28, 0, 0, 0, 0, 0, 75,
850  81, 82, 83, 88, 89, 90, 0, 73, 74, 76,
851  77, 78, 79, 80, 84, 85, 86, 87, 0, 69,
852  70, 71, 72, 45, 0, 0, 0, 0, 0, 0,
853  0, 38, 0, 0, 0, 0, 46, 0, 43, 0,
854  30, 0, 0, 0, 0, 0, 0, 39, 40, 0,
855  48, 49, 50, 0, 0, 0, 0, 0, 0, 0,
856  36, 0, 0, 0, 24, 0, 0, 0, 0, 32,
857  0, 29, 41, 0, 27, 31, 33, 34, 35, 37,
858  0, 47
859 };
860 
861  /* YYPGOTO[NTERM-NUM]. */
862 static const yytype_int16 yypgoto[] =
863 {
864  -147, -147, -147, 30, 2, -147, -147, -147, -147, -147,
865  28, -147, -147, -147, -147, -147, -40, -82, -147, -147,
866  -147, -147, -147, -147, -147, -147, -147, -146
867 };
868 
869  /* YYDEFGOTO[NTERM-NUM]. */
870 static const yytype_int16 yydefgoto[] =
871 {
872  -1, 2, 3, 4, 9, 101, 14, 15, 34, 35,
873  36, 37, 102, 181, 156, 157, 81, 82, 83, 84,
874  128, 129, 130, 131, 132, 85, 86, 87
875 };
876 
877  /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
878  positive, shift that token. If negative, reduce the rule whose
879  number is the opposite. If YYTABLE_NINF, syntax error. */
880 static const yytype_int16 yytable[] =
881 {
882  91, 103, 28, 133, 39, 1, 5, 10, 29, 30,
883  31, 62, 63, 12, 13, 40, 16, 18, 17, 21,
884  19, 20, 22, 23, 24, 25, 26, 38, 41, 90,
885  180, 27, 149, 11, 88, 104, 105, 190, 108, 106,
886  107, 135, 136, 100, 137, 138, 148, 139, -6, -11,
887  141, 173, 150, 170, 174, 189, 6, 32, 164, 140,
888  7, 8, 171, 89, 142, 143, 144, 145, 33, 191,
889  0, 0, 0, 0, 0, 0, 147, 0, 0, 0,
890  0, 0, 109, 110, 111, 112, 113, 114, 115, 0,
891  0, 0, 0, 0, 0, 0, 151, 152, 153, 154,
892  116, 158, 0, 117, 118, 119, 120, 121, 122, 123,
893  124, 125, 126, 127, 0, 169, 0, 0, 0, 172,
894  0, 0, 0, 0, 0, 175, 176, 177, 178, 5,
895  0, 182, 0, 184, 92, 93, 94, 95, 96, 42,
896  43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
897  53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
898  63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
899  0, 0, 0, 0, 0, 0, 0, 0, 73, 97,
900  75, 98, 77, 7, 8, 78, 0, 0, 0, 0,
901  99, 0, 0, 0, 0, 79, 0, 0, 0, 0,
902  0, 0, 0, 80, 42, 43, 44, 45, 46, 47,
903  48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
904  58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
905  68, 69, 70, 71, 72, 0, 0, 0, 0, 0,
906  0, 0, 0, 73, 74, 75, 76, 77, 0, 0,
907  78, 109, 110, 111, 112, 113, 114, 115, 0, 0,
908  79, 0, 0, 0, 0, 0, 0, 0, 80, 0,
909  0, 134, 117, 118, 119, 120, 121, 122, 123, 124,
910  125, 126, 127, 109, 110, 111, 112, 113, 114, 115,
911  0, 0, 0, 0, 0, 0, 0, 0, 146, 0,
912  0, 0, 0, 0, 117, 118, 119, 120, 121, 122,
913  123, 124, 125, 126, 127, 109, 110, 111, 112, 113,
914  114, 115, 0, 0, 0, 0, 0, 0, 0, 0,
915  0, 0, 0, 155, 0, 0, 117, 118, 119, 120,
916  121, 122, 123, 124, 125, 126, 127, 109, 110, 111,
917  112, 113, 114, 115, 0, 0, 0, 0, 0, 0,
918  0, 0, 0, 0, 0, 159, 0, 0, 117, 118,
919  119, 120, 121, 122, 123, 124, 125, 126, 127, 109,
920  110, 111, 112, 113, 114, 115, 0, 0, 0, 0,
921  0, 0, 0, 0, 160, 0, 0, 0, 0, 0,
922  117, 118, 119, 120, 121, 122, 123, 124, 125, 126,
923  127, 109, 110, 111, 112, 113, 114, 115, 0, 0,
924  0, 0, 0, 0, 0, 0, 161, 0, 0, 0,
925  0, 0, 117, 118, 119, 120, 121, 122, 123, 124,
926  125, 126, 127, 109, 110, 111, 112, 113, 114, 115,
927  0, 0, 0, 0, 0, 0, 0, 0, 162, 0,
928  0, 0, 0, 0, 117, 118, 119, 120, 121, 122,
929  123, 124, 125, 126, 127, 109, 110, 111, 112, 113,
930  114, 115, 0, 0, 0, 0, 0, 0, 0, 0,
931  0, 0, 0, 0, 0, 163, 117, 118, 119, 120,
932  121, 122, 123, 124, 125, 126, 127, 109, 110, 111,
933  112, 113, 114, 115, 0, 0, 0, 0, 0, 0,
934  0, 0, 0, 0, 0, 165, 0, 0, 117, 118,
935  119, 120, 121, 122, 123, 124, 125, 126, 127, 109,
936  110, 111, 112, 113, 114, 115, 0, 0, 0, 0,
937  0, 0, 0, 0, 0, 0, 0, 166, 0, 0,
938  117, 118, 119, 120, 121, 122, 123, 124, 125, 126,
939  127, 109, 110, 111, 112, 113, 114, 115, 0, 0,
940  0, 0, 0, 0, 0, 0, 0, 0, 0, 167,
941  0, 0, 117, 118, 119, 120, 121, 122, 123, 124,
942  125, 126, 127, 109, 110, 111, 112, 113, 114, 115,
943  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
944  0, 168, 0, 0, 117, 118, 119, 120, 121, 122,
945  123, 124, 125, 126, 127, 109, 110, 111, 112, 113,
946  114, 115, 0, 0, 0, 0, 0, 0, 0, 0,
947  0, 0, 0, 0, 0, 179, 117, 118, 119, 120,
948  121, 122, 123, 124, 125, 126, 127, 109, 110, 111,
949  112, 113, 114, 115, 0, 0, 0, 0, 0, 0,
950  0, 0, 0, 0, 0, 183, 0, 0, 117, 118,
951  119, 120, 121, 122, 123, 124, 125, 126, 127, 109,
952  110, 111, 112, 113, 114, 115, 0, 0, 0, 0,
953  0, 0, 0, 0, 185, 0, 0, 0, 0, 0,
954  117, 118, 119, 120, 121, 122, 123, 124, 125, 126,
955  127, 109, 110, 111, 112, 113, 114, 115, 0, 0,
956  0, 0, 0, 0, 0, 0, 186, 0, 0, 0,
957  0, 0, 117, 118, 119, 120, 121, 122, 123, 124,
958  125, 126, 127, 109, 110, 111, 112, 113, 114, 115,
959  0, 0, 0, 0, 0, 0, 0, 0, 187, 0,
960  0, 0, 0, 0, 117, 118, 119, 120, 121, 122,
961  123, 124, 125, 126, 127, 109, 110, 111, 112, 113,
962  114, 115, 0, 0, 0, 0, 0, 0, 0, 0,
963  188, 0, 0, 0, 0, 0, 117, 118, 119, 120,
964  121, 122, 123, 124, 125, 126, 127, 109, 110, 111,
965  112, 113, 114, 115, 0, 0, 0, 0, 0, 0,
966  0, 0, 0, 0, 0, 0, 0, 0, 117, 118,
967  119, 120, 121, 122, 123, 124, 125, 126, 127
968 };
969 
970 static const yytype_int16 yycheck[] =
971 {
972  40, 41, 4, 85, 59, 5, 9, 0, 10, 11,
973  12, 39, 40, 65, 59, 70, 66, 6, 69, 7,
974  59, 59, 59, 8, 59, 7, 59, 59, 50, 4,
975  13, 67, 59, 3, 68, 65, 65, 183, 78, 65,
976  65, 65, 65, 41, 65, 65, 128, 65, 65, 65,
977  65, 50, 66, 66, 59, 59, 59, 59, 69, 99,
978  63, 64, 69, 35, 104, 105, 106, 107, 70, 66,
979  -1, -1, -1, -1, -1, -1, 116, -1, -1, -1,
980  -1, -1, 51, 52, 53, 54, 55, 56, 57, -1,
981  -1, -1, -1, -1, -1, -1, 136, 137, 138, 139,
982  69, 141, -1, 72, 73, 74, 75, 76, 77, 78,
983  79, 80, 81, 82, -1, 155, -1, -1, -1, 159,
984  -1, -1, -1, -1, -1, 165, 166, 167, 168, 9,
985  -1, 171, -1, 173, 14, 15, 16, 17, 18, 19,
986  20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
987  30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
988  40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
989  -1, -1, -1, -1, -1, -1, -1, -1, 58, 59,
990  60, 61, 62, 63, 64, 65, -1, -1, -1, -1,
991  70, -1, -1, -1, -1, 75, -1, -1, -1, -1,
992  -1, -1, -1, 83, 19, 20, 21, 22, 23, 24,
993  25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
994  35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
995  45, 46, 47, 48, 49, -1, -1, -1, -1, -1,
996  -1, -1, -1, 58, 59, 60, 61, 62, -1, -1,
997  65, 51, 52, 53, 54, 55, 56, 57, -1, -1,
998  75, -1, -1, -1, -1, -1, -1, -1, 83, -1,
999  -1, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1000  80, 81, 82, 51, 52, 53, 54, 55, 56, 57,
1001  -1, -1, -1, -1, -1, -1, -1, -1, 66, -1,
1002  -1, -1, -1, -1, 72, 73, 74, 75, 76, 77,
1003  78, 79, 80, 81, 82, 51, 52, 53, 54, 55,
1004  56, 57, -1, -1, -1, -1, -1, -1, -1, -1,
1005  -1, -1, -1, 69, -1, -1, 72, 73, 74, 75,
1006  76, 77, 78, 79, 80, 81, 82, 51, 52, 53,
1007  54, 55, 56, 57, -1, -1, -1, -1, -1, -1,
1008  -1, -1, -1, -1, -1, 69, -1, -1, 72, 73,
1009  74, 75, 76, 77, 78, 79, 80, 81, 82, 51,
1010  52, 53, 54, 55, 56, 57, -1, -1, -1, -1,
1011  -1, -1, -1, -1, 66, -1, -1, -1, -1, -1,
1012  72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
1013  82, 51, 52, 53, 54, 55, 56, 57, -1, -1,
1014  -1, -1, -1, -1, -1, -1, 66, -1, -1, -1,
1015  -1, -1, 72, 73, 74, 75, 76, 77, 78, 79,
1016  80, 81, 82, 51, 52, 53, 54, 55, 56, 57,
1017  -1, -1, -1, -1, -1, -1, -1, -1, 66, -1,
1018  -1, -1, -1, -1, 72, 73, 74, 75, 76, 77,
1019  78, 79, 80, 81, 82, 51, 52, 53, 54, 55,
1020  56, 57, -1, -1, -1, -1, -1, -1, -1, -1,
1021  -1, -1, -1, -1, -1, 71, 72, 73, 74, 75,
1022  76, 77, 78, 79, 80, 81, 82, 51, 52, 53,
1023  54, 55, 56, 57, -1, -1, -1, -1, -1, -1,
1024  -1, -1, -1, -1, -1, 69, -1, -1, 72, 73,
1025  74, 75, 76, 77, 78, 79, 80, 81, 82, 51,
1026  52, 53, 54, 55, 56, 57, -1, -1, -1, -1,
1027  -1, -1, -1, -1, -1, -1, -1, 69, -1, -1,
1028  72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
1029  82, 51, 52, 53, 54, 55, 56, 57, -1, -1,
1030  -1, -1, -1, -1, -1, -1, -1, -1, -1, 69,
1031  -1, -1, 72, 73, 74, 75, 76, 77, 78, 79,
1032  80, 81, 82, 51, 52, 53, 54, 55, 56, 57,
1033  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1034  -1, 69, -1, -1, 72, 73, 74, 75, 76, 77,
1035  78, 79, 80, 81, 82, 51, 52, 53, 54, 55,
1036  56, 57, -1, -1, -1, -1, -1, -1, -1, -1,
1037  -1, -1, -1, -1, -1, 71, 72, 73, 74, 75,
1038  76, 77, 78, 79, 80, 81, 82, 51, 52, 53,
1039  54, 55, 56, 57, -1, -1, -1, -1, -1, -1,
1040  -1, -1, -1, -1, -1, 69, -1, -1, 72, 73,
1041  74, 75, 76, 77, 78, 79, 80, 81, 82, 51,
1042  52, 53, 54, 55, 56, 57, -1, -1, -1, -1,
1043  -1, -1, -1, -1, 66, -1, -1, -1, -1, -1,
1044  72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
1045  82, 51, 52, 53, 54, 55, 56, 57, -1, -1,
1046  -1, -1, -1, -1, -1, -1, 66, -1, -1, -1,
1047  -1, -1, 72, 73, 74, 75, 76, 77, 78, 79,
1048  80, 81, 82, 51, 52, 53, 54, 55, 56, 57,
1049  -1, -1, -1, -1, -1, -1, -1, -1, 66, -1,
1050  -1, -1, -1, -1, 72, 73, 74, 75, 76, 77,
1051  78, 79, 80, 81, 82, 51, 52, 53, 54, 55,
1052  56, 57, -1, -1, -1, -1, -1, -1, -1, -1,
1053  66, -1, -1, -1, -1, -1, 72, 73, 74, 75,
1054  76, 77, 78, 79, 80, 81, 82, 51, 52, 53,
1055  54, 55, 56, 57, -1, -1, -1, -1, -1, -1,
1056  -1, -1, -1, -1, -1, -1, -1, -1, 72, 73,
1057  74, 75, 76, 77, 78, 79, 80, 81, 82
1058 };
1059 
1060  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1061  symbol of state STATE-NUM. */
1062 static const yytype_int8 yystos[] =
1063 {
1064  0, 5, 85, 86, 87, 9, 59, 63, 64, 88,
1065  0, 87, 65, 59, 90, 91, 66, 69, 6, 59,
1066  59, 7, 59, 8, 59, 7, 59, 67, 4, 10,
1067  11, 12, 59, 70, 92, 93, 94, 95, 59, 59,
1068  70, 50, 19, 20, 21, 22, 23, 24, 25, 26,
1069  27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
1070  37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
1071  47, 48, 49, 58, 59, 60, 61, 62, 65, 75,
1072  83, 100, 101, 102, 103, 109, 110, 111, 68, 94,
1073  4, 100, 14, 15, 16, 17, 18, 59, 61, 70,
1074  88, 89, 96, 100, 65, 65, 65, 65, 100, 51,
1075  52, 53, 54, 55, 56, 57, 69, 72, 73, 74,
1076  75, 76, 77, 78, 79, 80, 81, 82, 104, 105,
1077  106, 107, 108, 101, 71, 65, 65, 65, 65, 65,
1078  100, 65, 100, 100, 100, 100, 66, 100, 101, 59,
1079  66, 100, 100, 100, 100, 69, 98, 99, 100, 69,
1080  66, 66, 66, 71, 69, 69, 69, 69, 69, 100,
1081  66, 69, 100, 50, 59, 100, 100, 100, 100, 71,
1082  13, 97, 100, 69, 100, 66, 66, 66, 66, 59,
1083  111, 66
1084 };
1085 
1086  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1087 static const yytype_int8 yyr1[] =
1088 {
1089  0, 84, 85, 86, 86, 87, 88, 88, 88, 88,
1090  89, 89, 90, 90, 91, 91, 92, 92, 93, 93,
1091  94, 94, 95, 95, 95, 95, 95, 95, 96, 96,
1092  96, 96, 96, 96, 96, 96, 97, 97, 98, 98,
1093  99, 99, 100, 100, 101, 101, 101, 101, 101, 101,
1094  101, 102, 102, 102, 102, 102, 102, 102, 102, 102,
1095  102, 102, 103, 103, 103, 103, 103, 103, 103, 104,
1096  104, 104, 104, 105, 105, 105, 106, 106, 106, 106,
1097  106, 107, 107, 107, 107, 108, 108, 108, 108, 108,
1098  108, 109, 109, 109, 109, 109, 109, 109, 110, 110,
1099  110, 110, 110, 110, 110, 110, 110, 110, 111, 111
1100 };
1101 
1102  /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
1103 static const yytype_int8 yyr2[] =
1104 {
1105  0, 2, 1, 1, 2, 16, 1, 1, 1, 1,
1106  1, 1, 0, 1, 1, 3, 0, 1, 1, 2,
1107  1, 2, 2, 2, 7, 1, 3, 7, 1, 5,
1108  3, 6, 5, 6, 6, 6, 0, 2, 0, 1,
1109  1, 3, 1, 3, 1, 2, 3, 8, 4, 4,
1110  4, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1111  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1112  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1113  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1114  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1115  1, 1, 1, 1, 1, 1, 1, 1, 1, 1
1116 };
1117 
1118 
1119 enum { YYENOMEM = -2 };
1120 
1121 #define yyerrok (yyerrstatus = 0)
1122 #define yyclearin (yychar = YYEMPTY)
1124 #define YYACCEPT goto yyacceptlab
1125 #define YYABORT goto yyabortlab
1126 #define YYERROR goto yyerrorlab
1128 
1129 #define YYRECOVERING() (!!yyerrstatus)
1131 #define YYBACKUP(Token, Value) \
1132  do \
1133  if (yychar == YYEMPTY) \
1134  { \
1135  yychar = (Token); \
1136  yylval = (Value); \
1137  YYPOPSTACK (yylen); \
1138  yystate = *yyssp; \
1139  goto yybackup; \
1140  } \
1141  else \
1142  { \
1143  yyerror (YY_("syntax error: cannot back up")); \
1144  YYERROR; \
1145  } \
1146  while (0)
1147 
1148 /* Backward compatibility with an undocumented macro.
1149  Use YYerror or YYUNDEF. */
1150 #define YYERRCODE YYUNDEF
1152 
1153 /* Enable debugging if requested. */
1154 #if YYDEBUG
1155 
1156 # ifndef YYFPRINTF
1157 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1158 # define YYFPRINTF fprintf
1159 # endif
1160 
1161 # define YYDPRINTF(Args) \
1162 do { \
1163  if (yydebug) \
1164  YYFPRINTF Args; \
1165 } while (0)
1166 
1167 /* This macro is provided for backward compatibility. */
1168 # ifndef YY_LOCATION_PRINT
1169 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1170 # endif
1171 
1172 
1173 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \
1174 do { \
1175  if (yydebug) \
1176  { \
1177  YYFPRINTF (stderr, "%s ", Title); \
1178  yy_symbol_print (stderr, \
1179  Kind, Value); \
1180  YYFPRINTF (stderr, "\n"); \
1181  } \
1182 } while (0)
1183 
1184 
1185 /*-----------------------------------.
1186 | Print this symbol's value on YYO. |
1187 `-----------------------------------*/
1188 
1189 static void
1190 yy_symbol_value_print (FILE *yyo,
1191  yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
1192 {
1193  FILE *yyoutput = yyo;
1194  YYUSE (yyoutput);
1195  if (!yyvaluep)
1196  return;
1197 # ifdef YYPRINT
1198  if (yykind < YYNTOKENS)
1199  YYPRINT (yyo, yytoknum[yykind], *yyvaluep);
1200 # endif
1202  YYUSE (yykind);
1204 }
1205 
1206 
1207 /*---------------------------.
1208 | Print this symbol on YYO. |
1209 `---------------------------*/
1210 
1211 static void
1212 yy_symbol_print (FILE *yyo,
1213  yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
1214 {
1215  YYFPRINTF (yyo, "%s %s (",
1216  yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));
1217 
1218  yy_symbol_value_print (yyo, yykind, yyvaluep);
1219  YYFPRINTF (yyo, ")");
1220 }
1221 
1222 /*------------------------------------------------------------------.
1223 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1224 | TOP (included). |
1225 `------------------------------------------------------------------*/
1226 
1227 static void
1228 yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
1229 {
1230  YYFPRINTF (stderr, "Stack now");
1231  for (; yybottom <= yytop; yybottom++)
1232  {
1233  int yybot = *yybottom;
1234  YYFPRINTF (stderr, " %d", yybot);
1235  }
1236  YYFPRINTF (stderr, "\n");
1237 }
1238 
1239 # define YY_STACK_PRINT(Bottom, Top) \
1240 do { \
1241  if (yydebug) \
1242  yy_stack_print ((Bottom), (Top)); \
1243 } while (0)
1244 
1245 
1246 /*------------------------------------------------.
1247 | Report that the YYRULE is going to be reduced. |
1248 `------------------------------------------------*/
1249 
1250 static void
1251 yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp,
1252  int yyrule)
1253 {
1254  int yylno = yyrline[yyrule];
1255  int yynrhs = yyr2[yyrule];
1256  int yyi;
1257  YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
1258  yyrule - 1, yylno);
1259  /* The symbols being reduced. */
1260  for (yyi = 0; yyi < yynrhs; yyi++)
1261  {
1262  YYFPRINTF (stderr, " $%d = ", yyi + 1);
1263  yy_symbol_print (stderr,
1264  YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
1265  &yyvsp[(yyi + 1) - (yynrhs)]);
1266  YYFPRINTF (stderr, "\n");
1267  }
1268 }
1269 
1270 # define YY_REDUCE_PRINT(Rule) \
1271 do { \
1272  if (yydebug) \
1273  yy_reduce_print (yyssp, yyvsp, Rule); \
1274 } while (0)
1275 
1276 /* Nonzero means print parse trace. It is left uninitialized so that
1277  multiple parsers can coexist. */
1278 int yydebug;
1279 #else /* !YYDEBUG */
1280 # define YYDPRINTF(Args) ((void) 0)
1281 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
1282 # define YY_STACK_PRINT(Bottom, Top)
1283 # define YY_REDUCE_PRINT(Rule)
1284 #endif /* !YYDEBUG */
1285 
1286 
1287 /* YYINITDEPTH -- initial size of the parser's stacks. */
1288 #ifndef YYINITDEPTH
1289 # define YYINITDEPTH 200
1290 #endif
1291 
1292 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1293  if the built-in stack extension method is used).
1294 
1295  Do not make this value too large; the results are undefined if
1296  YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1297  evaluated with infinite-precision integer arithmetic. */
1298 
1299 #ifndef YYMAXDEPTH
1300 # define YYMAXDEPTH 10000
1301 #endif
1302 
1303 
1304 
1305 
1306 
1307 
1308 /*-----------------------------------------------.
1309 | Release the memory associated to this symbol. |
1310 `-----------------------------------------------*/
1311 
1312 static void
1313 yydestruct (const char *yymsg,
1314  yysymbol_kind_t yykind, YYSTYPE *yyvaluep)
1315 {
1316  YYUSE (yyvaluep);
1317  if (!yymsg)
1318  yymsg = "Deleting";
1319  YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
1320 
1322  YYUSE (yykind);
1324 }
1325 
1326 
1327 /* The lookahead symbol. */
1329 
1330 /* The semantic value of the lookahead symbol. */
1332 /* Number of syntax errors so far. */
1334 
1335 
1336 
1337 
1338 /*----------.
1339 | yyparse. |
1340 `----------*/
1341 
1342 int
1343 yyparse (void)
1344 {
1345  yy_state_fast_t yystate;
1346  /* Number of tokens to shift before error messages enabled. */
1347  int yyerrstatus;
1348 
1349  /* The stacks and their tools:
1350  'yyss': related to states.
1351  'yyvs': related to semantic values.
1352 
1353  Refer to the stacks through separate pointers, to allow yyoverflow
1354  to reallocate them elsewhere. */
1355 
1356  /* Their size. */
1357  YYPTRDIFF_T yystacksize;
1358 
1359  /* The state stack. */
1360  yy_state_t yyssa[YYINITDEPTH];
1361  yy_state_t *yyss;
1362  yy_state_t *yyssp;
1363 
1364  /* The semantic value stack. */
1365  YYSTYPE yyvsa[YYINITDEPTH];
1366  YYSTYPE *yyvs;
1367  YYSTYPE *yyvsp;
1368 
1369  int yyn;
1370  /* The return value of yyparse. */
1371  int yyresult;
1372  /* Lookahead token as an internal (translated) token number. */
1374  /* The variables used to return semantic value and location from the
1375  action routines. */
1376  YYSTYPE yyval;
1377 
1378 
1379 
1380 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1381 
1382  /* The number of symbols on the RHS of the reduced rule.
1383  Keep to zero when no symbol should be popped. */
1384  int yylen = 0;
1385 
1386  yynerrs = 0;
1387  yystate = 0;
1388  yyerrstatus = 0;
1389 
1390  yystacksize = YYINITDEPTH;
1391  yyssp = yyss = yyssa;
1392  yyvsp = yyvs = yyvsa;
1393 
1394 
1395  YYDPRINTF ((stderr, "Starting parse\n"));
1396 
1397  yychar = YYEMPTY; /* Cause a token to be read. */
1398  goto yysetstate;
1399 
1400 
1401 /*------------------------------------------------------------.
1402 | yynewstate -- push a new state, which is found in yystate. |
1403 `------------------------------------------------------------*/
1404 yynewstate:
1405  /* In all cases, when you get here, the value and location stacks
1406  have just been pushed. So pushing a state here evens the stacks. */
1407  yyssp++;
1408 
1409 
1410 /*--------------------------------------------------------------------.
1411 | yysetstate -- set current state (the top of the stack) to yystate. |
1412 `--------------------------------------------------------------------*/
1413 yysetstate:
1414  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1415  YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
1417  *yyssp = YY_CAST (yy_state_t, yystate);
1419  YY_STACK_PRINT (yyss, yyssp);
1420 
1421  if (yyss + yystacksize - 1 <= yyssp)
1422 #if !defined yyoverflow && !defined YYSTACK_RELOCATE
1423  goto yyexhaustedlab;
1424 #else
1425  {
1426  /* Get the current used size of the three stacks, in elements. */
1427  YYPTRDIFF_T yysize = yyssp - yyss + 1;
1428 
1429 # if defined yyoverflow
1430  {
1431  /* Give user a chance to reallocate the stack. Use copies of
1432  these so that the &'s don't force the real ones into
1433  memory. */
1434  yy_state_t *yyss1 = yyss;
1435  YYSTYPE *yyvs1 = yyvs;
1436 
1437  /* Each stack pointer address is followed by the size of the
1438  data in use in that stack, in bytes. This used to be a
1439  conditional around just the two extra args, but that might
1440  be undefined if yyoverflow is a macro. */
1441  yyoverflow (YY_("memory exhausted"),
1442  &yyss1, yysize * YYSIZEOF (*yyssp),
1443  &yyvs1, yysize * YYSIZEOF (*yyvsp),
1444  &yystacksize);
1445  yyss = yyss1;
1446  yyvs = yyvs1;
1447  }
1448 # else /* defined YYSTACK_RELOCATE */
1449  /* Extend the stack our own way. */
1450  if (YYMAXDEPTH <= yystacksize)
1451  goto yyexhaustedlab;
1452  yystacksize *= 2;
1453  if (YYMAXDEPTH < yystacksize)
1454  yystacksize = YYMAXDEPTH;
1455 
1456  {
1457  yy_state_t *yyss1 = yyss;
1458  union yyalloc *yyptr =
1459  YY_CAST (union yyalloc *,
1460  YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
1461  if (! yyptr)
1462  goto yyexhaustedlab;
1463  YYSTACK_RELOCATE (yyss_alloc, yyss);
1464  YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1465 # undef YYSTACK_RELOCATE
1466  if (yyss1 != yyssa)
1467  YYSTACK_FREE (yyss1);
1468  }
1469 # endif
1470 
1471  yyssp = yyss + yysize - 1;
1472  yyvsp = yyvs + yysize - 1;
1473 
1475  YYDPRINTF ((stderr, "Stack size increased to %ld\n",
1476  YY_CAST (long, yystacksize)));
1478 
1479  if (yyss + yystacksize - 1 <= yyssp)
1480  YYABORT;
1481  }
1482 #endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
1483 
1484  if (yystate == YYFINAL)
1485  YYACCEPT;
1486 
1487  goto yybackup;
1488 
1489 
1490 /*-----------.
1491 | yybackup. |
1492 `-----------*/
1493 yybackup:
1494  /* Do appropriate processing given the current state. Read a
1495  lookahead token if we need one and don't already have one. */
1496 
1497  /* First try to decide what to do without reference to lookahead token. */
1498  yyn = yypact[yystate];
1499  if (yypact_value_is_default (yyn))
1500  goto yydefault;
1501 
1502  /* Not known => get a lookahead token if don't already have one. */
1503 
1504  /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */
1505  if (yychar == YYEMPTY)
1506  {
1507  YYDPRINTF ((stderr, "Reading a token\n"));
1508  yychar = yylex ();
1509  }
1510 
1511  if (yychar <= YYEOF)
1512  {
1513  yychar = YYEOF;
1514  yytoken = YYSYMBOL_YYEOF;
1515  YYDPRINTF ((stderr, "Now at end of input.\n"));
1516  }
1517  else if (yychar == YYerror)
1518  {
1519  /* The scanner already issued an error message, process directly
1520  to error recovery. But do not keep the error token as
1521  lookahead, it is too special and may lead us to an endless
1522  loop in error recovery. */
1523  yychar = YYUNDEF;
1524  yytoken = YYSYMBOL_YYerror;
1525  goto yyerrlab1;
1526  }
1527  else
1528  {
1529  yytoken = YYTRANSLATE (yychar);
1530  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1531  }
1532 
1533  /* If the proper action on seeing token YYTOKEN is to reduce or to
1534  detect an error, take that action. */
1535  yyn += yytoken;
1536  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1537  goto yydefault;
1538  yyn = yytable[yyn];
1539  if (yyn <= 0)
1540  {
1541  if (yytable_value_is_error (yyn))
1542  goto yyerrlab;
1543  yyn = -yyn;
1544  goto yyreduce;
1545  }
1546 
1547  /* Count tokens shifted since error; after three, turn off error
1548  status. */
1549  if (yyerrstatus)
1550  yyerrstatus--;
1551 
1552  /* Shift the lookahead token. */
1553  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1554  yystate = yyn;
1556  *++yyvsp = yylval;
1558 
1559  /* Discard the shifted token. */
1560  yychar = YYEMPTY;
1561  goto yynewstate;
1562 
1563 
1564 /*-----------------------------------------------------------.
1565 | yydefault -- do the default action for the current state. |
1566 `-----------------------------------------------------------*/
1567 yydefault:
1568  yyn = yydefact[yystate];
1569  if (yyn == 0)
1570  goto yyerrlab;
1571  goto yyreduce;
1572 
1573 
1574 /*-----------------------------.
1575 | yyreduce -- do a reduction. |
1576 `-----------------------------*/
1577 yyreduce:
1578  /* yyn is the number of a rule to reduce with. */
1579  yylen = yyr2[yyn];
1580 
1581  /* If YYLEN is nonzero, implement the default value of the action:
1582  '$$ = $1'.
1583 
1584  Otherwise, the following line sets YYVAL to garbage.
1585  This behavior is undocumented and Bison
1586  users should not rely upon it. Assigning to YYVAL
1587  unconditionally makes the parser a bit smaller, and it avoids a
1588  GCC warning that YYVAL may be used uninitialized. */
1589  yyval = yyvsp[1-yylen];
1590 
1591 
1592  YY_REDUCE_PRINT (yyn);
1593  switch (yyn)
1594  {
1595  case 5:
1596 #line 132 "parser.y"
1597  {
1598  symbol_exprt proc(to_symbol_expr(parser_stack(yyvsp[-14])));
1599  code_typet::parameterst parameters;
1600  forall_operands(it, parser_stack(yyvsp[-12]))
1601  {
1602  symbol_exprt s(to_symbol_expr(*it));
1605  parameters.push_back(p);
1606  }
1607  proc.type() = code_typet(std::move(parameters), typet());
1608 
1609  symbol_exprt rv(to_symbol_expr(parser_stack(yyvsp[-9])));
1610  symbol_exprt rl(to_symbol_expr(parser_stack(yyvsp[-7])));
1611 
1612  symbol_exprt tv(to_symbol_expr(parser_stack(yyvsp[-5])));
1613  symbol_exprt tl(to_symbol_expr(parser_stack(yyvsp[-3])));
1614 
1615  jsil_declarationt decl;
1616  decl.add_declarator(proc);
1617  decl.add_returns(rv.get_identifier(), rl.get_identifier());
1618  decl.add_throws(tv.get_identifier(), tl.get_identifier());
1619  if(parser_stack(yyvsp[-1]).is_not_nil())
1620  decl.add_value(to_code_block(to_code(parser_stack(yyvsp[-1]))));
1621 
1622  PARSER.parse_tree.items.push_back(decl);
1623  }
1624 #line 1625 "jsil_y.tab.cpp"
1625  break;
1626 
1627  case 7:
1628 #line 163 "parser.y"
1629  {
1631  newstack(yyval).swap(e);
1632  }
1633 #line 1634 "jsil_y.tab.cpp"
1634  break;
1635 
1636  case 8:
1637 #line 168 "parser.y"
1638  {
1639  parser_stack(yyval).set("proc_type", "builtin");
1640  }
1641 #line 1642 "jsil_y.tab.cpp"
1642  break;
1643 
1644  case 9:
1645 #line 172 "parser.y"
1646  {
1647  parser_stack(yyval).set("proc_type", "spec");
1648  }
1649 #line 1650 "jsil_y.tab.cpp"
1650  break;
1651 
1652  case 11:
1653 #line 179 "parser.y"
1654  {
1656  to_string_constant(parser_stack(yyval)).get_value());
1657  parser_stack(yyval).swap(s);
1658  }
1659 #line 1660 "jsil_y.tab.cpp"
1660  break;
1661 
1662  case 12:
1663 #line 187 "parser.y"
1664  {
1665  newstack(yyval);
1666  }
1667 #line 1668 "jsil_y.tab.cpp"
1668  break;
1669 
1670  case 14:
1671 #line 194 "parser.y"
1672  {
1673  newstack(yyval).id(ID_parameters);
1674  parser_stack(yyval).add_to_operands(std::move(parser_stack(yyvsp[0])));
1675  }
1676 #line 1677 "jsil_y.tab.cpp"
1677  break;
1678 
1679  case 15:
1680 #line 199 "parser.y"
1681  {
1682  yyval=yyvsp[-2];
1683  parser_stack(yyval).add_to_operands(std::move(parser_stack(yyvsp[0])));
1684  }
1685 #line 1686 "jsil_y.tab.cpp"
1686  break;
1687 
1688  case 16:
1689 #line 206 "parser.y"
1690  {
1691  newstack(yyval);
1692  }
1693 #line 1694 "jsil_y.tab.cpp"
1694  break;
1695 
1696  case 18:
1697 #line 213 "parser.y"
1698  {
1699  code_blockt b({static_cast<codet &>(parser_stack(yyvsp[0]))});
1700  newstack(yyval).swap(b);
1701  }
1702 #line 1703 "jsil_y.tab.cpp"
1703  break;
1704 
1705  case 19:
1706 #line 218 "parser.y"
1707  {
1708  yyval=yyvsp[-1];
1709  parser_stack(yyval).add_to_operands(std::move(parser_stack(yyvsp[0])));
1710  }
1711 #line 1712 "jsil_y.tab.cpp"
1712  break;
1713 
1714  case 20:
1715 #line 225 "parser.y"
1716  {
1717  newstack(yyval)=code_skipt();
1718  }
1719 #line 1720 "jsil_y.tab.cpp"
1720  break;
1721 
1722  case 21:
1723 #line 229 "parser.y"
1724  {
1725  yyval=yyvsp[-1];
1726  }
1727 #line 1728 "jsil_y.tab.cpp"
1728  break;
1729 
1730  case 22:
1731 #line 235 "parser.y"
1732  {
1733  code_labelt l(
1734  to_symbol_expr(parser_stack(yyvsp[0])).get_identifier(),
1735  code_skipt());
1736  newstack(yyval).swap(l);
1737  }
1738 #line 1739 "jsil_y.tab.cpp"
1739  break;
1740 
1741  case 23:
1742 #line 242 "parser.y"
1743  {
1744  code_gotot g(to_symbol_expr(parser_stack(yyvsp[0])).get_identifier());
1745  newstack(yyval).swap(g);
1746  }
1747 #line 1748 "jsil_y.tab.cpp"
1748  break;
1749 
1750  case 24:
1751 #line 247 "parser.y"
1752  {
1753  code_gotot lt(to_symbol_expr(parser_stack(yyvsp[-2])).get_identifier());
1754  code_gotot lf(to_symbol_expr(parser_stack(yyvsp[0])).get_identifier());
1755 
1756  code_ifthenelset ite(parser_stack(yyvsp[-4]), std::move(lt), std::move(lf));
1757 
1758  newstack(yyval).swap(ite);
1759  }
1760 #line 1761 "jsil_y.tab.cpp"
1761  break;
1762 
1763  case 25:
1764 #line 256 "parser.y"
1765  {
1766  newstack(yyval)=code_skipt();
1767  }
1768 #line 1769 "jsil_y.tab.cpp"
1769  break;
1770 
1771  case 26:
1772 #line 260 "parser.y"
1773  {
1774  code_assignt a(parser_stack(yyvsp[-2]), parser_stack(yyvsp[0]));
1775  newstack(yyval).swap(a);
1776  }
1777 #line 1778 "jsil_y.tab.cpp"
1778  break;
1779 
1780  case 27:
1781 #line 265 "parser.y"
1782  {
1783  index_exprt i(parser_stack(yyvsp[-5]), parser_stack(yyvsp[-3]));
1784  code_assignt a(i, parser_stack(yyvsp[0]));
1785  newstack(yyval).swap(a);
1786  }
1787 #line 1788 "jsil_y.tab.cpp"
1788  break;
1789 
1790  case 29:
1791 #line 274 "parser.y"
1792  {
1793  side_effect_expr_function_callt f(parser_stack(yyvsp[-4]), {}, typet{}, {});
1794  if(parser_stack(yyvsp[-2]).is_not_nil())
1795  f.arguments().swap(parser_stack(yyvsp[-2]).operands());
1796 
1797  newstack(yyval).swap(f);
1798 
1799  if(parser_stack(yyvsp[0]).is_not_nil())
1800  {
1801  with_exprt w(parser_stack(yyval), parser_stack(yyvsp[0]), nil_exprt());
1802  parser_stack(yyval).swap(w);
1803  }
1804  }
1805 #line 1806 "jsil_y.tab.cpp"
1806  break;
1807 
1808  case 30:
1809 #line 288 "parser.y"
1810  {
1811  exprt n("new");
1812  newstack(yyval).swap(n);
1813  }
1814 #line 1815 "jsil_y.tab.cpp"
1815  break;
1816 
1817  case 31:
1818 #line 293 "parser.y"
1819  {
1820  exprt has_field("hasField");
1821  has_field.add_to_operands(std::move(parser_stack(yyvsp[-3])), std::move(parser_stack(yyvsp[-1])));
1822 
1823  newstack(yyval).swap(has_field);
1824  }
1825 #line 1826 "jsil_y.tab.cpp"
1826  break;
1827 
1828  case 32:
1829 #line 300 "parser.y"
1830  {
1831  index_exprt i(parser_stack(yyvsp[-3]), parser_stack(yyvsp[-1]));
1832  newstack(yyval).swap(i);
1833  }
1834 #line 1835 "jsil_y.tab.cpp"
1835  break;
1836 
1837  case 33:
1838 #line 305 "parser.y"
1839  {
1840  exprt d("delete");
1841  d.add_to_operands(std::move(parser_stack(yyvsp[-3])), std::move(parser_stack(yyvsp[-1])));
1842 
1843  newstack(yyval).swap(d);
1844  }
1845 #line 1846 "jsil_y.tab.cpp"
1846  break;
1847 
1848  case 34:
1849 #line 312 "parser.y"
1850  {
1851  exprt proto_field("protoField");
1852  proto_field.add_to_operands(std::move(parser_stack(yyvsp[-3])), std::move(parser_stack(yyvsp[-1])));
1853 
1854  newstack(yyval).swap(proto_field);
1855  }
1856 #line 1857 "jsil_y.tab.cpp"
1857  break;
1858 
1859  case 35:
1860 #line 319 "parser.y"
1861  {
1862  exprt proto_obj("protoObj");
1863  proto_obj.add_to_operands(std::move(parser_stack(yyvsp[-3])), std::move(parser_stack(yyvsp[-1])));
1864 
1865  newstack(yyval).swap(proto_obj);
1866  }
1867 #line 1868 "jsil_y.tab.cpp"
1868  break;
1869 
1870  case 36:
1871 #line 328 "parser.y"
1872  {
1873  newstack(yyval);
1874  }
1875 #line 1876 "jsil_y.tab.cpp"
1876  break;
1877 
1878  case 37:
1879 #line 332 "parser.y"
1880  {
1881  yyval=yyvsp[0];
1882  }
1883 #line 1884 "jsil_y.tab.cpp"
1884  break;
1885 
1886  case 38:
1887 #line 338 "parser.y"
1888  {
1889  newstack(yyval);
1890  }
1891 #line 1892 "jsil_y.tab.cpp"
1892  break;
1893 
1894  case 40:
1895 #line 345 "parser.y"
1896  {
1897  newstack(yyval).id(ID_expression_list);
1898  parser_stack(yyval).add_to_operands(std::move(parser_stack(yyvsp[0])));
1899  }
1900 #line 1901 "jsil_y.tab.cpp"
1901  break;
1902 
1903  case 41:
1904 #line 350 "parser.y"
1905  {
1906  yyval=yyvsp[-2];
1907  parser_stack(yyval).add_to_operands(std::move(parser_stack(yyvsp[0])));
1908  }
1909 #line 1910 "jsil_y.tab.cpp"
1910  break;
1911 
1912  case 43:
1913 #line 358 "parser.y"
1914  {
1915  yyval=yyvsp[-1];
1916  parser_stack(yyval).add_to_operands(std::move(parser_stack(yyvsp[-2])), std::move(parser_stack(yyvsp[0])));
1917  }
1918 #line 1919 "jsil_y.tab.cpp"
1919  break;
1920 
1921  case 45:
1922 #line 366 "parser.y"
1923  {
1924  yyval=yyvsp[-1];
1925  parser_stack(yyval).add_to_operands(std::move(parser_stack(yyvsp[0])));
1926  }
1927 #line 1928 "jsil_y.tab.cpp"
1928  break;
1929 
1930  case 46:
1931 #line 371 "parser.y"
1932  {
1933  yyval=yyvsp[-1];
1934  }
1935 #line 1936 "jsil_y.tab.cpp"
1936  break;
1937 
1938  case 47:
1939 #line 375 "parser.y"
1940  {
1941  exprt ref("ref");
1942  ref.add_to_operands(
1943  std::move(parser_stack(yyvsp[-5])),
1944  std::move(parser_stack(yyvsp[-3])),
1945  std::move(parser_stack(yyvsp[-1])));
1946 
1947  newstack(yyval).swap(ref);
1948  }
1949 #line 1950 "jsil_y.tab.cpp"
1950  break;
1951 
1952  case 48:
1953 #line 385 "parser.y"
1954  {
1955  exprt field("field");
1956  field.add_to_operands(std::move(parser_stack(yyvsp[-1])));
1957 
1958  newstack(yyval).swap(field);
1959  }
1960 #line 1961 "jsil_y.tab.cpp"
1961  break;
1962 
1963  case 49:
1964 #line 392 "parser.y"
1965  {
1966  exprt base(ID_base);
1967  base.add_to_operands(std::move(parser_stack(yyvsp[-1])));
1968 
1969  newstack(yyval).swap(base);
1970  }
1971 #line 1972 "jsil_y.tab.cpp"
1972  break;
1973 
1974  case 50:
1975 #line 399 "parser.y"
1976  {
1977  exprt typeof_expr(ID_typeof);
1978  typeof_expr.add_to_operands(std::move(parser_stack(yyvsp[-1])));
1979 
1980  newstack(yyval).swap(typeof_expr);
1981  }
1982 #line 1983 "jsil_y.tab.cpp"
1983  break;
1984 
1985  case 52:
1986 #line 409 "parser.y"
1987  {
1988  newstack(yyval).id(ID_null);
1989  }
1990 #line 1991 "jsil_y.tab.cpp"
1991  break;
1992 
1993  case 53:
1994 #line 413 "parser.y"
1995  {
1996  newstack(yyval).id("undefined");
1997  }
1998 #line 1999 "jsil_y.tab.cpp"
1999  break;
2000 
2001  case 54:
2002 #line 417 "parser.y"
2003  {
2004  newstack(yyval).id(ID_empty);
2005  }
2006 #line 2007 "jsil_y.tab.cpp"
2007  break;
2008 
2009  case 55:
2010 #line 421 "parser.y"
2011  {
2012  newstack(yyval) = true_exprt();
2013  }
2014 #line 2015 "jsil_y.tab.cpp"
2015  break;
2016 
2017  case 56:
2018 #line 425 "parser.y"
2019  {
2020  newstack(yyval) = false_exprt();
2021  }
2022 #line 2023 "jsil_y.tab.cpp"
2023  break;
2024 
2025  case 58:
2026 #line 430 "parser.y"
2027  {
2029  .get_value(), string_typet());
2030  parser_stack(yyval).swap(c);
2031  }
2032 #line 2033 "jsil_y.tab.cpp"
2033  break;
2034 
2035  case 62:
2036 #line 441 "parser.y"
2037  {
2038  newstack(yyval).id("proto");
2039  }
2040 #line 2041 "jsil_y.tab.cpp"
2041  break;
2042 
2043  case 63:
2044 #line 445 "parser.y"
2045  {
2046  newstack(yyval).id("fid");
2047  }
2048 #line 2049 "jsil_y.tab.cpp"
2049  break;
2050 
2051  case 64:
2052 #line 449 "parser.y"
2053  {
2054  newstack(yyval).id("scope");
2055  }
2056 #line 2057 "jsil_y.tab.cpp"
2057  break;
2058 
2059  case 65:
2060 #line 453 "parser.y"
2061  {
2062  newstack(yyval).id("constructid");
2063  }
2064 #line 2065 "jsil_y.tab.cpp"
2065  break;
2066 
2067  case 66:
2068 #line 457 "parser.y"
2069  {
2070  newstack(yyval).id("primvalue");
2071  }
2072 #line 2073 "jsil_y.tab.cpp"
2073  break;
2074 
2075  case 67:
2076 #line 461 "parser.y"
2077  {
2078  newstack(yyval).id("targetfunction");
2079  }
2080 #line 2081 "jsil_y.tab.cpp"
2081  break;
2082 
2083  case 68:
2084 #line 465 "parser.y"
2085  {
2086  newstack(yyval).id(ID_class);
2087  }
2088 #line 2089 "jsil_y.tab.cpp"
2089  break;
2090 
2091  case 73:
2092 #line 477 "parser.y"
2093  {
2094  newstack(yyval).id(ID_equal);
2095  }
2096 #line 2097 "jsil_y.tab.cpp"
2097  break;
2098 
2099  case 74:
2100 #line 481 "parser.y"
2101  {
2102  newstack(yyval).id(ID_lt);
2103  }
2104 #line 2105 "jsil_y.tab.cpp"
2105  break;
2106 
2107  case 75:
2108 #line 485 "parser.y"
2109  {
2110  newstack(yyval).id(ID_le);
2111  }
2112 #line 2113 "jsil_y.tab.cpp"
2113  break;
2114 
2115  case 76:
2116 #line 491 "parser.y"
2117  {
2118  newstack(yyval).id(ID_plus);
2119  }
2120 #line 2121 "jsil_y.tab.cpp"
2121  break;
2122 
2123  case 77:
2124 #line 495 "parser.y"
2125  {
2126  newstack(yyval).id(ID_minus);
2127  }
2128 #line 2129 "jsil_y.tab.cpp"
2129  break;
2130 
2131  case 78:
2132 #line 499 "parser.y"
2133  {
2134  newstack(yyval).id(ID_mult);
2135  }
2136 #line 2137 "jsil_y.tab.cpp"
2137  break;
2138 
2139  case 79:
2140 #line 503 "parser.y"
2141  {
2142  newstack(yyval).id(ID_div);
2143  }
2144 #line 2145 "jsil_y.tab.cpp"
2145  break;
2146 
2147  case 80:
2148 #line 507 "parser.y"
2149  {
2150  newstack(yyval).id(ID_mod);
2151  }
2152 #line 2153 "jsil_y.tab.cpp"
2153  break;
2154 
2155  case 81:
2156 #line 513 "parser.y"
2157  {
2158  newstack(yyval).id(ID_and);
2159  }
2160 #line 2161 "jsil_y.tab.cpp"
2161  break;
2162 
2163  case 82:
2164 #line 517 "parser.y"
2165  {
2166  newstack(yyval).id(ID_or);
2167  }
2168 #line 2169 "jsil_y.tab.cpp"
2169  break;
2170 
2171  case 83:
2172 #line 521 "parser.y"
2173  {
2174  newstack(yyval).id("subtype_of");
2175  }
2176 #line 2177 "jsil_y.tab.cpp"
2177  break;
2178 
2179  case 84:
2180 #line 525 "parser.y"
2181  {
2182  newstack(yyval).id(ID_concatenation);
2183  }
2184 #line 2185 "jsil_y.tab.cpp"
2185  break;
2186 
2187  case 85:
2188 #line 531 "parser.y"
2189  {
2190  newstack(yyval).id(ID_bitand);
2191  }
2192 #line 2193 "jsil_y.tab.cpp"
2193  break;
2194 
2195  case 86:
2196 #line 535 "parser.y"
2197  {
2198  newstack(yyval).id(ID_bitor);
2199  }
2200 #line 2201 "jsil_y.tab.cpp"
2201  break;
2202 
2203  case 87:
2204 #line 539 "parser.y"
2205  {
2206  newstack(yyval).id(ID_bitxor);
2207  }
2208 #line 2209 "jsil_y.tab.cpp"
2209  break;
2210 
2211  case 88:
2212 #line 543 "parser.y"
2213  {
2214  newstack(yyval).id(ID_shl);
2215  }
2216 #line 2217 "jsil_y.tab.cpp"
2217  break;
2218 
2219  case 89:
2220 #line 547 "parser.y"
2221  {
2222  newstack(yyval).id(ID_shr);
2223  }
2224 #line 2225 "jsil_y.tab.cpp"
2225  break;
2226 
2227  case 90:
2228 #line 551 "parser.y"
2229  {
2230  newstack(yyval).id(ID_lshr);
2231  }
2232 #line 2233 "jsil_y.tab.cpp"
2233  break;
2234 
2235  case 91:
2236 #line 557 "parser.y"
2237  {
2238  newstack(yyval).id(ID_not);
2239  }
2240 #line 2241 "jsil_y.tab.cpp"
2241  break;
2242 
2243  case 92:
2244 #line 561 "parser.y"
2245  {
2246  newstack(yyval).id(ID_unary_minus);
2247  }
2248 #line 2249 "jsil_y.tab.cpp"
2249  break;
2250 
2251  case 93:
2252 #line 565 "parser.y"
2253  {
2254  newstack(yyval).id("num_to_string");
2255  }
2256 #line 2257 "jsil_y.tab.cpp"
2257  break;
2258 
2259  case 94:
2260 #line 569 "parser.y"
2261  {
2262  newstack(yyval).id("string_to_num");
2263  }
2264 #line 2265 "jsil_y.tab.cpp"
2265  break;
2266 
2267  case 95:
2268 #line 573 "parser.y"
2269  {
2270  newstack(yyval).id("num_to_int32");
2271  }
2272 #line 2273 "jsil_y.tab.cpp"
2273  break;
2274 
2275  case 96:
2276 #line 577 "parser.y"
2277  {
2278  newstack(yyval).id("num_to_uint32");
2279  }
2280 #line 2281 "jsil_y.tab.cpp"
2281  break;
2282 
2283  case 97:
2284 #line 581 "parser.y"
2285  {
2286  newstack(yyval).id(ID_bitnot);
2287  }
2288 #line 2289 "jsil_y.tab.cpp"
2289  break;
2290 
2291  case 98:
2292 #line 587 "parser.y"
2293  {
2294  newstack(yyval).id("null_type");
2295  }
2296 #line 2297 "jsil_y.tab.cpp"
2297  break;
2298 
2299  case 99:
2300 #line 591 "parser.y"
2301  {
2302  newstack(yyval).id("undefined_type");
2303  }
2304 #line 2305 "jsil_y.tab.cpp"
2305  break;
2306 
2307  case 100:
2308 #line 595 "parser.y"
2309  {
2310  newstack(yyval).id(ID_boolean);
2311  }
2312 #line 2313 "jsil_y.tab.cpp"
2313  break;
2314 
2315  case 101:
2316 #line 599 "parser.y"
2317  {
2318  newstack(yyval).id(ID_string);
2319  }
2320 #line 2321 "jsil_y.tab.cpp"
2321  break;
2322 
2323  case 102:
2324 #line 603 "parser.y"
2325  {
2326  newstack(yyval).id("number");
2327  }
2328 #line 2329 "jsil_y.tab.cpp"
2329  break;
2330 
2331  case 103:
2332 #line 607 "parser.y"
2333  {
2334  newstack(yyval).id("builtin_object");
2335  }
2336 #line 2337 "jsil_y.tab.cpp"
2337  break;
2338 
2339  case 104:
2340 #line 611 "parser.y"
2341  {
2342  newstack(yyval).id("user_object");
2343  }
2344 #line 2345 "jsil_y.tab.cpp"
2345  break;
2346 
2347  case 105:
2348 #line 615 "parser.y"
2349  {
2350  newstack(yyval).id("object");
2351  }
2352 #line 2353 "jsil_y.tab.cpp"
2353  break;
2354 
2355  case 107:
2356 #line 620 "parser.y"
2357  {
2358  newstack(yyval).id(ID_pointer);
2359  newstack(yyval).set(ID_C_reference, true);
2360  }
2361 #line 2362 "jsil_y.tab.cpp"
2362  break;
2363 
2364  case 108:
2365 #line 627 "parser.y"
2366  {
2367  newstack(yyval).id(ID_member);
2368  }
2369 #line 2370 "jsil_y.tab.cpp"
2370  break;
2371 
2372  case 109:
2373 #line 631 "parser.y"
2374  {
2375  newstack(yyval).id("variable");
2376  }
2377 #line 2378 "jsil_y.tab.cpp"
2378  break;
2379 
2380 
2381 #line 2382 "jsil_y.tab.cpp"
2382 
2383  default: break;
2384  }
2385  /* User semantic actions sometimes alter yychar, and that requires
2386  that yytoken be updated with the new translation. We take the
2387  approach of translating immediately before every use of yytoken.
2388  One alternative is translating here after every semantic action,
2389  but that translation would be missed if the semantic action invokes
2390  YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
2391  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
2392  incorrect destructor might then be invoked immediately. In the
2393  case of YYERROR or YYBACKUP, subsequent parser actions might lead
2394  to an incorrect destructor call or verbose syntax error message
2395  before the lookahead is translated. */
2396  YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc);
2397 
2398  YYPOPSTACK (yylen);
2399  yylen = 0;
2400 
2401  *++yyvsp = yyval;
2402 
2403  /* Now 'shift' the result of the reduction. Determine what state
2404  that goes to, based on the state we popped back to and the rule
2405  number reduced by. */
2406  {
2407  const int yylhs = yyr1[yyn] - YYNTOKENS;
2408  const int yyi = yypgoto[yylhs] + *yyssp;
2409  yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
2410  ? yytable[yyi]
2411  : yydefgoto[yylhs]);
2412  }
2413 
2414  goto yynewstate;
2415 
2416 
2417 /*--------------------------------------.
2418 | yyerrlab -- here on detecting error. |
2419 `--------------------------------------*/
2420 yyerrlab:
2421  /* Make sure we have latest lookahead translation. See comments at
2422  user semantic actions for why this is necessary. */
2423  yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar);
2424  /* If not already recovering from an error, report this error. */
2425  if (!yyerrstatus)
2426  {
2427  ++yynerrs;
2428  yyerror (YY_("syntax error"));
2429  }
2430 
2431  if (yyerrstatus == 3)
2432  {
2433  /* If just tried and failed to reuse lookahead token after an
2434  error, discard it. */
2435 
2436  if (yychar <= YYEOF)
2437  {
2438  /* Return failure if at end of input. */
2439  if (yychar == YYEOF)
2440  YYABORT;
2441  }
2442  else
2443  {
2444  yydestruct ("Error: discarding",
2445  yytoken, &yylval);
2446  yychar = YYEMPTY;
2447  }
2448  }
2449 
2450  /* Else will try to reuse lookahead token after shifting the error
2451  token. */
2452  goto yyerrlab1;
2453 
2454 
2455 /*---------------------------------------------------.
2456 | yyerrorlab -- error raised explicitly by YYERROR. |
2457 `---------------------------------------------------*/
2458 yyerrorlab:
2459  /* Pacify compilers when the user code never invokes YYERROR and the
2460  label yyerrorlab therefore never appears in user code. */
2461  if (0)
2462  YYERROR;
2463 
2464  /* Do not reclaim the symbols of the rule whose action triggered
2465  this YYERROR. */
2466  YYPOPSTACK (yylen);
2467  yylen = 0;
2468  YY_STACK_PRINT (yyss, yyssp);
2469  yystate = *yyssp;
2470  goto yyerrlab1;
2471 
2472 
2473 /*-------------------------------------------------------------.
2474 | yyerrlab1 -- common code for both syntax error and YYERROR. |
2475 `-------------------------------------------------------------*/
2476 yyerrlab1:
2477  yyerrstatus = 3; /* Each real token shifted decrements this. */
2478 
2479  /* Pop stack until we find a state that shifts the error token. */
2480  for (;;)
2481  {
2482  yyn = yypact[yystate];
2483  if (!yypact_value_is_default (yyn))
2484  {
2485  yyn += YYSYMBOL_YYerror;
2486  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
2487  {
2488  yyn = yytable[yyn];
2489  if (0 < yyn)
2490  break;
2491  }
2492  }
2493 
2494  /* Pop the current state because it cannot handle the error token. */
2495  if (yyssp == yyss)
2496  YYABORT;
2497 
2498 
2499  yydestruct ("Error: popping",
2500  YY_ACCESSING_SYMBOL (yystate), yyvsp);
2501  YYPOPSTACK (1);
2502  yystate = *yyssp;
2503  YY_STACK_PRINT (yyss, yyssp);
2504  }
2505 
2507  *++yyvsp = yylval;
2509 
2510 
2511  /* Shift the error token. */
2512  YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp);
2513 
2514  yystate = yyn;
2515  goto yynewstate;
2516 
2517 
2518 /*-------------------------------------.
2519 | yyacceptlab -- YYACCEPT comes here. |
2520 `-------------------------------------*/
2521 yyacceptlab:
2522  yyresult = 0;
2523  goto yyreturn;
2524 
2525 
2526 /*-----------------------------------.
2527 | yyabortlab -- YYABORT comes here. |
2528 `-----------------------------------*/
2529 yyabortlab:
2530  yyresult = 1;
2531  goto yyreturn;
2532 
2533 
2534 #if !defined yyoverflow
2535 /*-------------------------------------------------.
2536 | yyexhaustedlab -- memory exhaustion comes here. |
2537 `-------------------------------------------------*/
2538 yyexhaustedlab:
2539  yyerror (YY_("memory exhausted"));
2540  yyresult = 2;
2541  /* Fall through. */
2542 #endif
2543 
2544 
2545 /*-----------------------------------------------------.
2546 | yyreturn -- parsing is finished, return the result. |
2547 `-----------------------------------------------------*/
2548 yyreturn:
2549  if (yychar != YYEMPTY)
2550  {
2551  /* Make sure we have latest lookahead translation. See comments at
2552  user semantic actions for why this is necessary. */
2553  yytoken = YYTRANSLATE (yychar);
2554  yydestruct ("Cleanup: discarding lookahead",
2555  yytoken, &yylval);
2556  }
2557  /* Do not reclaim the symbols of the rule whose action triggered
2558  this YYABORT or YYACCEPT. */
2559  YYPOPSTACK (yylen);
2560  YY_STACK_PRINT (yyss, yyssp);
2561  while (yyssp != yyss)
2562  {
2563  yydestruct ("Cleanup: popping",
2564  YY_ACCESSING_SYMBOL (+*yyssp), yyvsp);
2565  YYPOPSTACK (1);
2566  }
2567 #ifndef yyoverflow
2568  if (yyss != yyssa)
2569  YYSTACK_FREE (yyss);
2570 #endif
2571 
2572  return yyresult;
2573 }
2574 
2575 #line 636 "parser.y"
2576 
with_exprt
Operator to update elements in structs and arrays.
Definition: std_expr.h:3079
jsil_declarationt
Definition: jsil_parse_tree.h:24
YYSYMBOL_YYACCEPT
@ YYSYMBOL_YYACCEPT
Definition: jsil_y.tab.cpp:323
YYSYMBOL_TOK_HAS_FIELD
@ YYSYMBOL_TOK_HAS_FIELD
Definition: jsil_y.tab.cpp:254
YYSYMBOL_TOK_NEWLINE
@ YYSYMBOL_TOK_NEWLINE
Definition: jsil_y.tab.cpp:243
code_blockt
A codet representing sequential composition of program statements.
Definition: std_code.h:173
YYSYMBOL_program
@ YYSYMBOL_program
Definition: jsil_y.tab.cpp:324
YYSYMBOL_83_
@ YYSYMBOL_83_
Definition: jsil_y.tab.cpp:322
yyjsilparse
int yyjsilparse(void)
Definition: jsil_y.tab.cpp:1343
TOK_UNDEFINED
@ TOK_UNDEFINED
Definition: jsil_y.tab.h:78
yylex
#define yylex
Definition: jsil_y.tab.cpp:69
TOK_FLOATING
@ TOK_FLOATING
Definition: ansi_c_y.tab.h:119
malloc
void * malloc(unsigned)
yylval
#define yylval
Definition: jsil_y.tab.cpp:73
yydestruct
static void yydestruct(const char *yymsg, yysymbol_kind_t yykind, unsigned *yyvaluep)
Definition: jsil_y.tab.cpp:1313
TOK_AND
@ TOK_AND
Definition: jsil_y.tab.h:106
TOK_LEQ
@ TOK_LEQ
Definition: jsil_y.tab.h:105
TOK_PROTO_FIELD
@ TOK_PROTO_FIELD
Definition: jsil_y.tab.h:71
YYSYMBOL_TOK_SIGNED_RIGHT_SHIFT
@ YYSYMBOL_TOK_SIGNED_RIGHT_SHIFT
Definition: jsil_y.tab.cpp:295
yynerrs
#define yynerrs
Definition: jsil_y.tab.cpp:72
YYLAST
#define YYLAST
Definition: jsil_y.tab.cpp:660
yysymbol_kind_t
yysymbol_kind_t
Definition: ansi_c_y.tab.cpp:389
YYSYMBOL_proc_ident_expr
@ YYSYMBOL_proc_ident_expr
Definition: jsil_y.tab.cpp:328
free
void free(void *)
YYSYMBOL_TOK_PROTO_OBJ
@ YYSYMBOL_TOK_PROTO_OBJ
Definition: jsil_y.tab.cpp:257
TOK_LABEL
@ TOK_LABEL
Definition: jsil_y.tab.h:64
YYSYMBOL_TOK_EMPTY
@ YYSYMBOL_TOK_EMPTY
Definition: jsil_y.tab.cpp:264
YYSYMBOL_73_
@ YYSYMBOL_73_
Definition: jsil_y.tab.cpp:312
YYSYMBOL_TOK_STRING
@ YYSYMBOL_TOK_STRING
Definition: jsil_y.tab.cpp:300
YYSYMBOL_78_
@ YYSYMBOL_78_
Definition: jsil_y.tab.cpp:317
YYSYMBOL_TOK_TRUE
@ YYSYMBOL_TOK_TRUE
Definition: jsil_y.tab.cpp:265
YYSYMBOL_TOK_STRING_TO_NUM
@ YYSYMBOL_TOK_STRING_TO_NUM
Definition: jsil_y.tab.cpp:275
YYSYMBOL_TOK_FID
@ YYSYMBOL_TOK_FID
Definition: jsil_y.tab.cpp:268
YYSYMBOL_TOK_PROTO_FIELD
@ YYSYMBOL_TOK_PROTO_FIELD
Definition: jsil_y.tab.cpp:256
typet
The type of an expression, extends irept.
Definition: type.h:29
TOK_STRING_TO_NUM
@ TOK_STRING_TO_NUM
Definition: jsil_y.tab.h:90
code_typet::parameterst
std::vector< parametert > parameterst
Definition: std_types.h:738
YYSYMBOL_81_
@ YYSYMBOL_81_
Definition: jsil_y.tab.cpp:320
TOK_LEFT_SHIFT
@ TOK_LEFT_SHIFT
Definition: jsil_y.tab.h:109
TOK_PROTO_OBJ
@ TOK_PROTO_OBJ
Definition: jsil_y.tab.h:72
YYSYMBOL_TOK_T_OBJECT
@ YYSYMBOL_TOK_T_OBJECT
Definition: jsil_y.tab.cpp:287
TOK_BUILTIN_LOC
@ TOK_BUILTIN_LOC
Definition: jsil_y.tab.h:116
side_effect_expr_function_callt
A side_effect_exprt representation of a function call side effect.
Definition: std_code.h:2127
TOK_NUM_TO_UINT32
@ TOK_NUM_TO_UINT32
Definition: jsil_y.tab.h:92
YYSYMBOL_TOK_SUBTYPE_OF
@ YYSYMBOL_TOK_SUBTYPE_OF
Definition: jsil_y.tab.cpp:293
TOK_OR
@ TOK_OR
Definition: jsil_y.tab.h:107
YYSYMBOL_69_
@ YYSYMBOL_69_
Definition: jsil_y.tab.cpp:308
code_typet::parametert::set_identifier
void set_identifier(const irep_idt &identifier)
Definition: std_types.h:782
YYSYMBOL_TOK_TO
@ YYSYMBOL_TOK_TO
Definition: jsil_y.tab.cpp:246
yytype_uint16
unsigned short yytype_uint16
Definition: jsil_y.tab.cpp:411
symbol_exprt::typeless
static symbol_exprt typeless(const irep_idt &id)
Generate a symbol_exprt without a proper type.
Definition: std_expr.h:101
YYSYMBOL_70_
@ YYSYMBOL_70_
Definition: jsil_y.tab.cpp:309
TOK_T_BOOLEAN
@ TOK_T_BOOLEAN
Definition: jsil_y.tab.h:97
TOK_SIGNED_RIGHT_SHIFT
@ TOK_SIGNED_RIGHT_SHIFT
Definition: jsil_y.tab.h:110
YY_SYMBOL_PRINT
#define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
Definition: jsil_y.tab.cpp:1281
TOK_EVAL
@ TOK_EVAL
Definition: jsil_y.tab.h:63
YYSYMBOL_TOK_TYPEOF
@ YYSYMBOL_TOK_TYPEOF
Definition: jsil_y.tab.cpp:261
YYSYMBOL_TOK_UNDEFINED
@ YYSYMBOL_TOK_UNDEFINED
Definition: jsil_y.tab.cpp:263
yytype_int8
signed char yytype_int8
Definition: jsil_y.tab.cpp:383
TOK_NEW
@ TOK_NEW
Definition: ansi_c_y.tab.h:228
TOK_T_REFERENCE
@ TOK_T_REFERENCE
Definition: jsil_y.tab.h:103
TOK_IDENTIFIER
@ TOK_IDENTIFIER
Definition: ansi_c_y.tab.h:116
to_string_constant
const string_constantt & to_string_constant(const exprt &expr)
Definition: string_constant.h:31
jsil_parser.h
YYSYMBOL_66_
@ YYSYMBOL_66_
Definition: jsil_y.tab.cpp:305
string_constant.h
YYSYMBOL_72_
@ YYSYMBOL_72_
Definition: jsil_y.tab.cpp:311
TOK_SCANNER_ERROR
@ TOK_SCANNER_ERROR
Definition: ansi_c_y.tab.h:216
exprt
Base class for all expressions.
Definition: expr.h:53
YY_ATTRIBUTE_UNUSED
#define YY_ATTRIBUTE_UNUSED
Definition: jsil_y.tab.cpp:485
YYSYMBOL_expressions_opt
@ YYSYMBOL_expressions_opt
Definition: jsil_y.tab.cpp:337
YYSIZEOF
#define YYSIZEOF(X)
Definition: jsil_y.tab.cpp:451
yyalloc::yyss_alloc
yy_state_t yyss_alloc
Definition: ansi_c_y.tab.cpp:1074
yy_state_t
yytype_int16 yy_state_t
Definition: ansi_c_y.tab.cpp:925
YYSYMBOL_TOK_SCOPE
@ YYSYMBOL_TOK_SCOPE
Definition: jsil_y.tab.cpp:269
YYSYMBOL_TOK_DELETE
@ YYSYMBOL_TOK_DELETE
Definition: jsil_y.tab.cpp:255
YYPTRDIFF_T
#define YYPTRDIFF_T
Definition: jsil_y.tab.cpp:427
YYSYMBOL_YYEOF
@ YYSYMBOL_YYEOF
Definition: jsil_y.tab.cpp:239
YY_IGNORE_MAYBE_UNINITIALIZED_END
#define YY_IGNORE_MAYBE_UNINITIALIZED_END
Definition: jsil_y.tab.cpp:509
YYSTYPE
#define YYSTYPE
Definition: jsil_y.tab.cpp:88
TOK_GOTO
@ TOK_GOTO
Definition: ansi_c_y.tab.h:73
YYSYMBOL_TOK_LEQ
@ YYSYMBOL_TOK_LEQ
Definition: jsil_y.tab.cpp:290
YYSYMBOL_TOK_REF
@ YYSYMBOL_TOK_REF
Definition: jsil_y.tab.cpp:258
YYSYMBOL_TOK_T_BOOLEAN
@ YYSYMBOL_TOK_T_BOOLEAN
Definition: jsil_y.tab.cpp:282
jsil_declarationt::add_throws
void add_throws(const irep_idt &value, const irep_idt &label)
Definition: jsil_parse_tree.h:63
YYSYMBOL_77_
@ YYSYMBOL_77_
Definition: jsil_y.tab.cpp:316
YYSYMBOL_TOK_NEW
@ YYSYMBOL_TOK_NEW
Definition: jsil_y.tab.cpp:253
YY_STACK_PRINT
#define YY_STACK_PRINT(Bottom, Top)
Definition: jsil_y.tab.cpp:1282
newstack
#define newstack(x)
Definition: parser.h:142
symbol_exprt
Expression to hold a symbol (variable)
Definition: std_expr.h:82
YYSYMBOL_YYerror
@ YYSYMBOL_YYerror
Definition: jsil_y.tab.cpp:240
TOK_SPEC_IDENTIFIER
@ TOK_SPEC_IDENTIFIER
Definition: jsil_y.tab.h:118
YYSYMBOL_TOK_UNSIGNED_RIGHT_SHIFT
@ YYSYMBOL_TOK_UNSIGNED_RIGHT_SHIFT
Definition: jsil_y.tab.cpp:296
YYSYMBOL_TOK_FLOATING
@ YYSYMBOL_TOK_FLOATING
Definition: jsil_y.tab.cpp:299
TOK_FALSE
@ TOK_FALSE
Definition: ansi_c_y.tab.h:203
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
Definition: jsil_y.tab.cpp:508
YYSYMBOL_TOK_PRIMVALUE
@ YYSYMBOL_TOK_PRIMVALUE
Definition: jsil_y.tab.cpp:271
YYEMPTY
@ YYEMPTY
Definition: ansi_c_y.tab.h:53
TOK_SKIP
@ TOK_SKIP
Definition: jsil_y.tab.h:66
yysymbol_kind_t
yysymbol_kind_t
Definition: jsil_y.tab.cpp:237
code_ifthenelset
codet representation of an if-then-else statement.
Definition: std_code.h:749
YYSYMBOL_jsil_type
@ YYSYMBOL_jsil_type
Definition: jsil_y.tab.cpp:349
TOK_TO
@ TOK_TO
Definition: jsil_y.tab.h:61
YYSYMBOL_TOK_SCANNER_ERROR
@ YYSYMBOL_TOK_SCANNER_ERROR
Definition: jsil_y.tab.cpp:242
yyjsiltext
char * yyjsiltext
Definition: jsil_lex.yy.cpp:1475
to_code
const codet & to_code(const exprt &expr)
Definition: std_code.h:158
YYSYMBOL_procedure_decl
@ YYSYMBOL_procedure_decl
Definition: jsil_y.tab.cpp:326
yy_state_t
yytype_uint8 yy_state_t
Definition: jsil_y.tab.cpp:455
YYSYMBOL_TOK_T_NULL
@ YYSYMBOL_TOK_T_NULL
Definition: jsil_y.tab.cpp:280
YYSTYPE
Definition: xml_y.tab.cpp:170
TOK_UNSIGNED_RIGHT_SHIFT
@ TOK_UNSIGNED_RIGHT_SHIFT
Definition: jsil_y.tab.h:111
YYSYMBOL_rhs
@ YYSYMBOL_rhs
Definition: jsil_y.tab.cpp:335
jsil_declarationt::add_returns
void add_returns(const irep_idt &value, const irep_idt &label)
Definition: jsil_parse_tree.h:45
YYSYMBOL_proc_ident
@ YYSYMBOL_proc_ident
Definition: jsil_y.tab.cpp:327
TOK_MEMBER_REFERENCE
@ TOK_MEMBER_REFERENCE
Definition: jsil_y.tab.h:93
YYSYMBOL_TOK_T_USER_OBJECT
@ YYSYMBOL_TOK_T_USER_OBJECT
Definition: jsil_y.tab.cpp:286
YYSYMBOL_binary_op
@ YYSYMBOL_binary_op
Definition: jsil_y.tab.cpp:343
YYMAXDEPTH
#define YYMAXDEPTH
Definition: jsil_y.tab.cpp:1300
exprt::type
typet & type()
Return the type of the expression.
Definition: expr.h:81
jsil_y.tab.h
YYSYMBOL_TOK_NUM_TO_STRING
@ YYSYMBOL_TOK_NUM_TO_STRING
Definition: jsil_y.tab.cpp:274
TOK_BUILTIN_IDENTIFIER
@ TOK_BUILTIN_IDENTIFIER
Definition: jsil_y.tab.h:117
YYSYMBOL_TOK_CLASS
@ YYSYMBOL_TOK_CLASS
Definition: jsil_y.tab.cpp:273
yycheck
static const yytype_int16 yycheck[]
Definition: jsil_y.tab.cpp:970
yydebug
#define yydebug
Definition: jsil_y.tab.cpp:71
TOK_SCOPE
@ TOK_SCOPE
Definition: ansi_c_y.tab.h:242
TOK_PROTO
@ TOK_PROTO
Definition: jsil_y.tab.h:82
TOK_PROCEDURE
@ TOK_PROCEDURE
Definition: jsil_y.tab.h:59
YYSYMBOL_TOK_T_NUMBER
@ YYSYMBOL_TOK_T_NUMBER
Definition: jsil_y.tab.cpp:284
YYSYMBOL_TOK_PROTO
@ YYSYMBOL_TOK_PROTO
Definition: jsil_y.tab.cpp:267
YYSYMBOL_TOK_FIELD
@ YYSYMBOL_TOK_FIELD
Definition: jsil_y.tab.cpp:259
yytype_uint8
unsigned char yytype_uint8
Definition: ansi_c_y.tab.cpp:870
yyr2
static const yytype_int8 yyr2[]
Definition: jsil_y.tab.cpp:1103
yy_state_fast_t
int yy_state_fast_t
Definition: jsil_y.tab.cpp:458
YYSYMBOL_TOK_SKIP
@ YYSYMBOL_TOK_SKIP
Definition: jsil_y.tab.cpp:251
yytokentype
yytokentype
Definition: ansi_c_y.tab.h:52
YYSTACK_ALLOC
#define YYSTACK_ALLOC
Definition: jsil_y.tab.cpp:569
YY_ACCESSING_SYMBOL
#define YY_ACCESSING_SYMBOL(State)
Accessing symbol of state STATE.
Definition: jsil_y.tab.cpp:738
YYSYMBOL_75_
@ YYSYMBOL_75_
Definition: jsil_y.tab.cpp:314
YYSTACK_RELOCATE
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
Definition: jsil_y.tab.cpp:624
YYSYMBOL_expression
@ YYSYMBOL_expression
Definition: jsil_y.tab.cpp:339
TOK_HAS_FIELD
@ TOK_HAS_FIELD
Definition: jsil_y.tab.h:69
YY_ASSERT
#define YY_ASSERT(E)
Definition: jsil_y.tab.cpp:528
YYSYMBOL_TOK_T_REFERENCE
@ YYSYMBOL_TOK_T_REFERENCE
Definition: jsil_y.tab.cpp:288
yyjsillex
int yyjsillex()
The main scanner function which does all the work.
Definition: jsil_lex.yy.cpp:1730
YYSYMBOL_TOK_T_BUILTIN_OBJECT
@ YYSYMBOL_TOK_T_BUILTIN_OBJECT
Definition: jsil_y.tab.cpp:285
YYSYMBOL_TOK_RETURNS
@ YYSYMBOL_TOK_RETURNS
Definition: jsil_y.tab.cpp:245
forall_operands
#define forall_operands(it, expr)
Definition: expr.h:18
YYSYMBOL_compare_op
@ YYSYMBOL_compare_op
Definition: jsil_y.tab.cpp:344
YY_IGNORE_USELESS_CAST_BEGIN
#define YY_IGNORE_USELESS_CAST_BEGIN
Definition: jsil_y.tab.cpp:523
YYSYMBOL_statements
@ YYSYMBOL_statements
Definition: jsil_y.tab.cpp:332
YYNSTATES
#define YYNSTATES
Definition: jsil_y.tab.cpp:669
YYSYMBOL_TOK_WITH
@ YYSYMBOL_TOK_WITH
Definition: jsil_y.tab.cpp:252
code_gotot
codet representation of a goto statement.
Definition: std_code.h:1130
code_labelt
codet representation of a label for branch targets.
Definition: std_code.h:1378
symbol_exprt::get_identifier
const irep_idt & get_identifier() const
Definition: std_expr.h:111
nil_exprt
The NIL expression.
Definition: std_expr.h:4002
YYSYMBOL_parameters
@ YYSYMBOL_parameters
Definition: jsil_y.tab.cpp:330
TOK_NUM_TO_STRING
@ TOK_NUM_TO_STRING
Definition: jsil_y.tab.h:89
YYSYMBOL_TOK_NULL
@ YYSYMBOL_TOK_NULL
Definition: jsil_y.tab.cpp:262
YYSYMBOL_71_
@ YYSYMBOL_71_
Definition: jsil_y.tab.cpp:310
YYSYMBOL_bitwise_op
@ YYSYMBOL_bitwise_op
Definition: jsil_y.tab.cpp:347
YYSYMBOL_79_
@ YYSYMBOL_79_
Definition: jsil_y.tab.cpp:318
YYSYMBOL_TOK_BUILTIN_LOC
@ YYSYMBOL_TOK_BUILTIN_LOC
Definition: jsil_y.tab.cpp:301
TOK_STRING
@ TOK_STRING
Definition: ansi_c_y.tab.h:121
yypgoto
static const yytype_int16 yypgoto[]
Definition: jsil_y.tab.cpp:862
YYSYMBOL_atom_expression
@ YYSYMBOL_atom_expression
Definition: jsil_y.tab.cpp:340
YYSYMBOL_YYEMPTY
@ YYSYMBOL_YYEMPTY
Definition: jsil_y.tab.cpp:238
yychar
#define yychar
Definition: jsil_y.tab.cpp:74
yyerror
#define yyerror
Definition: jsil_y.tab.cpp:70
yytype_uint8
unsigned char yytype_uint8
Definition: jsil_y.tab.cpp:400
YYSYMBOL_65_
@ YYSYMBOL_65_
Definition: jsil_y.tab.cpp:304
YY_
#define YY_(Msgid)
Definition: jsil_y.tab.cpp:468
YYSYMBOL_arithmetic_op
@ YYSYMBOL_arithmetic_op
Definition: jsil_y.tab.cpp:345
YY_NULLPTR
#define YY_NULLPTR
Definition: jsil_y.tab.cpp:131
TOK_FID
@ TOK_FID
Definition: jsil_y.tab.h:83
to_symbol_expr
const symbol_exprt & to_symbol_expr(const exprt &expr)
Cast an exprt to a symbol_exprt.
Definition: std_expr.h:177
YYSTACK_FREE
#define YYSTACK_FREE
Definition: jsil_y.tab.cpp:570
code_typet
Base type of functions.
Definition: std_types.h:736
YYACCEPT
#define YYACCEPT
Definition: jsil_y.tab.cpp:1124
YYSYMBOL_statements_opt
@ YYSYMBOL_statements_opt
Definition: jsil_y.tab.cpp:331
false_exprt
The Boolean constant false.
Definition: std_expr.h:3993
TOK_RETURNS
@ TOK_RETURNS
Definition: jsil_y.tab.h:60
YYSYMBOL_TOK_CONSTRUCTID
@ YYSYMBOL_TOK_CONSTRUCTID
Definition: jsil_y.tab.cpp:270
YYSYMBOL_parameters_opt
@ YYSYMBOL_parameters_opt
Definition: jsil_y.tab.cpp:329
yyalloc::yyvs_alloc
unsigned yyvs_alloc
Definition: ansi_c_y.tab.cpp:1075
YYSYMBOL_TOK_NOT
@ YYSYMBOL_TOK_NOT
Definition: jsil_y.tab.cpp:297
YYSYMBOL_TOK_T_STRING
@ YYSYMBOL_TOK_T_STRING
Definition: jsil_y.tab.cpp:283
YYINITDEPTH
#define YYINITDEPTH
Definition: jsil_y.tab.cpp:1289
YYFINAL
#define YYFINAL
Definition: jsil_y.tab.cpp:658
TOK_DELETE
@ TOK_DELETE
Definition: ansi_c_y.tab.h:222
YYNTOKENS
#define YYNTOKENS
Definition: jsil_y.tab.cpp:663
TOK_FIELD
@ TOK_FIELD
Definition: jsil_y.tab.h:74
YYSYMBOL_boolean_op
@ YYSYMBOL_boolean_op
Definition: jsil_y.tab.cpp:346
YYSYMBOL_80_
@ YYSYMBOL_80_
Definition: jsil_y.tab.cpp:319
YYERROR
#define YYERROR
Definition: jsil_y.tab.cpp:1126
std_code.h
YYSYMBOL_TOK_AND
@ YYSYMBOL_TOK_AND
Definition: jsil_y.tab.cpp:291
YYSYMBOL_statement
@ YYSYMBOL_statement
Definition: jsil_y.tab.cpp:333
jsil_declarationt::add_value
void add_value(const code_blockt &code)
Definition: jsil_parse_tree.h:81
yyr1
static const yytype_int8 yyr1[]
Definition: jsil_y.tab.cpp:1087
yytable_value_is_error
#define yytable_value_is_error(Yyn)
Definition: jsil_y.tab.cpp:805
TOK_TRUE
@ TOK_TRUE
Definition: ansi_c_y.tab.h:202
TOK_NOT
@ TOK_NOT
Definition: jsil_y.tab.h:112
YYSYMBOL_TOK_THROWS
@ YYSYMBOL_TOK_THROWS
Definition: jsil_y.tab.cpp:247
TOK_T_NUMBER
@ TOK_T_NUMBER
Definition: jsil_y.tab.h:99
yypact_value_is_default
#define yypact_value_is_default(Yyn)
Definition: jsil_y.tab.cpp:800
YYSYMBOL_67_
@ YYSYMBOL_67_
Definition: jsil_y.tab.cpp:306
YYABORT
#define YYABORT
Definition: jsil_y.tab.cpp:1125
yydefact
static const yytype_int8 yydefact[]
Definition: jsil_y.tab.cpp:837
YYSYMBOL_YYUNDEF
@ YYSYMBOL_YYUNDEF
Definition: jsil_y.tab.cpp:241
YYSYMBOL_TOK_BASE
@ YYSYMBOL_TOK_BASE
Definition: jsil_y.tab.cpp:260
YY_CAST
#define YY_CAST(Type, Val)
Definition: jsil_y.tab.cpp:119
YYSYMBOL_TOK_IDENTIFIER
@ YYSYMBOL_TOK_IDENTIFIER
Definition: jsil_y.tab.cpp:298
YYSYMBOL_TOK_EVAL
@ YYSYMBOL_TOK_EVAL
Definition: jsil_y.tab.cpp:248
yytype_int16
short yytype_int16
Definition: jsil_y.tab.cpp:391
YYSYMBOL_76_
@ YYSYMBOL_76_
Definition: jsil_y.tab.cpp:315
yytype_int8
signed char yytype_int8
Definition: ansi_c_y.tab.cpp:853
YYTRANSLATE
#define YYTRANSLATE(YYX)
Definition: jsil_y.tab.cpp:676
code_skipt
A codet representing a skip statement.
Definition: std_code.h:273
YYENOMEM
@ YYENOMEM
Definition: jsil_y.tab.cpp:1119
PARSER
#define PARSER
Definition: jsil_y.tab.cpp:81
TOK_T_USER_OBJECT
@ TOK_T_USER_OBJECT
Definition: jsil_y.tab.h:101
TOK_DEFEQ
@ TOK_DEFEQ
Definition: jsil_y.tab.h:104
TOK_BASE
@ TOK_BASE
Definition: jsil_y.tab.h:75
YY_REDUCE_PRINT
#define YY_REDUCE_PRINT(Rule)
Definition: jsil_y.tab.cpp:1283
YYSYMBOL_74_
@ YYSYMBOL_74_
Definition: jsil_y.tab.cpp:313
YYSYMBOL_TOK_BUILTIN_IDENTIFIER
@ YYSYMBOL_TOK_BUILTIN_IDENTIFIER
Definition: jsil_y.tab.cpp:302
yystos
static const yytype_int8 yystos[]
Definition: jsil_y.tab.cpp:1062
side_effect_expr_function_callt::arguments
exprt::operandst & arguments()
Definition: std_code.h:2171
TOK_NEWLINE
@ TOK_NEWLINE
Definition: jsil_y.tab.h:58
yytable
static const yytype_int16 yytable[]
Definition: jsil_y.tab.cpp:880
TOK_T_NULL
@ TOK_T_NULL
Definition: jsil_y.tab.h:95
TOK_TYPEOF
@ TOK_TYPEOF
Definition: ansi_c_y.tab.h:129
string_typet
String type.
Definition: std_types.h:1655
TOK_T_BUILTIN_OBJECT
@ TOK_T_BUILTIN_OBJECT
Definition: jsil_y.tab.h:100
YYSYMBOL_literal
@ YYSYMBOL_literal
Definition: jsil_y.tab.cpp:341
YYSYMBOL_TOK_NUM_TO_UINT32
@ YYSYMBOL_TOK_NUM_TO_UINT32
Definition: jsil_y.tab.cpp:277
YYSYMBOL_TOK_FALSE
@ YYSYMBOL_TOK_FALSE
Definition: jsil_y.tab.cpp:266
TOK_EMPTY
@ TOK_EMPTY
Definition: jsil_y.tab.h:79
yyparse
#define yyparse
Definition: jsil_y.tab.cpp:68
code_typet::parametert
Definition: std_types.h:753
exprt::add_to_operands
void add_to_operands(const exprt &expr)
Add the given argument to the end of exprt's operands.
Definition: expr.h:155
yyalloc
Definition: ansi_c_y.tab.cpp:1073
YYEOF
@ YYEOF
Definition: ansi_c_y.tab.h:54
YYSYMBOL_TOK_DEFEQ
@ YYSYMBOL_TOK_DEFEQ
Definition: jsil_y.tab.cpp:289
YYSYMBOL_TOK_NUM_TO_INT32
@ YYSYMBOL_TOK_NUM_TO_INT32
Definition: jsil_y.tab.cpp:276
YYerror
@ YYerror
Definition: ansi_c_y.tab.h:55
YY_IGNORE_USELESS_CAST_END
#define YY_IGNORE_USELESS_CAST_END
Definition: jsil_y.tab.cpp:524
YYDPRINTF
#define YYDPRINTF(Args)
Definition: jsil_y.tab.cpp:1280
TOK_PRIMVALUE
@ TOK_PRIMVALUE
Definition: jsil_y.tab.h:86
YYSYMBOL_82_
@ YYSYMBOL_82_
Definition: jsil_y.tab.cpp:321
TOK_WITH
@ TOK_WITH
Definition: jsil_y.tab.h:67
yypact
static const yytype_int16 yypact[]
Definition: jsil_y.tab.cpp:810
YYSYMBOL_TOK_VARIABLE_REFERENCE
@ YYSYMBOL_TOK_VARIABLE_REFERENCE
Definition: jsil_y.tab.cpp:279
TOK_T_STRING
@ TOK_T_STRING
Definition: jsil_y.tab.h:98
to_code_block
const code_blockt & to_code_block(const codet &code)
Definition: std_code.h:259
YYSIZE_T
#define YYSIZE_T
Definition: jsil_y.tab.cpp:441
YYSYMBOL_TOK_TARGETFUNCTION
@ YYSYMBOL_TOK_TARGETFUNCTION
Definition: jsil_y.tab.cpp:272
YYSYMBOL_TOK_LEFT_SHIFT
@ YYSYMBOL_TOK_LEFT_SHIFT
Definition: jsil_y.tab.cpp:294
YYSYMBOL_unary_op
@ YYSYMBOL_unary_op
Definition: jsil_y.tab.cpp:348
yyjsillval
unsigned yyjsillval
Definition: jsil_y.tab.cpp:1331
YYSYMBOL_builtin_field
@ YYSYMBOL_builtin_field
Definition: jsil_y.tab.cpp:342
YYSYMBOL_TOK_PROCEDURE
@ YYSYMBOL_TOK_PROCEDURE
Definition: jsil_y.tab.cpp:244
jsil_declarationt::add_declarator
void add_declarator(const symbol_exprt &expr)
Definition: jsil_parse_tree.h:30
YYSYMBOL_procedure_decls
@ YYSYMBOL_procedure_decls
Definition: jsil_y.tab.cpp:325
index_exprt
Array index operator.
Definition: std_expr.h:1299
YYSYMBOL_TOK_LABEL
@ YYSYMBOL_TOK_LABEL
Definition: jsil_y.tab.cpp:249
YYSYMBOL_TOK_SPEC_IDENTIFIER
@ YYSYMBOL_TOK_SPEC_IDENTIFIER
Definition: jsil_y.tab.cpp:303
YYSYMBOL_expressions
@ YYSYMBOL_expressions
Definition: jsil_y.tab.cpp:338
yytranslate
static const yytype_int8 yytranslate[]
Definition: jsil_y.tab.cpp:683
code_assignt
A codet representing an assignment in the program.
Definition: std_code.h:298
YYSYMBOL_with_opt
@ YYSYMBOL_with_opt
Definition: jsil_y.tab.cpp:336
true_exprt
The Boolean constant true.
Definition: std_expr.h:3984
YYSYMBOL_instruction
@ YYSYMBOL_instruction
Definition: jsil_y.tab.cpp:334
constant_exprt
A constant literal expression.
Definition: std_expr.h:3935
TOK_THROWS
@ TOK_THROWS
Definition: jsil_y.tab.h:62
TOK_CONSTRUCTID
@ TOK_CONSTRUCTID
Definition: jsil_y.tab.h:85
yydefgoto
static const yytype_int16 yydefgoto[]
Definition: jsil_y.tab.cpp:870
std_expr.h
TOK_REF
@ TOK_REF
Definition: jsil_y.tab.h:73
YYSYMBOL_TOK_T_UNDEFINED
@ YYSYMBOL_TOK_T_UNDEFINED
Definition: jsil_y.tab.cpp:281
parser_stack
#define parser_stack(x)
Definition: parser.h:144
YYPOPSTACK
#define YYPOPSTACK(N)
YYUSE
#define YYUSE(E)
Definition: jsil_y.tab.cpp:491
TOK_NUM_TO_INT32
@ TOK_NUM_TO_INT32
Definition: jsil_y.tab.h:91
TOK_NULL
@ TOK_NULL
Definition: jsil_y.tab.h:77
TOK_T_OBJECT
@ TOK_T_OBJECT
Definition: jsil_y.tab.h:102
YYSYMBOL_TOK_OR
@ YYSYMBOL_TOK_OR
Definition: jsil_y.tab.cpp:292
YYSTACK_BYTES
#define YYSTACK_BYTES(N)
Definition: jsil_y.tab.cpp:613
YYSYMBOL_TOK_GOTO
@ YYSYMBOL_TOK_GOTO
Definition: jsil_y.tab.cpp:250
YYSYMBOL_ref_type
@ YYSYMBOL_ref_type
Definition: jsil_y.tab.cpp:350
TOK_SUBTYPE_OF
@ TOK_SUBTYPE_OF
Definition: jsil_y.tab.h:108
yytype_int16
short yytype_int16
Definition: ansi_c_y.tab.cpp:861
yy_state_fast_t
int yy_state_fast_t
Definition: ansi_c_y.tab.cpp:928
YYSYMBOL_68_
@ YYSYMBOL_68_
Definition: jsil_y.tab.cpp:307
TOK_CLASS
@ TOK_CLASS
Definition: ansi_c_y.tab.h:221
TOK_T_UNDEFINED
@ TOK_T_UNDEFINED
Definition: jsil_y.tab.h:96
yytoken_kind_t
enum yytokentype yytoken_kind_t
Definition: ansi_c_y.tab.h:252
TOK_TARGETFUNCTION
@ TOK_TARGETFUNCTION
Definition: jsil_y.tab.h:87
YYUNDEF
@ YYUNDEF
Definition: ansi_c_y.tab.h:56
codet
Data structure for representing an arbitrary statement in a program.
Definition: std_code.h:35
YYSYMBOL_TOK_MEMBER_REFERENCE
@ YYSYMBOL_TOK_MEMBER_REFERENCE
Definition: jsil_y.tab.cpp:278
TOK_VARIABLE_REFERENCE
@ TOK_VARIABLE_REFERENCE
Definition: jsil_y.tab.h:94