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