ReactOS  0.4.15-dev-980-ge160524
parser.tab.c
Go to the documentation of this file.
1 /* A Bison parser, made by GNU Bison 3.4.1. */
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.4.1"
52 
53 /* Skeleton name. */
54 #define YYSKELETON_NAME "yacc.c"
55 
56 /* Pure parsers. */
57 #define YYPURE 1
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 parser_parse
68 #define yylex parser_lex
69 #define yyerror parser_error
70 #define yydebug parser_debug
71 #define yynerrs parser_nerrs
72 
73 
74 /* First part of user prologue. */
75 #line 19 "parser.y"
76 
77 
78 #include "vbscript.h"
79 #include "parse.h"
80 
81 #include "wine/debug.h"
82 
83 WINE_DEFAULT_DEBUG_CHANNEL(vbscript);
84 
85 static int parser_error(parser_ctx_t *,const char*);
86 
87 static void parse_complete(parser_ctx_t*,BOOL);
88 static void handle_isexpression_script(parser_ctx_t *ctx, expression_t *expr);
89 
90 static void source_add_statement(parser_ctx_t*,statement_t*);
91 static void source_add_class(parser_ctx_t*,class_decl_t*);
92 
93 static void *new_expression(parser_ctx_t*,expression_type_t,size_t);
94 static expression_t *new_bool_expression(parser_ctx_t*,VARIANT_BOOL);
95 static expression_t *new_string_expression(parser_ctx_t*,const WCHAR*);
96 static expression_t *new_long_expression(parser_ctx_t*,expression_type_t,LONG);
97 static expression_t *new_double_expression(parser_ctx_t*,double);
98 static expression_t *new_unary_expression(parser_ctx_t*,expression_type_t,expression_t*);
99 static expression_t *new_binary_expression(parser_ctx_t*,expression_type_t,expression_t*,expression_t*);
100 static expression_t *new_new_expression(parser_ctx_t*,const WCHAR*);
101 
102 static member_expression_t *new_member_expression(parser_ctx_t*,expression_t*,const WCHAR*);
103 
104 static void *new_statement(parser_ctx_t*,statement_type_t,size_t);
105 static statement_t *new_call_statement(parser_ctx_t*,BOOL,member_expression_t*);
106 static statement_t *new_assign_statement(parser_ctx_t*,member_expression_t*,expression_t*);
107 static statement_t *new_set_statement(parser_ctx_t*,member_expression_t*,expression_t*);
108 static statement_t *new_dim_statement(parser_ctx_t*,dim_decl_t*);
109 static statement_t *new_while_statement(parser_ctx_t*,statement_type_t,expression_t*,statement_t*);
110 static statement_t *new_forto_statement(parser_ctx_t*,const WCHAR*,expression_t*,expression_t*,expression_t*,statement_t*);
111 static statement_t *new_foreach_statement(parser_ctx_t*,const WCHAR*,expression_t*,statement_t*);
112 static statement_t *new_if_statement(parser_ctx_t*,expression_t*,statement_t*,elseif_decl_t*,statement_t*);
113 static statement_t *new_function_statement(parser_ctx_t*,function_decl_t*);
114 static statement_t *new_onerror_statement(parser_ctx_t*,BOOL);
115 static statement_t *new_const_statement(parser_ctx_t*,const_decl_t*);
116 static statement_t *new_select_statement(parser_ctx_t*,expression_t*,case_clausule_t*);
117 
118 static dim_decl_t *new_dim_decl(parser_ctx_t*,const WCHAR*,BOOL,dim_list_t*);
119 static dim_list_t *new_dim(parser_ctx_t*,unsigned,dim_list_t*);
120 static elseif_decl_t *new_elseif_decl(parser_ctx_t*,expression_t*,statement_t*);
121 static function_decl_t *new_function_decl(parser_ctx_t*,const WCHAR*,function_type_t,unsigned,arg_decl_t*,statement_t*);
122 static arg_decl_t *new_argument_decl(parser_ctx_t*,const WCHAR*,BOOL);
123 static const_decl_t *new_const_decl(parser_ctx_t*,const WCHAR*,expression_t*);
124 static case_clausule_t *new_case_clausule(parser_ctx_t*,expression_t*,statement_t*,case_clausule_t*);
125 
126 static class_decl_t *new_class_decl(parser_ctx_t*);
127 static class_decl_t *add_class_function(parser_ctx_t*,class_decl_t*,function_decl_t*);
128 static class_decl_t *add_dim_prop(parser_ctx_t*,class_decl_t*,dim_decl_t*,unsigned);
129 
130 static statement_t *link_statements(statement_t*,statement_t*);
131 
132 #define STORAGE_IS_PRIVATE 1
133 #define STORAGE_IS_DEFAULT 2
134 
135 #define CHECK_ERROR if(((parser_ctx_t*)ctx)->hres != S_OK) YYABORT
136 
137 
138 #line 139 "parser.tab.c"
139 
140 # ifndef YY_NULLPTR
141 # if defined __cplusplus
142 # if 201103L <= __cplusplus
143 # define YY_NULLPTR nullptr
144 # else
145 # define YY_NULLPTR 0
146 # endif
147 # else
148 # define YY_NULLPTR ((void*)0)
149 # endif
150 # endif
151 
152 /* Enabling verbose error messages. */
153 #ifdef YYERROR_VERBOSE
154 # undef YYERROR_VERBOSE
155 # define YYERROR_VERBOSE 1
156 #else
157 # define YYERROR_VERBOSE 0
158 #endif
159 
160 /* Use api.header.include to #include this header
161  instead of duplicating it here. */
162 #ifndef YY_PARSER_E_REACTOSSYNC_GCC_DLL_WIN32_VBSCRIPT_PARSER_TAB_H_INCLUDED
163 # define YY_PARSER_E_REACTOSSYNC_GCC_DLL_WIN32_VBSCRIPT_PARSER_TAB_H_INCLUDED
164 /* Debug traces. */
165 #ifndef YYDEBUG
166 # define YYDEBUG 0
167 #endif
168 #if YYDEBUG
169 extern int parser_debug;
170 #endif
171 
172 /* Token type. */
173 #ifndef YYTOKENTYPE
174 # define YYTOKENTYPE
175  enum yytokentype
176  {
177  tEXPRESSION = 258,
178  tEOF = 259,
179  tNL = 260,
180  tEMPTYBRACKETS = 261,
181  tLTEQ = 262,
182  tGTEQ = 263,
183  tNEQ = 264,
184  tSTOP = 265,
185  tME = 266,
186  tREM = 267,
187  tTRUE = 268,
188  tFALSE = 269,
189  tNOT = 270,
190  tAND = 271,
191  tOR = 272,
192  tXOR = 273,
193  tEQV = 274,
194  tIMP = 275,
195  tIS = 276,
196  tMOD = 277,
197  tCALL = 278,
198  tDIM = 279,
199  tSUB = 280,
200  tFUNCTION = 281,
201  tGET = 282,
202  tLET = 283,
203  tCONST = 284,
204  tIF = 285,
205  tELSE = 286,
206  tELSEIF = 287,
207  tEND = 288,
208  tTHEN = 289,
209  tEXIT = 290,
210  tWHILE = 291,
211  tWEND = 292,
212  tDO = 293,
213  tLOOP = 294,
214  tUNTIL = 295,
215  tFOR = 296,
216  tTO = 297,
217  tEACH = 298,
218  tIN = 299,
219  tSELECT = 300,
220  tCASE = 301,
221  tBYREF = 302,
222  tBYVAL = 303,
223  tOPTION = 304,
224  tNOTHING = 305,
225  tEMPTY = 306,
226  tNULL = 307,
227  tCLASS = 308,
228  tSET = 309,
229  tNEW = 310,
230  tPUBLIC = 311,
231  tPRIVATE = 312,
232  tNEXT = 313,
233  tON = 314,
234  tRESUME = 315,
235  tGOTO = 316,
236  tIdentifier = 317,
237  tString = 318,
238  tDEFAULT = 319,
239  tERROR = 320,
240  tEXPLICIT = 321,
241  tPROPERTY = 322,
242  tSTEP = 323,
243  tInt = 324,
244  tDouble = 325
245  };
246 #endif
247 
248 /* Value type. */
249 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
250 union YYSTYPE
251 {
252 #line 87 "parser.y"
253 
254  const WCHAR *string;
255  statement_t *statement;
256  expression_t *expression;
257  member_expression_t *member;
258  elseif_decl_t *elseif;
259  dim_decl_t *dim_decl;
260  dim_list_t *dim_list;
261  function_decl_t *func_decl;
262  arg_decl_t *arg_decl;
263  class_decl_t *class_decl;
264  const_decl_t *const_decl;
265  case_clausule_t *case_clausule;
266  unsigned uint;
267  LONG integer;
268  BOOL boolean;
269  double dbl;
270 
271 #line 272 "parser.tab.c"
272 
273 };
274 typedef union YYSTYPE YYSTYPE;
275 # define YYSTYPE_IS_TRIVIAL 1
276 # define YYSTYPE_IS_DECLARED 1
277 #endif
278 
279 
280 
281 int parser_parse (parser_ctx_t *ctx);
282 
283 #endif /* !YY_PARSER_E_REACTOSSYNC_GCC_DLL_WIN32_VBSCRIPT_PARSER_TAB_H_INCLUDED */
284 
285 
286 
287 #ifdef short
288 # undef short
289 #endif
290 
291 #ifdef YYTYPE_UINT8
292 typedef YYTYPE_UINT8 yytype_uint8;
293 #else
294 typedef unsigned char yytype_uint8;
295 #endif
296 
297 #ifdef YYTYPE_INT8
298 typedef YYTYPE_INT8 yytype_int8;
299 #else
300 typedef signed char yytype_int8;
301 #endif
302 
303 #ifdef YYTYPE_UINT16
304 typedef YYTYPE_UINT16 yytype_uint16;
305 #else
306 typedef unsigned short yytype_uint16;
307 #endif
308 
309 #ifdef YYTYPE_INT16
310 typedef YYTYPE_INT16 yytype_int16;
311 #else
312 typedef short yytype_int16;
313 #endif
314 
315 #ifndef YYSIZE_T
316 # ifdef __SIZE_TYPE__
317 # define YYSIZE_T __SIZE_TYPE__
318 # elif defined size_t
319 # define YYSIZE_T size_t
320 # elif ! defined YYSIZE_T
321 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
322 # define YYSIZE_T size_t
323 # else
324 # define YYSIZE_T unsigned
325 # endif
326 #endif
327 
328 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
329 
330 #ifndef YY_
331 # if defined YYENABLE_NLS && YYENABLE_NLS
332 # if ENABLE_NLS
333 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
334 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
335 # endif
336 # endif
337 # ifndef YY_
338 # define YY_(Msgid) Msgid
339 # endif
340 #endif
341 
342 #ifndef YY_ATTRIBUTE
343 # if (defined __GNUC__ \
344  && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
345  || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
346 # define YY_ATTRIBUTE(Spec) __attribute__(Spec)
347 # else
348 # define YY_ATTRIBUTE(Spec) /* empty */
349 # endif
350 #endif
351 
352 #ifndef YY_ATTRIBUTE_PURE
353 # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
354 #endif
355 
356 #ifndef YY_ATTRIBUTE_UNUSED
357 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
358 #endif
359 
360 /* Suppress unused-variable warnings by "using" E. */
361 #if ! defined lint || defined __GNUC__
362 # define YYUSE(E) ((void) (E))
363 #else
364 # define YYUSE(E) /* empty */
365 #endif
366 
367 #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
368 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
369 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
370  _Pragma ("GCC diagnostic push") \
371  _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
372  _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
373 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
374  _Pragma ("GCC diagnostic pop")
375 #else
376 # define YY_INITIAL_VALUE(Value) Value
377 #endif
378 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
379 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
380 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
381 #endif
382 #ifndef YY_INITIAL_VALUE
383 # define YY_INITIAL_VALUE(Value) /* Nothing. */
384 #endif
385 
386 
387 #define YY_ASSERT(E) ((void) (0 && (E)))
388 
389 #if ! defined yyoverflow || YYERROR_VERBOSE
390 
391 /* The parser invokes alloca or malloc; define the necessary symbols. */
392 
393 # ifdef YYSTACK_USE_ALLOCA
394 # if YYSTACK_USE_ALLOCA
395 # ifdef __GNUC__
396 # define YYSTACK_ALLOC __builtin_alloca
397 # elif defined __BUILTIN_VA_ARG_INCR
398 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
399 # elif defined _AIX
400 # define YYSTACK_ALLOC __alloca
401 # elif defined _MSC_VER
402 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
403 # define alloca _alloca
404 # else
405 # define YYSTACK_ALLOC alloca
406 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
407 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
408  /* Use EXIT_SUCCESS as a witness for stdlib.h. */
409 # ifndef EXIT_SUCCESS
410 # define EXIT_SUCCESS 0
411 # endif
412 # endif
413 # endif
414 # endif
415 # endif
416 
417 # ifdef YYSTACK_ALLOC
418  /* Pacify GCC's 'empty if-body' warning. */
419 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
420 # ifndef YYSTACK_ALLOC_MAXIMUM
421  /* The OS might guarantee only one guard page at the bottom of the stack,
422  and a page size can be as small as 4096 bytes. So we cannot safely
423  invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
424  to allow for a few compiler-allocated temporary stack slots. */
425 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
426 # endif
427 # else
428 # define YYSTACK_ALLOC YYMALLOC
429 # define YYSTACK_FREE YYFREE
430 # ifndef YYSTACK_ALLOC_MAXIMUM
431 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
432 # endif
433 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
434  && ! ((defined YYMALLOC || defined malloc) \
435  && (defined YYFREE || defined free)))
436 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
437 # ifndef EXIT_SUCCESS
438 # define EXIT_SUCCESS 0
439 # endif
440 # endif
441 # ifndef YYMALLOC
442 # define YYMALLOC malloc
443 # if ! defined malloc && ! defined EXIT_SUCCESS
444 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
445 # endif
446 # endif
447 # ifndef YYFREE
448 # define YYFREE free
449 # if ! defined free && ! defined EXIT_SUCCESS
450 void free (void *); /* INFRINGES ON USER NAME SPACE */
451 # endif
452 # endif
453 # endif
454 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
455 
456 
457 #if (! defined yyoverflow \
458  && (! defined __cplusplus \
459  || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
460 
461 /* A type that is properly aligned for any stack member. */
462 union yyalloc
463 {
464  yytype_int16 yyss_alloc;
465  YYSTYPE yyvs_alloc;
466 };
467 
468 /* The size of the maximum gap between one aligned stack and the next. */
469 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
470 
471 /* The size of an array large to enough to hold all stacks, each with
472  N elements. */
473 # define YYSTACK_BYTES(N) \
474  ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
475  + YYSTACK_GAP_MAXIMUM)
476 
477 # define YYCOPY_NEEDED 1
478 
479 /* Relocate STACK from its old location to the new one. The
480  local variables YYSIZE and YYSTACKSIZE give the old and new number of
481  elements in the stack, and YYPTR gives the new location of the
482  stack. Advance YYPTR to a properly aligned location for the next
483  stack. */
484 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
485  do \
486  { \
487  YYSIZE_T yynewbytes; \
488  YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
489  Stack = &yyptr->Stack_alloc; \
490  yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
491  yyptr += yynewbytes / sizeof (*yyptr); \
492  } \
493  while (0)
494 
495 #endif
496 
497 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
498 /* Copy COUNT objects from SRC to DST. The source and destination do
499  not overlap. */
500 # ifndef YYCOPY
501 # if defined __GNUC__ && 1 < __GNUC__
502 # define YYCOPY(Dst, Src, Count) \
503  __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
504 # else
505 # define YYCOPY(Dst, Src, Count) \
506  do \
507  { \
508  YYSIZE_T yyi; \
509  for (yyi = 0; yyi < (Count); yyi++) \
510  (Dst)[yyi] = (Src)[yyi]; \
511  } \
512  while (0)
513 # endif
514 # endif
515 #endif /* !YYCOPY_NEEDED */
516 
517 /* YYFINAL -- State number of the termination state. */
518 #define YYFINAL 48
519 /* YYLAST -- Last index in YYTABLE. */
520 #define YYLAST 1153
521 
522 /* YYNTOKENS -- Number of terminals. */
523 #define YYNTOKENS 87
524 /* YYNNTS -- Number of nonterminals. */
525 #define YYNNTS 63
526 /* YYNRULES -- Number of rules. */
527 #define YYNRULES 232
528 /* YYNSTATES -- Number of states. */
529 #define YYNSTATES 405
530 
531 #define YYUNDEFTOK 2
532 #define YYMAXUTOK 325
533 
534 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
535  as returned by yylex, with out-of-bounds checking. */
536 #define YYTRANSLATE(YYX) \
537  ((unsigned) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
538 
539 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
540  as returned by yylex. */
541 static const yytype_uint8 yytranslate[] =
542 {
543  0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
544  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
545  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
546  2, 2, 2, 2, 2, 2, 2, 2, 81, 2,
547  76, 77, 84, 82, 75, 78, 74, 85, 73, 2,
548  2, 2, 2, 2, 2, 2, 2, 2, 71, 2,
549  80, 72, 79, 2, 2, 2, 2, 2, 2, 2,
550  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
551  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
552  2, 2, 83, 2, 86, 2, 2, 2, 2, 2,
553  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
554  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
555  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
556  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
557  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
558  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
559  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
560  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
561  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
562  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
563  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
564  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
565  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
566  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
567  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
568  2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
569  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
570  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
571  25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
572  35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
573  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
574  55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
575  65, 66, 67, 68, 69, 70
576 };
577 
578 #if YYDEBUG
579  /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
580 static const yytype_uint16 yyrline[] =
581 {
582  0, 148, 148, 149, 152, 153, 156, 157, 158, 161,
583  162, 165, 166, 167, 170, 171, 174, 175, 178, 181,
584  182, 183, 184, 185, 188, 189, 190, 192, 193, 194,
585  196, 199, 202, 203, 204, 205, 206, 207, 208, 209,
586  211, 212, 213, 214, 215, 217, 219, 223, 224, 227,
587  228, 231, 232, 233, 236, 237, 240, 241, 244, 247,
588  248, 251, 252, 255, 256, 259, 261, 262, 266, 267,
589  270, 271, 274, 275, 278, 282, 283, 286, 287, 288,
590  292, 293, 296, 297, 300, 301, 302, 305, 306, 309,
591  310, 313, 314, 317, 318, 321, 322, 325, 326, 329,
592  330, 333, 334, 337, 338, 339, 340, 341, 342, 343,
593  344, 347, 348, 351, 352, 353, 356, 357, 360, 361,
594  365, 366, 368, 372, 373, 376, 377, 378, 379, 380,
595  383, 384, 387, 388, 389, 390, 391, 392, 393, 396,
596  397, 398, 401, 402, 405, 406, 409, 412, 413, 414,
597  416, 418, 420, 421, 422, 423, 426, 428, 430, 434,
598  436, 440, 441, 444, 445, 446, 449, 450, 453, 454,
599  457, 458, 459, 463, 464, 465, 466, 467, 468, 472,
600  473, 474, 475, 476, 477, 478, 479, 480, 481, 482,
601  483, 484, 485, 486, 487, 488, 489, 490, 491, 492,
602  493, 494, 495, 496, 497, 498, 499, 500, 501, 502,
603  503, 504, 505, 506, 507, 508, 509, 510, 511, 512,
604  513, 514, 515, 516, 517, 518, 519, 520, 521, 525,
605  526, 527, 528
606 };
607 #endif
608 
609 #if YYDEBUG || YYERROR_VERBOSE || 0
610 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
611  First, the terminals, then, starting at YYNTOKENS, nonterminals. */
612 static const char *const yytname[] =
613 {
614  "$end", "error", "$undefined", "tEXPRESSION", "tEOF", "tNL",
615  "tEMPTYBRACKETS", "tLTEQ", "tGTEQ", "tNEQ", "tSTOP", "tME", "tREM",
616  "tTRUE", "tFALSE", "tNOT", "tAND", "tOR", "tXOR", "tEQV", "tIMP", "tIS",
617  "tMOD", "tCALL", "tDIM", "tSUB", "tFUNCTION", "tGET", "tLET", "tCONST",
618  "tIF", "tELSE", "tELSEIF", "tEND", "tTHEN", "tEXIT", "tWHILE", "tWEND",
619  "tDO", "tLOOP", "tUNTIL", "tFOR", "tTO", "tEACH", "tIN", "tSELECT",
620  "tCASE", "tBYREF", "tBYVAL", "tOPTION", "tNOTHING", "tEMPTY", "tNULL",
621  "tCLASS", "tSET", "tNEW", "tPUBLIC", "tPRIVATE", "tNEXT", "tON",
622  "tRESUME", "tGOTO", "tIdentifier", "tString", "tDEFAULT", "tERROR",
623  "tEXPLICIT", "tPROPERTY", "tSTEP", "tInt", "tDouble", "':'", "'='",
624  "'0'", "'.'", "','", "'('", "')'", "'-'", "'>'", "'<'", "'&'", "'+'",
625  "'\\\\'", "'*'", "'/'", "'^'", "$accept", "Program",
626  "OptionExplicit_opt", "SourceElements", "ExpressionNl_opt",
627  "BodyStatements", "StatementsNl_opt", "StatementsNl", "StatementNl",
628  "Statement", "SimpleStatement", "MemberExpression", "DimDeclList",
629  "DimDecl", "DimList", "ConstDeclList", "ConstDecl", "ConstExpression",
630  "DoType", "Step_opt", "IfStatement", "EndIf_opt", "ElseIfs_opt",
631  "ElseIfs", "ElseIf", "Else_opt", "CaseClausules", "Arguments_opt",
632  "ArgumentList_opt", "ArgumentList", "EmptyBrackets_opt",
633  "ExpressionList", "Expression", "EqvExpression", "XorExpression",
634  "OrExpression", "AndExpression", "NotExpression", "EqualityExpression",
635  "ConcatExpression", "AdditiveExpression", "ModExpression",
636  "IntdivExpression", "MultiplicativeExpression", "ExpExpression",
637  "UnaryExpression", "CallExpression", "LiteralExpression",
638  "NumericLiteralExpression", "IntegerValue", "PrimaryExpression",
639  "ClassDeclaration", "ClassBody", "PropertyDecl", "FunctionDecl",
640  "Storage_opt", "Storage", "ArgumentsDecl_opt", "ArgumentDeclList",
641  "ArgumentDecl", "Identifier", "DotIdentifier", "StSep", YY_NULLPTR
642 };
643 #endif
644 
645 # ifdef YYPRINT
646 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
647  (internal) symbol number NUM (which must be that of a token). */
648 static const yytype_uint16 yytoknum[] =
649 {
650  0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
651  265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
652  275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
653  285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
654  295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
655  305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
656  315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
657  325, 58, 61, 48, 46, 44, 40, 41, 45, 62,
658  60, 38, 43, 92, 42, 47, 94
659 };
660 # endif
661 
662 #define YYPACT_NINF -294
663 
664 #define yypact_value_is_default(Yystate) \
665  (!!((Yystate) == (-294)))
666 
667 #define YYTABLE_NINF -162
668 
669 #define yytable_value_is_error(Yytable_value) \
670  0
671 
672  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
673  STATE-NUM. */
674 static const yytype_int16 yypact[] =
675 {
676  34, 617, -19, 50, -294, -294, -294, -294, 617, -294,
677  -294, -294, 166, -294, -294, -294, -294, -294, -294, -294,
678  -294, -294, -294, 617, 660, 660, 30, 2, 16, 43,
679  96, 51, 111, -294, 37, 53, -17, 110, 100, 41,
680  65, -294, 119, -294, -294, -294, -294, 15, -294, 466,
681  -294, -294, 19, -294, -294, -294, -294, 545, -294, -294,
682  -294, 617, 617, 617, 617, 617, 660, 660, 660, 660,
683  660, 660, 660, 660, 660, 660, 660, 660, 660, 660,
684  660, 1085, 15, 15, -294, -294, -294, 368, 166, 166,
685  617, 117, 617, 20, 107, 163, 166, 368, 126, -294,
686  149, 721, -294, 212, 152, 391, -294, 119, -294, -294,
687  131, -294, -294, 545, 147, -8, 43, 96, 51, 111,
688  -294, 53, 53, 53, 53, 53, 53, 53, -17, 110,
689  110, 100, 41, 65, 65, -294, -294, -294, -294, -294,
690  -294, -294, -294, -294, -294, -294, -294, -294, -294, -294,
691  -294, -294, -294, -294, -294, -294, -294, -294, -294, -294,
692  -294, -294, -294, -294, -294, -294, -294, -294, -294, -294,
693  -294, -294, -294, -294, -294, -294, -294, -294, -294, -294,
694  -294, -294, -294, -294, -294, -294, -294, -294, -294, 2,
695  -294, 154, 11, -294, 160, 164, 18, -294, -294, -294,
696  -294, -294, 9, -294, -294, 617, 771, 166, 169, 617,
697  15, 2, -294, 144, -294, -294, 721, 545, 172, -294,
698  -294, -32, 166, 166, -294, -294, 545, 171, 166, -294,
699  68, 166, 116, 516, 821, 9, 199, -294, 721, 202,
700  617, 9, 82, 175, 190, 176, -294, 4, 617, 13,
701  13, -294, -294, -294, -294, 173, 177, -294, -16, -294,
702  -294, 721, 66, 216, 771, 142, -294, 617, 104, 211,
703  166, 227, 15, 15, 85, 201, 617, -294, -294, 241,
704  97, -294, 15, 15, -294, 68, -294, 234, 1021, 237,
705  -294, -294, 230, 617, 9, 617, 588, 238, 15, 221,
706  82, 82, -5, 15, 241, 166, 166, 200, 203, 270,
707  871, 871, -294, 617, 249, -294, 234, 248, -294, -294,
708  241, 921, 7, 15, 15, 10, 239, 82, 15, -294,
709  -294, 224, 225, 226, 82, 270, 270, -294, 97, -294,
710  250, 871, 212, 256, 113, 285, 258, -294, -294, 243,
711  617, 15, 1021, 721, 617, -294, -294, -294, 13, 228,
712  229, -294, -294, -294, -294, 267, -294, 271, 305, 971,
713  283, -294, 241, 921, -294, 211, -294, 15, 97, 97,
714  -294, -294, 721, -294, -294, 257, -294, 871, 240, 242,
715  -294, -294, 281, 15, 15, 251, 871, 871, -294, 287,
716  288, 255, 261, -294, -294
717 };
718 
719  /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
720  Performed when YYTABLE does not specify something else to do. Zero
721  means the default is an error. */
722 static const yytype_uint8 yydefact[] =
723 {
724  4, 9, 0, 0, 6, 145, 132, 133, 0, 138,
725  136, 137, 0, 173, 134, 174, 175, 176, 177, 178,
726  140, 141, 139, 0, 0, 0, 0, 87, 0, 91,
727  93, 95, 97, 99, 101, 103, 111, 113, 116, 118,
728  120, 123, 126, 125, 135, 130, 47, 0, 1, 161,
729  102, 127, 0, 128, 129, 3, 88, 0, 131, 80,
730  10, 0, 0, 0, 0, 0, 0, 0, 0, 0,
731  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
732  0, 0, 229, 230, 5, 2, 40, 0, 0, 0,
733  0, 0, 0, 0, 0, 0, 0, 0, 164, 165,
734  0, 19, 7, 0, 21, 87, 28, 0, 8, 33,
735  0, 162, 144, 0, 0, 84, 92, 94, 96, 98,
736  100, 109, 108, 105, 110, 104, 106, 107, 112, 115,
737  114, 117, 119, 121, 122, 124, 180, 181, 182, 183,
738  184, 185, 186, 187, 188, 189, 190, 191, 192, 193,
739  194, 195, 196, 197, 198, 199, 200, 201, 202, 203,
740  204, 205, 206, 207, 208, 209, 210, 211, 212, 213,
741  214, 215, 216, 217, 218, 219, 220, 221, 222, 223,
742  224, 225, 226, 227, 228, 179, 48, 231, 232, 87,
743  27, 49, 51, 43, 56, 0, 0, 38, 36, 34,
744  35, 37, 0, 61, 62, 0, 161, 0, 0, 0,
745  0, 87, 163, 0, 20, 18, 23, 0, 131, 24,
746  83, 82, 0, 0, 86, 81, 0, 25, 0, 53,
747  0, 0, 0, 161, 161, 0, 0, 15, 16, 0,
748  0, 0, 161, 131, 0, 0, 22, 0, 0, 87,
749  87, 85, 50, 143, 142, 0, 54, 57, 0, 58,
750  59, 14, 68, 0, 161, 32, 17, 0, 0, 77,
751  0, 0, 154, 148, 0, 162, 0, 41, 42, 26,
752  0, 166, 0, 0, 52, 0, 60, 70, 161, 0,
753  66, 29, 0, 0, 0, 0, 0, 0, 152, 0,
754  161, 161, 0, 150, 39, 0, 0, 0, 168, 87,
755  161, 161, 55, 0, 75, 71, 72, 68, 69, 30,
756  31, 161, 63, 0, 0, 89, 0, 161, 0, 155,
757  149, 0, 0, 0, 161, 87, 87, 167, 0, 170,
758  0, 161, 12, 0, 0, 0, 0, 73, 67, 0,
759  0, 0, 161, 14, 0, 46, 153, 146, 87, 0,
760  0, 151, 171, 172, 169, 0, 13, 0, 0, 161,
761  0, 45, 64, 161, 78, 77, 90, 0, 0, 0,
762  159, 160, 14, 76, 65, 0, 79, 161, 0, 0,
763  74, 44, 0, 0, 0, 0, 161, 161, 156, 0,
764  0, 0, 0, 157, 158
765 };
766 
767  /* YYPGOTO[NTERM-NUM]. */
768 static const yytype_int16 yypgoto[] =
769 {
770  -294, -294, -294, -294, -294, -293, -233, -231, -38, -85,
771  -294, -46, 101, 54, 40, 99, -294, -294, 69, -294,
772  -294, 23, -294, 22, -294, -294, -40, -99, -294, -103,
773  -96, -11, 3, 276, 282, 284, 290, 27, -294, 130,
774  272, 102, 279, 269, 128, 39, 21, 120, 90, -294,
775  -294, -294, -268, -294, -229, -227, -199, -245, 25, -157,
776  -12, -294, 98
777 };
778 
779  /* YYDEFGOTO[NTERM-NUM]. */
780 static const yytype_int16 yydefgoto[] =
781 {
782  -1, 3, 4, 49, 26, 340, 236, 237, 238, 103,
783  104, 27, 190, 191, 255, 193, 194, 259, 205, 351,
784  106, 290, 314, 315, 316, 346, 297, 58, 219, 114,
785  59, 324, 115, 29, 30, 31, 32, 33, 34, 35,
786  36, 37, 38, 39, 40, 41, 42, 43, 44, 256,
787  45, 108, 271, 272, 109, 110, 111, 282, 307, 308,
788  46, 186, 84
789 };
790 
791  /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
792  positive, shift that token. If negative, reduce the rule whose
793  number is the opposite. If YYTABLE_NINF, syntax error. */
794 static const yytype_int16 yytable[] =
795 {
796  51, 263, 220, 105, 28, 283, 218, 266, 56, 221,
797  224, 102, 61, 273, 82, 274, 214, 229, 343, 56,
798  82, 60, 331, 332, 61, 82, 52, 61, 287, 61,
799  61, 292, 329, 330, 55, 50, 61, 1, 61, 61,
800  -80, 189, -80, 275, 66, 67, 68, 47, 366, 333,
801  48, 211, 233, 20, 21, 105, 203, 22, 69, 356,
802  204, 74, 62, 53, 54, 75, 361, 226, 64, 185,
803  107, 273, 273, 274, 274, 350, 192, 195, 57, 226,
804  83, 112, 208, 2, 210, 354, 83, 230, 349, 280,
805  227, 83, 120, 196, 392, 202, 112, 288, 273, 289,
806  274, 275, 275, 399, 400, 273, 270, 274, 107, 70,
807  222, 223, 243, 377, 63, -147, 71, 72, 107, 135,
808  375, 374, 107, 251, 61, 78, 79, 65, 275, 6,
809  7, 246, 76, 61, 73, 275, 383, 253, 98, 99,
810  385, 254, 197, 198, 305, 306, 295, 368, 262, 390,
811  207, 80, 302, 281, 281, 199, 222, 223, 200, 13,
812  105, 15, 16, 17, 18, 19, 9, 10, 11, 13,
813  105, 15, 16, 17, 18, 19, 129, 130, 203, 14,
814  187, 188, 204, 77, 201, 20, 21, 105, 105, 22,
815  212, 206, 105, 81, 258, 239, 121, 122, 123, 124,
816  125, 126, 127, 317, 244, 245, 133, 134, 235, 209,
817  249, 250, 241, 339, 213, 105, 192, 215, 105, 195,
818  247, 388, 389, 216, 225, 342, 342, 107, 13, 228,
819  15, 16, 17, 18, 19, 231, 232, 107, 265, 362,
820  363, 240, 105, 268, 248, -131, 267, 276, 277, 278,
821  284, 279, 285, 291, 107, 107, 342, 296, 192, 107,
822  299, 61, 281, 303, 105, 105, 313, 318, 309, 319,
823  294, 326, 341, 341, 328, 105, 56, 337, 338, 304,
824  345, 289, 107, 365, 355, 107, 358, 359, 360, 367,
825  369, 370, 380, 335, 336, 105, 320, 381, 322, 325,
826  234, 371, 342, 341, 378, 379, 105, 105, 242, 107,
827  382, 342, 342, 384, 395, 391, 344, 393, 398, 394,
828  401, 402, 403, 105, 298, 312, 309, 105, 404, 252,
829  257, 107, 107, 264, 293, 386, 105, 116, 347, 269,
830  348, 105, 107, 376, 117, 128, 132, 118, 286, 341,
831  105, 105, 260, 372, 119, 131, 0, 325, 341, 341,
832  0, 0, 107, 364, 0, 0, 309, 309, 0, 0,
833  300, 301, 0, 107, 107, 0, 0, 0, 0, 5,
834  310, 311, 0, 0, 0, 0, 0, 0, 0, 0,
835  107, 0, 321, 0, 107, 0, 327, 56, 0, 0,
836  0, 334, 5, 107, 6, 7, 8, 0, 107, 0,
837  0, 0, 0, 0, 0, 0, 0, 107, 107, 0,
838  0, 352, 353, 0, 0, 0, 357, 0, 0, 0,
839  13, 0, 15, 16, 17, 18, 19, 0, 0, 0,
840  0, 9, 10, 11, 23, 0, 12, 0, 0, 373,
841  0, 0, 0, 13, 14, 15, 16, 17, 18, 19,
842  20, 21, 0, 0, 22, 0, 113, 217, 0, 24,
843  85, 0, 0, 25, 0, 387, 86, 5, 0, 0,
844  0, 0, 0, 0, 0, 0, 0, 0, 0, 87,
845  88, 396, 397, 0, 0, 89, 90, 0, 0, 0,
846  0, 91, 92, 0, 93, 0, 0, 94, 0, 0,
847  0, 95, 0, 0, 0, 0, 0, 0, 0, 96,
848  97, 261, 98, 99, 0, 100, 86, 5, 13, 0,
849  15, 16, 17, 18, 19, 0, 0, 101, 0, 87,
850  88, 0, 23, 0, 0, 89, 90, 0, 0, 0,
851  0, 91, 92, 0, 93, 0, 5, 94, 6, 7,
852  8, 95, 0, 0, 0, 0, 0, 0, 0, 0,
853  97, 0, 98, 99, 0, 100, 0, 0, 13, 0,
854  15, 16, 17, 18, 19, 0, 0, 101, 0, 0,
855  0, 0, 23, 0, 0, 9, 10, 11, 0, 5,
856  12, 6, 7, 8, 0, 0, 0, 13, 14, 15,
857  16, 17, 18, 19, 20, 21, 0, 0, 22, 323,
858  113, 23, 0, 24, 0, 0, 0, 25, 5, 0,
859  6, 7, 8, 0, 0, 0, 0, 0, 9, 10,
860  11, 0, 0, 12, 0, 0, 0, 0, 0, 0,
861  13, 14, 15, 16, 17, 18, 19, 20, 21, 0,
862  0, 22, 0, 0, 23, 0, 24, 9, 10, 11,
863  25, 5, 12, 6, 7, 0, 0, 0, 0, 13,
864  14, 15, 16, 17, 18, 19, 20, 21, 0, 0,
865  22, 0, 0, 23, 0, 24, 0, 0, 0, 25,
866  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
867  9, 10, 11, 0, 0, 12, 0, 0, 0, 0,
868  0, 0, 13, 14, 15, 16, 17, 18, 19, 20,
869  21, 86, 5, 22, 0, 0, 23, 0, 24, 0,
870  0, 0, 25, 0, 87, 88, -161, -161, 0, 0,
871  89, 90, 0, 0, 0, 0, 91, 92, 0, 93,
872  0, 0, 94, 0, 0, 0, 95, 0, 0, 0,
873  0, 0, 0, 0, 0, 97, 0, 98, 99, 0,
874  100, 86, 5, 13, 0, 15, 16, 17, 18, 19,
875  0, 0, 101, 0, 87, 88, 0, 23, 0, 0,
876  89, 90, 0, 0, 0, 0, 91, 92, 0, 93,
877  -14, 0, 94, 0, 0, 0, 95, 0, 0, 0,
878  0, 0, 0, 0, 0, 97, 0, 98, 99, 0,
879  100, 86, 5, 13, 0, 15, 16, 17, 18, 19,
880  0, 0, 101, 0, 87, 88, 0, 23, 0, 0,
881  89, 90, 0, 0, 0, 0, 91, 92, -14, 93,
882  0, 0, 94, 0, 0, 0, 95, 0, 0, 0,
883  0, 0, 0, 0, 0, 97, 0, 98, 99, 0,
884  100, 86, 5, 13, 0, 15, 16, 17, 18, 19,
885  0, 0, 101, 0, 87, 88, 0, 23, 0, 0,
886  89, 90, 0, 0, -11, 0, 91, 92, 0, 93,
887  0, 0, 94, 0, 0, 0, 95, 0, 0, 0,
888  0, 0, 0, 0, 0, 97, 0, 98, 99, 0,
889  100, 86, 5, 13, 0, 15, 16, 17, 18, 19,
890  0, 0, 101, 0, 87, 88, 0, 23, 0, 0,
891  89, 90, 0, 0, 0, 0, 91, 92, 0, 93,
892  0, 0, 94, 0, 0, 0, 95, 0, 0, 0,
893  0, 0, 0, 0, 0, 97, 0, 98, 99, -14,
894  100, 86, 5, 13, 0, 15, 16, 17, 18, 19,
895  0, 0, 101, 0, 87, 88, 0, 23, 0, 0,
896  89, 90, 0, 0, -14, 0, 91, 92, 0, 93,
897  0, 0, 94, 0, 0, 0, 95, 0, 0, 0,
898  0, 0, 0, 0, 0, 97, 0, 98, 99, 0,
899  100, 86, 5, 13, 0, 15, 16, 17, 18, 19,
900  0, 0, 101, 0, 87, 88, 0, 23, 0, 0,
901  89, 90, 0, 0, 0, 0, 91, 92, 0, 93,
902  0, 0, 94, 0, 0, 0, 95, 0, 0, 0,
903  0, 0, 0, 0, 0, 97, 0, 98, 99, 0,
904  100, 0, 0, 13, 0, 15, 16, 17, 18, 19,
905  0, 0, 101, 0, 0, 0, 0, 23, 136, 137,
906  138, 139, 140, 141, 142, 143, 144, 145, 146, 147,
907  148, 149, 150, 151, 152, 153, 154, 155, 156, 157,
908  158, 159, 160, 161, 162, 163, 164, 165, 166, 167,
909  168, 169, 170, 171, 172, 173, 174, 175, 176, 177,
910  178, 179, 180, 181, 182, 183, 184, 13, 0, 15,
911  16, 17, 18, 19
912 };
913 
914 static const yytype_int16 yycheck[] =
915 {
916  12, 234, 105, 49, 1, 250, 105, 238, 6, 105,
917  113, 49, 20, 242, 5, 242, 101, 6, 311, 6,
918  5, 5, 27, 28, 20, 5, 23, 20, 261, 20,
919  20, 264, 300, 301, 4, 8, 20, 3, 20, 20,
920  72, 87, 74, 242, 7, 8, 9, 66, 341, 54,
921  0, 97, 34, 69, 70, 101, 36, 73, 21, 327,
922  40, 78, 19, 24, 25, 82, 334, 75, 17, 81,
923  49, 300, 301, 300, 301, 68, 88, 89, 76, 75,
924  71, 77, 94, 49, 96, 75, 71, 76, 321, 76,
925  189, 71, 65, 90, 387, 92, 77, 31, 327, 33,
926  327, 300, 301, 396, 397, 334, 24, 334, 87, 72,
927  25, 26, 211, 358, 18, 33, 79, 80, 97, 80,
928  353, 352, 101, 226, 20, 84, 85, 16, 327, 13,
929  14, 216, 22, 20, 81, 334, 369, 69, 56, 57,
930  373, 73, 25, 26, 47, 48, 42, 34, 233, 382,
931  43, 86, 67, 249, 250, 38, 25, 26, 41, 62,
932  206, 64, 65, 66, 67, 68, 50, 51, 52, 62,
933  216, 64, 65, 66, 67, 68, 74, 75, 36, 63,
934  82, 83, 40, 83, 67, 69, 70, 233, 234, 73,
935  64, 93, 238, 74, 78, 207, 66, 67, 68, 69,
936  70, 71, 72, 288, 60, 61, 78, 79, 205, 46,
937  222, 223, 209, 309, 65, 261, 228, 5, 264, 231,
938  217, 378, 379, 71, 77, 310, 311, 206, 62, 75,
939  64, 65, 66, 67, 68, 75, 72, 216, 39, 335,
940  336, 72, 288, 240, 72, 74, 44, 72, 58, 73,
941  77, 248, 75, 37, 233, 234, 341, 46, 270, 238,
942  33, 20, 358, 62, 310, 311, 32, 30, 280, 39,
943  267, 33, 310, 311, 53, 321, 6, 77, 75, 276,
944  31, 33, 261, 33, 45, 264, 62, 62, 62, 33,
945  5, 33, 25, 305, 306, 341, 293, 26, 295, 296,
946  202, 58, 387, 341, 76, 76, 352, 353, 210, 288,
947  5, 396, 397, 30, 33, 58, 313, 77, 67, 77,
948  33, 33, 67, 369, 270, 285, 338, 373, 67, 228,
949  231, 310, 311, 235, 265, 375, 382, 61, 316, 241,
950  317, 387, 321, 354, 62, 73, 77, 63, 258, 387,
951  396, 397, 232, 350, 64, 76, -1, 354, 396, 397,
952  -1, -1, 341, 338, -1, -1, 378, 379, -1, -1,
953  272, 273, -1, 352, 353, -1, -1, -1, -1, 11,
954  282, 283, -1, -1, -1, -1, -1, -1, -1, -1,
955  369, -1, 294, -1, 373, -1, 298, 6, -1, -1,
956  -1, 303, 11, 382, 13, 14, 15, -1, 387, -1,
957  -1, -1, -1, -1, -1, -1, -1, 396, 397, -1,
958  -1, 323, 324, -1, -1, -1, 328, -1, -1, -1,
959  62, -1, 64, 65, 66, 67, 68, -1, -1, -1,
960  -1, 50, 51, 52, 76, -1, 55, -1, -1, 351,
961  -1, -1, -1, 62, 63, 64, 65, 66, 67, 68,
962  69, 70, -1, -1, 73, -1, 75, 76, -1, 78,
963  4, -1, -1, 82, -1, 377, 10, 11, -1, -1,
964  -1, -1, -1, -1, -1, -1, -1, -1, -1, 23,
965  24, 393, 394, -1, -1, 29, 30, -1, -1, -1,
966  -1, 35, 36, -1, 38, -1, -1, 41, -1, -1,
967  -1, 45, -1, -1, -1, -1, -1, -1, -1, 53,
968  54, 5, 56, 57, -1, 59, 10, 11, 62, -1,
969  64, 65, 66, 67, 68, -1, -1, 71, -1, 23,
970  24, -1, 76, -1, -1, 29, 30, -1, -1, -1,
971  -1, 35, 36, -1, 38, -1, 11, 41, 13, 14,
972  15, 45, -1, -1, -1, -1, -1, -1, -1, -1,
973  54, -1, 56, 57, -1, 59, -1, -1, 62, -1,
974  64, 65, 66, 67, 68, -1, -1, 71, -1, -1,
975  -1, -1, 76, -1, -1, 50, 51, 52, -1, 11,
976  55, 13, 14, 15, -1, -1, -1, 62, 63, 64,
977  65, 66, 67, 68, 69, 70, -1, -1, 73, 31,
978  75, 76, -1, 78, -1, -1, -1, 82, 11, -1,
979  13, 14, 15, -1, -1, -1, -1, -1, 50, 51,
980  52, -1, -1, 55, -1, -1, -1, -1, -1, -1,
981  62, 63, 64, 65, 66, 67, 68, 69, 70, -1,
982  -1, 73, -1, -1, 76, -1, 78, 50, 51, 52,
983  82, 11, 55, 13, 14, -1, -1, -1, -1, 62,
984  63, 64, 65, 66, 67, 68, 69, 70, -1, -1,
985  73, -1, -1, 76, -1, 78, -1, -1, -1, 82,
986  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
987  50, 51, 52, -1, -1, 55, -1, -1, -1, -1,
988  -1, -1, 62, 63, 64, 65, 66, 67, 68, 69,
989  70, 10, 11, 73, -1, -1, 76, -1, 78, -1,
990  -1, -1, 82, -1, 23, 24, 25, 26, -1, -1,
991  29, 30, -1, -1, -1, -1, 35, 36, -1, 38,
992  -1, -1, 41, -1, -1, -1, 45, -1, -1, -1,
993  -1, -1, -1, -1, -1, 54, -1, 56, 57, -1,
994  59, 10, 11, 62, -1, 64, 65, 66, 67, 68,
995  -1, -1, 71, -1, 23, 24, -1, 76, -1, -1,
996  29, 30, -1, -1, -1, -1, 35, 36, -1, 38,
997  39, -1, 41, -1, -1, -1, 45, -1, -1, -1,
998  -1, -1, -1, -1, -1, 54, -1, 56, 57, -1,
999  59, 10, 11, 62, -1, 64, 65, 66, 67, 68,
1000  -1, -1, 71, -1, 23, 24, -1, 76, -1, -1,
1001  29, 30, -1, -1, -1, -1, 35, 36, 37, 38,
1002  -1, -1, 41, -1, -1, -1, 45, -1, -1, -1,
1003  -1, -1, -1, -1, -1, 54, -1, 56, 57, -1,
1004  59, 10, 11, 62, -1, 64, 65, 66, 67, 68,
1005  -1, -1, 71, -1, 23, 24, -1, 76, -1, -1,
1006  29, 30, -1, -1, 33, -1, 35, 36, -1, 38,
1007  -1, -1, 41, -1, -1, -1, 45, -1, -1, -1,
1008  -1, -1, -1, -1, -1, 54, -1, 56, 57, -1,
1009  59, 10, 11, 62, -1, 64, 65, 66, 67, 68,
1010  -1, -1, 71, -1, 23, 24, -1, 76, -1, -1,
1011  29, 30, -1, -1, -1, -1, 35, 36, -1, 38,
1012  -1, -1, 41, -1, -1, -1, 45, -1, -1, -1,
1013  -1, -1, -1, -1, -1, 54, -1, 56, 57, 58,
1014  59, 10, 11, 62, -1, 64, 65, 66, 67, 68,
1015  -1, -1, 71, -1, 23, 24, -1, 76, -1, -1,
1016  29, 30, -1, -1, 33, -1, 35, 36, -1, 38,
1017  -1, -1, 41, -1, -1, -1, 45, -1, -1, -1,
1018  -1, -1, -1, -1, -1, 54, -1, 56, 57, -1,
1019  59, 10, 11, 62, -1, 64, 65, 66, 67, 68,
1020  -1, -1, 71, -1, 23, 24, -1, 76, -1, -1,
1021  29, 30, -1, -1, -1, -1, 35, 36, -1, 38,
1022  -1, -1, 41, -1, -1, -1, 45, -1, -1, -1,
1023  -1, -1, -1, -1, -1, 54, -1, 56, 57, -1,
1024  59, -1, -1, 62, -1, 64, 65, 66, 67, 68,
1025  -1, -1, 71, -1, -1, -1, -1, 76, 13, 14,
1026  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
1027  25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
1028  35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
1029  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1030  55, 56, 57, 58, 59, 60, 61, 62, -1, 64,
1031  65, 66, 67, 68
1032 };
1033 
1034  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1035  symbol of state STATE-NUM. */
1036 static const yytype_uint8 yystos[] =
1037 {
1038  0, 3, 49, 88, 89, 11, 13, 14, 15, 50,
1039  51, 52, 55, 62, 63, 64, 65, 66, 67, 68,
1040  69, 70, 73, 76, 78, 82, 91, 98, 119, 120,
1041  121, 122, 123, 124, 125, 126, 127, 128, 129, 130,
1042  131, 132, 133, 134, 135, 137, 147, 66, 0, 90,
1043  124, 147, 119, 132, 132, 4, 6, 76, 114, 117,
1044  5, 20, 19, 18, 17, 16, 7, 8, 9, 21,
1045  72, 79, 80, 81, 78, 82, 22, 83, 84, 85,
1046  86, 74, 5, 71, 149, 4, 10, 23, 24, 29,
1047  30, 35, 36, 38, 41, 45, 53, 54, 56, 57,
1048  59, 71, 95, 96, 97, 98, 107, 133, 138, 141,
1049  142, 143, 77, 75, 116, 119, 120, 121, 122, 123,
1050  124, 126, 126, 126, 126, 126, 126, 126, 127, 128,
1051  128, 129, 130, 131, 131, 132, 13, 14, 15, 16,
1052  17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
1053  27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
1054  37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
1055  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
1056  57, 58, 59, 60, 61, 147, 148, 149, 149, 98,
1057  99, 100, 147, 102, 103, 147, 119, 25, 26, 38,
1058  41, 67, 119, 36, 40, 105, 149, 43, 147, 46,
1059  147, 98, 64, 65, 96, 5, 71, 76, 114, 115,
1060  116, 117, 25, 26, 116, 77, 75, 114, 75, 6,
1061  76, 75, 72, 34, 149, 119, 93, 94, 95, 147,
1062  72, 119, 149, 114, 60, 61, 96, 119, 72, 147,
1063  147, 116, 99, 69, 73, 101, 136, 102, 78, 104,
1064  134, 5, 96, 93, 149, 39, 94, 44, 119, 149,
1065  24, 139, 140, 141, 142, 143, 72, 58, 73, 119,
1066  76, 117, 144, 144, 77, 75, 135, 93, 31, 33,
1067  108, 37, 93, 105, 119, 42, 46, 113, 100, 33,
1068  149, 149, 67, 62, 119, 47, 48, 145, 146, 147,
1069  149, 149, 101, 32, 109, 110, 111, 96, 30, 39,
1070  119, 149, 119, 31, 118, 119, 33, 149, 53, 139,
1071  139, 27, 28, 54, 149, 147, 147, 77, 75, 117,
1072  92, 95, 96, 92, 119, 31, 112, 110, 108, 93,
1073  68, 106, 149, 149, 75, 45, 139, 149, 62, 62,
1074  62, 139, 117, 117, 145, 33, 92, 33, 34, 5,
1075  33, 58, 119, 149, 94, 93, 118, 144, 76, 76,
1076  25, 26, 5, 93, 30, 93, 113, 149, 146, 146,
1077  93, 58, 92, 77, 77, 33, 149, 149, 67, 92,
1078  92, 33, 33, 67, 67
1079 };
1080 
1081  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1082 static const yytype_uint8 yyr1[] =
1083 {
1084  0, 87, 88, 88, 89, 89, 90, 90, 90, 91,
1085  91, 92, 92, 92, 93, 93, 94, 94, 95, 96,
1086  96, 96, 96, 96, 97, 97, 97, 97, 97, 97,
1087  97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
1088  97, 97, 97, 97, 97, 97, 97, 98, 98, 99,
1089  99, 100, 100, 100, 101, 101, 102, 102, 103, 104,
1090  104, 105, 105, 106, 106, 107, 107, 107, 108, 108,
1091  109, 109, 110, 110, 111, 112, 112, 113, 113, 113,
1092  114, 114, 115, 115, 116, 116, 116, 117, 117, 118,
1093  118, 119, 119, 120, 120, 121, 121, 122, 122, 123,
1094  123, 124, 124, 125, 125, 125, 125, 125, 125, 125,
1095  125, 126, 126, 127, 127, 127, 128, 128, 129, 129,
1096  130, 130, 130, 131, 131, 132, 132, 132, 132, 132,
1097  133, 133, 134, 134, 134, 134, 134, 134, 134, 135,
1098  135, 135, 136, 136, 137, 137, 138, 139, 139, 139,
1099  139, 139, 139, 139, 139, 139, 140, 140, 140, 141,
1100  141, 142, 142, 143, 143, 143, 144, 144, 145, 145,
1101  146, 146, 146, 147, 147, 147, 147, 147, 147, 148,
1102  148, 148, 148, 148, 148, 148, 148, 148, 148, 148,
1103  148, 148, 148, 148, 148, 148, 148, 148, 148, 148,
1104  148, 148, 148, 148, 148, 148, 148, 148, 148, 148,
1105  148, 148, 148, 148, 148, 148, 148, 148, 148, 148,
1106  148, 148, 148, 148, 148, 148, 148, 148, 148, 149,
1107  149, 149, 149
1108 };
1109 
1110  /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
1111 static const yytype_uint8 yyr2[] =
1112 {
1113  0, 2, 3, 3, 0, 3, 0, 2, 2, 0,
1114  2, 0, 1, 2, 0, 1, 1, 2, 2, 1,
1115  2, 1, 3, 2, 2, 3, 4, 2, 1, 5,
1116  6, 6, 4, 1, 2, 2, 2, 2, 2, 5,
1117  1, 4, 4, 2, 10, 8, 7, 1, 3, 1,
1118  3, 1, 4, 2, 1, 3, 1, 3, 3, 1,
1119  2, 1, 1, 0, 2, 9, 5, 7, 0, 2,
1120  0, 1, 1, 2, 5, 0, 3, 0, 4, 5,
1121  1, 3, 1, 1, 1, 3, 2, 0, 1, 1,
1122  3, 1, 3, 1, 3, 1, 3, 1, 3, 1,
1123  3, 1, 2, 1, 3, 3, 3, 3, 3, 3,
1124  3, 1, 3, 1, 3, 3, 1, 3, 1, 3,
1125  1, 3, 3, 1, 3, 1, 1, 2, 2, 2,
1126  1, 2, 1, 1, 1, 1, 1, 1, 1, 1,
1127  1, 1, 1, 1, 3, 1, 7, 0, 1, 3,
1128  2, 4, 2, 4, 1, 3, 9, 11, 11, 8,
1129  8, 0, 1, 2, 1, 1, 1, 3, 1, 3,
1130  2, 3, 3, 1, 1, 1, 1, 1, 1, 1,
1131  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1132  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1133  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1134  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1135  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1136  1, 2, 2
1137 };
1138 
1139 
1140 #define yyerrok (yyerrstatus = 0)
1141 #define yyclearin (yychar = YYEMPTY)
1142 #define YYEMPTY (-2)
1143 #define YYEOF 0
1144 
1145 #define YYACCEPT goto yyacceptlab
1146 #define YYABORT goto yyabortlab
1147 #define YYERROR goto yyerrorlab
1148 
1149 
1150 #define YYRECOVERING() (!!yyerrstatus)
1151 
1152 #define YYBACKUP(Token, Value) \
1153  do \
1154  if (yychar == YYEMPTY) \
1155  { \
1156  yychar = (Token); \
1157  yylval = (Value); \
1158  YYPOPSTACK (yylen); \
1159  yystate = *yyssp; \
1160  goto yybackup; \
1161  } \
1162  else \
1163  { \
1164  yyerror (ctx, YY_("syntax error: cannot back up")); \
1165  YYERROR; \
1166  } \
1167  while (0)
1168 
1169 /* Error token number */
1170 #define YYTERROR 1
1171 #define YYERRCODE 256
1172 
1173 
1174 
1175 /* Enable debugging if requested. */
1176 #if YYDEBUG
1177 
1178 # ifndef YYFPRINTF
1179 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1180 # define YYFPRINTF fprintf
1181 # endif
1182 
1183 # define YYDPRINTF(Args) \
1184 do { \
1185  if (yydebug) \
1186  YYFPRINTF Args; \
1187 } while (0)
1188 
1189 /* This macro is provided for backward compatibility. */
1190 #ifndef YY_LOCATION_PRINT
1191 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1192 #endif
1193 
1194 
1195 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1196 do { \
1197  if (yydebug) \
1198  { \
1199  YYFPRINTF (stderr, "%s ", Title); \
1200  yy_symbol_print (stderr, \
1201  Type, Value, ctx); \
1202  YYFPRINTF (stderr, "\n"); \
1203  } \
1204 } while (0)
1205 
1206 
1207 /*-----------------------------------.
1208 | Print this symbol's value on YYO. |
1209 `-----------------------------------*/
1210 
1211 static void
1212 yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, parser_ctx_t *ctx)
1213 {
1214  FILE *yyoutput = yyo;
1215  YYUSE (yyoutput);
1216  YYUSE (ctx);
1217  if (!yyvaluep)
1218  return;
1219 # ifdef YYPRINT
1220  if (yytype < YYNTOKENS)
1221  YYPRINT (yyo, yytoknum[yytype], *yyvaluep);
1222 # endif
1223  YYUSE (yytype);
1224 }
1225 
1226 
1227 /*---------------------------.
1228 | Print this symbol on YYO. |
1229 `---------------------------*/
1230 
1231 static void
1232 yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, parser_ctx_t *ctx)
1233 {
1234  YYFPRINTF (yyo, "%s %s (",
1235  yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
1236 
1237  yy_symbol_value_print (yyo, yytype, yyvaluep, ctx);
1238  YYFPRINTF (yyo, ")");
1239 }
1240 
1241 /*------------------------------------------------------------------.
1242 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1243 | TOP (included). |
1244 `------------------------------------------------------------------*/
1245 
1246 static void
1247 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1248 {
1249  YYFPRINTF (stderr, "Stack now");
1250  for (; yybottom <= yytop; yybottom++)
1251  {
1252  int yybot = *yybottom;
1253  YYFPRINTF (stderr, " %d", yybot);
1254  }
1255  YYFPRINTF (stderr, "\n");
1256 }
1257 
1258 # define YY_STACK_PRINT(Bottom, Top) \
1259 do { \
1260  if (yydebug) \
1261  yy_stack_print ((Bottom), (Top)); \
1262 } while (0)
1263 
1264 
1265 /*------------------------------------------------.
1266 | Report that the YYRULE is going to be reduced. |
1267 `------------------------------------------------*/
1268 
1269 static void
1270 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, parser_ctx_t *ctx)
1271 {
1272  unsigned long yylno = yyrline[yyrule];
1273  int yynrhs = yyr2[yyrule];
1274  int yyi;
1275  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1276  yyrule - 1, yylno);
1277  /* The symbols being reduced. */
1278  for (yyi = 0; yyi < yynrhs; yyi++)
1279  {
1280  YYFPRINTF (stderr, " $%d = ", yyi + 1);
1281  yy_symbol_print (stderr,
1282  yystos[yyssp[yyi + 1 - yynrhs]],
1283  &yyvsp[(yyi + 1) - (yynrhs)]
1284  , ctx);
1285  YYFPRINTF (stderr, "\n");
1286  }
1287 }
1288 
1289 # define YY_REDUCE_PRINT(Rule) \
1290 do { \
1291  if (yydebug) \
1292  yy_reduce_print (yyssp, yyvsp, Rule, ctx); \
1293 } while (0)
1294 
1295 /* Nonzero means print parse trace. It is left uninitialized so that
1296  multiple parsers can coexist. */
1297 int yydebug;
1298 #else /* !YYDEBUG */
1299 # define YYDPRINTF(Args)
1300 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1301 # define YY_STACK_PRINT(Bottom, Top)
1302 # define YY_REDUCE_PRINT(Rule)
1303 #endif /* !YYDEBUG */
1304 
1305 
1306 /* YYINITDEPTH -- initial size of the parser's stacks. */
1307 #ifndef YYINITDEPTH
1308 # define YYINITDEPTH 200
1309 #endif
1310 
1311 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1312  if the built-in stack extension method is used).
1313 
1314  Do not make this value too large; the results are undefined if
1315  YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1316  evaluated with infinite-precision integer arithmetic. */
1317 
1318 #ifndef YYMAXDEPTH
1319 # define YYMAXDEPTH 10000
1320 #endif
1321 
1322 
1323 #if YYERROR_VERBOSE
1324 
1325 # ifndef yystrlen
1326 # if defined __GLIBC__ && defined _STRING_H
1327 # define yystrlen strlen
1328 # else
1329 /* Return the length of YYSTR. */
1330 static YYSIZE_T
1331 yystrlen (const char *yystr)
1332 {
1333  YYSIZE_T yylen;
1334  for (yylen = 0; yystr[yylen]; yylen++)
1335  continue;
1336  return yylen;
1337 }
1338 # endif
1339 # endif
1340 
1341 # ifndef yystpcpy
1342 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1343 # define yystpcpy stpcpy
1344 # else
1345 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1346  YYDEST. */
1347 static char *
1348 yystpcpy (char *yydest, const char *yysrc)
1349 {
1350  char *yyd = yydest;
1351  const char *yys = yysrc;
1352 
1353  while ((*yyd++ = *yys++) != '\0')
1354  continue;
1355 
1356  return yyd - 1;
1357 }
1358 # endif
1359 # endif
1360 
1361 # ifndef yytnamerr
1362 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1363  quotes and backslashes, so that it's suitable for yyerror. The
1364  heuristic is that double-quoting is unnecessary unless the string
1365  contains an apostrophe, a comma, or backslash (other than
1366  backslash-backslash). YYSTR is taken from yytname. If YYRES is
1367  null, do not copy; instead, return the length of what the result
1368  would have been. */
1369 static YYSIZE_T
1370 yytnamerr (char *yyres, const char *yystr)
1371 {
1372  if (*yystr == '"')
1373  {
1374  YYSIZE_T yyn = 0;
1375  char const *yyp = yystr;
1376 
1377  for (;;)
1378  switch (*++yyp)
1379  {
1380  case '\'':
1381  case ',':
1382  goto do_not_strip_quotes;
1383 
1384  case '\\':
1385  if (*++yyp != '\\')
1386  goto do_not_strip_quotes;
1387  else
1388  goto append;
1389 
1390  append:
1391  default:
1392  if (yyres)
1393  yyres[yyn] = *yyp;
1394  yyn++;
1395  break;
1396 
1397  case '"':
1398  if (yyres)
1399  yyres[yyn] = '\0';
1400  return yyn;
1401  }
1402  do_not_strip_quotes: ;
1403  }
1404 
1405  if (! yyres)
1406  return yystrlen (yystr);
1407 
1408  return (YYSIZE_T) (yystpcpy (yyres, yystr) - yyres);
1409 }
1410 # endif
1411 
1412 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1413  about the unexpected token YYTOKEN for the state stack whose top is
1414  YYSSP.
1415 
1416  Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
1417  not large enough to hold the message. In that case, also set
1418  *YYMSG_ALLOC to the required number of bytes. Return 2 if the
1419  required number of bytes is too large to store. */
1420 static int
1421 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1422  yytype_int16 *yyssp, int yytoken)
1423 {
1424  YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
1425  YYSIZE_T yysize = yysize0;
1426  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1427  /* Internationalized format string. */
1428  const char *yyformat = YY_NULLPTR;
1429  /* Arguments of yyformat. */
1430  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1431  /* Number of reported tokens (one for the "unexpected", one per
1432  "expected"). */
1433  int yycount = 0;
1434 
1435  /* There are many possibilities here to consider:
1436  - If this state is a consistent state with a default action, then
1437  the only way this function was invoked is if the default action
1438  is an error action. In that case, don't check for expected
1439  tokens because there are none.
1440  - The only way there can be no lookahead present (in yychar) is if
1441  this state is a consistent state with a default action. Thus,
1442  detecting the absence of a lookahead is sufficient to determine
1443  that there is no unexpected or expected token to report. In that
1444  case, just report a simple "syntax error".
1445  - Don't assume there isn't a lookahead just because this state is a
1446  consistent state with a default action. There might have been a
1447  previous inconsistent state, consistent state with a non-default
1448  action, or user semantic action that manipulated yychar.
1449  - Of course, the expected token list depends on states to have
1450  correct lookahead information, and it depends on the parser not
1451  to perform extra reductions after fetching a lookahead from the
1452  scanner and before detecting a syntax error. Thus, state merging
1453  (from LALR or IELR) and default reductions corrupt the expected
1454  token list. However, the list is correct for canonical LR with
1455  one exception: it will still contain any token that will not be
1456  accepted due to an error action in a later state.
1457  */
1458  if (yytoken != YYEMPTY)
1459  {
1460  int yyn = yypact[*yyssp];
1461  yyarg[yycount++] = yytname[yytoken];
1462  if (!yypact_value_is_default (yyn))
1463  {
1464  /* Start YYX at -YYN if negative to avoid negative indexes in
1465  YYCHECK. In other words, skip the first -YYN actions for
1466  this state because they are default actions. */
1467  int yyxbegin = yyn < 0 ? -yyn : 0;
1468  /* Stay within bounds of both yycheck and yytname. */
1469  int yychecklim = YYLAST - yyn + 1;
1470  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1471  int yyx;
1472 
1473  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1474  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1475  && !yytable_value_is_error (yytable[yyx + yyn]))
1476  {
1477  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1478  {
1479  yycount = 1;
1480  yysize = yysize0;
1481  break;
1482  }
1483  yyarg[yycount++] = yytname[yyx];
1484  {
1485  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
1486  if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
1487  yysize = yysize1;
1488  else
1489  return 2;
1490  }
1491  }
1492  }
1493  }
1494 
1495  switch (yycount)
1496  {
1497 # define YYCASE_(N, S) \
1498  case N: \
1499  yyformat = S; \
1500  break
1501  default: /* Avoid compiler warnings. */
1502  YYCASE_(0, YY_("syntax error"));
1503  YYCASE_(1, YY_("syntax error, unexpected %s"));
1504  YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1505  YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1506  YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1507  YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1508 # undef YYCASE_
1509  }
1510 
1511  {
1512  YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
1513  if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
1514  yysize = yysize1;
1515  else
1516  return 2;
1517  }
1518 
1519  if (*yymsg_alloc < yysize)
1520  {
1521  *yymsg_alloc = 2 * yysize;
1522  if (! (yysize <= *yymsg_alloc
1523  && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1524  *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1525  return 1;
1526  }
1527 
1528  /* Avoid sprintf, as that infringes on the user's name space.
1529  Don't have undefined behavior even if the translation
1530  produced a string with the wrong number of "%s"s. */
1531  {
1532  char *yyp = *yymsg;
1533  int yyi = 0;
1534  while ((*yyp = *yyformat) != '\0')
1535  if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1536  {
1537  yyp += yytnamerr (yyp, yyarg[yyi++]);
1538  yyformat += 2;
1539  }
1540  else
1541  {
1542  yyp++;
1543  yyformat++;
1544  }
1545  }
1546  return 0;
1547 }
1548 #endif /* YYERROR_VERBOSE */
1549 
1550 /*-----------------------------------------------.
1551 | Release the memory associated to this symbol. |
1552 `-----------------------------------------------*/
1553 
1554 static void
1555 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, parser_ctx_t *ctx)
1556 {
1557  YYUSE (yyvaluep);
1558  YYUSE (ctx);
1559  if (!yymsg)
1560  yymsg = "Deleting";
1561  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1562 
1563  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1564  YYUSE (yytype);
1565  YY_IGNORE_MAYBE_UNINITIALIZED_END
1566 }
1567 
1568 
1569 
1570 
1571 /*----------.
1572 | yyparse. |
1573 `----------*/
1574 
1575 int
1576 yyparse (parser_ctx_t *ctx)
1577 {
1578 /* The lookahead symbol. */
1579 int yychar;
1580 
1581 
1582 /* The semantic value of the lookahead symbol. */
1583 /* Default value used for initialization, for pacifying older GCCs
1584  or non-GCC compilers. */
1585 YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
1586 YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
1587 
1588  /* Number of syntax errors so far. */
1589  int yynerrs;
1590 
1591  int yystate;
1592  /* Number of tokens to shift before error messages enabled. */
1593  int yyerrstatus;
1594 
1595  /* The stacks and their tools:
1596  'yyss': related to states.
1597  'yyvs': related to semantic values.
1598 
1599  Refer to the stacks through separate pointers, to allow yyoverflow
1600  to reallocate them elsewhere. */
1601 
1602  /* The state stack. */
1603  yytype_int16 yyssa[YYINITDEPTH];
1604  yytype_int16 *yyss;
1605  yytype_int16 *yyssp;
1606 
1607  /* The semantic value stack. */
1608  YYSTYPE yyvsa[YYINITDEPTH];
1609  YYSTYPE *yyvs;
1610  YYSTYPE *yyvsp;
1611 
1612  YYSIZE_T yystacksize;
1613 
1614  int yyn;
1615  int yyresult;
1616  /* Lookahead token as an internal (translated) token number. */
1617  int yytoken = 0;
1618  /* The variables used to return semantic value and location from the
1619  action routines. */
1620  YYSTYPE yyval;
1621 
1622 #if YYERROR_VERBOSE
1623  /* Buffer for error messages, and its allocated size. */
1624  char yymsgbuf[128];
1625  char *yymsg = yymsgbuf;
1626  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1627 #endif
1628 
1629 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1630 
1631  /* The number of symbols on the RHS of the reduced rule.
1632  Keep to zero when no symbol should be popped. */
1633  int yylen = 0;
1634 
1635  yyssp = yyss = yyssa;
1636  yyvsp = yyvs = yyvsa;
1637  yystacksize = YYINITDEPTH;
1638 
1639  YYDPRINTF ((stderr, "Starting parse\n"));
1640 
1641  yystate = 0;
1642  yyerrstatus = 0;
1643  yynerrs = 0;
1644  yychar = YYEMPTY; /* Cause a token to be read. */
1645  goto yysetstate;
1646 
1647 
1648 /*------------------------------------------------------------.
1649 | yynewstate -- push a new state, which is found in yystate. |
1650 `------------------------------------------------------------*/
1651 yynewstate:
1652  /* In all cases, when you get here, the value and location stacks
1653  have just been pushed. So pushing a state here evens the stacks. */
1654  yyssp++;
1655 
1656 
1657 /*--------------------------------------------------------------------.
1658 | yynewstate -- set current state (the top of the stack) to yystate. |
1659 `--------------------------------------------------------------------*/
1660 yysetstate:
1661  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1662  YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
1663  *yyssp = (yytype_int16) yystate;
1664 
1665  if (yyss + yystacksize - 1 <= yyssp)
1666 #if !defined yyoverflow && !defined YYSTACK_RELOCATE
1667  goto yyexhaustedlab;
1668 #else
1669  {
1670  /* Get the current used size of the three stacks, in elements. */
1671  YYSIZE_T yysize = (YYSIZE_T) (yyssp - yyss + 1);
1672 
1673 # if defined yyoverflow
1674  {
1675  /* Give user a chance to reallocate the stack. Use copies of
1676  these so that the &'s don't force the real ones into
1677  memory. */
1678  YYSTYPE *yyvs1 = yyvs;
1679  yytype_int16 *yyss1 = yyss;
1680 
1681  /* Each stack pointer address is followed by the size of the
1682  data in use in that stack, in bytes. This used to be a
1683  conditional around just the two extra args, but that might
1684  be undefined if yyoverflow is a macro. */
1685  yyoverflow (YY_("memory exhausted"),
1686  &yyss1, yysize * sizeof (*yyssp),
1687  &yyvs1, yysize * sizeof (*yyvsp),
1688  &yystacksize);
1689  yyss = yyss1;
1690  yyvs = yyvs1;
1691  }
1692 # else /* defined YYSTACK_RELOCATE */
1693  /* Extend the stack our own way. */
1694  if (YYMAXDEPTH <= yystacksize)
1695  goto yyexhaustedlab;
1696  yystacksize *= 2;
1697  if (YYMAXDEPTH < yystacksize)
1698  yystacksize = YYMAXDEPTH;
1699 
1700  {
1701  yytype_int16 *yyss1 = yyss;
1702  union yyalloc *yyptr =
1703  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1704  if (! yyptr)
1705  goto yyexhaustedlab;
1706  YYSTACK_RELOCATE (yyss_alloc, yyss);
1707  YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1708 # undef YYSTACK_RELOCATE
1709  if (yyss1 != yyssa)
1710  YYSTACK_FREE (yyss1);
1711  }
1712 # endif
1713 
1714  yyssp = yyss + yysize - 1;
1715  yyvsp = yyvs + yysize - 1;
1716 
1717  YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1718  (unsigned long) yystacksize));
1719 
1720  if (yyss + yystacksize - 1 <= yyssp)
1721  YYABORT;
1722  }
1723 #endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
1724 
1725  if (yystate == YYFINAL)
1726  YYACCEPT;
1727 
1728  goto yybackup;
1729 
1730 
1731 /*-----------.
1732 | yybackup. |
1733 `-----------*/
1734 yybackup:
1735  /* Do appropriate processing given the current state. Read a
1736  lookahead token if we need one and don't already have one. */
1737 
1738  /* First try to decide what to do without reference to lookahead token. */
1739  yyn = yypact[yystate];
1740  if (yypact_value_is_default (yyn))
1741  goto yydefault;
1742 
1743  /* Not known => get a lookahead token if don't already have one. */
1744 
1745  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1746  if (yychar == YYEMPTY)
1747  {
1748  YYDPRINTF ((stderr, "Reading a token: "));
1749  yychar = yylex (&yylval, ctx);
1750  }
1751 
1752  if (yychar <= YYEOF)
1753  {
1754  yychar = yytoken = YYEOF;
1755  YYDPRINTF ((stderr, "Now at end of input.\n"));
1756  }
1757  else
1758  {
1759  yytoken = YYTRANSLATE (yychar);
1760  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1761  }
1762 
1763  /* If the proper action on seeing token YYTOKEN is to reduce or to
1764  detect an error, take that action. */
1765  yyn += yytoken;
1766  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1767  goto yydefault;
1768  yyn = yytable[yyn];
1769  if (yyn <= 0)
1770  {
1771  if (yytable_value_is_error (yyn))
1772  goto yyerrlab;
1773  yyn = -yyn;
1774  goto yyreduce;
1775  }
1776 
1777  /* Count tokens shifted since error; after three, turn off error
1778  status. */
1779  if (yyerrstatus)
1780  yyerrstatus--;
1781 
1782  /* Shift the lookahead token. */
1783  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1784 
1785  /* Discard the shifted token. */
1786  yychar = YYEMPTY;
1787 
1788  yystate = yyn;
1789  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1790  *++yyvsp = yylval;
1791  YY_IGNORE_MAYBE_UNINITIALIZED_END
1792  goto yynewstate;
1793 
1794 
1795 /*-----------------------------------------------------------.
1796 | yydefault -- do the default action for the current state. |
1797 `-----------------------------------------------------------*/
1798 yydefault:
1799  yyn = yydefact[yystate];
1800  if (yyn == 0)
1801  goto yyerrlab;
1802  goto yyreduce;
1803 
1804 
1805 /*-----------------------------.
1806 | yyreduce -- do a reduction. |
1807 `-----------------------------*/
1808 yyreduce:
1809  /* yyn is the number of a rule to reduce with. */
1810  yylen = yyr2[yyn];
1811 
1812  /* If YYLEN is nonzero, implement the default value of the action:
1813  '$$ = $1'.
1814 
1815  Otherwise, the following line sets YYVAL to garbage.
1816  This behavior is undocumented and Bison
1817  users should not rely upon it. Assigning to YYVAL
1818  unconditionally makes the parser a bit smaller, and it avoids a
1819  GCC warning that YYVAL may be used uninitialized. */
1820  yyval = yyvsp[1-yylen];
1821 
1822 
1823  YY_REDUCE_PRINT (yyn);
1824  switch (yyn)
1825  {
1826  case 2:
1827 #line 148 "parser.y"
1828  { parse_complete(ctx, (yyvsp[-2].boolean)); }
1829 #line 1830 "parser.tab.c"
1830  break;
1831 
1832  case 3:
1833 #line 149 "parser.y"
1834  { handle_isexpression_script(ctx, (yyvsp[-1].expression)); }
1835 #line 1836 "parser.tab.c"
1836  break;
1837 
1838  case 4:
1839 #line 152 "parser.y"
1840  { (yyval.boolean) = FALSE; }
1841 #line 1842 "parser.tab.c"
1842  break;
1843 
1844  case 5:
1845 #line 153 "parser.y"
1846  { (yyval.boolean) = TRUE; }
1847 #line 1848 "parser.tab.c"
1848  break;
1849 
1850  case 7:
1851 #line 157 "parser.y"
1852  { source_add_statement(ctx, (yyvsp[0].statement)); }
1853 #line 1854 "parser.tab.c"
1854  break;
1855 
1856  case 8:
1857 #line 158 "parser.y"
1858  { source_add_class(ctx, (yyvsp[0].class_decl)); }
1859 #line 1860 "parser.tab.c"
1860  break;
1861 
1862  case 9:
1863 #line 161 "parser.y"
1864  { (yyval.expression) = NULL; }
1865 #line 1866 "parser.tab.c"
1866  break;
1867 
1868  case 10:
1869 #line 162 "parser.y"
1870  { (yyval.expression) = (yyvsp[-1].expression); }
1871 #line 1872 "parser.tab.c"
1872  break;
1873 
1874  case 11:
1875 #line 165 "parser.y"
1876  { (yyval.statement) = NULL; }
1877 #line 1878 "parser.tab.c"
1878  break;
1879 
1880  case 12:
1881 #line 166 "parser.y"
1882  { (yyval.statement) = (yyvsp[0].statement); }
1883 #line 1884 "parser.tab.c"
1884  break;
1885 
1886  case 13:
1887 #line 167 "parser.y"
1888  { (yyval.statement) = link_statements((yyvsp[-1].statement), (yyvsp[0].statement)); }
1889 #line 1890 "parser.tab.c"
1890  break;
1891 
1892  case 14:
1893 #line 170 "parser.y"
1894  { (yyval.statement) = NULL; }
1895 #line 1896 "parser.tab.c"
1896  break;
1897 
1898  case 15:
1899 #line 171 "parser.y"
1900  { (yyval.statement) = (yyvsp[0].statement); }
1901 #line 1902 "parser.tab.c"
1902  break;
1903 
1904  case 16:
1905 #line 174 "parser.y"
1906  { (yyval.statement) = (yyvsp[0].statement); }
1907 #line 1908 "parser.tab.c"
1908  break;
1909 
1910  case 17:
1911 #line 175 "parser.y"
1912  { (yyval.statement) = link_statements((yyvsp[-1].statement), (yyvsp[0].statement)); }
1913 #line 1914 "parser.tab.c"
1914  break;
1915 
1916  case 18:
1917 #line 178 "parser.y"
1918  { (yyval.statement) = (yyvsp[-1].statement); }
1919 #line 1920 "parser.tab.c"
1920  break;
1921 
1922  case 19:
1923 #line 181 "parser.y"
1924  { (yyval.statement) = NULL; }
1925 #line 1926 "parser.tab.c"
1926  break;
1927 
1928  case 20:
1929 #line 182 "parser.y"
1930  { (yyval.statement) = (yyvsp[0].statement); }
1931 #line 1932 "parser.tab.c"
1932  break;
1933 
1934  case 21:
1935 #line 183 "parser.y"
1936  { (yyval.statement) = (yyvsp[0].statement); }
1937 #line 1938 "parser.tab.c"
1938  break;
1939 
1940  case 22:
1941 #line 184 "parser.y"
1942  { (yyvsp[-2].statement)->next = (yyvsp[0].statement); (yyval.statement) = (yyvsp[-2].statement); }
1943 #line 1944 "parser.tab.c"
1944  break;
1945 
1946  case 23:
1947 #line 185 "parser.y"
1948  { (yyval.statement) = (yyvsp[-1].statement); }
1949 #line 1950 "parser.tab.c"
1950  break;
1951 
1952  case 24:
1953 #line 188 "parser.y"
1954  { (yyvsp[-1].member)->args = (yyvsp[0].expression); (yyval.statement) = new_call_statement(ctx, FALSE, (yyvsp[-1].member)); CHECK_ERROR; }
1955 #line 1956 "parser.tab.c"
1956  break;
1957 
1958  case 25:
1959 #line 189 "parser.y"
1960  { (yyvsp[-1].member)->args = (yyvsp[0].expression); (yyval.statement) = new_call_statement(ctx, TRUE, (yyvsp[-1].member)); CHECK_ERROR; }
1961 #line 1962 "parser.tab.c"
1962  break;
1963 
1964  case 26:
1965 #line 191 "parser.y"
1966  { (yyvsp[-3].member)->args = (yyvsp[-2].expression); (yyval.statement) = new_assign_statement(ctx, (yyvsp[-3].member), (yyvsp[0].expression)); CHECK_ERROR; }
1967 #line 1968 "parser.tab.c"
1968  break;
1969 
1970  case 27:
1971 #line 192 "parser.y"
1972  { (yyval.statement) = new_dim_statement(ctx, (yyvsp[0].dim_decl)); CHECK_ERROR; }
1973 #line 1974 "parser.tab.c"
1974  break;
1975 
1976  case 28:
1977 #line 193 "parser.y"
1978  { (yyval.statement) = (yyvsp[0].statement); }
1979 #line 1980 "parser.tab.c"
1980  break;
1981 
1982  case 29:
1983 #line 195 "parser.y"
1984  { (yyval.statement) = new_while_statement(ctx, STAT_WHILE, (yyvsp[-3].expression), (yyvsp[-1].statement)); CHECK_ERROR; }
1985 #line 1986 "parser.tab.c"
1986  break;
1987 
1988  case 30:
1989 #line 197 "parser.y"
1990  { (yyval.statement) = new_while_statement(ctx, (yyvsp[-4].boolean) ? STAT_WHILELOOP : STAT_UNTIL, (yyvsp[-3].expression), (yyvsp[-1].statement));
1991  CHECK_ERROR; }
1992 #line 1993 "parser.tab.c"
1993  break;
1994 
1995  case 31:
1996 #line 200 "parser.y"
1997  { (yyval.statement) = new_while_statement(ctx, (yyvsp[-1].boolean) ? STAT_DOWHILE : STAT_DOUNTIL, (yyvsp[0].expression), (yyvsp[-3].statement));
1998  CHECK_ERROR; }
1999 #line 2000 "parser.tab.c"
2000  break;
2001 
2002  case 32:
2003 #line 202 "parser.y"
2004  { (yyval.statement) = new_while_statement(ctx, STAT_DOWHILE, NULL, (yyvsp[-1].statement)); CHECK_ERROR; }
2005 #line 2006 "parser.tab.c"
2006  break;
2007 
2008  case 33:
2009 #line 203 "parser.y"
2010  { (yyval.statement) = new_function_statement(ctx, (yyvsp[0].func_decl)); CHECK_ERROR; }
2011 #line 2012 "parser.tab.c"
2012  break;
2013 
2014  case 34:
2015 #line 204 "parser.y"
2016  { (yyval.statement) = new_statement(ctx, STAT_EXITDO, 0); CHECK_ERROR; }
2017 #line 2018 "parser.tab.c"
2018  break;
2019 
2020  case 35:
2021 #line 205 "parser.y"
2022  { (yyval.statement) = new_statement(ctx, STAT_EXITFOR, 0); CHECK_ERROR; }
2023 #line 2024 "parser.tab.c"
2024  break;
2025 
2026  case 36:
2027 #line 206 "parser.y"
2028  { (yyval.statement) = new_statement(ctx, STAT_EXITFUNC, 0); CHECK_ERROR; }
2029 #line 2030 "parser.tab.c"
2030  break;
2031 
2032  case 37:
2033 #line 207 "parser.y"
2034  { (yyval.statement) = new_statement(ctx, STAT_EXITPROP, 0); CHECK_ERROR; }
2035 #line 2036 "parser.tab.c"
2036  break;
2037 
2038  case 38:
2039 #line 208 "parser.y"
2040  { (yyval.statement) = new_statement(ctx, STAT_EXITSUB, 0); CHECK_ERROR; }
2041 #line 2042 "parser.tab.c"
2042  break;
2043 
2044  case 39:
2045 #line 210 "parser.y"
2046  { (yyvsp[-3].member)->args = (yyvsp[-2].expression); (yyval.statement) = new_set_statement(ctx, (yyvsp[-3].member), (yyvsp[0].expression)); CHECK_ERROR; }
2047 #line 2048 "parser.tab.c"
2048  break;
2049 
2050  case 40:
2051 #line 211 "parser.y"
2052  { (yyval.statement) = new_statement(ctx, STAT_STOP, 0); CHECK_ERROR; }
2053 #line 2054 "parser.tab.c"
2054  break;
2055 
2056  case 41:
2057 #line 212 "parser.y"
2058  { (yyval.statement) = new_onerror_statement(ctx, TRUE); CHECK_ERROR; }
2059 #line 2060 "parser.tab.c"
2060  break;
2061 
2062  case 42:
2063 #line 213 "parser.y"
2064  { (yyval.statement) = new_onerror_statement(ctx, FALSE); CHECK_ERROR; }
2065 #line 2066 "parser.tab.c"
2066  break;
2067 
2068  case 43:
2069 #line 214 "parser.y"
2070  { (yyval.statement) = new_const_statement(ctx, (yyvsp[0].const_decl)); CHECK_ERROR; }
2071 #line 2072 "parser.tab.c"
2072  break;
2073 
2074  case 44:
2075 #line 216 "parser.y"
2076  { (yyval.statement) = new_forto_statement(ctx, (yyvsp[-8].string), (yyvsp[-6].expression), (yyvsp[-4].expression), (yyvsp[-3].expression), (yyvsp[-1].statement)); CHECK_ERROR; }
2077 #line 2078 "parser.tab.c"
2078  break;
2079 
2080  case 45:
2081 #line 218 "parser.y"
2082  { (yyval.statement) = new_foreach_statement(ctx, (yyvsp[-5].string), (yyvsp[-3].expression), (yyvsp[-1].statement)); }
2083 #line 2084 "parser.tab.c"
2084  break;
2085 
2086  case 46:
2087 #line 220 "parser.y"
2088  { (yyval.statement) = new_select_statement(ctx, (yyvsp[-4].expression), (yyvsp[-2].case_clausule)); }
2089 #line 2090 "parser.tab.c"
2090  break;
2091 
2092  case 47:
2093 #line 223 "parser.y"
2094  { (yyval.member) = new_member_expression(ctx, NULL, (yyvsp[0].string)); CHECK_ERROR; }
2095 #line 2096 "parser.tab.c"
2096  break;
2097 
2098  case 48:
2099 #line 224 "parser.y"
2100  { (yyval.member) = new_member_expression(ctx, (yyvsp[-2].expression), (yyvsp[0].string)); CHECK_ERROR; }
2101 #line 2102 "parser.tab.c"
2102  break;
2103 
2104  case 49:
2105 #line 227 "parser.y"
2106  { (yyval.dim_decl) = (yyvsp[0].dim_decl); }
2107 #line 2108 "parser.tab.c"
2108  break;
2109 
2110  case 50:
2111 #line 228 "parser.y"
2112  { (yyvsp[-2].dim_decl)->next = (yyvsp[0].dim_decl); (yyval.dim_decl) = (yyvsp[-2].dim_decl); }
2113 #line 2114 "parser.tab.c"
2114  break;
2115 
2116  case 51:
2117 #line 231 "parser.y"
2118  { (yyval.dim_decl) = new_dim_decl(ctx, (yyvsp[0].string), FALSE, NULL); CHECK_ERROR; }
2119 #line 2120 "parser.tab.c"
2120  break;
2121 
2122  case 52:
2123 #line 232 "parser.y"
2124  { (yyval.dim_decl) = new_dim_decl(ctx, (yyvsp[-3].string), TRUE, (yyvsp[-1].dim_list)); CHECK_ERROR; }
2125 #line 2126 "parser.tab.c"
2126  break;
2127 
2128  case 53:
2129 #line 233 "parser.y"
2130  { (yyval.dim_decl) = new_dim_decl(ctx, (yyvsp[-1].string), TRUE, NULL); CHECK_ERROR; }
2131 #line 2132 "parser.tab.c"
2132  break;
2133 
2134  case 54:
2135 #line 236 "parser.y"
2136  { (yyval.dim_list) = new_dim(ctx, (yyvsp[0].uint), NULL); }
2137 #line 2138 "parser.tab.c"
2138  break;
2139 
2140  case 55:
2141 #line 237 "parser.y"
2142  { (yyval.dim_list) = new_dim(ctx, (yyvsp[-2].uint), (yyvsp[0].dim_list)); }
2143 #line 2144 "parser.tab.c"
2144  break;
2145 
2146  case 56:
2147 #line 240 "parser.y"
2148  { (yyval.const_decl) = (yyvsp[0].const_decl); }
2149 #line 2150 "parser.tab.c"
2150  break;
2151 
2152  case 57:
2153 #line 241 "parser.y"
2154  { (yyvsp[-2].const_decl)->next = (yyvsp[0].const_decl); (yyval.const_decl) = (yyvsp[-2].const_decl); }
2155 #line 2156 "parser.tab.c"
2156  break;
2157 
2158  case 58:
2159 #line 244 "parser.y"
2160  { (yyval.const_decl) = new_const_decl(ctx, (yyvsp[-2].string), (yyvsp[0].expression)); CHECK_ERROR; }
2161 #line 2162 "parser.tab.c"
2162  break;
2163 
2164  case 59:
2165 #line 247 "parser.y"
2166  { (yyval.expression) = (yyvsp[0].expression); }
2167 #line 2168 "parser.tab.c"
2168  break;
2169 
2170  case 60:
2171 #line 248 "parser.y"
2172  { (yyval.expression) = new_unary_expression(ctx, EXPR_NEG, (yyvsp[0].expression)); CHECK_ERROR; }
2173 #line 2174 "parser.tab.c"
2174  break;
2175 
2176  case 61:
2177 #line 251 "parser.y"
2178  { (yyval.boolean) = TRUE; }
2179 #line 2180 "parser.tab.c"
2180  break;
2181 
2182  case 62:
2183 #line 252 "parser.y"
2184  { (yyval.boolean) = FALSE; }
2185 #line 2186 "parser.tab.c"
2186  break;
2187 
2188  case 63:
2189 #line 255 "parser.y"
2190  { (yyval.expression) = NULL;}
2191 #line 2192 "parser.tab.c"
2192  break;
2193 
2194  case 64:
2195 #line 256 "parser.y"
2196  { (yyval.expression) = (yyvsp[0].expression); }
2197 #line 2198 "parser.tab.c"
2198  break;
2199 
2200  case 65:
2201 #line 260 "parser.y"
2202  { (yyval.statement) = new_if_statement(ctx, (yyvsp[-7].expression), (yyvsp[-4].statement), (yyvsp[-3].elseif), (yyvsp[-2].statement)); CHECK_ERROR; }
2203 #line 2204 "parser.tab.c"
2204  break;
2205 
2206  case 66:
2207 #line 261 "parser.y"
2208  { (yyval.statement) = new_if_statement(ctx, (yyvsp[-3].expression), (yyvsp[-1].statement), NULL, NULL); CHECK_ERROR; }
2209 #line 2210 "parser.tab.c"
2210  break;
2211 
2212  case 67:
2213 #line 263 "parser.y"
2214  { (yyval.statement) = new_if_statement(ctx, (yyvsp[-5].expression), (yyvsp[-3].statement), NULL, (yyvsp[-1].statement)); CHECK_ERROR; }
2215 #line 2216 "parser.tab.c"
2216  break;
2217 
2218  case 70:
2219 #line 270 "parser.y"
2220  { (yyval.elseif) = NULL; }
2221 #line 2222 "parser.tab.c"
2222  break;
2223 
2224  case 71:
2225 #line 271 "parser.y"
2226  { (yyval.elseif) = (yyvsp[0].elseif); }
2227 #line 2228 "parser.tab.c"
2228  break;
2229 
2230  case 72:
2231 #line 274 "parser.y"
2232  { (yyval.elseif) = (yyvsp[0].elseif); }
2233 #line 2234 "parser.tab.c"
2234  break;
2235 
2236  case 73:
2237 #line 275 "parser.y"
2238  { (yyvsp[-1].elseif)->next = (yyvsp[0].elseif); (yyval.elseif) = (yyvsp[-1].elseif); }
2239 #line 2240 "parser.tab.c"
2240  break;
2241 
2242  case 74:
2243 #line 279 "parser.y"
2244  { (yyval.elseif) = new_elseif_decl(ctx, (yyvsp[-3].expression), (yyvsp[0].statement)); }
2245 #line 2246 "parser.tab.c"
2246  break;
2247 
2248  case 75:
2249 #line 282 "parser.y"
2250  { (yyval.statement) = NULL; }
2251 #line 2252 "parser.tab.c"
2252  break;
2253 
2254  case 76:
2255 #line 283 "parser.y"
2256  { (yyval.statement) = (yyvsp[0].statement); }
2257 #line 2258 "parser.tab.c"
2258  break;
2259 
2260  case 77:
2261 #line 286 "parser.y"
2262  { (yyval.case_clausule) = NULL; }
2263 #line 2264 "parser.tab.c"
2264  break;
2265 
2266  case 78:
2267 #line 287 "parser.y"
2268  { (yyval.case_clausule) = new_case_clausule(ctx, NULL, (yyvsp[0].statement), NULL); }
2269 #line 2270 "parser.tab.c"
2270  break;
2271 
2272  case 79:
2273 #line 289 "parser.y"
2274  { (yyval.case_clausule) = new_case_clausule(ctx, (yyvsp[-3].expression), (yyvsp[-1].statement), (yyvsp[0].case_clausule)); }
2275 #line 2276 "parser.tab.c"
2276  break;
2277 
2278  case 80:
2279 #line 292 "parser.y"
2280  { (yyval.expression) = NULL; }
2281 #line 2282 "parser.tab.c"
2282  break;
2283 
2284  case 81:
2285 #line 293 "parser.y"
2286  { (yyval.expression) = (yyvsp[-1].expression); }
2287 #line 2288 "parser.tab.c"
2288  break;
2289 
2290  case 82:
2291 #line 296 "parser.y"
2292  { (yyval.expression) = NULL; }
2293 #line 2294 "parser.tab.c"
2294  break;
2295 
2296  case 83:
2297 #line 297 "parser.y"
2298  { (yyval.expression) = (yyvsp[0].expression); }
2299 #line 2300 "parser.tab.c"
2300  break;
2301 
2302  case 84:
2303 #line 300 "parser.y"
2304  { (yyval.expression) = (yyvsp[0].expression); }
2305 #line 2306 "parser.tab.c"
2306  break;
2307 
2308  case 85:
2309 #line 301 "parser.y"
2310  { (yyvsp[-2].expression)->next = (yyvsp[0].expression); (yyval.expression) = (yyvsp[-2].expression); }
2311 #line 2312 "parser.tab.c"
2312  break;
2313 
2314  case 86:
2315 #line 302 "parser.y"
2316  { (yyval.expression) = new_expression(ctx, EXPR_NOARG, 0); CHECK_ERROR; (yyval.expression)->next = (yyvsp[0].expression); }
2317 #line 2318 "parser.tab.c"
2318  break;
2319 
2320  case 89:
2321 #line 309 "parser.y"
2322  { (yyval.expression) = (yyvsp[0].expression); }
2323 #line 2324 "parser.tab.c"
2324  break;
2325 
2326  case 90:
2327 #line 310 "parser.y"
2328  { (yyvsp[-2].expression)->next = (yyvsp[0].expression); (yyval.expression) = (yyvsp[-2].expression); }
2329 #line 2330 "parser.tab.c"
2330  break;
2331 
2332  case 91:
2333 #line 313 "parser.y"
2334  { (yyval.expression) = (yyvsp[0].expression); }
2335 #line 2336 "parser.tab.c"
2336  break;
2337 
2338  case 92:
2339 #line 314 "parser.y"
2340  { (yyval.expression) = new_binary_expression(ctx, EXPR_IMP, (yyvsp[-2].expression), (yyvsp[0].expression)); CHECK_ERROR; }
2341 #line 2342 "parser.tab.c"
2342  break;
2343 
2344  case 93:
2345 #line 317 "parser.y"
2346  { (yyval.expression) = (yyvsp[0].expression); }
2347 #line 2348 "parser.tab.c"
2348  break;
2349 
2350  case 94:
2351 #line 318 "parser.y"
2352  { (yyval.expression) = new_binary_expression(ctx, EXPR_EQV, (yyvsp[-2].expression), (yyvsp[0].expression)); CHECK_ERROR; }
2353 #line 2354 "parser.tab.c"
2354  break;
2355 
2356  case 95:
2357 #line 321 "parser.y"
2358  { (yyval.expression) = (yyvsp[0].expression); }
2359 #line 2360 "parser.tab.c"
2360  break;
2361 
2362  case 96:
2363 #line 322 "parser.y"
2364  { (yyval.expression) = new_binary_expression(ctx, EXPR_XOR, (yyvsp[-2].expression), (yyvsp[0].expression)); CHECK_ERROR; }
2365 #line 2366 "parser.tab.c"
2366  break;
2367 
2368  case 97:
2369 #line 325 "parser.y"
2370  { (yyval.expression) = (yyvsp[0].expression); }
2371 #line 2372 "parser.tab.c"
2372  break;
2373 
2374  case 98:
2375 #line 326 "parser.y"
2376  { (yyval.expression) = new_binary_expression(ctx, EXPR_OR, (yyvsp[-2].expression), (yyvsp[0].expression)); CHECK_ERROR; }
2377 #line 2378 "parser.tab.c"
2378  break;
2379 
2380  case 99:
2381 #line 329 "parser.y"
2382  { (yyval.expression) = (yyvsp[0].expression); }
2383 #line 2384 "parser.tab.c"
2384  break;
2385 
2386  case 100:
2387 #line 330 "parser.y"
2388  { (yyval.expression) = new_binary_expression(ctx, EXPR_AND, (yyvsp[-2].expression), (yyvsp[0].expression)); CHECK_ERROR; }
2389 #line 2390 "parser.tab.c"
2390  break;
2391 
2392  case 101:
2393 #line 333 "parser.y"
2394  { (yyval.expression) = (yyvsp[0].expression); }
2395 #line 2396 "parser.tab.c"
2396  break;
2397 
2398  case 102:
2399 #line 334 "parser.y"
2400  { (yyval.expression) = new_unary_expression(ctx, EXPR_NOT, (yyvsp[0].expression)); CHECK_ERROR; }
2401 #line 2402 "parser.tab.c"
2402  break;
2403 
2404  case 103:
2405 #line 337 "parser.y"
2406  { (yyval.expression) = (yyvsp[0].expression); }
2407 #line 2408 "parser.tab.c"
2408  break;
2409 
2410  case 104:
2411 #line 338 "parser.y"
2412  { (yyval.expression) = new_binary_expression(ctx, EXPR_EQUAL, (yyvsp[-2].expression), (yyvsp[0].expression)); CHECK_ERROR; }
2413 #line 2414 "parser.tab.c"
2414  break;
2415 
2416  case 105:
2417 #line 339 "parser.y"
2418  { (yyval.expression) = new_binary_expression(ctx, EXPR_NEQUAL, (yyvsp[-2].expression), (yyvsp[0].expression)); CHECK_ERROR; }
2419 #line 2420 "parser.tab.c"
2420  break;
2421 
2422  case 106:
2423 #line 340 "parser.y"
2424  { (yyval.expression) = new_binary_expression(ctx, EXPR_GT, (yyvsp[-2].expression), (yyvsp[0].expression)); CHECK_ERROR; }
2425 #line 2426 "parser.tab.c"
2426  break;
2427 
2428  case 107:
2429 #line 341 "parser.y"
2430  { (yyval.expression) = new_binary_expression(ctx, EXPR_LT, (yyvsp[-2].expression), (yyvsp[0].expression)); CHECK_ERROR; }
2431 #line 2432 "parser.tab.c"
2432  break;
2433 
2434  case 108:
2435 #line 342 "parser.y"
2436  { (yyval.expression) = new_binary_expression(ctx, EXPR_GTEQ, (yyvsp[-2].expression), (yyvsp[0].expression)); CHECK_ERROR; }
2437 #line 2438 "parser.tab.c"
2438  break;
2439 
2440  case 109:
2441 #line 343 "parser.y"
2442  { (yyval.expression) = new_binary_expression(ctx, EXPR_LTEQ, (yyvsp[-2].expression), (yyvsp[0].expression)); CHECK_ERROR; }
2443 #line 2444 "parser.tab.c"
2444  break;
2445 
2446  case 110:
2447 #line 344 "parser.y"
2448  { (yyval.expression) = new_binary_expression(ctx, EXPR_IS, (yyvsp[-2].expression), (yyvsp[0].expression)); CHECK_ERROR; }
2449 #line 2450 "parser.tab.c"
2450  break;
2451 
2452  case 111:
2453 #line 347 "parser.y"
2454  { (yyval.expression) = (yyvsp[0].expression); }
2455 #line 2456 "parser.tab.c"
2456  break;
2457 
2458  case 112:
2459 #line 348 "parser.y"
2460  { (yyval.expression) = new_binary_expression(ctx, EXPR_CONCAT, (yyvsp[-2].expression), (yyvsp[0].expression)); CHECK_ERROR; }
2461 #line 2462 "parser.tab.c"
2462  break;
2463 
2464  case 113:
2465 #line 351 "parser.y"
2466  { (yyval.expression) = (yyvsp[0].expression); }
2467 #line 2468 "parser.tab.c"
2468  break;
2469 
2470  case 114:
2471 #line 352 "parser.y"
2472  { (yyval.expression) = new_binary_expression(ctx, EXPR_ADD, (yyvsp[-2].expression), (yyvsp[0].expression)); CHECK_ERROR; }
2473 #line 2474 "parser.tab.c"
2474  break;
2475 
2476  case 115:
2477 #line 353 "parser.y"
2478  { (yyval.expression) = new_binary_expression(ctx, EXPR_SUB, (yyvsp[-2].expression), (yyvsp[0].expression)); CHECK_ERROR; }
2479 #line 2480 "parser.tab.c"
2480  break;
2481 
2482  case 116:
2483 #line 356 "parser.y"
2484  { (yyval.expression) = (yyvsp[0].expression); }
2485 #line 2486 "parser.tab.c"
2486  break;
2487 
2488  case 117:
2489 #line 357 "parser.y"
2490  { (yyval.expression) = new_binary_expression(ctx, EXPR_MOD, (yyvsp[-2].expression), (yyvsp[0].expression)); CHECK_ERROR; }
2491 #line 2492 "parser.tab.c"
2492  break;
2493 
2494  case 118:
2495 #line 360 "parser.y"
2496  { (yyval.expression) = (yyvsp[0].expression); }
2497 #line 2498 "parser.tab.c"
2498  break;
2499 
2500  case 119:
2501 #line 362 "parser.y"
2502  { (yyval.expression) = new_binary_expression(ctx, EXPR_IDIV, (yyvsp[-2].expression), (yyvsp[0].expression)); CHECK_ERROR; }
2503 #line 2504 "parser.tab.c"
2504  break;
2505 
2506  case 120:
2507 #line 365 "parser.y"
2508  { (yyval.expression) = (yyvsp[0].expression); }
2509 #line 2510 "parser.tab.c"
2510  break;
2511 
2512  case 121:
2513 #line 367 "parser.y"
2514  { (yyval.expression) = new_binary_expression(ctx, EXPR_MUL, (yyvsp[-2].expression), (yyvsp[0].expression)); CHECK_ERROR; }
2515 #line 2516 "parser.tab.c"
2516  break;
2517 
2518  case 122:
2519 #line 369 "parser.y"
2520  { (yyval.expression) = new_binary_expression(ctx, EXPR_DIV, (yyvsp[-2].expression), (yyvsp[0].expression)); CHECK_ERROR; }
2521 #line 2522 "parser.tab.c"
2522  break;
2523 
2524  case 123:
2525 #line 372 "parser.y"
2526  { (yyval.expression) = (yyvsp[0].expression); }
2527 #line 2528 "parser.tab.c"
2528  break;
2529 
2530  case 124:
2531 #line 373 "parser.y"
2532  { (yyval.expression) = new_binary_expression(ctx, EXPR_EXP, (yyvsp[-2].expression), (yyvsp[0].expression)); CHECK_ERROR; }
2533 #line 2534 "parser.tab.c"
2534  break;
2535 
2536  case 125:
2537 #line 376 "parser.y"
2538  { (yyval.expression) = (yyvsp[0].expression); }
2539 #line 2540 "parser.tab.c"
2540  break;
2541 
2542  case 126:
2543 #line 377 "parser.y"
2544  { (yyval.expression) = (yyvsp[0].expression); }
2545 #line 2546 "parser.tab.c"
2546  break;
2547 
2548  case 127:
2549 #line 378 "parser.y"
2550  { (yyval.expression) = new_new_expression(ctx, (yyvsp[0].string)); CHECK_ERROR; }
2551 #line 2552 "parser.tab.c"
2552  break;
2553 
2554  case 128:
2555 #line 379 "parser.y"
2556  { (yyval.expression) = new_unary_expression(ctx, EXPR_NEG, (yyvsp[0].expression)); CHECK_ERROR; }
2557 #line 2558 "parser.tab.c"
2558  break;
2559 
2560  case 129:
2561 #line 380 "parser.y"
2562  { (yyval.expression) = (yyvsp[0].expression); }
2563 #line 2564 "parser.tab.c"
2564  break;
2565 
2566  case 130:
2567 #line 383 "parser.y"
2568  { (yyval.expression) = (yyvsp[0].expression); }
2569 #line 2570 "parser.tab.c"
2570  break;
2571 
2572  case 131:
2573 #line 384 "parser.y"
2574  { (yyvsp[-1].member)->args = (yyvsp[0].expression); (yyval.expression) = &(yyvsp[-1].member)->expr; }
2575 #line 2576 "parser.tab.c"
2576  break;
2577 
2578  case 132:
2579 #line 387 "parser.y"
2580  { (yyval.expression) = new_bool_expression(ctx, VARIANT_TRUE); CHECK_ERROR; }
2581 #line 2582 "parser.tab.c"
2582  break;
2583 
2584  case 133:
2585 #line 388 "parser.y"
2586  { (yyval.expression) = new_bool_expression(ctx, VARIANT_FALSE); CHECK_ERROR; }
2587 #line 2588 "parser.tab.c"
2588  break;
2589 
2590  case 134:
2591 #line 389 "parser.y"
2592  { (yyval.expression) = new_string_expression(ctx, (yyvsp[0].string)); CHECK_ERROR; }
2593 #line 2594 "parser.tab.c"
2594  break;
2595 
2596  case 135:
2597 #line 390 "parser.y"
2598  { (yyval.expression) = (yyvsp[0].expression); }
2599 #line 2600 "parser.tab.c"
2600  break;
2601 
2602  case 136:
2603 #line 391 "parser.y"
2604  { (yyval.expression) = new_expression(ctx, EXPR_EMPTY, 0); CHECK_ERROR; }
2605 #line 2606 "parser.tab.c"
2606  break;
2607 
2608  case 137:
2609 #line 392 "parser.y"
2610  { (yyval.expression) = new_expression(ctx, EXPR_NULL, 0); CHECK_ERROR; }
2611 #line 2612 "parser.tab.c"
2612  break;
2613 
2614  case 138:
2615 #line 393 "parser.y"
2616  { (yyval.expression) = new_expression(ctx, EXPR_NOTHING, 0); CHECK_ERROR; }
2617 #line 2618 "parser.tab.c"
2618  break;
2619 
2620  case 139:
2621 #line 396 "parser.y"
2622  { (yyval.expression) = new_long_expression(ctx, EXPR_INT, 0); CHECK_ERROR; }
2623 #line 2624 "parser.tab.c"
2624  break;
2625 
2626  case 140:
2627 #line 397 "parser.y"
2628  { (yyval.expression) = new_long_expression(ctx, EXPR_INT, (yyvsp[0].integer)); CHECK_ERROR; }
2629 #line 2630 "parser.tab.c"
2630  break;
2631 
2632  case 141:
2633 #line 398 "parser.y"
2634  { (yyval.expression) = new_double_expression(ctx, (yyvsp[0].dbl)); CHECK_ERROR; }
2635 #line 2636 "parser.tab.c"
2636  break;
2637 
2638  case 142:
2639 #line 401 "parser.y"
2640  { (yyval.uint) = 0; }
2641 #line 2642 "parser.tab.c"
2642  break;
2643 
2644  case 143:
2645 #line 402 "parser.y"
2646  { (yyval.uint) = (yyvsp[0].integer); }
2647 #line 2648 "parser.tab.c"
2648  break;
2649 
2650  case 144:
2651 #line 405 "parser.y"
2652  { (yyval.expression) = new_unary_expression(ctx, EXPR_BRACKETS, (yyvsp[-1].expression)); }
2653 #line 2654 "parser.tab.c"
2654  break;
2655 
2656  case 145:
2657 #line 406 "parser.y"
2658  { (yyval.expression) = new_expression(ctx, EXPR_ME, 0); CHECK_ERROR; }
2659 #line 2660 "parser.tab.c"
2660  break;
2661 
2662  case 146:
2663 #line 409 "parser.y"
2664  { (yyvsp[-3].class_decl)->name = (yyvsp[-5].string); (yyval.class_decl) = (yyvsp[-3].class_decl); }
2665 #line 2666 "parser.tab.c"
2666  break;
2667 
2668  case 147:
2669 #line 412 "parser.y"
2670  { (yyval.class_decl) = new_class_decl(ctx); }
2671 #line 2672 "parser.tab.c"
2672  break;
2673 
2674  case 148:
2675 #line 413 "parser.y"
2676  { (yyval.class_decl) = add_class_function(ctx, new_class_decl(ctx), (yyvsp[0].func_decl)); CHECK_ERROR; }
2677 #line 2678 "parser.tab.c"
2678  break;
2679 
2680  case 149:
2681 #line 414 "parser.y"
2682  { (yyval.class_decl) = add_class_function(ctx, (yyvsp[0].class_decl), (yyvsp[-2].func_decl)); CHECK_ERROR; }
2683 #line 2684 "parser.tab.c"
2684  break;
2685 
2686  case 150:
2687 #line 416 "parser.y"
2688  { dim_decl_t *dim_decl = new_dim_decl(ctx, (yyvsp[0].string), FALSE, NULL); CHECK_ERROR;
2689  (yyval.class_decl) = add_dim_prop(ctx, new_class_decl(ctx), dim_decl, (yyvsp[-1].uint)); CHECK_ERROR; }
2690 #line 2691 "parser.tab.c"
2691  break;
2692 
2693  case 151:
2694 #line 418 "parser.y"
2695  { dim_decl_t *dim_decl = new_dim_decl(ctx, (yyvsp[-2].string), FALSE, NULL); CHECK_ERROR;
2696  (yyval.class_decl) = add_dim_prop(ctx, (yyvsp[0].class_decl), dim_decl, (yyvsp[-3].uint)); CHECK_ERROR; }
2697 #line 2698 "parser.tab.c"
2698  break;
2699 
2700  case 152:
2701 #line 420 "parser.y"
2702  { (yyval.class_decl) = add_dim_prop(ctx, new_class_decl(ctx), (yyvsp[0].dim_decl), 0); CHECK_ERROR; }
2703 #line 2704 "parser.tab.c"
2704  break;
2705 
2706  case 153:
2707 #line 421 "parser.y"
2708  { (yyval.class_decl) = add_dim_prop(ctx, (yyvsp[0].class_decl), (yyvsp[-2].dim_decl), 0); CHECK_ERROR; }
2709 #line 2710 "parser.tab.c"
2710  break;
2711 
2712  case 154:
2713 #line 422 "parser.y"
2714  { (yyval.class_decl) = add_class_function(ctx, new_class_decl(ctx), (yyvsp[0].func_decl)); CHECK_ERROR; }
2715 #line 2716 "parser.tab.c"
2716  break;
2717 
2718  case 155:
2719 #line 423 "parser.y"
2720  { (yyval.class_decl) = add_class_function(ctx, (yyvsp[0].class_decl), (yyvsp[-2].func_decl)); CHECK_ERROR; }
2721 #line 2722 "parser.tab.c"
2722  break;
2723 
2724  case 156:
2725 #line 427 "parser.y"
2726  { (yyval.func_decl) = new_function_decl(ctx, (yyvsp[-5].string), FUNC_PROPGET, (yyvsp[-8].uint), (yyvsp[-4].arg_decl), (yyvsp[-2].statement)); CHECK_ERROR; }
2727 #line 2728 "parser.tab.c"
2728  break;
2729 
2730  case 157:
2731 #line 429 "parser.y"
2732  { (yyval.func_decl) = new_function_decl(ctx, (yyvsp[-7].string), FUNC_PROPLET, (yyvsp[-10].uint), (yyvsp[-5].arg_decl), (yyvsp[-2].statement)); CHECK_ERROR; }
2733 #line 2734 "parser.tab.c"
2734  break;
2735 
2736  case 158:
2737 #line 431 "parser.y"
2738  { (yyval.func_decl) = new_function_decl(ctx, (yyvsp[-7].string), FUNC_PROPSET, (yyvsp[-10].uint), (yyvsp[-5].arg_decl), (yyvsp[-2].statement)); CHECK_ERROR; }
2739 #line 2740 "parser.tab.c"
2740  break;
2741 
2742  case 159:
2743 #line 435 "parser.y"
2744  { (yyval.func_decl) = new_function_decl(ctx, (yyvsp[-5].string), FUNC_SUB, (yyvsp[-7].uint), (yyvsp[-4].arg_decl), (yyvsp[-2].statement)); CHECK_ERROR; }
2745 #line 2746 "parser.tab.c"
2746  break;
2747 
2748  case 160:
2749 #line 437 "parser.y"
2750  { (yyval.func_decl) = new_function_decl(ctx, (yyvsp[-5].string), FUNC_FUNCTION, (yyvsp[-7].uint), (yyvsp[-4].arg_decl), (yyvsp[-2].statement)); CHECK_ERROR; }
2751 #line 2752 "parser.tab.c"
2752  break;
2753 
2754  case 161:
2755 #line 440 "parser.y"
2756  { (yyval.uint) = 0; }
2757 #line 2758 "parser.tab.c"
2758  break;
2759 
2760  case 162:
2761 #line 441 "parser.y"
2762  { (yyval.uint) = (yyvsp[0].uint); }
2763 #line 2764 "parser.tab.c"
2764  break;
2765 
2766  case 163:
2767 #line 444 "parser.y"
2768  { (yyval.uint) = STORAGE_IS_DEFAULT; }
2769 #line 2770 "parser.tab.c"
2770  break;
2771 
2772  case 164:
2773 #line 445 "parser.y"
2774  { (yyval.uint) = 0; }
2775 #line 2776 "parser.tab.c"
2776  break;
2777 
2778  case 165:
2779 #line 446 "parser.y"
2780  { (yyval.uint) = STORAGE_IS_PRIVATE; }
2781 #line 2782 "parser.tab.c"
2782  break;
2783 
2784  case 166:
2785 #line 449 "parser.y"
2786  { (yyval.arg_decl) = NULL; }
2787 #line 2788 "parser.tab.c"
2788  break;
2789 
2790  case 167:
2791 #line 450 "parser.y"
2792  { (yyval.arg_decl) = (yyvsp[-1].arg_decl); }
2793 #line 2794 "parser.tab.c"
2794  break;
2795 
2796  case 168:
2797 #line 453 "parser.y"
2798  { (yyval.arg_decl) = (yyvsp[0].arg_decl); }
2799 #line 2800 "parser.tab.c"
2800  break;
2801 
2802  case 169:
2803 #line 454 "parser.y"
2804  { (yyvsp[-2].arg_decl)->next = (yyvsp[0].arg_decl); (yyval.arg_decl) = (yyvsp[-2].arg_decl); }
2805 #line 2806 "parser.tab.c"
2806  break;
2807 
2808  case 170:
2809 #line 457 "parser.y"
2810  { (yyval.arg_decl) = new_argument_decl(ctx, (yyvsp[-1].string), TRUE); }
2811 #line 2812 "parser.tab.c"
2812  break;
2813 
2814  case 171:
2815 #line 458 "parser.y"
2816  { (yyval.arg_decl) = new_argument_decl(ctx, (yyvsp[-1].string), TRUE); }
2817 #line 2818 "parser.tab.c"
2818  break;
2819 
2820  case 172:
2821 #line 459 "parser.y"
2822  { (yyval.arg_decl) = new_argument_decl(ctx, (yyvsp[-1].string), FALSE); }
2823 #line 2824 "parser.tab.c"
2824  break;
2825 
2826  case 173:
2827 #line 463 "parser.y"
2828  { (yyval.string) = (yyvsp[0].string); }
2829 #line 2830 "parser.tab.c"
2830  break;
2831 
2832  case 174:
2833 #line 464 "parser.y"
2834  { (yyval.string) = (yyvsp[0].string); }
2835 #line 2836 "parser.tab.c"
2836  break;
2837 
2838  case 175:
2839 #line 465 "parser.y"
2840  { (yyval.string) = (yyvsp[0].string); }
2841 #line 2842 "parser.tab.c"
2842  break;
2843 
2844  case 176:
2845 #line 466 "parser.y"
2846  { (yyval.string) = (yyvsp[0].string); }
2847 #line 2848 "parser.tab.c"
2848  break;
2849 
2850  case 177:
2851 #line 467 "parser.y"
2852  { (yyval.string) = (yyvsp[0].string); }
2853 #line 2854 "parser.tab.c"
2854  break;
2855 
2856  case 178:
2857 #line 468 "parser.y"
2858  { (yyval.string) = (yyvsp[0].string); }
2859 #line 2860 "parser.tab.c"
2860  break;
2861 
2862  case 179:
2863 #line 472 "parser.y"
2864  { (yyval.string) = (yyvsp[0].string); }
2865 #line 2866 "parser.tab.c"
2866  break;
2867 
2868  case 180:
2869 #line 473 "parser.y"
2870  { (yyval.string) = (yyvsp[0].string); }
2871 #line 2872 "parser.tab.c"
2872  break;
2873 
2874  case 181:
2875 #line 474 "parser.y"
2876  { (yyval.string) = (yyvsp[0].string); }
2877 #line 2878 "parser.tab.c"
2878  break;
2879 
2880  case 182:
2881 #line 475 "parser.y"
2882  { (yyval.string) = (yyvsp[0].string); }
2883 #line 2884 "parser.tab.c"
2884  break;
2885 
2886  case 183:
2887 #line 476 "parser.y"
2888  { (yyval.string) = (yyvsp[0].string); }
2889 #line 2890 "parser.tab.c"
2890  break;
2891 
2892  case 184:
2893 #line 477 "parser.y"
2894  { (yyval.string) = (yyvsp[0].string); }
2895 #line 2896 "parser.tab.c"
2896  break;
2897 
2898  case 185:
2899 #line 478 "parser.y"
2900  { (yyval.string) = (yyvsp[0].string); }
2901 #line 2902 "parser.tab.c"
2902  break;
2903 
2904  case 186:
2905 #line 479 "parser.y"
2906  { (yyval.string) = (yyvsp[0].string); }
2907 #line 2908 "parser.tab.c"
2908  break;
2909 
2910  case 187:
2911 #line 480 "parser.y"
2912  { (yyval.string) = (yyvsp[0].string); }
2913 #line 2914 "parser.tab.c"
2914  break;
2915 
2916  case 188:
2917 #line 481 "parser.y"
2918  { (yyval.string) = (yyvsp[0].string); }
2919 #line 2920 "parser.tab.c"
2920  break;
2921 
2922  case 189:
2923 #line 482 "parser.y"
2924  { (yyval.string) = (yyvsp[0].string); }
2925 #line 2926 "parser.tab.c"
2926  break;
2927 
2928  case 190:
2929 #line 483 "parser.y"
2930  { (yyval.string) = (yyvsp[0].string); }
2931 #line 2932 "parser.tab.c"
2932  break;
2933 
2934  case 191:
2935 #line 484 "parser.y"
2936  { (yyval.string) = (yyvsp[0].string); }
2937 #line 2938 "parser.tab.c"
2938  break;
2939 
2940  case 192:
2941 #line 485 "parser.y"
2942  { (yyval.string) = (yyvsp[0].string); }
2943 #line 2944 "parser.tab.c"
2944  break;
2945 
2946  case 193:
2947 #line 486 "parser.y"
2948  { (yyval.string) = (yyvsp[0].string); }
2949 #line 2950 "parser.tab.c"
2950  break;
2951 
2952  case 194:
2953 #line 487 "parser.y"
2954  { (yyval.string) = (yyvsp[0].string); }
2955 #line 2956 "parser.tab.c"
2956  break;
2957 
2958  case 195:
2959 #line 488 "parser.y"
2960  { (yyval.string) = (yyvsp[0].string); }
2961 #line 2962 "parser.tab.c"
2962  break;
2963 
2964  case 196:
2965 #line 489 "parser.y"
2966  { (yyval.string) = (yyvsp[0].string); }
2967 #line 2968 "parser.tab.c"
2968  break;
2969 
2970  case 197:
2971 #line 490 "parser.y"
2972  { (yyval.string) = (yyvsp[0].string); }
2973 #line 2974 "parser.tab.c"
2974  break;
2975 
2976  case 198:
2977 #line 491 "parser.y"
2978  { (yyval.string) = (yyvsp[0].string); }
2979 #line 2980 "parser.tab.c"
2980  break;
2981 
2982  case 199:
2983 #line 492 "parser.y"
2984  { (yyval.string) = (yyvsp[0].string); }
2985 #line 2986 "parser.tab.c"
2986  break;
2987 
2988  case 200:
2989 #line 493 "parser.y"
2990  { (yyval.string) = (yyvsp[0].string); }
2991 #line 2992 "parser.tab.c"
2992  break;
2993 
2994  case 201:
2995 #line 494 "parser.y"
2996  { (yyval.string) = (yyvsp[0].string); }
2997 #line 2998 "parser.tab.c"
2998  break;
2999 
3000  case 202:
3001 #line 495 "parser.y"
3002  { (yyval.string) = (yyvsp[0].string); }
3003 #line 3004 "parser.tab.c"
3004  break;
3005 
3006  case 203:
3007 #line 496 "parser.y"
3008  { (yyval.string) = (yyvsp[0].string); }
3009 #line 3010 "parser.tab.c"
3010  break;
3011 
3012  case 204:
3013 #line 497 "parser.y"
3014  { (yyval.string) = (yyvsp[0].string); }
3015 #line 3016 "parser.tab.c"
3016  break;
3017 
3018  case 205:
3019 #line 498 "parser.y"
3020  { (yyval.string) = (yyvsp[0].string); }
3021 #line 3022 "parser.tab.c"
3022  break;
3023 
3024  case 206:
3025 #line 499 "parser.y"
3026  { (yyval.string) = (yyvsp[0].string); }
3027 #line 3028 "parser.tab.c"
3028  break;
3029 
3030  case 207:
3031 #line 500 "parser.y"
3032  { (yyval.string) = (yyvsp[0].string); }
3033 #line 3034 "parser.tab.c"
3034  break;
3035 
3036  case 208:
3037 #line 501 "parser.y"
3038  { (yyval.string) = (yyvsp[0].string); }
3039 #line 3040 "parser.tab.c"
3040  break;
3041 
3042  case 209:
3043 #line 502 "parser.y"
3044  { (yyval.string) = (yyvsp[0].string); }
3045 #line 3046 "parser.tab.c"
3046  break;
3047 
3048  case 210:
3049 #line 503 "parser.y"
3050  { (yyval.string) = (yyvsp[0].string); }
3051 #line 3052 "parser.tab.c"
3052  break;
3053 
3054  case 211:
3055 #line 504 "parser.y"
3056  { (yyval.string) = (yyvsp[0].string); }
3057 #line 3058 "parser.tab.c"
3058  break;
3059 
3060  case 212:
3061 #line 505 "parser.y"
3062  { (yyval.string) = (yyvsp[0].string); }
3063 #line 3064 "parser.tab.c"
3064  break;
3065 
3066  case 213:
3067 #line 506 "parser.y"
3068  { (yyval.string) = (yyvsp[0].string); }
3069 #line 3070 "parser.tab.c"
3070  break;
3071 
3072  case 214:
3073 #line 507 "parser.y"
3074  { (yyval.string) = (yyvsp[0].string); }
3075 #line 3076 "parser.tab.c"
3076  break;
3077 
3078  case 215:
3079 #line 508 "parser.y"
3080  { (yyval.string) = (yyvsp[0].string); }
3081 #line 3082 "parser.tab.c"
3082  break;
3083 
3084  case 216:
3085 #line 509 "parser.y"
3086  { (yyval.string) = (yyvsp[0].string); }
3087 #line 3088 "parser.tab.c"
3088  break;
3089 
3090  case 217:
3091 #line 510 "parser.y"
3092  { (yyval.string) = (yyvsp[0].string); }
3093 #line 3094 "parser.tab.c"
3094  break;
3095 
3096  case 218:
3097 #line 511 "parser.y"
3098  { (yyval.string) = (yyvsp[0].string); }
3099 #line 3100 "parser.tab.c"
3100  break;
3101 
3102  case 219:
3103 #line 512 "parser.y"
3104  { (yyval.string) = (yyvsp[0].string); }
3105 #line 3106 "parser.tab.c"
3106  break;
3107 
3108  case 220:
3109 #line 513 "parser.y"
3110  { (yyval.string) = (yyvsp[0].string); }
3111 #line 3112 "parser.tab.c"
3112  break;
3113 
3114  case 221:
3115 #line 514 "parser.y"
3116  { (yyval.string) = (yyvsp[0].string); }
3117 #line 3118 "parser.tab.c"
3118  break;
3119 
3120  case 222:
3121 #line 515 "parser.y"
3122  { (yyval.string) = (yyvsp[0].string); }
3123 #line 3124 "parser.tab.c"
3124  break;
3125 
3126  case 223:
3127 #line 516 "parser.y"
3128  { (yyval.string) = (yyvsp[0].string); }
3129 #line 3130 "parser.tab.c"
3130  break;
3131 
3132  case 224:
3133 #line 517 "parser.y"
3134  { (yyval.string) = (yyvsp[0].string); }
3135 #line 3136 "parser.tab.c"
3136  break;
3137 
3138  case 225:
3139 #line 518 "parser.y"
3140  { (yyval.string) = (yyvsp[0].string); }
3141 #line 3142 "parser.tab.c"
3142  break;
3143 
3144  case 226:
3145 #line 519 "parser.y"
3146  { (yyval.string) = (yyvsp[0].string); }
3147 #line 3148 "parser.tab.c"
3148  break;
3149 
3150  case 227:
3151 #line 520 "parser.y"
3152  { (yyval.string) = (yyvsp[0].string); }
3153 #line 3154 "parser.tab.c"
3154  break;
3155 
3156  case 228:
3157 #line 521 "parser.y"
3158  { (yyval.string) = (yyvsp[0].string); }
3159 #line 3160 "parser.tab.c"
3160  break;
3161 
3162 
3163 #line 3164 "parser.tab.c"
3164 
3165  default: break;
3166  }
3167  /* User semantic actions sometimes alter yychar, and that requires
3168  that yytoken be updated with the new translation. We take the
3169  approach of translating immediately before every use of yytoken.
3170  One alternative is translating here after every semantic action,
3171  but that translation would be missed if the semantic action invokes
3172  YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
3173  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
3174  incorrect destructor might then be invoked immediately. In the
3175  case of YYERROR or YYBACKUP, subsequent parser actions might lead
3176  to an incorrect destructor call or verbose syntax error message
3177  before the lookahead is translated. */
3178  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
3179 
3180  YYPOPSTACK (yylen);
3181  yylen = 0;
3182  YY_STACK_PRINT (yyss, yyssp);
3183 
3184  *++yyvsp = yyval;
3185 
3186  /* Now 'shift' the result of the reduction. Determine what state
3187  that goes to, based on the state we popped back to and the rule
3188  number reduced by. */
3189  {
3190  const int yylhs = yyr1[yyn] - YYNTOKENS;
3191  const int yyi = yypgoto[yylhs] + *yyssp;
3192  yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
3193  ? yytable[yyi]
3194  : yydefgoto[yylhs]);
3195  }
3196 
3197  goto yynewstate;
3198 
3199 
3200 /*--------------------------------------.
3201 | yyerrlab -- here on detecting error. |
3202 `--------------------------------------*/
3203 yyerrlab:
3204  /* Make sure we have latest lookahead translation. See comments at
3205  user semantic actions for why this is necessary. */
3206  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
3207 
3208  /* If not already recovering from an error, report this error. */
3209  if (!yyerrstatus)
3210  {
3211  ++yynerrs;
3212 #if ! YYERROR_VERBOSE
3213  yyerror (ctx, YY_("syntax error"));
3214 #else
3215 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
3216  yyssp, yytoken)
3217  {
3218  char const *yymsgp = YY_("syntax error");
3219  int yysyntax_error_status;
3220  yysyntax_error_status = YYSYNTAX_ERROR;
3221  if (yysyntax_error_status == 0)
3222  yymsgp = yymsg;
3223  else if (yysyntax_error_status == 1)
3224  {
3225  if (yymsg != yymsgbuf)
3226  YYSTACK_FREE (yymsg);
3227  yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
3228  if (!yymsg)
3229  {
3230  yymsg = yymsgbuf;
3231  yymsg_alloc = sizeof yymsgbuf;
3232  yysyntax_error_status = 2;
3233  }
3234  else
3235  {
3236  yysyntax_error_status = YYSYNTAX_ERROR;
3237  yymsgp = yymsg;
3238  }
3239  }
3240  yyerror (ctx, yymsgp);
3241  if (yysyntax_error_status == 2)
3242  goto yyexhaustedlab;
3243  }
3244 # undef YYSYNTAX_ERROR
3245 #endif
3246  }
3247 
3248 
3249 
3250  if (yyerrstatus == 3)
3251  {
3252  /* If just tried and failed to reuse lookahead token after an
3253  error, discard it. */
3254 
3255  if (yychar <= YYEOF)
3256  {
3257  /* Return failure if at end of input. */
3258  if (yychar == YYEOF)
3259  YYABORT;
3260  }
3261  else
3262  {
3263  yydestruct ("Error: discarding",
3264  yytoken, &yylval, ctx);
3265  yychar = YYEMPTY;
3266  }
3267  }
3268 
3269  /* Else will try to reuse lookahead token after shifting the error
3270  token. */
3271  goto yyerrlab1;
3272 
3273 
3274 /*---------------------------------------------------.
3275 | yyerrorlab -- error raised explicitly by YYERROR. |
3276 `---------------------------------------------------*/
3277 yyerrorlab:
3278  /* Pacify compilers when the user code never invokes YYERROR and the
3279  label yyerrorlab therefore never appears in user code. */
3280  if (0)
3281  YYERROR;
3282 
3283  /* Do not reclaim the symbols of the rule whose action triggered
3284  this YYERROR. */
3285  YYPOPSTACK (yylen);
3286  yylen = 0;
3287  YY_STACK_PRINT (yyss, yyssp);
3288  yystate = *yyssp;
3289  goto yyerrlab1;
3290 
3291 
3292 /*-------------------------------------------------------------.
3293 | yyerrlab1 -- common code for both syntax error and YYERROR. |
3294 `-------------------------------------------------------------*/
3295 yyerrlab1:
3296  yyerrstatus = 3; /* Each real token shifted decrements this. */
3297 
3298  for (;;)
3299  {
3300  yyn = yypact[yystate];
3301  if (!yypact_value_is_default (yyn))
3302  {
3303  yyn += YYTERROR;
3304  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
3305  {
3306  yyn = yytable[yyn];
3307  if (0 < yyn)
3308  break;
3309  }
3310  }
3311 
3312  /* Pop the current state because it cannot handle the error token. */
3313  if (yyssp == yyss)
3314  YYABORT;
3315 
3316 
3317  yydestruct ("Error: popping",
3318  yystos[yystate], yyvsp, ctx);
3319  YYPOPSTACK (1);
3320  yystate = *yyssp;
3321  YY_STACK_PRINT (yyss, yyssp);
3322  }
3323 
3324  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
3325  *++yyvsp = yylval;
3326  YY_IGNORE_MAYBE_UNINITIALIZED_END
3327 
3328 
3329  /* Shift the error token. */
3330  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
3331 
3332  yystate = yyn;
3333  goto yynewstate;
3334 
3335 
3336 /*-------------------------------------.
3337 | yyacceptlab -- YYACCEPT comes here. |
3338 `-------------------------------------*/
3339 yyacceptlab:
3340  yyresult = 0;
3341  goto yyreturn;
3342 
3343 
3344 /*-----------------------------------.
3345 | yyabortlab -- YYABORT comes here. |
3346 `-----------------------------------*/
3347 yyabortlab:
3348  yyresult = 1;
3349  goto yyreturn;
3350 
3351 
3352 #if !defined yyoverflow || YYERROR_VERBOSE
3353 /*-------------------------------------------------.
3354 | yyexhaustedlab -- memory exhaustion comes here. |
3355 `-------------------------------------------------*/
3356 yyexhaustedlab:
3357  yyerror (ctx, YY_("memory exhausted"));
3358  yyresult = 2;
3359  /* Fall through. */
3360 #endif
3361 
3362 
3363 /*-----------------------------------------------------.
3364 | yyreturn -- parsing is finished, return the result. |
3365 `-----------------------------------------------------*/
3366 yyreturn:
3367  if (yychar != YYEMPTY)
3368  {
3369  /* Make sure we have latest lookahead translation. See comments at
3370  user semantic actions for why this is necessary. */
3371  yytoken = YYTRANSLATE (yychar);
3372  yydestruct ("Cleanup: discarding lookahead",
3373  yytoken, &yylval, ctx);
3374  }
3375  /* Do not reclaim the symbols of the rule whose action triggered
3376  this YYABORT or YYACCEPT. */
3377  YYPOPSTACK (yylen);
3378  YY_STACK_PRINT (yyss, yyssp);
3379  while (yyssp != yyss)
3380  {
3381  yydestruct ("Cleanup: popping",
3382  yystos[*yyssp], yyvsp, ctx);
3383  YYPOPSTACK (1);
3384  }
3385 #ifndef yyoverflow
3386  if (yyss != yyssa)
3387  YYSTACK_FREE (yyss);
3388 #endif
3389 #if YYERROR_VERBOSE
3390  if (yymsg != yymsgbuf)
3391  YYSTACK_FREE (yymsg);
3392 #endif
3393  return yyresult;
3394 }
3395 #line 530 "parser.y"
3396 
3397 
3398 static int parser_error(parser_ctx_t *ctx, const char *str)
3399 {
3400  return 0;
3401 }
3402 
3403 static void source_add_statement(parser_ctx_t *ctx, statement_t *stat)
3404 {
3405  if(!stat)
3406  return;
3407 
3408  if(ctx->stats) {
3409  ctx->stats_tail->next = stat;
3410  ctx->stats_tail = stat;
3411  }else {
3412  ctx->stats = ctx->stats_tail = stat;
3413  }
3414 }
3415 
3416 static void source_add_class(parser_ctx_t *ctx, class_decl_t *class_decl)
3417 {
3418  class_decl->next = ctx->class_decls;
3419  ctx->class_decls = class_decl;
3420 }
3421 
3422 static void parse_complete(parser_ctx_t *ctx, BOOL option_explicit)
3423 {
3424  ctx->parse_complete = TRUE;
3425  ctx->option_explicit = option_explicit;
3426 }
3427 
3428 static void handle_isexpression_script(parser_ctx_t *ctx, expression_t *expr)
3429 {
3430  retval_statement_t *stat;
3431 
3432  ctx->parse_complete = TRUE;
3433  if(!expr)
3434  return;
3435 
3436  stat = new_statement(ctx, STAT_RETVAL, sizeof(*stat));
3437  if(!stat)
3438  return;
3439 
3440  stat->expr = expr;
3441  ctx->stats = &stat->stat;
3442 }
3443 
3444 static void *new_expression(parser_ctx_t *ctx, expression_type_t type, size_t size)
3445 {
3446  expression_t *expr;
3447 
3448  expr = parser_alloc(ctx, size ? size : sizeof(*expr));
3449  if(expr) {
3450  expr->type = type;
3451  expr->next = NULL;
3452  }
3453 
3454  return expr;
3455 }
3456 
3457 static expression_t *new_bool_expression(parser_ctx_t *ctx, VARIANT_BOOL value)
3458 {
3459  bool_expression_t *expr;
3460 
3461  expr = new_expression(ctx, EXPR_BOOL, sizeof(*expr));
3462  if(!expr)
3463  return NULL;
3464 
3465  expr->value = value;
3466  return &expr->expr;
3467 }
3468 
3469 static expression_t *new_string_expression(parser_ctx_t *ctx, const WCHAR *value)
3470 {
3471  string_expression_t *expr;
3472 
3473  expr = new_expression(ctx, EXPR_STRING, sizeof(*expr));
3474  if(!expr)
3475  return NULL;
3476 
3477  expr->value = value;
3478  return &expr->expr;
3479 }
3480 
3481 static expression_t *new_long_expression(parser_ctx_t *ctx, expression_type_t type, LONG value)
3482 {
3483  int_expression_t *expr;
3484 
3485  expr = new_expression(ctx, type, sizeof(*expr));
3486  if(!expr)
3487  return NULL;
3488 
3489  expr->value = value;
3490  return &expr->expr;
3491 }
3492 
3493 static expression_t *new_double_expression(parser_ctx_t *ctx, double value)
3494 {
3495  double_expression_t *expr;
3496 
3497  expr = new_expression(ctx, EXPR_DOUBLE, sizeof(*expr));
3498  if(!expr)
3499  return NULL;
3500 
3501  expr->value = value;
3502  return &expr->expr;
3503 }
3504 
3505 static expression_t *new_unary_expression(parser_ctx_t *ctx, expression_type_t type, expression_t *subexpr)
3506 {
3507  unary_expression_t *expr;
3508 
3509  expr = new_expression(ctx, type, sizeof(*expr));
3510  if(!expr)
3511  return NULL;
3512 
3513  expr->subexpr = subexpr;
3514  return &expr->expr;
3515 }
3516 
3517 static expression_t *new_binary_expression(parser_ctx_t *ctx, expression_type_t type, expression_t *left, expression_t *right)
3518 {
3519  binary_expression_t *expr;
3520 
3521  expr = new_expression(ctx, type, sizeof(*expr));
3522  if(!expr)
3523  return NULL;
3524 
3525  expr->left = left;
3526  expr->right = right;
3527  return &expr->expr;
3528 }
3529 
3530 static member_expression_t *new_member_expression(parser_ctx_t *ctx, expression_t *obj_expr, const WCHAR *identifier)
3531 {
3532  member_expression_t *expr;
3533 
3534  expr = new_expression(ctx, EXPR_MEMBER, sizeof(*expr));
3535  if(!expr)
3536  return NULL;
3537 
3538  expr->obj_expr = obj_expr;
3539  expr->identifier = identifier;
3540  expr->args = NULL;
3541  return expr;
3542 }
3543 
3544 static expression_t *new_new_expression(parser_ctx_t *ctx, const WCHAR *identifier)
3545 {
3546  string_expression_t *expr;
3547 
3548  expr = new_expression(ctx, EXPR_NEW, sizeof(*expr));
3549  if(!expr)
3550  return NULL;
3551 
3552  expr->value = identifier;
3553  return &expr->expr;
3554 }
3555 
3556 static void *new_statement(parser_ctx_t *ctx, statement_type_t type, size_t size)
3557 {
3558  statement_t *stat;
3559 
3560  stat = parser_alloc(ctx, size ? size : sizeof(*stat));
3561  if(stat) {
3562  stat->type = type;
3563  stat->next = NULL;
3564  }
3565 
3566  return stat;
3567 }
3568 
3569 static statement_t *new_call_statement(parser_ctx_t *ctx, BOOL is_strict, member_expression_t *expr)
3570 {
3571  call_statement_t *stat;
3572 
3573  stat = new_statement(ctx, STAT_CALL, sizeof(*stat));
3574  if(!stat)
3575  return NULL;
3576 
3577  stat->expr = expr;
3578  stat->is_strict = is_strict;
3579  return &stat->stat;
3580 }
3581 
3582 static statement_t *new_assign_statement(parser_ctx_t *ctx, member_expression_t *left, expression_t *right)
3583 {
3584  assign_statement_t *stat;
3585 
3586  stat = new_statement(ctx, STAT_ASSIGN, sizeof(*stat));
3587  if(!stat)
3588  return NULL;
3589 
3590  stat->member_expr = left;
3591  stat->value_expr = right;
3592  return &stat->stat;
3593 }
3594 
3595 static statement_t *new_set_statement(parser_ctx_t *ctx, member_expression_t *left, expression_t *right)
3596 {
3597  assign_statement_t *stat;
3598 
3599  stat = new_statement(ctx, STAT_SET, sizeof(*stat));
3600  if(!stat)
3601  return NULL;
3602 
3603  stat->member_expr = left;
3604  stat->value_expr = right;
3605  return &stat->stat;
3606 }
3607 
3608 static dim_decl_t *new_dim_decl(parser_ctx_t *ctx, const WCHAR *name, BOOL is_array, dim_list_t *dims)
3609 {
3610  dim_decl_t *decl;
3611 
3612  decl = parser_alloc(ctx, sizeof(*decl));
3613  if(!decl)
3614  return NULL;
3615 
3616  decl->name = name;
3617  decl->is_array = is_array;
3618  decl->dims = dims;
3619  decl->next = NULL;
3620  return decl;
3621 }
3622 
3623 static dim_list_t *new_dim(parser_ctx_t *ctx, unsigned val, dim_list_t *next)
3624 {
3625  dim_list_t *ret;
3626 
3627  ret = parser_alloc(ctx, sizeof(*ret));
3628  if(!ret)
3629  return NULL;
3630 
3631  ret->val = val;
3632  ret->next = next;
3633  return ret;
3634 }
3635 
3636 static statement_t *new_dim_statement(parser_ctx_t *ctx, dim_decl_t *decls)
3637 {
3638  dim_statement_t *stat;
3639 
3640  stat = new_statement(ctx, STAT_DIM, sizeof(*stat));
3641  if(!stat)
3642  return NULL;
3643 
3644  stat->dim_decls = decls;
3645  return &stat->stat;
3646 }
3647 
3648 static elseif_decl_t *new_elseif_decl(parser_ctx_t *ctx, expression_t *expr, statement_t *stat)
3649 {
3650  elseif_decl_t *decl;
3651 
3652  decl = parser_alloc(ctx, sizeof(*decl));
3653  if(!decl)
3654  return NULL;
3655 
3656  decl->expr = expr;
3657  decl->stat = stat;
3658  decl->next = NULL;
3659  return decl;
3660 }
3661 
3662 static statement_t *new_while_statement(parser_ctx_t *ctx, statement_type_t type, expression_t *expr, statement_t *body)
3663 {
3664  while_statement_t *stat;
3665 
3666  stat = new_statement(ctx, type, sizeof(*stat));
3667  if(!stat)
3668  return NULL;
3669 
3670  stat->expr = expr;
3671  stat->body = body;
3672  return &stat->stat;
3673 }
3674 
3675 static statement_t *new_forto_statement(parser_ctx_t *ctx, const WCHAR *identifier, expression_t *from_expr,
3676  expression_t *to_expr, expression_t *step_expr, statement_t *body)
3677 {
3678  forto_statement_t *stat;
3679 
3680  stat = new_statement(ctx, STAT_FORTO, sizeof(*stat));
3681  if(!stat)
3682  return NULL;
3683 
3684  stat->identifier = identifier;
3685  stat->from_expr = from_expr;
3686  stat->to_expr = to_expr;
3687  stat->step_expr = step_expr;
3688  stat->body = body;
3689  return &stat->stat;
3690 }
3691 
3692 static statement_t *new_foreach_statement(parser_ctx_t *ctx, const WCHAR *identifier, expression_t *group_expr,
3693  statement_t *body)
3694 {
3695  foreach_statement_t *stat;
3696 
3697  stat = new_statement(ctx, STAT_FOREACH, sizeof(*stat));
3698  if(!stat)
3699  return NULL;
3700 
3701  stat->identifier = identifier;
3702  stat->group_expr = group_expr;
3703  stat->body = body;
3704  return &stat->stat;
3705 }
3706 
3707 static statement_t *new_if_statement(parser_ctx_t *ctx, expression_t *expr, statement_t *if_stat, elseif_decl_t *elseif_decl,
3708  statement_t *else_stat)
3709 {
3710  if_statement_t *stat;
3711 
3712  stat = new_statement(ctx, STAT_IF, sizeof(*stat));
3713  if(!stat)
3714  return NULL;
3715 
3716  stat->expr = expr;
3717  stat->if_stat = if_stat;
3718  stat->elseifs = elseif_decl;
3719  stat->else_stat = else_stat;
3720  return &stat->stat;
3721 }
3722 
3723 static statement_t *new_select_statement(parser_ctx_t *ctx, expression_t *expr, case_clausule_t *case_clausules)
3724 {
3725  select_statement_t *stat;
3726 
3727  stat = new_statement(ctx, STAT_SELECT, sizeof(*stat));
3728  if(!stat)
3729  return NULL;
3730 
3731  stat->expr = expr;
3732  stat->case_clausules = case_clausules;
3733  return &stat->stat;
3734 }
3735 
3736 static case_clausule_t *new_case_clausule(parser_ctx_t *ctx, expression_t *expr, statement_t *stat, case_clausule_t *next)
3737 {
3738  case_clausule_t *ret;
3739 
3740  ret = parser_alloc(ctx, sizeof(*ret));
3741  if(!ret)
3742  return NULL;
3743 
3744  ret->expr = expr;
3745  ret->stat = stat;
3746  ret->next = next;
3747  return ret;
3748 }
3749 
3750 static statement_t *new_onerror_statement(parser_ctx_t *ctx, BOOL resume_next)
3751 {
3752  onerror_statement_t *stat;
3753 
3754  stat = new_statement(ctx, STAT_ONERROR, sizeof(*stat));
3755  if(!stat)
3756  return NULL;
3757 
3758  stat->resume_next = resume_next;
3759  return &stat->stat;
3760 }
3761 
3762 static arg_decl_t *new_argument_decl(parser_ctx_t *ctx, const WCHAR *name, BOOL by_ref)
3763 {
3764  arg_decl_t *arg_decl;
3765 
3766  arg_decl = parser_alloc(ctx, sizeof(*arg_decl));
3767  if(!arg_decl)
3768  return NULL;
3769 
3770  arg_decl->name = name;
3771  arg_decl->by_ref = by_ref;
3772  arg_decl->next = NULL;
3773  return arg_decl;
3774 }
3775 
3776 static function_decl_t *new_function_decl(parser_ctx_t *ctx, const WCHAR *name, function_type_t type,
3777  unsigned storage_flags, arg_decl_t *arg_decl, statement_t *body)
3778 {
3779  function_decl_t *decl;
3780 
3781  if(storage_flags & STORAGE_IS_DEFAULT) {
3782  if(type == FUNC_PROPGET) {
3783  type = FUNC_DEFGET;
3784  }else {
3785  FIXME("Invalid default property\n");
3786  ctx->hres = E_FAIL;
3787  return NULL;
3788  }
3789  }
3790 
3791  decl = parser_alloc(ctx, sizeof(*decl));
3792  if(!decl)
3793  return NULL;
3794 
3795  decl->name = name;
3796  decl->type = type;
3797  decl->is_public = !(storage_flags & STORAGE_IS_PRIVATE);
3798  decl->args = arg_decl;
3799  decl->body = body;
3800  decl->next = NULL;
3801  decl->next_prop_func = NULL;
3802  return decl;
3803 }
3804 
3805 static statement_t *new_function_statement(parser_ctx_t *ctx, function_decl_t *decl)
3806 {
3807  function_statement_t *stat;
3808 
3809  stat = new_statement(ctx, STAT_FUNC, sizeof(*stat));
3810  if(!stat)
3811  return NULL;
3812 
3813  stat->func_decl = decl;
3814  return &stat->stat;
3815 }
3816 
3817 static class_decl_t *new_class_decl(parser_ctx_t *ctx)
3818 {
3819  class_decl_t *class_decl;
3820 
3821  class_decl = parser_alloc(ctx, sizeof(*class_decl));
3822  if(!class_decl)
3823  return NULL;
3824 
3825  class_decl->funcs = NULL;
3826  class_decl->props = NULL;
3827  class_decl->next = NULL;
3828  return class_decl;
3829 }
3830 
3831 static class_decl_t *add_class_function(parser_ctx_t *ctx, class_decl_t *class_decl, function_decl_t *decl)
3832 {
3833  function_decl_t *iter;
3834 
3835  for(iter = class_decl->funcs; iter; iter = iter->next) {
3836  if(!wcsicmp(iter->name, decl->name)) {
3837  if(decl->type == FUNC_SUB || decl->type == FUNC_FUNCTION) {
3838  FIXME("Redefinition of %s::%s\n", debugstr_w(class_decl->name), debugstr_w(decl->name));
3839  ctx->hres = E_FAIL;
3840  return NULL;
3841  }
3842 
3843  while(1) {
3844  if(iter->type == decl->type) {
3845  FIXME("Redefinition of %s::%s\n", debugstr_w(class_decl->name), debugstr_w(decl->name));
3846  ctx->hres = E_FAIL;
3847  return NULL;
3848  }
3849  if(!iter->next_prop_func)
3850  break;
3851  iter = iter->next_prop_func;
3852  }
3853 
3854  iter->next_prop_func = decl;
3855  return class_decl;
3856  }
3857  }
3858 
3859  decl->next = class_decl->funcs;
3860  class_decl->funcs = decl;
3861  return class_decl;
3862 }
3863 
3864 static class_decl_t *add_dim_prop(parser_ctx_t *ctx, class_decl_t *class_decl, dim_decl_t *dim_decl, unsigned storage_flags)
3865 {
3866  if(storage_flags & STORAGE_IS_DEFAULT) {
3867  FIXME("variant prop van't be default value\n");
3868  ctx->hres = E_FAIL;
3869  return NULL;
3870  }
3871 
3872  dim_decl->is_public = !(storage_flags & STORAGE_IS_PRIVATE);
3873  dim_decl->next = class_decl->props;
3874  class_decl->props = dim_decl;
3875  return class_decl;
3876 }
3877 
3878 static const_decl_t *new_const_decl(parser_ctx_t *ctx, const WCHAR *name, expression_t *expr)
3879 {
3880  const_decl_t *decl;
3881 
3882  decl = parser_alloc(ctx, sizeof(*decl));
3883  if(!decl)
3884  return NULL;
3885 
3886  decl->name = name;
3887  decl->value_expr = expr;
3888  decl->next = NULL;
3889  return decl;
3890 }
3891 
3892 static statement_t *new_const_statement(parser_ctx_t *ctx, const_decl_t *decls)
3893 {
3894  const_statement_t *stat;
3895 
3896  stat = new_statement(ctx, STAT_CONST, sizeof(*stat));
3897  if(!stat)
3898  return NULL;
3899 
3900  stat->decls = decls;
3901  return &stat->stat;
3902 }
3903 
3904 static statement_t *link_statements(statement_t *head, statement_t *tail)
3905 {
3906  statement_t *iter;
3907 
3908  for(iter = head; iter->next; iter = iter->next);
3909  iter->next = tail;
3910 
3911  return head;
3912 }
3913 
3914 void *parser_alloc(parser_ctx_t *ctx, size_t size)
3915 {
3916  void *ret;
3917 
3918  ret = heap_pool_alloc(&ctx->heap, size);
3919  if(!ret)
3920  ctx->hres = E_OUTOFMEMORY;
3921  return ret;
3922 }
3923 
3924 HRESULT parse_script(parser_ctx_t *ctx, const WCHAR *code, const WCHAR *delimiter, DWORD flags)
3925 {
3926  static const WCHAR html_delimiterW[] = {'<','/','s','c','r','i','p','t','>',0};
3927 
3928  ctx->code = ctx->ptr = code;
3929  ctx->end = ctx->code + lstrlenW(ctx->code);
3930 
3931  heap_pool_init(&ctx->heap);
3932 
3933  ctx->parse_complete = FALSE;
3934  ctx->hres = S_OK;
3935 
3936  ctx->last_token = tNL;
3937  ctx->last_nl = 0;
3938  ctx->stats = ctx->stats_tail = NULL;
3939  ctx->class_decls = NULL;
3940  ctx->option_explicit = FALSE;
3941  ctx->is_html = delimiter && !wcsicmp(delimiter, html_delimiterW);
3942 
3943  if(flags & SCRIPTTEXT_ISEXPRESSION)
3944  ctx->last_token = tEXPRESSION;
3945 
3946  parser_parse(ctx);
3947 
3948  if(FAILED(ctx->hres))
3949  return ctx->hres;
3950  if(!ctx->parse_complete) {
3951  FIXME("parser failed around %s\n", debugstr_w(ctx->code+20 > ctx->ptr ? ctx->code : ctx->ptr-20));
3952  return E_FAIL;
3953  }
3954 
3955  return S_OK;
3956 }
3957 
3958 void parser_release(parser_ctx_t *ctx)
3959 {
3960  heap_pool_free(&ctx->heap);
3961 }
YYSTYPE::expression
expression_t * expression
Definition: parser.tab.c:256
_arg_decl_t::next
struct _arg_decl_t * next
Definition: parse.h:165
EXPR_XOR
Definition: parse.h:55
select_statement_t
Definition: parse.h:248
YYEMPTY
#define YYEMPTY
Definition: parser.tab.c:1142
expression_type_t
expression_type_t
Definition: parser.h:216
parse_script
HRESULT parse_script(parser_ctx_t *ctx, const WCHAR *code, const WCHAR *delimiter, DWORD flags)
Definition: parser.tab.c:3924
while_statement_t
Definition: parser.h:150
YYSTYPE::dim_list
dim_list_t * dim_list
Definition: parser.tab.c:260
EXPR_ME
Definition: parse.h:41
yypact_value_is_default
#define yypact_value_is_default(Yystate)
Definition: parser.tab.c:664
expr::expr
struct complex_expr expr
Definition: query.h:91
yyparse
#define yyparse
Definition: parser.tab.c:67
expr
LOCAL int expr(arg_t *ap, int *altp)
Definition: match.c:512
YYDPRINTF
#define YYDPRINTF(Args)
Definition: parser.tab.c:1299
tail
struct outqueuenode * tail
Definition: adnsresfilter.c:66
_function_decl_t::name
const WCHAR * name
Definition: parse.h:169
_const_decl_t::value_expr
expression_t * value_expr
Definition: parse.h:233
new_assign_statement
static statement_t * new_assign_statement(parser_ctx_t *, member_expression_t *, expression_t *)
Definition: parser.tab.c:3582
YYSTYPE::integer
LONG integer
Definition: parser.tab.c:267
malloc
void * malloc(YYSIZE_T)
new_function_statement
static statement_t * new_function_statement(parser_ctx_t *, function_decl_t *)
Definition: parser.tab.c:3805
yynerrs
#define yynerrs
Definition: parser.tab.c:71
new_if_statement
static statement_t * new_if_statement(parser_ctx_t *, expression_t *, statement_t *, elseif_decl_t *, statement_t *)
Definition: parser.tab.c:3707
head
struct outqueuenode * head
Definition: adnsresfilter.c:66
new_unary_expression
static expression_t * new_unary_expression(parser_ctx_t *, expression_type_t, expression_t *)
Definition: parser.tab.c:3505
yylloc
YYLTYPE yylloc
Definition: hlsl.tab.c:2413
_class_decl_t::next
struct _class_decl_t * next
Definition: parse.h:187
TRUE
#define TRUE
Definition: types.h:120
_function_decl_t::next
struct _function_decl_t * next
Definition: parse.h:174
heap_pool_alloc
void * heap_pool_alloc(heap_pool_t *, DWORD) __WINE_ALLOC_SIZE(2) DECLSPEC_HIDDEN
Definition: jsutils.c:77
new_string_expression
static expression_t * new_string_expression(parser_ctx_t *, const WCHAR *)
Definition: parser.tab.c:3469
YYSTYPE::string
LPWSTR string
Definition: sql.tab.c:240
EXPR_EXP
Definition: parse.h:32
source_add_statement
static void source_add_statement(parser_ctx_t *, statement_t *)
Definition: parser.tab.c:3403
_class_decl_t::funcs
function_decl_t * funcs
Definition: parse.h:185
YY_SYMBOL_PRINT
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: parser.tab.c:1300
int_expression_t
Definition: parse.h:68
new_elseif_decl
static elseif_decl_t * new_elseif_decl(parser_ctx_t *, expression_t *, statement_t *)
Definition: parser.tab.c:3648
yytname
static const char *const yytname[]
Definition: parser.tab.c:834
yytable_value_is_error
#define yytable_value_is_error(Yytable_value)
Definition: parser.tab.c:669
_class_decl_t
Definition: parse.h:183
_statement_t
Definition: parser.h:123
yylval
YYSTYPE yylval
Definition: parser.tab.c:2356
type
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
new_member_expression
static member_expression_t * new_member_expression(parser_ctx_t *, expression_t *, const WCHAR *)
Definition: parser.tab.c:3530
_function_decl_t::type
function_type_t type
Definition: parse.h:170
parser_release
void parser_release(parser_ctx_t *ctx)
Definition: parser.tab.c:4361
yystpcpy
static char * yystpcpy(char *yydest, const char *yysrc)
Definition: parser.tab.c:2135
free
void free(void *)
Definition: cabinet.c:147
YY_IGNORE_MAYBE_UNINITIALIZED_END
#define YY_IGNORE_MAYBE_UNINITIALIZED_END
Definition: parser.tab.c:380
YYSYNTAX_ERROR
#define YYSYNTAX_ERROR
new_while_statement
static statement_t * new_while_statement(parser_ctx_t *, statement_type_t, expression_t *, statement_t *)
Definition: parser.tab.c:3662
EXPR_IMP
Definition: parse.h:36
YYSTACK_ALLOC
#define YYSTACK_ALLOC
Definition: parser.tab.c:428
yytype_int16
short yytype_int16
Definition: asmshader.tab.c:406
append
static void append(struct dump_context *dc, const void *data, unsigned size)
Definition: minidump.c:397
lstrlenW
#define lstrlenW
Definition: compat.h:498
E_FAIL
#define E_FAIL
Definition: ddrawi.h:102
yystrlen
static YYSIZE_T yystrlen(const char *yystr)
Definition: parser.tab.c:2118
args
Definition: match.c:390
VARIANT_BOOL
short VARIANT_BOOL
Definition: compat.h:2038
expr
Definition: query.h:86
YYABORT
#define YYABORT
Definition: parser.tab.c:1146
STORAGE_IS_DEFAULT
#define STORAGE_IS_DEFAULT
Definition: parser.tab.c:133
YYSTYPE::arg_decl
arg_decl_t * arg_decl
Definition: parser.tab.c:262
new_select_statement
static statement_t * new_select_statement(parser_ctx_t *, expression_t *, case_clausule_t *)
Definition: parser.tab.c:3723
new_const_decl
static const_decl_t * new_const_decl(parser_ctx_t *, const WCHAR *, expression_t *)
Definition: parser.tab.c:3878
YY_NULLPTR
#define YY_NULLPTR
Definition: parser.tab.c:148
new_binary_expression
static expression_t * new_binary_expression(parser_ctx_t *, expression_type_t, expression_t *, expression_t *)
Definition: parser.tab.c:3517
_elseif_decl_t::next
struct _elseif_decl_t * next
Definition: parse.h:193
_statement_t::next
statement_t * next
Definition: parser.h:125
new_const_statement
static statement_t * new_const_statement(parser_ctx_t *, const_decl_t *)
Definition: parser.tab.c:3892
YYINITDEPTH
#define YYINITDEPTH
Definition: parser.tab.c:1308
yylex
#define yylex
Definition: parser.tab.c:68
new_function_decl
static function_decl_t * new_function_decl(parser_ctx_t *, const WCHAR *, function_type_t, unsigned, arg_decl_t *, statement_t *)
Definition: parser.tab.c:3776
function_type_t
function_type_t
Definition: vbscript.h:307
_function_decl_t::args
arg_decl_t * args
Definition: parse.h:172
YYSTYPE::case_clausule
case_clausule_t * case_clausule
Definition: parser.tab.c:298
add_dim_prop
static class_decl_t * add_dim_prop(parser_ctx_t *, class_decl_t *, dim_decl_t *, unsigned)
Definition: parser.tab.c:3864
new_bool_expression
static expression_t * new_bool_expression(parser_ctx_t *, VARIANT_BOOL)
Definition: parser.tab.c:3457
YYSTYPE::boolean
BOOL boolean
Definition: parser.tab.c:268
parser_error
static int parser_error(parser_ctx_t *, const char *)
Definition: parser.tab.c:3398
yydebug
#define yydebug
Definition: parser.tab.c:70
_const_decl_t::next
struct _const_decl_t * next
Definition: parse.h:234
new_double_expression
static expression_t * new_double_expression(parser_ctx_t *, double)
Definition: parser.tab.c:3493
E_OUTOFMEMORY
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
_dim_decl_t::is_public
BOOL is_public
Definition: parse.h:152
parser_parse
int parser_parse(parser_ctx_t *ctx)
FALSE
#define FALSE
Definition: types.h:117
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
expr::type
int type
Definition: query.h:88
LONG
long LONG
Definition: pedump.c:60
YYNTOKENS
#define YYNTOKENS
Definition: parser.tab.c:523
YYTRANSLATE
#define YYTRANSLATE(YYX)
Definition: parser.tab.c:536
debugstr_w
#define debugstr_w
Definition: kernel32.h:32
FIXME
#define FIXME(fmt,...)
Definition: debug.h:111
forto_statement_t
Definition: parse.h:210
_const_decl_t::name
const WCHAR * name
Definition: parse.h:232
WINE_DEFAULT_DEBUG_CHANNEL
WINE_DEFAULT_DEBUG_CHANNEL(jscript)
CHECK_ERROR
#define CHECK_ERROR
Definition: parser.tab.c:135
_case_clausule_t
Definition: parser.h:191
_arg_decl_t::name
const WCHAR * name
Definition: parse.h:163
str
const WCHAR * str
Definition: rpc_transport.c:2472
onerror_statement_t
Definition: parse.h:226
new_class_decl
static class_decl_t * new_class_decl(parser_ctx_t *)
Definition: parser.tab.c:3817
YYSTYPE::elseif
elseif_decl_t * elseif
Definition: parser.tab.c:258
NULL
smooth NULL
Definition: ftsmooth.c:416
_dim_decl_t::is_array
BOOL is_array
Definition: parse.h:151
delimiter
const char * delimiter
Definition: string.c:1566
is_array
static int is_array(const type_t *t)
Definition: header.h:64
yytype_uint16
unsigned short yytype_uint16
Definition: parser.tab.c:348
_dim_statement_t
Definition: parse.h:157
_class_decl_t::props
dim_decl_t * props
Definition: parse.h:186
yypact
static const yytype_int16 yypact[]
Definition: parser.tab.c:674
_elseif_decl_t
Definition: parse.h:190
string_expression_t
Definition: parse.h:78
parser_alloc
void * parser_alloc(parser_ctx_t *ctx, size_t size)
Definition: parser.tab.c:3914
val
GLuint GLfloat * val
Definition: glext.h:7180
YY_STACK_PRINT
#define YY_STACK_PRINT(Bottom, Top)
Definition: parser.tab.c:1301
EXPR_EQV
Definition: parse.h:31
YYSTACK_ALLOC_MAXIMUM
#define YYSTACK_ALLOC_MAXIMUM
Definition: parser.tab.c:431
yyalloc::yyss_alloc
yytype_int16 yyss_alloc
Definition: asmshader.tab.c:558
yyerror
#define yyerror
Definition: parser.tab.c:69
yytranslate
static const yytype_uint8 yytranslate[]
Definition: parser.tab.c:541
yytype_int8
signed char yytype_int8
Definition: parser.tab.c:342
new_dim_decl
static dim_decl_t * new_dim_decl(parser_ctx_t *, const WCHAR *, BOOL, dim_list_t *)
Definition: parser.tab.c:3608
yytokentype
yytokentype
Definition: asmshader.tab.c:160
yystos
static const yytype_uint8 yystos[]
Definition: parser.tab.c:1036
new_call_statement
static statement_t * new_call_statement(parser_ctx_t *, BOOL, member_expression_t *)
Definition: parser.tab.c:3569
YYSTACK_RELOCATE
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
Definition: parser.tab.c:484
size
GLsizeiptr size
Definition: glext.h:5919
YY_ASSERT
#define YY_ASSERT(E)
Definition: parser.tab.c:387
assign_statement_t
Definition: parse.h:138
YYSTACK_BYTES
#define YYSTACK_BYTES(N)
Definition: parser.tab.c:473
function_statement_t
Definition: parse.h:178
_function_decl_t::next_prop_func
struct _function_decl_t * next_prop_func
Definition: parse.h:175
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180
new_case_clausule
static case_clausule_t * new_case_clausule(parser_ctx_t *, expression_t *, statement_t *, case_clausule_t *)
Definition: parser.tab.c:3736
yytype_uint16
unsigned short yytype_uint16
Definition: asmshader.tab.c:400
YYSTYPE::statement
statement_t * statement
Definition: parser.tab.c:308
HRESULT
LONG HRESULT
Definition: typedefs.h:79
yyalloc::yyvs_alloc
YYSTYPE yyvs_alloc
Definition: asmshader.tab.c:559
_class_decl_t::name
const WCHAR * name
Definition: parse.h:184
_elseif_decl_t::stat
statement_t * stat
Definition: parse.h:192
yycheck
static const yytype_int16 yycheck[]
Definition: parser.tab.c:914
_iobuf
Definition: mbstring.h:19
yytype_uint8
unsigned char yytype_uint8
Definition: parser.tab.c:336
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
left
GLint left
Definition: glext.h:7726
_function_decl_t::is_public
BOOL is_public
Definition: parse.h:171
new_forto_statement
static statement_t * new_forto_statement(parser_ctx_t *, const WCHAR *, expression_t *, expression_t *, expression_t *, statement_t *)
Definition: parser.tab.c:3675
right
GLdouble GLdouble right
Definition: glext.h:10859
EXPR_INT
Definition: parse.h:37
new_argument_decl
static arg_decl_t * new_argument_decl(parser_ctx_t *, const WCHAR *, BOOL)
Definition: parser.tab.c:3762
statement_type_t
statement_type_t
Definition: parser.h:104
flags
GLbitfield flags
Definition: glext.h:7161
YYSIZE_T
#define YYSIZE_T
Definition: parser.tab.c:322
wcsicmp
#define wcsicmp
Definition: compat.h:15
YYSTYPE::const_decl
const_decl_t * const_decl
Definition: parser.tab.c:264
bool_expression_t
Definition: parse.h:63
ret
int ret
Definition: wcstombs-tests.c:31
_expression_t
Definition: parser.h:277
_dim_decl_t
Definition: parse.h:149
YYSTYPE::uint
unsigned uint
Definition: parser.tab.c:266
YYSTYPE::string
const WCHAR * string
Definition: parser.tab.c:254
yydefact
static const yytype_uint8 yydefact[]
Definition: parser.tab.c:722
yyr2
static const yytype_uint8 yyr2[]
Definition: parser.tab.c:1111
YY_REDUCE_PRINT
#define YY_REDUCE_PRINT(Rule)
Definition: parser.tab.c:1302
stat
Definition: stat.h:55
parser_debug
int parser_debug
Definition: widl.c:111
_dim_list_t
Definition: parse.h:144
new_dim_statement
static statement_t * new_dim_statement(parser_ctx_t *, dim_decl_t *)
Definition: parser.tab.c:3636
code
Definition: inflate.c:139
foreach_statement_t
Definition: parse.h:219
code
int code
Definition: i386-dis.c:3591
value
GLsizei const GLfloat * value
Definition: glext.h:6069
heap_pool_init
void heap_pool_init(heap_pool_t *) DECLSPEC_HIDDEN
Definition: jsutils.c:71
EXPR_LT
Definition: parse.h:39
new_expression
static void * new_expression(parser_ctx_t *, expression_type_t, size_t)
Definition: parser.tab.c:3444
add_class_function
static class_decl_t * add_class_function(parser_ctx_t *, class_decl_t *, function_decl_t *)
Definition: parser.tab.c:3831
_elseif_decl_t::expr
expression_t * expr
Definition: parse.h:191
EXPR_NEG
Definition: parse.h:45
_dim_decl_t::name
const WCHAR * name
Definition: parse.h:150
YYSTYPE::dim_decl
dim_decl_t * dim_decl
Definition: parser.tab.c:259
new_new_expression
static expression_t * new_new_expression(parser_ctx_t *, const WCHAR *)
Definition: parser.tab.c:3544
EXPR_IS
Definition: parse.h:38
new_statement
static void * new_statement(parser_ctx_t *, statement_type_t, size_t)
Definition: parser.tab.c:3556
FAILED
Definition: global_mem.c:34
yytable
static const yytype_int16 yytable[]
Definition: parser.tab.c:794
stat
_CRTIMP int __cdecl stat(const char *_Filename, struct stat *_Stat)
Definition: stat.h:345
retval_statement_t
Definition: parse.h:254
S_OK
#define S_OK
Definition: intsafe.h:59
next
static unsigned __int64 next
Definition: rand_nt.c:6
_const_decl_t
Definition: parse.h:231
yychar
int yychar
Definition: parser.tab.c:2353
YYERROR
#define YYERROR
Definition: parser.tab.c:1147
yypgoto
static const yytype_int16 yypgoto[]
Definition: parser.tab.c:768
handle_isexpression_script
static void handle_isexpression_script(parser_ctx_t *ctx, expression_t *expr)
Definition: parser.tab.c:3428
YYEOF
#define YYEOF
Definition: parser.tab.c:1143
member_expression_t
Definition: parser.h:322
STORAGE_IS_PRIVATE
#define STORAGE_IS_PRIVATE
Definition: parser.tab.c:132
new_long_expression
static expression_t * new_long_expression(parser_ctx_t *, expression_type_t, LONG)
Definition: parser.tab.c:3481
YYSTYPE::uint
unsigned int uint
Definition: ppy.tab.c:261
yysyntax_error
static int yysyntax_error(YYSIZE_T *yymsg_alloc, char **yymsg, yytype_int16 *yyssp, int yytoken)
Definition: parser.tab.c:2205
EXPR_GT
Definition: parse.h:33
body
static const void * body(MD5_CTX *ctx, const void *data, unsigned long size)
Definition: md5.c:100
YYSTYPE::member
member_expression_t * member
Definition: parser.tab.c:257
_function_decl_t::body
statement_t * body
Definition: parse.h:173
_dim_decl_t::next
struct _dim_decl_t * next
Definition: parse.h:154
YYPOPSTACK
#define YYPOPSTACK(N)
_arg_decl_t
Definition: parse.h:162
new_set_statement
static statement_t * new_set_statement(parser_ctx_t *, member_expression_t *, expression_t *)
Definition: parser.tab.c:3595
YY_
#define YY_(Msgid)
Definition: parser.tab.c:338
source_add_class
static void source_add_class(parser_ctx_t *, class_decl_t *)
Definition: parser.tab.c:3416
YYLAST
#define YYLAST
Definition: parser.tab.c:520
YYSTYPE::class_decl
class_decl_t * class_decl
Definition: parser.tab.c:263
yytype_int16
short yytype_int16
Definition: parser.tab.c:354
heap_pool_free
void heap_pool_free(heap_pool_t *) DECLSPEC_HIDDEN
Definition: jsutils.c:169
_dim_decl_t::dims
dim_list_t * dims
Definition: parse.h:153
name
Definition: name.c:38
stderr
FILE * stderr
parse_complete
static void parse_complete(parser_ctx_t *, BOOL)
Definition: parser.tab.c:3422
if_statement_t
Definition: parser.h:143
YYCASE_
#define YYCASE_(N, S)
new_foreach_statement
static statement_t * new_foreach_statement(parser_ctx_t *, const WCHAR *, expression_t *, statement_t *)
Definition: parser.tab.c:3692
parser_ctx_t
Definition: parse.h:259
EXPR_NOT
Definition: parse.h:49
YYFINAL
#define YYFINAL
Definition: parser.tab.c:518
unary_expression_t
Definition: parser.h:310
uint
UINT32 uint
Definition: types.h:83
_arg_decl_t::by_ref
BOOL by_ref
Definition: parse.h:164
YYTERROR
#define YYTERROR
Definition: parser.tab.c:1170
binary_expression_t
Definition: parser.h:304
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
Definition: parser.tab.c:379
new_onerror_statement
static statement_t * new_onerror_statement(parser_ctx_t *, BOOL)
Definition: parser.tab.c:3750
YYMAXDEPTH
#define YYMAXDEPTH
Definition: parser.tab.c:1319
YYSTYPE::dbl
double dbl
Definition: parser.tab.c:269
YYACCEPT
#define YYACCEPT
Definition: parser.tab.c:1145
YYSTACK_FREE
#define YYSTACK_FREE
Definition: parser.tab.c:429
YYUSE
#define YYUSE(E)
Definition: parser.tab.c:362
YY_INITIAL_VALUE
#define YY_INITIAL_VALUE(Value)
Definition: parser.tab.c:376
link_statements
static statement_t * link_statements(statement_t *, statement_t *)
Definition: parser.tab.c:3904
YYSTYPE::func_decl
function_decl_t * func_decl
Definition: parser.tab.c:261
new_dim
static dim_list_t * new_dim(parser_ctx_t *, unsigned, dim_list_t *)
Definition: parser.tab.c:3623
call_statement_t
Definition: parse.h:132
yydestruct
static void yydestruct(const char *yymsg, int yytype, YYSTYPE *yyvaluep, parser_ctx_t *ctx)
Definition: parser.tab.c:1555
yytype_uint8
unsigned char yytype_uint8
Definition: asmshader.tab.c:388
const_statement_t
Definition: parse.h:237
yydefgoto
static const yytype_int16 yydefgoto[]
Definition: parser.tab.c:780
yyr1
static const yytype_uint8 yyr1[]
Definition: parser.tab.c:1082
YYNSTATES
#define YYNSTATES
Definition: parser.tab.c:529
yytnamerr
static YYSIZE_T yytnamerr(char *yyres, const char *yystr)
Definition: parser.tab.c:2157
_function_decl_t
Definition: parse.h:168
double_expression_t
Definition: parse.h:73
name
GLuint const GLchar * name
Definition: glext.h:6031