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