1 /* A Bison parser, made by GNU Bison 3.0.4. */
2
3 /* Bison implementation for Yacc-like parsers in C
4
5 Copyright (C) 1984, 1989-1990, 2000-2015 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.4"
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
63
64 /* Copy the first part of user declarations. */
65
66
67 // Copyright 2016 The SwiftShader Authors. All Rights Reserved.
68 //
69 // Licensed under the Apache License, Version 2.0 (the "License");
70 // you may not use this file except in compliance with the License.
71 // You may obtain a copy of the License at
72 //
73 // http://www.apache.org/licenses/LICENSE-2.0
74 //
75 // Unless required by applicable law or agreed to in writing, software
76 // distributed under the License is distributed on an "AS IS" BASIS,
77 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
78 // See the License for the specific language governing permissions and
79 // limitations under the License.
80
81 // This file is auto-generated by generate_parser.sh. DO NOT EDIT!
82
83 // Ignore errors in auto-generated code.
84 #if defined(__GNUC__)
85 #pragma GCC diagnostic ignored "-Wunused-function"
86 #pragma GCC diagnostic ignored "-Wunused-variable"
87 #pragma GCC diagnostic ignored "-Wswitch-enum"
88 #elif defined(_MSC_VER)
89 #pragma warning(disable: 4065)
90 #pragma warning(disable: 4189)
91 #pragma warning(disable: 4505)
92 #pragma warning(disable: 4701)
93 #endif
94
95 #include "SymbolTable.h"
96 #include "ParseHelper.h"
97
98 #define YYENABLE_NLS 0
99
100
101
102 # ifndef YY_NULLPTR
103 # if defined __cplusplus && 201103L <= __cplusplus
104 # define YY_NULLPTR nullptr
105 # else
106 # define YY_NULLPTR 0
107 # endif
108 # endif
109
110 /* Enabling verbose error messages. */
111 #ifdef YYERROR_VERBOSE
112 # undef YYERROR_VERBOSE
113 # define YYERROR_VERBOSE 1
114 #else
115 # define YYERROR_VERBOSE 0
116 #endif
117
118 /* In a future release of Bison, this section will be replaced
119 by #include "glslang_tab.h". */
120 #ifndef YY_YY_GLSLANG_TAB_H_INCLUDED
121 # define YY_YY_GLSLANG_TAB_H_INCLUDED
122 /* Debug traces. */
123 #ifndef YYDEBUG
124 # define YYDEBUG 0
125 #endif
126 #if YYDEBUG
127 extern int yydebug;
128 #endif
129 /* "%code requires" blocks. */
130
131
132 #define YYLTYPE TSourceLoc
133 #define YYLTYPE_IS_DECLARED 1
134
135
136
137 /* Token type. */
138 #ifndef YYTOKENTYPE
139 # define YYTOKENTYPE
140 enum yytokentype
141 {
142 INVARIANT = 258,
143 HIGH_PRECISION = 259,
144 MEDIUM_PRECISION = 260,
145 LOW_PRECISION = 261,
146 PRECISION = 262,
147 ATTRIBUTE = 263,
148 CONST_QUAL = 264,
149 BOOL_TYPE = 265,
150 FLOAT_TYPE = 266,
151 INT_TYPE = 267,
152 UINT_TYPE = 268,
153 BREAK = 269,
154 CONTINUE = 270,
155 DO = 271,
156 ELSE = 272,
157 FOR = 273,
158 IF = 274,
159 DISCARD = 275,
160 RETURN = 276,
161 SWITCH = 277,
162 CASE = 278,
163 DEFAULT = 279,
164 BVEC2 = 280,
165 BVEC3 = 281,
166 BVEC4 = 282,
167 IVEC2 = 283,
168 IVEC3 = 284,
169 IVEC4 = 285,
170 VEC2 = 286,
171 VEC3 = 287,
172 VEC4 = 288,
173 UVEC2 = 289,
174 UVEC3 = 290,
175 UVEC4 = 291,
176 MATRIX2 = 292,
177 MATRIX3 = 293,
178 MATRIX4 = 294,
179 IN_QUAL = 295,
180 OUT_QUAL = 296,
181 INOUT_QUAL = 297,
182 UNIFORM = 298,
183 VARYING = 299,
184 MATRIX2x3 = 300,
185 MATRIX3x2 = 301,
186 MATRIX2x4 = 302,
187 MATRIX4x2 = 303,
188 MATRIX3x4 = 304,
189 MATRIX4x3 = 305,
190 CENTROID = 306,
191 FLAT = 307,
192 SMOOTH = 308,
193 STRUCT = 309,
194 VOID_TYPE = 310,
195 WHILE = 311,
196 SAMPLER2D = 312,
197 SAMPLERCUBE = 313,
198 SAMPLER_EXTERNAL_OES = 314,
199 SAMPLER2DRECT = 315,
200 SAMPLER2DARRAY = 316,
201 ISAMPLER2D = 317,
202 ISAMPLER3D = 318,
203 ISAMPLERCUBE = 319,
204 ISAMPLER2DARRAY = 320,
205 USAMPLER2D = 321,
206 USAMPLER3D = 322,
207 USAMPLERCUBE = 323,
208 USAMPLER2DARRAY = 324,
209 SAMPLER3D = 325,
210 SAMPLER3DRECT = 326,
211 SAMPLER2DSHADOW = 327,
212 SAMPLERCUBESHADOW = 328,
213 SAMPLER2DARRAYSHADOW = 329,
214 LAYOUT = 330,
215 IDENTIFIER = 331,
216 TYPE_NAME = 332,
217 FLOATCONSTANT = 333,
218 INTCONSTANT = 334,
219 UINTCONSTANT = 335,
220 BOOLCONSTANT = 336,
221 FIELD_SELECTION = 337,
222 LEFT_OP = 338,
223 RIGHT_OP = 339,
224 INC_OP = 340,
225 DEC_OP = 341,
226 LE_OP = 342,
227 GE_OP = 343,
228 EQ_OP = 344,
229 NE_OP = 345,
230 AND_OP = 346,
231 OR_OP = 347,
232 XOR_OP = 348,
233 MUL_ASSIGN = 349,
234 DIV_ASSIGN = 350,
235 ADD_ASSIGN = 351,
236 MOD_ASSIGN = 352,
237 LEFT_ASSIGN = 353,
238 RIGHT_ASSIGN = 354,
239 AND_ASSIGN = 355,
240 XOR_ASSIGN = 356,
241 OR_ASSIGN = 357,
242 SUB_ASSIGN = 358,
243 LEFT_PAREN = 359,
244 RIGHT_PAREN = 360,
245 LEFT_BRACKET = 361,
246 RIGHT_BRACKET = 362,
247 LEFT_BRACE = 363,
248 RIGHT_BRACE = 364,
249 DOT = 365,
250 COMMA = 366,
251 COLON = 367,
252 EQUAL = 368,
253 SEMICOLON = 369,
254 BANG = 370,
255 DASH = 371,
256 TILDE = 372,
257 PLUS = 373,
258 STAR = 374,
259 SLASH = 375,
260 PERCENT = 376,
261 LEFT_ANGLE = 377,
262 RIGHT_ANGLE = 378,
263 VERTICAL_BAR = 379,
264 CARET = 380,
265 AMPERSAND = 381,
266 QUESTION = 382
267 };
268 #endif
269
270 /* Value type. */
271 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
272
273 union YYSTYPE
274 {
275
276
277 struct {
278 union {
279 TString *string;
280 float f;
281 int i;
282 unsigned int u;
283 bool b;
284 };
285 TSymbol* symbol;
286 } lex;
287 struct {
288 TOperator op;
289 union {
290 TIntermNode* intermNode;
291 TIntermNodePair nodePair;
292 TIntermTyped* intermTypedNode;
293 TIntermAggregate* intermAggregate;
294 TIntermSwitch* intermSwitch;
295 TIntermCase* intermCase;
296 };
297 union {
298 TPublicType type;
299 TPrecision precision;
300 TLayoutQualifier layoutQualifier;
301 TQualifier qualifier;
302 TFunction* function;
303 TParameter param;
304 TField* field;
305 TFieldList* fieldList;
306 };
307 } interm;
308
309
310 };
311
312 typedef union YYSTYPE YYSTYPE;
313 # define YYSTYPE_IS_TRIVIAL 1
314 # define YYSTYPE_IS_DECLARED 1
315 #endif
316
317 /* Location type. */
318 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
319 typedef struct YYLTYPE YYLTYPE;
320 struct YYLTYPE
321 {
322 int first_line;
323 int first_column;
324 int last_line;
325 int last_column;
326 };
327 # define YYLTYPE_IS_DECLARED 1
328 # define YYLTYPE_IS_TRIVIAL 1
329 #endif
330
331
332
333 int yyparse (TParseContext* context, void* yyscanner);
334
335 #endif /* !YY_YY_GLSLANG_TAB_H_INCLUDED */
336
337 /* Copy the second part of user declarations. */
338
339
340 extern int yylex(YYSTYPE* yylval, YYLTYPE* yylloc, void* yyscanner);
341 extern void yyerror(YYLTYPE* lloc, TParseContext* context, void* scanner, const char* reason);
342
343 #define YYLLOC_DEFAULT(Current, Rhs, N) \
344 do { \
345 if (N) { \
346 (Current).first_file = YYRHSLOC(Rhs, 1).first_file; \
347 (Current).first_line = YYRHSLOC(Rhs, 1).first_line; \
348 (Current).last_file = YYRHSLOC(Rhs, N).last_file; \
349 (Current).last_line = YYRHSLOC(Rhs, N).last_line; \
350 } \
351 else { \
352 (Current).first_file = YYRHSLOC(Rhs, 0).last_file; \
353 (Current).first_line = YYRHSLOC(Rhs, 0).last_line; \
354 (Current).last_file = YYRHSLOC(Rhs, 0).last_file; \
355 (Current).last_line = YYRHSLOC(Rhs, 0).last_line; \
356 } \
357 } while (0)
358
359 #define FRAG_VERT_ONLY(S, L) { \
360 if (context->getShaderType() != GL_FRAGMENT_SHADER && \
361 context->getShaderType() != GL_VERTEX_SHADER) { \
362 context->error(L, " supported in vertex/fragment shaders only ", S); \
363 context->recover(); \
364 } \
365 }
366
367 #define VERTEX_ONLY(S, L) { \
368 if (context->getShaderType() != GL_VERTEX_SHADER) { \
369 context->error(L, " supported in vertex shaders only ", S); \
370 context->recover(); \
371 } \
372 }
373
374 #define FRAG_ONLY(S, L) { \
375 if (context->getShaderType() != GL_FRAGMENT_SHADER) { \
376 context->error(L, " supported in fragment shaders only ", S); \
377 context->recover(); \
378 } \
379 }
380
381 #define ES2_ONLY(S, L) { \
382 if (context->getShaderVersion() != 100) { \
383 context->error(L, " supported in GLSL ES 1.00 only ", S); \
384 context->recover(); \
385 } \
386 }
387
388 #define ES3_ONLY(TOKEN, LINE, REASON) { \
389 if (context->getShaderVersion() != 300) { \
390 context->error(LINE, REASON " supported in GLSL ES 3.00 only ", TOKEN); \
391 context->recover(); \
392 } \
393 }
394
395
396
397 #ifdef short
398 # undef short
399 #endif
400
401 #ifdef YYTYPE_UINT8
402 typedef YYTYPE_UINT8 yytype_uint8;
403 #else
404 typedef unsigned char yytype_uint8;
405 #endif
406
407 #ifdef YYTYPE_INT8
408 typedef YYTYPE_INT8 yytype_int8;
409 #else
410 typedef signed char yytype_int8;
411 #endif
412
413 #ifdef YYTYPE_UINT16
414 typedef YYTYPE_UINT16 yytype_uint16;
415 #else
416 typedef unsigned short int yytype_uint16;
417 #endif
418
419 #ifdef YYTYPE_INT16
420 typedef YYTYPE_INT16 yytype_int16;
421 #else
422 typedef short int yytype_int16;
423 #endif
424
425 #ifndef YYSIZE_T
426 # ifdef __SIZE_TYPE__
427 # define YYSIZE_T __SIZE_TYPE__
428 # elif defined size_t
429 # define YYSIZE_T size_t
430 # elif ! defined YYSIZE_T
431 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
432 # define YYSIZE_T size_t
433 # else
434 # define YYSIZE_T unsigned int
435 # endif
436 #endif
437
438 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
439
440 #ifndef YY_
441 # if defined YYENABLE_NLS && YYENABLE_NLS
442 # if ENABLE_NLS
443 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
444 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
445 # endif
446 # endif
447 # ifndef YY_
448 # define YY_(Msgid) Msgid
449 # endif
450 #endif
451
452 #ifndef YY_ATTRIBUTE
453 # if (defined __GNUC__ \
454 && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
455 || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
456 # define YY_ATTRIBUTE(Spec) __attribute__(Spec)
457 # else
458 # define YY_ATTRIBUTE(Spec) /* empty */
459 # endif
460 #endif
461
462 #ifndef YY_ATTRIBUTE_PURE
463 # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
464 #endif
465
466 #ifndef YY_ATTRIBUTE_UNUSED
467 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
468 #endif
469
470 #if !defined _Noreturn \
471 && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
472 # if defined _MSC_VER && 1200 <= _MSC_VER
473 # define _Noreturn __declspec (noreturn)
474 # else
475 # define _Noreturn YY_ATTRIBUTE ((__noreturn__))
476 # endif
477 #endif
478
479 /* Suppress unused-variable warnings by "using" E. */
480 #if ! defined lint || defined __GNUC__
481 # define YYUSE(E) ((void) (E))
482 #else
483 # define YYUSE(E) /* empty */
484 #endif
485
486 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
487 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
488 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
489 _Pragma ("GCC diagnostic push") \
490 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
491 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
492 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
493 _Pragma ("GCC diagnostic pop")
494 #else
495 # define YY_INITIAL_VALUE(Value) Value
496 #endif
497 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
498 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
499 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
500 #endif
501 #ifndef YY_INITIAL_VALUE
502 # define YY_INITIAL_VALUE(Value) /* Nothing. */
503 #endif
504
505
506 #if ! defined yyoverflow || YYERROR_VERBOSE
507
508 /* The parser invokes alloca or malloc; define the necessary symbols. */
509
510 # ifdef YYSTACK_USE_ALLOCA
511 # if YYSTACK_USE_ALLOCA
512 # ifdef __GNUC__
513 # define YYSTACK_ALLOC __builtin_alloca
514 # elif defined __BUILTIN_VA_ARG_INCR
515 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
516 # elif defined _AIX
517 # define YYSTACK_ALLOC __alloca
518 # elif defined _MSC_VER
519 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
520 # define alloca _alloca
521 # else
522 # define YYSTACK_ALLOC alloca
523 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
524 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
525 /* Use EXIT_SUCCESS as a witness for stdlib.h. */
526 # ifndef EXIT_SUCCESS
527 # define EXIT_SUCCESS 0
528 # endif
529 # endif
530 # endif
531 # endif
532 # endif
533
534 # ifdef YYSTACK_ALLOC
535 /* Pacify GCC's 'empty if-body' warning. */
536 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
537 # ifndef YYSTACK_ALLOC_MAXIMUM
538 /* The OS might guarantee only one guard page at the bottom of the stack,
539 and a page size can be as small as 4096 bytes. So we cannot safely
540 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
541 to allow for a few compiler-allocated temporary stack slots. */
542 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
543 # endif
544 # else
545 # define YYSTACK_ALLOC YYMALLOC
546 # define YYSTACK_FREE YYFREE
547 # ifndef YYSTACK_ALLOC_MAXIMUM
548 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
549 # endif
550 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
551 && ! ((defined YYMALLOC || defined malloc) \
552 && (defined YYFREE || defined free)))
553 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
554 # ifndef EXIT_SUCCESS
555 # define EXIT_SUCCESS 0
556 # endif
557 # endif
558 # ifndef YYMALLOC
559 # define YYMALLOC malloc
560 # if ! defined malloc && ! defined EXIT_SUCCESS
561 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
562 # endif
563 # endif
564 # ifndef YYFREE
565 # define YYFREE free
566 # if ! defined free && ! defined EXIT_SUCCESS
567 void free (void *); /* INFRINGES ON USER NAME SPACE */
568 # endif
569 # endif
570 # endif
571 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
572
573
574 #if (! defined yyoverflow \
575 && (! defined __cplusplus \
576 || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
577 && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
578
579 /* A type that is properly aligned for any stack member. */
580 union yyalloc
581 {
582 yytype_int16 yyss_alloc;
583 YYSTYPE yyvs_alloc;
584 YYLTYPE yyls_alloc;
585 };
586
587 /* The size of the maximum gap between one aligned stack and the next. */
588 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
589
590 /* The size of an array large to enough to hold all stacks, each with
591 N elements. */
592 # define YYSTACK_BYTES(N) \
593 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
594 + 2 * YYSTACK_GAP_MAXIMUM)
595
596 # define YYCOPY_NEEDED 1
597
598 /* Relocate STACK from its old location to the new one. The
599 local variables YYSIZE and YYSTACKSIZE give the old and new number of
600 elements in the stack, and YYPTR gives the new location of the
601 stack. Advance YYPTR to a properly aligned location for the next
602 stack. */
603 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
604 do \
605 { \
606 YYSIZE_T yynewbytes; \
607 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
608 Stack = &yyptr->Stack_alloc; \
609 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
610 yyptr += yynewbytes / sizeof (*yyptr); \
611 } \
612 while (0)
613
614 #endif
615
616 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
617 /* Copy COUNT objects from SRC to DST. The source and destination do
618 not overlap. */
619 # ifndef YYCOPY
620 # if defined __GNUC__ && 1 < __GNUC__
621 # define YYCOPY(Dst, Src, Count) \
622 __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
623 # else
624 # define YYCOPY(Dst, Src, Count) \
625 do \
626 { \
627 YYSIZE_T yyi; \
628 for (yyi = 0; yyi < (Count); yyi++) \
629 (Dst)[yyi] = (Src)[yyi]; \
630 } \
631 while (0)
632 # endif
633 # endif
634 #endif /* !YYCOPY_NEEDED */
635
636 /* YYFINAL -- State number of the termination state. */
637 #define YYFINAL 113
638 /* YYLAST -- Last index in YYTABLE. */
639 #define YYLAST 2530
640
641 /* YYNTOKENS -- Number of terminals. */
642 #define YYNTOKENS 128
643 /* YYNNTS -- Number of nonterminals. */
644 #define YYNNTS 93
645 /* YYNRULES -- Number of rules. */
646 #define YYNRULES 273
647 /* YYNSTATES -- Number of states. */
648 #define YYNSTATES 414
649
650 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
651 by yylex, with out-of-bounds checking. */
652 #define YYUNDEFTOK 2
653 #define YYMAXUTOK 382
654
655 #define YYTRANSLATE(YYX) \
656 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
657
658 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
659 as returned by yylex, without out-of-bounds checking. */
660 static const yytype_uint8 yytranslate[] =
661 {
662 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
663 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
664 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
665 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
666 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
667 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
668 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
669 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
670 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
671 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
672 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
673 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
674 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
675 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
676 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
677 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
678 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
679 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
680 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
681 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
682 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
683 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
684 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
685 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
686 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
687 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
688 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
689 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
690 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
691 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
692 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
693 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
694 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
695 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
696 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
697 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
698 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
699 115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
700 125, 126, 127
701 };
702
703 #if YYDEBUG
704 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
705 static const yytype_uint16 yyrline[] =
706 {
707 0, 229, 229, 249, 252, 257, 262, 267, 272, 278,
708 281, 284, 287, 290, 293, 299, 307, 318, 322, 330,
709 333, 339, 343, 350, 356, 365, 373, 379, 386, 396,
710 399, 402, 405, 415, 416, 417, 418, 426, 427, 431,
711 435, 443, 444, 447, 453, 454, 458, 465, 466, 469,
712 472, 475, 481, 482, 485, 491, 492, 499, 500, 507,
713 508, 515, 516, 522, 523, 529, 530, 536, 537, 543,
714 544, 552, 553, 554, 555, 557, 558, 559, 562, 565,
715 568, 571, 577, 580, 591, 599, 607, 610, 616, 623,
716 627, 631, 635, 642, 648, 651, 658, 666, 687, 713,
717 723, 751, 756, 766, 771, 781, 784, 787, 790, 796,
718 803, 806, 810, 814, 819, 824, 831, 835, 839, 843,
719 848, 853, 857, 864, 874, 880, 883, 889, 895, 902,
720 911, 920, 928, 931, 938, 942, 946, 951, 959, 962,
721 966, 970, 979, 988, 996, 1006, 1018, 1021, 1024, 1030,
722 1037, 1040, 1046, 1049, 1052, 1058, 1061, 1066, 1081, 1085,
723 1089, 1093, 1097, 1101, 1106, 1111, 1116, 1121, 1126, 1131,
724 1136, 1141, 1146, 1151, 1156, 1161, 1167, 1173, 1179, 1185,
725 1191, 1197, 1203, 1209, 1215, 1220, 1225, 1234, 1243, 1248,
726 1253, 1258, 1263, 1268, 1273, 1278, 1283, 1288, 1293, 1298,
727 1303, 1308, 1313, 1326, 1326, 1329, 1329, 1335, 1338, 1354,
728 1357, 1366, 1370, 1376, 1383, 1398, 1402, 1406, 1407, 1413,
729 1414, 1415, 1416, 1417, 1418, 1419, 1423, 1424, 1424, 1424,
730 1434, 1435, 1439, 1439, 1440, 1440, 1445, 1448, 1458, 1461,
731 1467, 1468, 1472, 1480, 1484, 1491, 1491, 1498, 1501, 1508,
732 1513, 1528, 1528, 1533, 1533, 1540, 1540, 1548, 1551, 1557,
733 1560, 1566, 1570, 1577, 1580, 1583, 1586, 1589, 1598, 1602,
734 1609, 1612, 1618, 1618
735 };
736 #endif
737
738 #if YYDEBUG || YYERROR_VERBOSE || 0
739 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
740 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
741 static const char *const yytname[] =
742 {
743 "$end", "error", "$undefined", "INVARIANT", "HIGH_PRECISION",
744 "MEDIUM_PRECISION", "LOW_PRECISION", "PRECISION", "ATTRIBUTE",
745 "CONST_QUAL", "BOOL_TYPE", "FLOAT_TYPE", "INT_TYPE", "UINT_TYPE",
746 "BREAK", "CONTINUE", "DO", "ELSE", "FOR", "IF", "DISCARD", "RETURN",
747 "SWITCH", "CASE", "DEFAULT", "BVEC2", "BVEC3", "BVEC4", "IVEC2", "IVEC3",
748 "IVEC4", "VEC2", "VEC3", "VEC4", "UVEC2", "UVEC3", "UVEC4", "MATRIX2",
749 "MATRIX3", "MATRIX4", "IN_QUAL", "OUT_QUAL", "INOUT_QUAL", "UNIFORM",
750 "VARYING", "MATRIX2x3", "MATRIX3x2", "MATRIX2x4", "MATRIX4x2",
751 "MATRIX3x4", "MATRIX4x3", "CENTROID", "FLAT", "SMOOTH", "STRUCT",
752 "VOID_TYPE", "WHILE", "SAMPLER2D", "SAMPLERCUBE", "SAMPLER_EXTERNAL_OES",
753 "SAMPLER2DRECT", "SAMPLER2DARRAY", "ISAMPLER2D", "ISAMPLER3D",
754 "ISAMPLERCUBE", "ISAMPLER2DARRAY", "USAMPLER2D", "USAMPLER3D",
755 "USAMPLERCUBE", "USAMPLER2DARRAY", "SAMPLER3D", "SAMPLER3DRECT",
756 "SAMPLER2DSHADOW", "SAMPLERCUBESHADOW", "SAMPLER2DARRAYSHADOW", "LAYOUT",
757 "IDENTIFIER", "TYPE_NAME", "FLOATCONSTANT", "INTCONSTANT",
758 "UINTCONSTANT", "BOOLCONSTANT", "FIELD_SELECTION", "LEFT_OP", "RIGHT_OP",
759 "INC_OP", "DEC_OP", "LE_OP", "GE_OP", "EQ_OP", "NE_OP", "AND_OP",
760 "OR_OP", "XOR_OP", "MUL_ASSIGN", "DIV_ASSIGN", "ADD_ASSIGN",
761 "MOD_ASSIGN", "LEFT_ASSIGN", "RIGHT_ASSIGN", "AND_ASSIGN", "XOR_ASSIGN",
762 "OR_ASSIGN", "SUB_ASSIGN", "LEFT_PAREN", "RIGHT_PAREN", "LEFT_BRACKET",
763 "RIGHT_BRACKET", "LEFT_BRACE", "RIGHT_BRACE", "DOT", "COMMA", "COLON",
764 "EQUAL", "SEMICOLON", "BANG", "DASH", "TILDE", "PLUS", "STAR", "SLASH",
765 "PERCENT", "LEFT_ANGLE", "RIGHT_ANGLE", "VERTICAL_BAR", "CARET",
766 "AMPERSAND", "QUESTION", "$accept", "variable_identifier",
767 "primary_expression", "postfix_expression", "integer_expression",
768 "function_call", "function_call_or_method", "function_call_generic",
769 "function_call_header_no_parameters",
770 "function_call_header_with_parameters", "function_call_header",
771 "function_identifier", "unary_expression", "unary_operator",
772 "multiplicative_expression", "additive_expression", "shift_expression",
773 "relational_expression", "equality_expression", "and_expression",
774 "exclusive_or_expression", "inclusive_or_expression",
775 "logical_and_expression", "logical_xor_expression",
776 "logical_or_expression", "conditional_expression",
777 "assignment_expression", "assignment_operator", "expression",
778 "constant_expression", "enter_struct", "declaration",
779 "function_prototype", "function_declarator",
780 "function_header_with_parameters", "function_header",
781 "parameter_declarator", "parameter_declaration", "parameter_qualifier",
782 "parameter_type_specifier", "init_declarator_list", "single_declaration",
783 "fully_specified_type", "interpolation_qualifier",
784 "parameter_type_qualifier", "type_qualifier", "storage_qualifier",
785 "type_specifier", "precision_qualifier", "layout_qualifier",
786 "layout_qualifier_id_list", "layout_qualifier_id",
787 "type_specifier_no_prec", "type_specifier_nonarray", "struct_specifier",
788 "$@1", "$@2", "struct_declaration_list", "struct_declaration",
789 "struct_declarator_list", "struct_declarator", "initializer",
790 "declaration_statement", "statement", "simple_statement",
791 "compound_statement", "$@3", "$@4", "statement_no_new_scope",
792 "statement_with_scope", "$@5", "$@6", "compound_statement_no_new_scope",
793 "statement_list", "expression_statement", "selection_statement",
794 "selection_rest_statement", "switch_statement", "$@7", "case_label",
795 "condition", "iteration_statement", "$@8", "$@9", "$@10",
796 "for_init_statement", "conditionopt", "for_rest_statement",
797 "jump_statement", "translation_unit", "external_declaration",
798 "function_definition", "$@11", YY_NULLPTR
799 };
800 #endif
801
802 # ifdef YYPRINT
803 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
804 (internal) symbol number NUM (which must be that of a token). */
805 static const yytype_uint16 yytoknum[] =
806 {
807 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
808 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
809 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
810 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
811 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
812 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
813 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
814 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
815 335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
816 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
817 355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
818 365, 366, 367, 368, 369, 370, 371, 372, 373, 374,
819 375, 376, 377, 378, 379, 380, 381, 382
820 };
821 # endif
822
823 #define YYPACT_NINF -344
824
825 #define yypact_value_is_default(Yystate) \
826 (!!((Yystate) == (-344)))
827
828 #define YYTABLE_NINF -233
829
830 #define yytable_value_is_error(Yytable_value) \
831 0
832
833 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
834 STATE-NUM. */
835 static const yytype_int16 yypact[] =
836 {
837 2168, 120, -344, -344, -344, 146, -344, -344, -344, -344,
838 -344, -344, -344, -344, -344, -344, -344, -344, -344, -344,
839 -344, -344, -344, -344, -344, -344, -344, -344, -344, -344,
840 -344, -344, -344, -344, -344, -344, -344, 127, -344, -344,
841 -41, -344, -344, -344, -344, -344, -344, -344, -344, -344,
842 -344, -344, -344, -344, -344, -344, -344, -344, -344, -84,
843 -344, -344, -68, -57, -39, 1, -89, -344, 41, 14,
844 1187, -344, -344, 2453, 14, -344, 15, -344, 2093, -344,
845 -344, -344, -344, 14, -344, 2453, -344, -344, 18, -344,
846 47, -344, 26, -344, 10, -344, -344, -344, -344, -344,
847 2317, 113, 60, -344, -66, -344, 31, -344, 2243, -344,
848 -344, -344, 1257, -344, -344, -344, -45, -344, 2243, 46,
849 -21, -344, 415, -344, -344, -344, -344, 68, 2317, -42,
850 -344, 1355, 1646, -344, 188, 2317, 89, 1838, -344, 85,
851 -344, -344, -344, -344, -344, 1646, 1646, 1646, -344, -344,
852 -344, -344, -344, -344, -344, 39, -344, -344, -344, 74,
853 -17, 1741, 96, -344, 1646, 37, -37, 91, -61, 87,
854 65, 81, 71, 116, 115, -64, -344, 102, -344, -344,
855 2243, 1923, 105, -344, 47, 97, 99, -344, 110, 131,
856 124, 1453, 138, 1646, 132, 142, 140, -344, -344, 123,
857 -344, -344, -77, -344, -68, 143, -344, -344, -344, -344,
858 531, -344, -344, -344, -344, -344, -344, 144, -344, -344,
859 1548, 1646, 141, 148, -344, -344, 89, 145, -9, -344,
860 -58, -344, -344, -344, -13, -344, -344, 1646, 2385, -344,
861 -344, 1646, 152, -344, -344, -344, 1646, 1646, 1646, 1646,
862 1646, 1646, 1646, 1646, 1646, 1646, 1646, 1646, 1646, 1646,
863 1646, 1646, 1646, 1646, 1646, 1646, -344, 2008, -344, -344,
864 -344, -344, -344, -344, 150, -344, 1646, -344, -344, -7,
865 1646, 147, -344, -344, -344, 647, -344, -344, -344, -344,
866 -344, -344, -344, -344, -344, -344, -344, 1646, 1646, -344,
867 -344, -344, 1646, 149, 153, -344, 1646, 151, 5, 1646,
868 89, -344, -70, -344, -344, 158, 157, -344, 165, -344,
869 -344, -344, -344, -344, 37, 37, -37, -37, 91, 91,
870 91, 91, -61, -61, 87, 65, 81, 71, 116, 115,
871 75, -344, 214, 26, 879, 995, -8, -344, 4, -344,
872 1092, 647, -344, -344, 164, 1646, 159, -344, 1646, -344,
873 166, -344, 1646, -344, -344, 1646, 170, -344, -344, -344,
874 -344, 1092, 150, -344, 157, 200, 2317, 172, 169, -344,
875 -344, 1646, -344, -344, 173, -344, 1646, -344, 167, 174,
876 265, -344, 175, 171, 763, -344, -344, 177, 9, 1646,
877 763, 150, -344, 1646, -344, -344, -344, -344, 178, 157,
878 -344, -344, -344, -344
879 };
880
881 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
882 Performed when YYTABLE does not specify something else to do. Zero
883 means the default is an error. */
884 static const yytype_uint16 yydefact[] =
885 {
886 0, 0, 146, 147, 148, 0, 128, 138, 162, 159,
887 160, 161, 166, 167, 168, 169, 170, 171, 163, 164,
888 165, 172, 173, 174, 175, 176, 177, 139, 140, 143,
889 129, 178, 179, 180, 181, 182, 183, 0, 126, 125,
890 0, 158, 184, 185, 186, 187, 189, 190, 191, 192,
891 193, 194, 195, 196, 197, 188, 198, 199, 200, 0,
892 202, 271, 272, 0, 95, 105, 0, 110, 116, 133,
893 0, 131, 123, 0, 134, 144, 155, 201, 0, 268,
894 270, 130, 122, 0, 136, 0, 141, 142, 0, 205,
895 0, 86, 0, 93, 105, 127, 106, 107, 108, 96,
896 0, 105, 0, 87, 117, 132, 0, 92, 0, 124,
897 145, 135, 0, 1, 269, 137, 0, 203, 0, 152,
898 0, 150, 0, 273, 97, 102, 104, 109, 0, 111,
899 98, 0, 0, 85, 0, 0, 0, 0, 207, 2,
900 6, 4, 5, 7, 28, 0, 0, 0, 156, 35,
901 34, 36, 33, 3, 9, 29, 11, 16, 17, 0,
902 0, 22, 0, 37, 0, 41, 44, 47, 52, 55,
903 57, 59, 61, 63, 65, 67, 84, 0, 26, 88,
904 0, 0, 0, 149, 0, 0, 0, 253, 0, 0,
905 0, 0, 0, 0, 0, 0, 227, 236, 240, 37,
906 69, 82, 0, 216, 0, 144, 219, 238, 218, 217,
907 0, 220, 221, 222, 223, 224, 225, 99, 101, 103,
908 0, 0, 0, 0, 215, 121, 0, 213, 0, 211,
909 0, 208, 30, 31, 0, 13, 14, 0, 0, 20,
910 19, 0, 158, 23, 25, 32, 0, 0, 0, 0,
911 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
912 0, 0, 0, 0, 0, 0, 157, 0, 206, 153,
913 154, 151, 264, 263, 234, 255, 0, 267, 265, 0,
914 0, 0, 248, 251, 226, 0, 72, 73, 75, 74,
915 77, 78, 79, 80, 81, 76, 71, 0, 0, 241,
916 237, 239, 0, 0, 0, 115, 0, 118, 0, 0,
917 0, 209, 0, 89, 8, 0, 15, 27, 12, 18,
918 24, 38, 39, 40, 43, 42, 45, 46, 50, 51,
919 48, 49, 53, 54, 56, 58, 60, 62, 64, 66,
920 0, 204, 0, 0, 0, 0, 0, 266, 0, 247,
921 0, 228, 70, 83, 0, 0, 112, 119, 0, 210,
922 0, 212, 0, 90, 10, 0, 0, 233, 235, 258,
923 257, 260, 234, 245, 249, 0, 0, 0, 0, 100,
924 113, 0, 120, 214, 0, 68, 0, 259, 0, 0,
925 244, 242, 0, 0, 0, 229, 114, 0, 0, 261,
926 0, 234, 246, 0, 231, 252, 230, 91, 0, 262,
927 256, 243, 250, 254
928 };
929
930 /* YYPGOTO[NTERM-NUM]. */
931 static const yytype_int16 yypgoto[] =
932 {
933 -344, -344, -344, -344, -344, -344, -344, 48, -344, -344,
934 -344, -344, 70, -344, -56, -49, -123, -53, 28, 29,
935 27, 32, 30, 33, -344, -110, -128, -344, -138, -119,
936 -344, 11, 17, -344, -344, -344, 168, 201, 197, 176,
937 -344, -344, -326, 7, -344, -105, 13, -69, 294, -344,
938 -344, 117, 0, -344, -344, -344, -344, -103, -121, 76,
939 -10, -215, -40, -203, -314, -86, -344, -344, -97, -343,
940 -344, -344, -87, 23, -36, -344, -344, -344, -344, -344,
941 -60, -344, -344, -344, -344, -344, -344, -344, -344, -344,
942 232, -344, -344
943 };
944
945 /* YYDEFGOTO[NTERM-NUM]. */
946 static const yytype_int16 yydefgoto[] =
947 {
948 -1, 153, 154, 155, 315, 156, 157, 158, 159, 160,
949 161, 162, 199, 164, 165, 166, 167, 168, 169, 170,
950 171, 172, 173, 174, 175, 200, 201, 297, 202, 177,
951 108, 203, 204, 63, 64, 65, 125, 99, 100, 126,
952 66, 67, 68, 69, 101, 70, 71, 72, 73, 74,
953 120, 121, 178, 76, 77, 180, 118, 137, 138, 228,
954 229, 225, 206, 207, 208, 209, 285, 378, 405, 342,
955 343, 344, 406, 210, 211, 212, 391, 213, 392, 214,
956 377, 215, 350, 274, 345, 371, 388, 389, 216, 78,
957 79, 80, 92
958 };
959
960 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
961 positive, shift that token. If negative, reduce the rule whose
962 number is the opposite. If YYTABLE_NINF, syntax error. */
963 static const yytype_int16 yytable[] =
964 {
965 75, 109, 176, 135, 224, 123, 305, 301, 83, 234,
966 95, 61, 223, 135, 84, 181, 231, 62, 312, 95,
967 90, 176, 102, 7, 375, 103, 253, 254, 264, 390,
968 368, 127, 135, 243, 298, 88, 362, 299, 130, 136,
969 131, 96, 97, 98, 363, 375, 91, 132, 93, 136,
970 96, 97, 98, 279, 27, 28, 313, 29, 411, 127,
971 231, 255, 256, 265, 220, 37, 226, 89, 136, 179,
972 75, 221, 94, 110, 281, 135, 135, 267, 75, 249,
973 404, 250, 105, 176, 183, 116, 404, 111, 240, 61,
974 184, 357, 314, 224, 241, 62, 115, 372, 298, 316,
975 75, 304, 310, 298, 298, 311, -94, 347, 75, 373,
976 176, 136, 136, 320, 408, 298, 310, 104, 75, 359,
977 298, 112, 205, 119, 235, 236, 117, 340, 75, 7,
978 328, 329, 330, 331, 122, 75, 129, 75, 346, 133,
979 380, 83, 348, 382, 217, 237, 231, 84, 301, 238,
980 2, 3, 4, 96, 97, 98, 246, 247, 248, 182,
981 27, 28, 135, 29, 81, 227, 396, 86, 87, 352,
982 353, 37, 38, 39, 251, 252, 257, 258, 224, 239,
983 75, 75, 163, 354, 269, 270, 298, 365, 412, -27,
984 360, 259, 176, 324, 325, 261, 82, 7, 136, 176,
985 244, 163, 326, 327, 332, 333, 260, 262, 263, 266,
986 205, 272, 374, 273, 275, 232, 233, 286, 287, 288,
987 289, 290, 291, 292, 293, 294, 295, 224, 27, 28,
988 224, 29, 81, 374, 245, 276, 296, 385, 277, 37,
989 38, 39, 280, 384, 282, 376, 283, -26, 398, 284,
990 302, 309, 176, 224, 306, 307, 367, -21, -232, 349,
991 356, 409, 355, 163, 358, 364, 376, 75, 298, -28,
992 366, 379, 381, 383, 386, 224, 393, 394, 395, 400,
993 397, 399, 401, 196, 403, 205, 319, 334, 336, 335,
994 163, 407, 413, 338, 337, 124, 218, 339, 128, 85,
995 361, 271, 308, 410, 219, 369, 402, 109, 351, 370,
996 114, 387, 0, 0, 0, 0, 321, 322, 323, 163,
997 163, 163, 163, 163, 163, 163, 163, 163, 163, 163,
998 163, 163, 163, 163, 163, 0, 0, 0, 0, 0,
999 0, 0, 0, 0, 205, 205, 0, 0, 0, 0,
1000 205, 205, 0, 0, 0, 0, 0, 0, 0, 0,
1001 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1002 0, 205, 163, 0, 0, 0, 75, 0, 0, 163,
1003 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1004 0, 0, 0, 0, 205, 0, 0, 0, 0, 0,
1005 205, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1006 0, 0, 0, 0, 0, 0, 0, 0, 1, 2,
1007 3, 4, 5, 6, 7, 8, 9, 10, 11, 185,
1008 186, 187, 163, 188, 189, 190, 191, 192, 193, 194,
1009 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
1010 22, 23, 24, 25, 26, 27, 28, 0, 29, 30,
1011 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
1012 41, 195, 42, 43, 44, 45, 46, 47, 48, 49,
1013 50, 51, 52, 53, 54, 55, 0, 56, 57, 58,
1014 59, 139, 60, 140, 141, 142, 143, 144, 0, 0,
1015 145, 146, 0, 0, 0, 0, 0, 0, 0, 0,
1016 0, 0, 0, 0, 0, 0, 0, 0, 0, 147,
1017 0, 0, 0, 196, 197, 0, 0, 0, 0, 198,
1018 149, 150, 151, 152, 1, 2, 3, 4, 5, 6,
1019 7, 8, 9, 10, 11, 185, 186, 187, 0, 188,
1020 189, 190, 191, 192, 193, 194, 12, 13, 14, 15,
1021 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
1022 26, 27, 28, 0, 29, 30, 31, 32, 33, 34,
1023 35, 36, 37, 38, 39, 40, 41, 195, 42, 43,
1024 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
1025 54, 55, 0, 56, 57, 58, 59, 139, 60, 140,
1026 141, 142, 143, 144, 0, 0, 145, 146, 0, 0,
1027 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1028 0, 0, 0, 0, 0, 147, 0, 0, 0, 196,
1029 300, 0, 0, 0, 0, 198, 149, 150, 151, 152,
1030 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
1031 11, 185, 186, 187, 0, 188, 189, 190, 191, 192,
1032 193, 194, 12, 13, 14, 15, 16, 17, 18, 19,
1033 20, 21, 22, 23, 24, 25, 26, 27, 28, 0,
1034 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
1035 39, 40, 41, 195, 42, 43, 44, 45, 46, 47,
1036 48, 49, 50, 51, 52, 53, 54, 55, 0, 56,
1037 57, 58, 59, 139, 60, 140, 141, 142, 143, 144,
1038 0, 0, 145, 146, 0, 0, 0, 0, 0, 0,
1039 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1040 0, 147, 0, 0, 0, 196, 0, 0, 0, 0,
1041 0, 198, 149, 150, 151, 152, 1, 2, 3, 4,
1042 5, 6, 7, 8, 9, 10, 11, 185, 186, 187,
1043 0, 188, 189, 190, 191, 192, 193, 194, 12, 13,
1044 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
1045 24, 25, 26, 27, 28, 0, 29, 30, 31, 32,
1046 33, 34, 35, 36, 37, 38, 39, 40, 41, 195,
1047 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
1048 52, 53, 54, 55, 0, 56, 57, 58, 59, 139,
1049 60, 140, 141, 142, 143, 144, 0, 0, 145, 146,
1050 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1051 0, 0, 0, 0, 0, 0, 0, 147, 0, 0,
1052 0, 122, 0, 0, 0, 0, 0, 198, 149, 150,
1053 151, 152, 1, 2, 3, 4, 5, 6, 7, 8,
1054 9, 10, 11, 185, 186, 187, 0, 188, 189, 190,
1055 191, 192, 193, 194, 12, 13, 14, 15, 16, 17,
1056 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
1057 28, 0, 29, 30, 31, 32, 33, 34, 35, 36,
1058 37, 38, 39, 40, 41, 195, 42, 43, 44, 45,
1059 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
1060 0, 56, 57, 58, 59, 139, 60, 140, 141, 142,
1061 143, 144, 0, 0, 145, 146, 0, 0, 0, 0,
1062 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1063 0, 0, 0, 147, 0, 0, 0, 0, 0, 0,
1064 0, 0, 0, 198, 149, 150, 151, 152, 1, 2,
1065 3, 4, 5, 6, 7, 8, 9, 10, 11, 0,
1066 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1067 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
1068 22, 23, 24, 25, 26, 27, 28, 0, 29, 30,
1069 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
1070 41, 0, 42, 43, 44, 45, 46, 47, 48, 49,
1071 50, 51, 52, 53, 54, 55, 0, 56, 57, 58,
1072 59, 139, 60, 140, 141, 142, 143, 144, 0, 0,
1073 145, 146, 0, 0, 0, 0, 0, 0, 0, 0,
1074 0, 0, 0, 0, 0, 134, 2, 3, 4, 147,
1075 6, 7, 8, 9, 10, 11, 0, 0, 0, 198,
1076 149, 150, 151, 152, 0, 0, 0, 12, 13, 14,
1077 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
1078 25, 26, 27, 28, 0, 29, 30, 31, 32, 33,
1079 34, 35, 36, 37, 38, 39, 40, 41, 0, 42,
1080 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
1081 53, 54, 55, 0, 56, 57, 58, 59, 139, 60,
1082 140, 141, 142, 143, 144, 0, 0, 145, 146, 0,
1083 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1084 0, 2, 3, 4, 0, 0, 147, 8, 9, 10,
1085 11, 0, 0, 0, 0, 0, 0, 149, 150, 151,
1086 152, 0, 12, 13, 14, 15, 16, 17, 18, 19,
1087 20, 21, 22, 23, 24, 25, 26, 0, 0, 0,
1088 0, 0, 31, 32, 33, 34, 35, 36, 0, 0,
1089 0, 40, 41, 0, 42, 43, 44, 45, 46, 47,
1090 48, 49, 50, 51, 52, 53, 54, 55, 0, 56,
1091 57, 58, 0, 106, 60, 0, 0, 8, 9, 10,
1092 11, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1093 0, 0, 12, 13, 14, 15, 16, 17, 18, 19,
1094 20, 21, 22, 23, 24, 25, 26, 0, 0, 0,
1095 0, 107, 31, 32, 33, 34, 35, 36, 0, 0,
1096 0, 40, 41, 0, 42, 43, 44, 45, 46, 47,
1097 48, 49, 50, 51, 52, 53, 54, 55, 0, 56,
1098 57, 58, 0, 139, 60, 140, 141, 142, 143, 144,
1099 0, 0, 145, 146, 0, 0, 0, 0, 0, 0,
1100 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1101 0, 147, 0, 0, 148, 8, 9, 10, 11, 0,
1102 0, 0, 149, 150, 151, 152, 0, 0, 0, 0,
1103 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
1104 22, 23, 24, 25, 26, 0, 0, 0, 0, 0,
1105 31, 32, 33, 34, 35, 36, 0, 0, 0, 40,
1106 41, 0, 42, 43, 44, 45, 46, 47, 48, 49,
1107 50, 51, 52, 53, 54, 55, 0, 56, 57, 58,
1108 0, 139, 60, 140, 141, 142, 143, 144, 0, 0,
1109 145, 146, 0, 0, 0, 0, 0, 0, 0, 0,
1110 0, 0, 0, 0, 0, 0, 0, 0, 0, 147,
1111 0, 0, 222, 8, 9, 10, 11, 0, 0, 0,
1112 149, 150, 151, 152, 0, 0, 0, 0, 12, 13,
1113 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
1114 24, 25, 26, 0, 0, 0, 0, 0, 31, 32,
1115 33, 34, 35, 36, 0, 0, 0, 40, 41, 0,
1116 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
1117 52, 53, 54, 55, 0, 56, 57, 58, 0, 139,
1118 60, 140, 141, 142, 143, 144, 0, 0, 145, 146,
1119 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1120 0, 0, 0, 0, 0, 0, 0, 147, 8, 9,
1121 10, 11, 0, 0, 0, 0, 0, 278, 149, 150,
1122 151, 152, 0, 12, 13, 14, 15, 16, 17, 18,
1123 19, 20, 21, 22, 23, 24, 25, 26, 0, 0,
1124 0, 0, 0, 31, 32, 33, 34, 35, 36, 0,
1125 0, 0, 40, 41, 0, 42, 43, 44, 45, 46,
1126 47, 48, 49, 50, 51, 52, 53, 54, 55, 0,
1127 56, 57, 58, 0, 139, 60, 140, 141, 142, 143,
1128 144, 0, 0, 145, 146, 0, 0, 0, 0, 0,
1129 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1130 0, 0, 147, 0, 0, 303, 8, 9, 10, 11,
1131 0, 0, 0, 149, 150, 151, 152, 0, 0, 0,
1132 0, 12, 13, 14, 15, 16, 17, 18, 19, 20,
1133 21, 22, 23, 24, 25, 26, 0, 0, 0, 0,
1134 0, 31, 32, 33, 34, 35, 36, 0, 0, 0,
1135 40, 41, 0, 42, 43, 44, 45, 46, 47, 48,
1136 49, 50, 51, 52, 53, 54, 55, 0, 56, 57,
1137 58, 0, 139, 60, 140, 141, 142, 143, 144, 0,
1138 0, 145, 146, 0, 0, 0, 0, 0, 0, 0,
1139 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1140 147, 8, 9, 10, 11, 0, 0, 0, 0, 0,
1141 0, 149, 150, 151, 152, 0, 12, 13, 14, 15,
1142 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
1143 26, 0, 0, 0, 0, 0, 31, 32, 33, 34,
1144 35, 36, 0, 0, 0, 40, 242, 0, 42, 43,
1145 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
1146 54, 55, 0, 56, 57, 58, 0, 139, 60, 140,
1147 141, 142, 143, 144, 0, 0, 145, 146, 0, 0,
1148 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1149 0, 134, 2, 3, 4, 147, 6, 7, 8, 9,
1150 10, 11, 0, 0, 0, 0, 149, 150, 151, 152,
1151 0, 0, 0, 12, 13, 14, 15, 16, 17, 18,
1152 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
1153 0, 29, 30, 31, 32, 33, 34, 35, 36, 37,
1154 38, 39, 40, 41, 0, 42, 43, 44, 45, 46,
1155 47, 48, 49, 50, 51, 52, 53, 54, 55, 0,
1156 56, 57, 58, 59, 0, 60, 0, 0, 0, 0,
1157 0, 0, 0, 0, 0, 0, 134, 2, 3, 4,
1158 0, 6, 7, 8, 9, 10, 11, 0, 0, 0,
1159 0, 0, 0, 0, 0, 0, 0, 230, 12, 13,
1160 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
1161 24, 25, 26, 27, 28, 0, 29, 30, 31, 32,
1162 33, 34, 35, 36, 37, 38, 39, 40, 41, 0,
1163 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
1164 52, 53, 54, 55, 0, 56, 57, 58, 59, 0,
1165 60, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1166 0, 134, 2, 3, 4, 0, 6, 7, 8, 9,
1167 10, 11, 0, 0, 0, 0, 0, 0, 0, 0,
1168 0, 0, 268, 12, 13, 14, 15, 16, 17, 18,
1169 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
1170 0, 29, 30, 31, 32, 33, 34, 35, 36, 37,
1171 38, 39, 40, 41, 0, 42, 43, 44, 45, 46,
1172 47, 48, 49, 50, 51, 52, 53, 54, 55, 0,
1173 56, 57, 58, 59, 0, 60, 0, 0, 0, 0,
1174 0, 0, 0, 113, 0, 0, 1, 2, 3, 4,
1175 5, 6, 7, 8, 9, 10, 11, 0, 0, 0,
1176 0, 0, 0, 0, 0, 0, 0, 341, 12, 13,
1177 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
1178 24, 25, 26, 27, 28, 0, 29, 30, 31, 32,
1179 33, 34, 35, 36, 37, 38, 39, 40, 41, 0,
1180 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
1181 52, 53, 54, 55, 0, 56, 57, 58, 59, 0,
1182 60, 1, 2, 3, 4, 5, 6, 7, 8, 9,
1183 10, 11, 0, 0, 0, 0, 0, 0, 0, 0,
1184 0, 0, 0, 12, 13, 14, 15, 16, 17, 18,
1185 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
1186 0, 29, 30, 31, 32, 33, 34, 35, 36, 37,
1187 38, 39, 40, 41, 0, 42, 43, 44, 45, 46,
1188 47, 48, 49, 50, 51, 52, 53, 54, 55, 0,
1189 56, 57, 58, 59, 0, 60, 134, 2, 3, 4,
1190 0, 6, 7, 8, 9, 10, 11, 0, 0, 0,
1191 0, 0, 0, 0, 0, 0, 0, 0, 12, 13,
1192 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
1193 24, 25, 26, 27, 28, 0, 29, 30, 31, 32,
1194 33, 34, 35, 36, 37, 38, 39, 40, 41, 0,
1195 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
1196 52, 53, 54, 55, 0, 56, 57, 58, 59, 0,
1197 60, 2, 3, 4, 0, 0, 0, 8, 9, 10,
1198 11, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1199 0, 0, 12, 13, 14, 15, 16, 17, 18, 19,
1200 20, 21, 22, 23, 24, 25, 26, 0, 0, 0,
1201 0, 0, 31, 32, 33, 34, 35, 36, 0, 0,
1202 0, 40, 41, 0, 42, 43, 44, 45, 46, 47,
1203 48, 49, 50, 51, 52, 53, 54, 55, 0, 56,
1204 57, 58, 0, 0, 60, 8, 9, 10, 11, 0,
1205 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1206 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
1207 22, 23, 24, 25, 26, 0, 0, 0, 0, 0,
1208 31, 32, 33, 34, 35, 36, 0, 0, 0, 40,
1209 41, 0, 42, 43, 44, 45, 46, 47, 48, 49,
1210 50, 51, 52, 53, 54, 55, 0, 56, 57, 58,
1211 0, 317, 60, 8, 9, 10, 11, 318, 0, 0,
1212 0, 0, 0, 0, 0, 0, 0, 0, 12, 13,
1213 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
1214 24, 25, 26, 0, 0, 0, 0, 0, 31, 32,
1215 33, 34, 35, 36, 0, 0, 0, 40, 41, 0,
1216 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
1217 52, 53, 54, 55, 0, 56, 57, 58, 0, 0,
1218 60
1219 };
1220
1221 static const yytype_int16 yycheck[] =
1222 {
1223 0, 70, 112, 108, 132, 92, 221, 210, 1, 147,
1224 9, 0, 131, 118, 1, 118, 137, 0, 76, 9,
1225 104, 131, 111, 9, 350, 114, 87, 88, 92, 372,
1226 344, 100, 137, 161, 111, 76, 106, 114, 104, 108,
1227 106, 40, 41, 42, 114, 371, 114, 113, 105, 118,
1228 40, 41, 42, 191, 40, 41, 114, 43, 401, 128,
1229 181, 122, 123, 127, 106, 51, 135, 108, 137, 114,
1230 70, 113, 111, 73, 193, 180, 181, 180, 78, 116,
1231 394, 118, 69, 193, 105, 85, 400, 74, 105, 78,
1232 111, 306, 105, 221, 111, 78, 83, 105, 111, 237,
1233 100, 220, 111, 111, 111, 114, 105, 114, 108, 105,
1234 220, 180, 181, 241, 105, 111, 111, 76, 118, 114,
1235 111, 106, 122, 76, 85, 86, 108, 265, 128, 9,
1236 253, 254, 255, 256, 108, 135, 76, 137, 276, 108,
1237 355, 134, 280, 358, 76, 106, 267, 134, 351, 110,
1238 4, 5, 6, 40, 41, 42, 119, 120, 121, 113,
1239 40, 41, 267, 43, 44, 76, 381, 40, 41, 297,
1240 298, 51, 52, 53, 83, 84, 89, 90, 306, 105,
1241 180, 181, 112, 302, 79, 80, 111, 112, 403, 104,
1242 309, 126, 302, 249, 250, 124, 76, 9, 267, 309,
1243 104, 131, 251, 252, 257, 258, 125, 91, 93, 107,
1244 210, 114, 350, 114, 104, 145, 146, 94, 95, 96,
1245 97, 98, 99, 100, 101, 102, 103, 355, 40, 41,
1246 358, 43, 44, 371, 164, 104, 113, 365, 114, 51,
1247 52, 53, 104, 362, 112, 350, 104, 104, 386, 109,
1248 106, 106, 362, 381, 113, 107, 343, 105, 108, 112,
1249 107, 399, 113, 193, 113, 107, 371, 267, 111, 104,
1250 56, 107, 113, 107, 104, 403, 76, 105, 109, 105,
1251 107, 114, 17, 108, 113, 285, 238, 259, 261, 260,
1252 220, 114, 114, 263, 262, 94, 128, 264, 101, 5,
1253 310, 184, 226, 400, 128, 345, 392, 376, 285, 345,
1254 78, 371, -1, -1, -1, -1, 246, 247, 248, 249,
1255 250, 251, 252, 253, 254, 255, 256, 257, 258, 259,
1256 260, 261, 262, 263, 264, -1, -1, -1, -1, -1,
1257 -1, -1, -1, -1, 344, 345, -1, -1, -1, -1,
1258 350, 351, -1, -1, -1, -1, -1, -1, -1, -1,
1259 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1260 -1, 371, 302, -1, -1, -1, 376, -1, -1, 309,
1261 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1262 -1, -1, -1, -1, 394, -1, -1, -1, -1, -1,
1263 400, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1264 -1, -1, -1, -1, -1, -1, -1, -1, 3, 4,
1265 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
1266 15, 16, 362, 18, 19, 20, 21, 22, 23, 24,
1267 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
1268 35, 36, 37, 38, 39, 40, 41, -1, 43, 44,
1269 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1270 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
1271 65, 66, 67, 68, 69, 70, -1, 72, 73, 74,
1272 75, 76, 77, 78, 79, 80, 81, 82, -1, -1,
1273 85, 86, -1, -1, -1, -1, -1, -1, -1, -1,
1274 -1, -1, -1, -1, -1, -1, -1, -1, -1, 104,
1275 -1, -1, -1, 108, 109, -1, -1, -1, -1, 114,
1276 115, 116, 117, 118, 3, 4, 5, 6, 7, 8,
1277 9, 10, 11, 12, 13, 14, 15, 16, -1, 18,
1278 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
1279 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
1280 39, 40, 41, -1, 43, 44, 45, 46, 47, 48,
1281 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
1282 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
1283 69, 70, -1, 72, 73, 74, 75, 76, 77, 78,
1284 79, 80, 81, 82, -1, -1, 85, 86, -1, -1,
1285 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1286 -1, -1, -1, -1, -1, 104, -1, -1, -1, 108,
1287 109, -1, -1, -1, -1, 114, 115, 116, 117, 118,
1288 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
1289 13, 14, 15, 16, -1, 18, 19, 20, 21, 22,
1290 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
1291 33, 34, 35, 36, 37, 38, 39, 40, 41, -1,
1292 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
1293 53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
1294 63, 64, 65, 66, 67, 68, 69, 70, -1, 72,
1295 73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
1296 -1, -1, 85, 86, -1, -1, -1, -1, -1, -1,
1297 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1298 -1, 104, -1, -1, -1, 108, -1, -1, -1, -1,
1299 -1, 114, 115, 116, 117, 118, 3, 4, 5, 6,
1300 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
1301 -1, 18, 19, 20, 21, 22, 23, 24, 25, 26,
1302 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
1303 37, 38, 39, 40, 41, -1, 43, 44, 45, 46,
1304 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
1305 57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
1306 67, 68, 69, 70, -1, 72, 73, 74, 75, 76,
1307 77, 78, 79, 80, 81, 82, -1, -1, 85, 86,
1308 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1309 -1, -1, -1, -1, -1, -1, -1, 104, -1, -1,
1310 -1, 108, -1, -1, -1, -1, -1, 114, 115, 116,
1311 117, 118, 3, 4, 5, 6, 7, 8, 9, 10,
1312 11, 12, 13, 14, 15, 16, -1, 18, 19, 20,
1313 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
1314 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
1315 41, -1, 43, 44, 45, 46, 47, 48, 49, 50,
1316 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
1317 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
1318 -1, 72, 73, 74, 75, 76, 77, 78, 79, 80,
1319 81, 82, -1, -1, 85, 86, -1, -1, -1, -1,
1320 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1321 -1, -1, -1, 104, -1, -1, -1, -1, -1, -1,
1322 -1, -1, -1, 114, 115, 116, 117, 118, 3, 4,
1323 5, 6, 7, 8, 9, 10, 11, 12, 13, -1,
1324 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1325 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
1326 35, 36, 37, 38, 39, 40, 41, -1, 43, 44,
1327 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1328 55, -1, 57, 58, 59, 60, 61, 62, 63, 64,
1329 65, 66, 67, 68, 69, 70, -1, 72, 73, 74,
1330 75, 76, 77, 78, 79, 80, 81, 82, -1, -1,
1331 85, 86, -1, -1, -1, -1, -1, -1, -1, -1,
1332 -1, -1, -1, -1, -1, 3, 4, 5, 6, 104,
1333 8, 9, 10, 11, 12, 13, -1, -1, -1, 114,
1334 115, 116, 117, 118, -1, -1, -1, 25, 26, 27,
1335 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
1336 38, 39, 40, 41, -1, 43, 44, 45, 46, 47,
1337 48, 49, 50, 51, 52, 53, 54, 55, -1, 57,
1338 58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
1339 68, 69, 70, -1, 72, 73, 74, 75, 76, 77,
1340 78, 79, 80, 81, 82, -1, -1, 85, 86, -1,
1341 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1342 -1, 4, 5, 6, -1, -1, 104, 10, 11, 12,
1343 13, -1, -1, -1, -1, -1, -1, 115, 116, 117,
1344 118, -1, 25, 26, 27, 28, 29, 30, 31, 32,
1345 33, 34, 35, 36, 37, 38, 39, -1, -1, -1,
1346 -1, -1, 45, 46, 47, 48, 49, 50, -1, -1,
1347 -1, 54, 55, -1, 57, 58, 59, 60, 61, 62,
1348 63, 64, 65, 66, 67, 68, 69, 70, -1, 72,
1349 73, 74, -1, 76, 77, -1, -1, 10, 11, 12,
1350 13, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1351 -1, -1, 25, 26, 27, 28, 29, 30, 31, 32,
1352 33, 34, 35, 36, 37, 38, 39, -1, -1, -1,
1353 -1, 114, 45, 46, 47, 48, 49, 50, -1, -1,
1354 -1, 54, 55, -1, 57, 58, 59, 60, 61, 62,
1355 63, 64, 65, 66, 67, 68, 69, 70, -1, 72,
1356 73, 74, -1, 76, 77, 78, 79, 80, 81, 82,
1357 -1, -1, 85, 86, -1, -1, -1, -1, -1, -1,
1358 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1359 -1, 104, -1, -1, 107, 10, 11, 12, 13, -1,
1360 -1, -1, 115, 116, 117, 118, -1, -1, -1, -1,
1361 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
1362 35, 36, 37, 38, 39, -1, -1, -1, -1, -1,
1363 45, 46, 47, 48, 49, 50, -1, -1, -1, 54,
1364 55, -1, 57, 58, 59, 60, 61, 62, 63, 64,
1365 65, 66, 67, 68, 69, 70, -1, 72, 73, 74,
1366 -1, 76, 77, 78, 79, 80, 81, 82, -1, -1,
1367 85, 86, -1, -1, -1, -1, -1, -1, -1, -1,
1368 -1, -1, -1, -1, -1, -1, -1, -1, -1, 104,
1369 -1, -1, 107, 10, 11, 12, 13, -1, -1, -1,
1370 115, 116, 117, 118, -1, -1, -1, -1, 25, 26,
1371 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
1372 37, 38, 39, -1, -1, -1, -1, -1, 45, 46,
1373 47, 48, 49, 50, -1, -1, -1, 54, 55, -1,
1374 57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
1375 67, 68, 69, 70, -1, 72, 73, 74, -1, 76,
1376 77, 78, 79, 80, 81, 82, -1, -1, 85, 86,
1377 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1378 -1, -1, -1, -1, -1, -1, -1, 104, 10, 11,
1379 12, 13, -1, -1, -1, -1, -1, 114, 115, 116,
1380 117, 118, -1, 25, 26, 27, 28, 29, 30, 31,
1381 32, 33, 34, 35, 36, 37, 38, 39, -1, -1,
1382 -1, -1, -1, 45, 46, 47, 48, 49, 50, -1,
1383 -1, -1, 54, 55, -1, 57, 58, 59, 60, 61,
1384 62, 63, 64, 65, 66, 67, 68, 69, 70, -1,
1385 72, 73, 74, -1, 76, 77, 78, 79, 80, 81,
1386 82, -1, -1, 85, 86, -1, -1, -1, -1, -1,
1387 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1388 -1, -1, 104, -1, -1, 107, 10, 11, 12, 13,
1389 -1, -1, -1, 115, 116, 117, 118, -1, -1, -1,
1390 -1, 25, 26, 27, 28, 29, 30, 31, 32, 33,
1391 34, 35, 36, 37, 38, 39, -1, -1, -1, -1,
1392 -1, 45, 46, 47, 48, 49, 50, -1, -1, -1,
1393 54, 55, -1, 57, 58, 59, 60, 61, 62, 63,
1394 64, 65, 66, 67, 68, 69, 70, -1, 72, 73,
1395 74, -1, 76, 77, 78, 79, 80, 81, 82, -1,
1396 -1, 85, 86, -1, -1, -1, -1, -1, -1, -1,
1397 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1398 104, 10, 11, 12, 13, -1, -1, -1, -1, -1,
1399 -1, 115, 116, 117, 118, -1, 25, 26, 27, 28,
1400 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
1401 39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
1402 49, 50, -1, -1, -1, 54, 55, -1, 57, 58,
1403 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
1404 69, 70, -1, 72, 73, 74, -1, 76, 77, 78,
1405 79, 80, 81, 82, -1, -1, 85, 86, -1, -1,
1406 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1407 -1, 3, 4, 5, 6, 104, 8, 9, 10, 11,
1408 12, 13, -1, -1, -1, -1, 115, 116, 117, 118,
1409 -1, -1, -1, 25, 26, 27, 28, 29, 30, 31,
1410 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
1411 -1, 43, 44, 45, 46, 47, 48, 49, 50, 51,
1412 52, 53, 54, 55, -1, 57, 58, 59, 60, 61,
1413 62, 63, 64, 65, 66, 67, 68, 69, 70, -1,
1414 72, 73, 74, 75, -1, 77, -1, -1, -1, -1,
1415 -1, -1, -1, -1, -1, -1, 3, 4, 5, 6,
1416 -1, 8, 9, 10, 11, 12, 13, -1, -1, -1,
1417 -1, -1, -1, -1, -1, -1, -1, 109, 25, 26,
1418 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
1419 37, 38, 39, 40, 41, -1, 43, 44, 45, 46,
1420 47, 48, 49, 50, 51, 52, 53, 54, 55, -1,
1421 57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
1422 67, 68, 69, 70, -1, 72, 73, 74, 75, -1,
1423 77, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1424 -1, 3, 4, 5, 6, -1, 8, 9, 10, 11,
1425 12, 13, -1, -1, -1, -1, -1, -1, -1, -1,
1426 -1, -1, 109, 25, 26, 27, 28, 29, 30, 31,
1427 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
1428 -1, 43, 44, 45, 46, 47, 48, 49, 50, 51,
1429 52, 53, 54, 55, -1, 57, 58, 59, 60, 61,
1430 62, 63, 64, 65, 66, 67, 68, 69, 70, -1,
1431 72, 73, 74, 75, -1, 77, -1, -1, -1, -1,
1432 -1, -1, -1, 0, -1, -1, 3, 4, 5, 6,
1433 7, 8, 9, 10, 11, 12, 13, -1, -1, -1,
1434 -1, -1, -1, -1, -1, -1, -1, 109, 25, 26,
1435 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
1436 37, 38, 39, 40, 41, -1, 43, 44, 45, 46,
1437 47, 48, 49, 50, 51, 52, 53, 54, 55, -1,
1438 57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
1439 67, 68, 69, 70, -1, 72, 73, 74, 75, -1,
1440 77, 3, 4, 5, 6, 7, 8, 9, 10, 11,
1441 12, 13, -1, -1, -1, -1, -1, -1, -1, -1,
1442 -1, -1, -1, 25, 26, 27, 28, 29, 30, 31,
1443 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
1444 -1, 43, 44, 45, 46, 47, 48, 49, 50, 51,
1445 52, 53, 54, 55, -1, 57, 58, 59, 60, 61,
1446 62, 63, 64, 65, 66, 67, 68, 69, 70, -1,
1447 72, 73, 74, 75, -1, 77, 3, 4, 5, 6,
1448 -1, 8, 9, 10, 11, 12, 13, -1, -1, -1,
1449 -1, -1, -1, -1, -1, -1, -1, -1, 25, 26,
1450 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
1451 37, 38, 39, 40, 41, -1, 43, 44, 45, 46,
1452 47, 48, 49, 50, 51, 52, 53, 54, 55, -1,
1453 57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
1454 67, 68, 69, 70, -1, 72, 73, 74, 75, -1,
1455 77, 4, 5, 6, -1, -1, -1, 10, 11, 12,
1456 13, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1457 -1, -1, 25, 26, 27, 28, 29, 30, 31, 32,
1458 33, 34, 35, 36, 37, 38, 39, -1, -1, -1,
1459 -1, -1, 45, 46, 47, 48, 49, 50, -1, -1,
1460 -1, 54, 55, -1, 57, 58, 59, 60, 61, 62,
1461 63, 64, 65, 66, 67, 68, 69, 70, -1, 72,
1462 73, 74, -1, -1, 77, 10, 11, 12, 13, -1,
1463 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1464 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
1465 35, 36, 37, 38, 39, -1, -1, -1, -1, -1,
1466 45, 46, 47, 48, 49, 50, -1, -1, -1, 54,
1467 55, -1, 57, 58, 59, 60, 61, 62, 63, 64,
1468 65, 66, 67, 68, 69, 70, -1, 72, 73, 74,
1469 -1, 76, 77, 10, 11, 12, 13, 82, -1, -1,
1470 -1, -1, -1, -1, -1, -1, -1, -1, 25, 26,
1471 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
1472 37, 38, 39, -1, -1, -1, -1, -1, 45, 46,
1473 47, 48, 49, 50, -1, -1, -1, 54, 55, -1,
1474 57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
1475 67, 68, 69, 70, -1, 72, 73, 74, -1, -1,
1476 77
1477 };
1478
1479 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1480 symbol of state STATE-NUM. */
1481 static const yytype_uint8 yystos[] =
1482 {
1483 0, 3, 4, 5, 6, 7, 8, 9, 10, 11,
1484 12, 13, 25, 26, 27, 28, 29, 30, 31, 32,
1485 33, 34, 35, 36, 37, 38, 39, 40, 41, 43,
1486 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
1487 54, 55, 57, 58, 59, 60, 61, 62, 63, 64,
1488 65, 66, 67, 68, 69, 70, 72, 73, 74, 75,
1489 77, 159, 160, 161, 162, 163, 168, 169, 170, 171,
1490 173, 174, 175, 176, 177, 180, 181, 182, 217, 218,
1491 219, 44, 76, 171, 174, 176, 40, 41, 76, 108,
1492 104, 114, 220, 105, 111, 9, 40, 41, 42, 165,
1493 166, 172, 111, 114, 76, 174, 76, 114, 158, 175,
1494 180, 174, 106, 0, 218, 174, 180, 108, 184, 76,
1495 178, 179, 108, 200, 165, 164, 167, 175, 166, 76,
1496 104, 106, 113, 108, 3, 173, 175, 185, 186, 76,
1497 78, 79, 80, 81, 82, 85, 86, 104, 107, 115,
1498 116, 117, 118, 129, 130, 131, 133, 134, 135, 136,
1499 137, 138, 139, 140, 141, 142, 143, 144, 145, 146,
1500 147, 148, 149, 150, 151, 152, 153, 157, 180, 114,
1501 183, 185, 113, 105, 111, 14, 15, 16, 18, 19,
1502 20, 21, 22, 23, 24, 56, 108, 109, 114, 140,
1503 153, 154, 156, 159, 160, 180, 190, 191, 192, 193,
1504 201, 202, 203, 205, 207, 209, 216, 76, 164, 167,
1505 106, 113, 107, 157, 154, 189, 175, 76, 187, 188,
1506 109, 186, 140, 140, 156, 85, 86, 106, 110, 105,
1507 105, 111, 55, 154, 104, 140, 119, 120, 121, 116,
1508 118, 83, 84, 87, 88, 122, 123, 89, 90, 126,
1509 125, 124, 91, 93, 92, 127, 107, 185, 109, 79,
1510 80, 179, 114, 114, 211, 104, 104, 114, 114, 156,
1511 104, 157, 112, 104, 109, 194, 94, 95, 96, 97,
1512 98, 99, 100, 101, 102, 103, 113, 155, 111, 114,
1513 109, 191, 106, 107, 157, 189, 113, 107, 187, 106,
1514 111, 114, 76, 114, 105, 132, 156, 76, 82, 135,
1515 154, 140, 140, 140, 142, 142, 143, 143, 144, 144,
1516 144, 144, 145, 145, 146, 147, 148, 149, 150, 151,
1517 156, 109, 197, 198, 199, 212, 156, 114, 156, 112,
1518 210, 201, 154, 154, 157, 113, 107, 189, 113, 114,
1519 157, 188, 106, 114, 107, 112, 56, 200, 192, 190,
1520 202, 213, 105, 105, 156, 170, 173, 208, 195, 107,
1521 189, 113, 189, 107, 157, 154, 104, 208, 214, 215,
1522 197, 204, 206, 76, 105, 109, 189, 107, 156, 114,
1523 105, 17, 193, 113, 192, 196, 200, 114, 105, 156,
1524 196, 197, 189, 114
1525 };
1526
1527 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1528 static const yytype_uint8 yyr1[] =
1529 {
1530 0, 128, 129, 130, 130, 130, 130, 130, 130, 131,
1531 131, 131, 131, 131, 131, 132, 133, 134, 134, 135,
1532 135, 136, 136, 137, 137, 138, 139, 139, 139, 140,
1533 140, 140, 140, 141, 141, 141, 141, 142, 142, 142,
1534 142, 143, 143, 143, 144, 144, 144, 145, 145, 145,
1535 145, 145, 146, 146, 146, 147, 147, 148, 148, 149,
1536 149, 150, 150, 151, 151, 152, 152, 153, 153, 154,
1537 154, 155, 155, 155, 155, 155, 155, 155, 155, 155,
1538 155, 155, 156, 156, 157, 158, 159, 159, 159, 159,
1539 159, 159, 159, 160, 161, 161, 162, 162, 163, 164,
1540 164, 165, 165, 165, 165, 166, 166, 166, 166, 167,
1541 168, 168, 168, 168, 168, 168, 169, 169, 169, 169,
1542 169, 169, 169, 170, 170, 171, 171, 172, 173, 173,
1543 173, 173, 173, 173, 173, 173, 173, 173, 174, 174,
1544 174, 174, 174, 174, 175, 175, 176, 176, 176, 177,
1545 178, 178, 179, 179, 179, 180, 180, 180, 181, 181,
1546 181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
1547 181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
1548 181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
1549 181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
1550 181, 181, 181, 183, 182, 184, 182, 185, 185, 186,
1551 186, 187, 187, 188, 188, 189, 190, 191, 191, 192,
1552 192, 192, 192, 192, 192, 192, 193, 194, 195, 193,
1553 196, 196, 198, 197, 199, 197, 200, 200, 201, 201,
1554 202, 202, 203, 204, 204, 206, 205, 207, 207, 208,
1555 208, 210, 209, 211, 209, 212, 209, 213, 213, 214,
1556 214, 215, 215, 216, 216, 216, 216, 216, 217, 217,
1557 218, 218, 220, 219
1558 };
1559
1560 /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
1561 static const yytype_uint8 yyr2[] =
1562 {
1563 0, 2, 1, 1, 1, 1, 1, 1, 3, 1,
1564 4, 1, 3, 2, 2, 1, 1, 1, 3, 2,
1565 2, 2, 1, 2, 3, 2, 1, 1, 1, 1,
1566 2, 2, 2, 1, 1, 1, 1, 1, 3, 3,
1567 3, 1, 3, 3, 1, 3, 3, 1, 3, 3,
1568 3, 3, 1, 3, 3, 1, 3, 1, 3, 1,
1569 3, 1, 3, 1, 3, 1, 3, 1, 5, 1,
1570 3, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1571 1, 1, 1, 3, 1, 2, 2, 2, 4, 5,
1572 6, 9, 2, 2, 1, 1, 2, 3, 3, 2,
1573 5, 3, 2, 3, 2, 0, 1, 1, 1, 1,
1574 1, 3, 6, 7, 8, 5, 1, 2, 5, 6,
1575 7, 4, 2, 1, 2, 1, 1, 1, 1, 1,
1576 2, 1, 2, 1, 1, 2, 2, 3, 1, 1,
1577 1, 2, 2, 1, 1, 2, 1, 1, 1, 4,
1578 1, 3, 1, 3, 3, 1, 3, 4, 1, 1,
1579 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1580 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1581 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1582 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1583 1, 1, 1, 0, 6, 0, 5, 1, 2, 3,
1584 4, 1, 3, 1, 4, 1, 1, 1, 1, 1,
1585 1, 1, 1, 1, 1, 1, 2, 0, 0, 5,
1586 1, 1, 0, 2, 0, 2, 2, 3, 1, 2,
1587 1, 2, 5, 3, 1, 0, 6, 3, 2, 1,
1588 4, 0, 6, 0, 8, 0, 7, 1, 1, 1,
1589 0, 2, 3, 2, 2, 2, 3, 2, 1, 2,
1590 1, 1, 0, 3
1591 };
1592
1593
1594 #define yyerrok (yyerrstatus = 0)
1595 #define yyclearin (yychar = YYEMPTY)
1596 #define YYEMPTY (-2)
1597 #define YYEOF 0
1598
1599 #define YYACCEPT goto yyacceptlab
1600 #define YYABORT goto yyabortlab
1601 #define YYERROR goto yyerrorlab
1602
1603
1604 #define YYRECOVERING() (!!yyerrstatus)
1605
1606 #define YYBACKUP(Token, Value) \
1607 do \
1608 if (yychar == YYEMPTY) \
1609 { \
1610 yychar = (Token); \
1611 yylval = (Value); \
1612 YYPOPSTACK (yylen); \
1613 yystate = *yyssp; \
1614 goto yybackup; \
1615 } \
1616 else \
1617 { \
1618 yyerror (&yylloc, context, yyscanner, YY_("syntax error: cannot back up")); \
1619 YYERROR; \
1620 } \
1621 while (0)
1622
1623 /* Error token number */
1624 #define YYTERROR 1
1625 #define YYERRCODE 256
1626
1627
1628 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
1629 If N is 0, then set CURRENT to the empty location which ends
1630 the previous symbol: RHS[0] (always defined). */
1631
1632 #ifndef YYLLOC_DEFAULT
1633 # define YYLLOC_DEFAULT(Current, Rhs, N) \
1634 do \
1635 if (N) \
1636 { \
1637 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
1638 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
1639 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
1640 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
1641 } \
1642 else \
1643 { \
1644 (Current).first_line = (Current).last_line = \
1645 YYRHSLOC (Rhs, 0).last_line; \
1646 (Current).first_column = (Current).last_column = \
1647 YYRHSLOC (Rhs, 0).last_column; \
1648 } \
1649 while (0)
1650 #endif
1651
1652 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
1653
1654
1655 /* Enable debugging if requested. */
1656 #if YYDEBUG
1657
1658 # ifndef YYFPRINTF
1659 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1660 # define YYFPRINTF fprintf
1661 # endif
1662
1663 # define YYDPRINTF(Args) \
1664 do { \
1665 if (yydebug) \
1666 YYFPRINTF Args; \
1667 } while (0)
1668
1669
1670 /* YY_LOCATION_PRINT -- Print the location on the stream.
1671 This macro was not mandated originally: define only if we know
1672 we won't break user code: when these are the locations we know. */
1673
1674 #ifndef YY_LOCATION_PRINT
1675 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1676
1677 /* Print *YYLOCP on YYO. Private, do not rely on its existence. */
1678
1679 YY_ATTRIBUTE_UNUSED
1680 static unsigned
yy_location_print_(FILE * yyo,YYLTYPE const * const yylocp)1681 yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp)
1682 {
1683 unsigned res = 0;
1684 int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;
1685 if (0 <= yylocp->first_line)
1686 {
1687 res += YYFPRINTF (yyo, "%d", yylocp->first_line);
1688 if (0 <= yylocp->first_column)
1689 res += YYFPRINTF (yyo, ".%d", yylocp->first_column);
1690 }
1691 if (0 <= yylocp->last_line)
1692 {
1693 if (yylocp->first_line < yylocp->last_line)
1694 {
1695 res += YYFPRINTF (yyo, "-%d", yylocp->last_line);
1696 if (0 <= end_col)
1697 res += YYFPRINTF (yyo, ".%d", end_col);
1698 }
1699 else if (0 <= end_col && yylocp->first_column < end_col)
1700 res += YYFPRINTF (yyo, "-%d", end_col);
1701 }
1702 return res;
1703 }
1704
1705 # define YY_LOCATION_PRINT(File, Loc) \
1706 yy_location_print_ (File, &(Loc))
1707
1708 # else
1709 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1710 # endif
1711 #endif
1712
1713
1714 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1715 do { \
1716 if (yydebug) \
1717 { \
1718 YYFPRINTF (stderr, "%s ", Title); \
1719 yy_symbol_print (stderr, \
1720 Type, Value, Location, context, yyscanner); \
1721 YYFPRINTF (stderr, "\n"); \
1722 } \
1723 } while (0)
1724
1725
1726 /*----------------------------------------.
1727 | Print this symbol's value on YYOUTPUT. |
1728 `----------------------------------------*/
1729
1730 static void
yy_symbol_value_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep,YYLTYPE const * const yylocationp,TParseContext * context,void * yyscanner)1731 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, TParseContext* context, void* yyscanner)
1732 {
1733 FILE *yyo = yyoutput;
1734 YYUSE (yyo);
1735 YYUSE (yylocationp);
1736 YYUSE (context);
1737 YYUSE (yyscanner);
1738 if (!yyvaluep)
1739 return;
1740 # ifdef YYPRINT
1741 if (yytype < YYNTOKENS)
1742 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1743 # endif
1744 YYUSE (yytype);
1745 }
1746
1747
1748 /*--------------------------------.
1749 | Print this symbol on YYOUTPUT. |
1750 `--------------------------------*/
1751
1752 static void
yy_symbol_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep,YYLTYPE const * const yylocationp,TParseContext * context,void * yyscanner)1753 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, TParseContext* context, void* yyscanner)
1754 {
1755 YYFPRINTF (yyoutput, "%s %s (",
1756 yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
1757
1758 YY_LOCATION_PRINT (yyoutput, *yylocationp);
1759 YYFPRINTF (yyoutput, ": ");
1760 yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, context, yyscanner);
1761 YYFPRINTF (yyoutput, ")");
1762 }
1763
1764 /*------------------------------------------------------------------.
1765 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1766 | TOP (included). |
1767 `------------------------------------------------------------------*/
1768
1769 static void
yy_stack_print(yytype_int16 * yybottom,yytype_int16 * yytop)1770 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1771 {
1772 YYFPRINTF (stderr, "Stack now");
1773 for (; yybottom <= yytop; yybottom++)
1774 {
1775 int yybot = *yybottom;
1776 YYFPRINTF (stderr, " %d", yybot);
1777 }
1778 YYFPRINTF (stderr, "\n");
1779 }
1780
1781 # define YY_STACK_PRINT(Bottom, Top) \
1782 do { \
1783 if (yydebug) \
1784 yy_stack_print ((Bottom), (Top)); \
1785 } while (0)
1786
1787
1788 /*------------------------------------------------.
1789 | Report that the YYRULE is going to be reduced. |
1790 `------------------------------------------------*/
1791
1792 static void
yy_reduce_print(yytype_int16 * yyssp,YYSTYPE * yyvsp,YYLTYPE * yylsp,int yyrule,TParseContext * context,void * yyscanner)1793 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, TParseContext* context, void* yyscanner)
1794 {
1795 unsigned long int yylno = yyrline[yyrule];
1796 int yynrhs = yyr2[yyrule];
1797 int yyi;
1798 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1799 yyrule - 1, yylno);
1800 /* The symbols being reduced. */
1801 for (yyi = 0; yyi < yynrhs; yyi++)
1802 {
1803 YYFPRINTF (stderr, " $%d = ", yyi + 1);
1804 yy_symbol_print (stderr,
1805 yystos[yyssp[yyi + 1 - yynrhs]],
1806 &(yyvsp[(yyi + 1) - (yynrhs)])
1807 , &(yylsp[(yyi + 1) - (yynrhs)]) , context, yyscanner);
1808 YYFPRINTF (stderr, "\n");
1809 }
1810 }
1811
1812 # define YY_REDUCE_PRINT(Rule) \
1813 do { \
1814 if (yydebug) \
1815 yy_reduce_print (yyssp, yyvsp, yylsp, Rule, context, yyscanner); \
1816 } while (0)
1817
1818 /* Nonzero means print parse trace. It is left uninitialized so that
1819 multiple parsers can coexist. */
1820 int yydebug;
1821 #else /* !YYDEBUG */
1822 # define YYDPRINTF(Args)
1823 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1824 # define YY_STACK_PRINT(Bottom, Top)
1825 # define YY_REDUCE_PRINT(Rule)
1826 #endif /* !YYDEBUG */
1827
1828
1829 /* YYINITDEPTH -- initial size of the parser's stacks. */
1830 #ifndef YYINITDEPTH
1831 # define YYINITDEPTH 200
1832 #endif
1833
1834 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1835 if the built-in stack extension method is used).
1836
1837 Do not make this value too large; the results are undefined if
1838 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1839 evaluated with infinite-precision integer arithmetic. */
1840
1841 #ifndef YYMAXDEPTH
1842 # define YYMAXDEPTH 10000
1843 #endif
1844
1845
1846 #if YYERROR_VERBOSE
1847
1848 # ifndef yystrlen
1849 # if defined __GLIBC__ && defined _STRING_H
1850 # define yystrlen strlen
1851 # else
1852 /* Return the length of YYSTR. */
1853 static YYSIZE_T
yystrlen(const char * yystr)1854 yystrlen (const char *yystr)
1855 {
1856 YYSIZE_T yylen;
1857 for (yylen = 0; yystr[yylen]; yylen++)
1858 continue;
1859 return yylen;
1860 }
1861 # endif
1862 # endif
1863
1864 # ifndef yystpcpy
1865 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1866 # define yystpcpy stpcpy
1867 # else
1868 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1869 YYDEST. */
1870 static char *
yystpcpy(char * yydest,const char * yysrc)1871 yystpcpy (char *yydest, const char *yysrc)
1872 {
1873 char *yyd = yydest;
1874 const char *yys = yysrc;
1875
1876 while ((*yyd++ = *yys++) != '\0')
1877 continue;
1878
1879 return yyd - 1;
1880 }
1881 # endif
1882 # endif
1883
1884 # ifndef yytnamerr
1885 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1886 quotes and backslashes, so that it's suitable for yyerror. The
1887 heuristic is that double-quoting is unnecessary unless the string
1888 contains an apostrophe, a comma, or backslash (other than
1889 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1890 null, do not copy; instead, return the length of what the result
1891 would have been. */
1892 static YYSIZE_T
yytnamerr(char * yyres,const char * yystr)1893 yytnamerr (char *yyres, const char *yystr)
1894 {
1895 if (*yystr == '"')
1896 {
1897 YYSIZE_T yyn = 0;
1898 char const *yyp = yystr;
1899
1900 for (;;)
1901 switch (*++yyp)
1902 {
1903 case '\'':
1904 case ',':
1905 goto do_not_strip_quotes;
1906
1907 case '\\':
1908 if (*++yyp != '\\')
1909 goto do_not_strip_quotes;
1910 /* Fall through. */
1911 default:
1912 if (yyres)
1913 yyres[yyn] = *yyp;
1914 yyn++;
1915 break;
1916
1917 case '"':
1918 if (yyres)
1919 yyres[yyn] = '\0';
1920 return yyn;
1921 }
1922 do_not_strip_quotes: ;
1923 }
1924
1925 if (! yyres)
1926 return yystrlen (yystr);
1927
1928 return yystpcpy (yyres, yystr) - yyres;
1929 }
1930 # endif
1931
1932 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1933 about the unexpected token YYTOKEN for the state stack whose top is
1934 YYSSP.
1935
1936 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
1937 not large enough to hold the message. In that case, also set
1938 *YYMSG_ALLOC to the required number of bytes. Return 2 if the
1939 required number of bytes is too large to store. */
1940 static int
yysyntax_error(YYSIZE_T * yymsg_alloc,char ** yymsg,yytype_int16 * yyssp,int yytoken)1941 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1942 yytype_int16 *yyssp, int yytoken)
1943 {
1944 YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
1945 YYSIZE_T yysize = yysize0;
1946 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1947 /* Internationalized format string. */
1948 const char *yyformat = YY_NULLPTR;
1949 /* Arguments of yyformat. */
1950 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1951 /* Number of reported tokens (one for the "unexpected", one per
1952 "expected"). */
1953 int yycount = 0;
1954
1955 /* There are many possibilities here to consider:
1956 - If this state is a consistent state with a default action, then
1957 the only way this function was invoked is if the default action
1958 is an error action. In that case, don't check for expected
1959 tokens because there are none.
1960 - The only way there can be no lookahead present (in yychar) is if
1961 this state is a consistent state with a default action. Thus,
1962 detecting the absence of a lookahead is sufficient to determine
1963 that there is no unexpected or expected token to report. In that
1964 case, just report a simple "syntax error".
1965 - Don't assume there isn't a lookahead just because this state is a
1966 consistent state with a default action. There might have been a
1967 previous inconsistent state, consistent state with a non-default
1968 action, or user semantic action that manipulated yychar.
1969 - Of course, the expected token list depends on states to have
1970 correct lookahead information, and it depends on the parser not
1971 to perform extra reductions after fetching a lookahead from the
1972 scanner and before detecting a syntax error. Thus, state merging
1973 (from LALR or IELR) and default reductions corrupt the expected
1974 token list. However, the list is correct for canonical LR with
1975 one exception: it will still contain any token that will not be
1976 accepted due to an error action in a later state.
1977 */
1978 if (yytoken != YYEMPTY)
1979 {
1980 int yyn = yypact[*yyssp];
1981 yyarg[yycount++] = yytname[yytoken];
1982 if (!yypact_value_is_default (yyn))
1983 {
1984 /* Start YYX at -YYN if negative to avoid negative indexes in
1985 YYCHECK. In other words, skip the first -YYN actions for
1986 this state because they are default actions. */
1987 int yyxbegin = yyn < 0 ? -yyn : 0;
1988 /* Stay within bounds of both yycheck and yytname. */
1989 int yychecklim = YYLAST - yyn + 1;
1990 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1991 int yyx;
1992
1993 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1994 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1995 && !yytable_value_is_error (yytable[yyx + yyn]))
1996 {
1997 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1998 {
1999 yycount = 1;
2000 yysize = yysize0;
2001 break;
2002 }
2003 yyarg[yycount++] = yytname[yyx];
2004 {
2005 YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
2006 if (! (yysize <= yysize1
2007 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
2008 return 2;
2009 yysize = yysize1;
2010 }
2011 }
2012 }
2013 }
2014
2015 switch (yycount)
2016 {
2017 # define YYCASE_(N, S) \
2018 case N: \
2019 yyformat = S; \
2020 break
2021 YYCASE_(0, YY_("syntax error"));
2022 YYCASE_(1, YY_("syntax error, unexpected %s"));
2023 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
2024 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
2025 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
2026 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
2027 # undef YYCASE_
2028 }
2029
2030 {
2031 YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
2032 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
2033 return 2;
2034 yysize = yysize1;
2035 }
2036
2037 if (*yymsg_alloc < yysize)
2038 {
2039 *yymsg_alloc = 2 * yysize;
2040 if (! (yysize <= *yymsg_alloc
2041 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
2042 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
2043 return 1;
2044 }
2045
2046 /* Avoid sprintf, as that infringes on the user's name space.
2047 Don't have undefined behavior even if the translation
2048 produced a string with the wrong number of "%s"s. */
2049 {
2050 char *yyp = *yymsg;
2051 int yyi = 0;
2052 while ((*yyp = *yyformat) != '\0')
2053 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
2054 {
2055 yyp += yytnamerr (yyp, yyarg[yyi++]);
2056 yyformat += 2;
2057 }
2058 else
2059 {
2060 yyp++;
2061 yyformat++;
2062 }
2063 }
2064 return 0;
2065 }
2066 #endif /* YYERROR_VERBOSE */
2067
2068 /*-----------------------------------------------.
2069 | Release the memory associated to this symbol. |
2070 `-----------------------------------------------*/
2071
2072 static void
yydestruct(const char * yymsg,int yytype,YYSTYPE * yyvaluep,YYLTYPE * yylocationp,TParseContext * context,void * yyscanner)2073 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, TParseContext* context, void* yyscanner)
2074 {
2075 YYUSE (yyvaluep);
2076 YYUSE (yylocationp);
2077 YYUSE (context);
2078 YYUSE (yyscanner);
2079 if (!yymsg)
2080 yymsg = "Deleting";
2081 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
2082
2083 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2084 YYUSE (yytype);
2085 YY_IGNORE_MAYBE_UNINITIALIZED_END
2086 }
2087
2088
2089
2090
2091 /*----------.
2092 | yyparse. |
2093 `----------*/
2094
2095 int
yyparse(TParseContext * context,void * yyscanner)2096 yyparse (TParseContext* context, void* yyscanner)
2097 {
2098 /* The lookahead symbol. */
2099 int yychar;
2100
2101
2102 /* The semantic value of the lookahead symbol. */
2103 /* Default value used for initialization, for pacifying older GCCs
2104 or non-GCC compilers. */
2105 YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
2106 YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
2107
2108 /* Location data for the lookahead symbol. */
2109 static YYLTYPE yyloc_default
2110 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
2111 = { 1, 1, 1, 1 }
2112 # endif
2113 ;
2114 YYLTYPE yylloc = yyloc_default;
2115
2116 /* Number of syntax errors so far. */
2117 int yynerrs;
2118
2119 int yystate;
2120 /* Number of tokens to shift before error messages enabled. */
2121 int yyerrstatus;
2122
2123 /* The stacks and their tools:
2124 'yyss': related to states.
2125 'yyvs': related to semantic values.
2126 'yyls': related to locations.
2127
2128 Refer to the stacks through separate pointers, to allow yyoverflow
2129 to reallocate them elsewhere. */
2130
2131 /* The state stack. */
2132 yytype_int16 yyssa[YYINITDEPTH];
2133 yytype_int16 *yyss;
2134 yytype_int16 *yyssp;
2135
2136 /* The semantic value stack. */
2137 YYSTYPE yyvsa[YYINITDEPTH];
2138 YYSTYPE *yyvs;
2139 YYSTYPE *yyvsp;
2140
2141 /* The location stack. */
2142 YYLTYPE yylsa[YYINITDEPTH];
2143 YYLTYPE *yyls;
2144 YYLTYPE *yylsp;
2145
2146 /* The locations where the error started and ended. */
2147 YYLTYPE yyerror_range[3];
2148
2149 YYSIZE_T yystacksize;
2150
2151 int yyn;
2152 int yyresult;
2153 /* Lookahead token as an internal (translated) token number. */
2154 int yytoken = 0;
2155 /* The variables used to return semantic value and location from the
2156 action routines. */
2157 YYSTYPE yyval;
2158 YYLTYPE yyloc;
2159
2160 #if YYERROR_VERBOSE
2161 /* Buffer for error messages, and its allocated size. */
2162 char yymsgbuf[128];
2163 char *yymsg = yymsgbuf;
2164 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
2165 #endif
2166
2167 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
2168
2169 /* The number of symbols on the RHS of the reduced rule.
2170 Keep to zero when no symbol should be popped. */
2171 int yylen = 0;
2172
2173 yyssp = yyss = yyssa;
2174 yyvsp = yyvs = yyvsa;
2175 yylsp = yyls = yylsa;
2176 yystacksize = YYINITDEPTH;
2177
2178 YYDPRINTF ((stderr, "Starting parse\n"));
2179
2180 yystate = 0;
2181 yyerrstatus = 0;
2182 yynerrs = 0;
2183 yychar = YYEMPTY; /* Cause a token to be read. */
2184 yylsp[0] = yylloc;
2185 goto yysetstate;
2186
2187 /*------------------------------------------------------------.
2188 | yynewstate -- Push a new state, which is found in yystate. |
2189 `------------------------------------------------------------*/
2190 yynewstate:
2191 /* In all cases, when you get here, the value and location stacks
2192 have just been pushed. So pushing a state here evens the stacks. */
2193 yyssp++;
2194
2195 yysetstate:
2196 *yyssp = yystate;
2197
2198 if (yyss + yystacksize - 1 <= yyssp)
2199 {
2200 /* Get the current used size of the three stacks, in elements. */
2201 YYSIZE_T yysize = yyssp - yyss + 1;
2202
2203 #ifdef yyoverflow
2204 {
2205 /* Give user a chance to reallocate the stack. Use copies of
2206 these so that the &'s don't force the real ones into
2207 memory. */
2208 YYSTYPE *yyvs1 = yyvs;
2209 yytype_int16 *yyss1 = yyss;
2210 YYLTYPE *yyls1 = yyls;
2211
2212 /* Each stack pointer address is followed by the size of the
2213 data in use in that stack, in bytes. This used to be a
2214 conditional around just the two extra args, but that might
2215 be undefined if yyoverflow is a macro. */
2216 yyoverflow (YY_("memory exhausted"),
2217 &yyss1, yysize * sizeof (*yyssp),
2218 &yyvs1, yysize * sizeof (*yyvsp),
2219 &yyls1, yysize * sizeof (*yylsp),
2220 &yystacksize);
2221
2222 yyls = yyls1;
2223 yyss = yyss1;
2224 yyvs = yyvs1;
2225 }
2226 #else /* no yyoverflow */
2227 # ifndef YYSTACK_RELOCATE
2228 goto yyexhaustedlab;
2229 # else
2230 /* Extend the stack our own way. */
2231 if (YYMAXDEPTH <= yystacksize)
2232 goto yyexhaustedlab;
2233 yystacksize *= 2;
2234 if (YYMAXDEPTH < yystacksize)
2235 yystacksize = YYMAXDEPTH;
2236
2237 {
2238 yytype_int16 *yyss1 = yyss;
2239 union yyalloc *yyptr =
2240 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
2241 if (! yyptr)
2242 goto yyexhaustedlab;
2243 YYSTACK_RELOCATE (yyss_alloc, yyss);
2244 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
2245 YYSTACK_RELOCATE (yyls_alloc, yyls);
2246 # undef YYSTACK_RELOCATE
2247 if (yyss1 != yyssa)
2248 YYSTACK_FREE (yyss1);
2249 }
2250 # endif
2251 #endif /* no yyoverflow */
2252
2253 yyssp = yyss + yysize - 1;
2254 yyvsp = yyvs + yysize - 1;
2255 yylsp = yyls + yysize - 1;
2256
2257 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2258 (unsigned long int) yystacksize));
2259
2260 if (yyss + yystacksize - 1 <= yyssp)
2261 YYABORT;
2262 }
2263
2264 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2265
2266 if (yystate == YYFINAL)
2267 YYACCEPT;
2268
2269 goto yybackup;
2270
2271 /*-----------.
2272 | yybackup. |
2273 `-----------*/
2274 yybackup:
2275
2276 /* Do appropriate processing given the current state. Read a
2277 lookahead token if we need one and don't already have one. */
2278
2279 /* First try to decide what to do without reference to lookahead token. */
2280 yyn = yypact[yystate];
2281 if (yypact_value_is_default (yyn))
2282 goto yydefault;
2283
2284 /* Not known => get a lookahead token if don't already have one. */
2285
2286 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
2287 if (yychar == YYEMPTY)
2288 {
2289 YYDPRINTF ((stderr, "Reading a token: "));
2290 yychar = yylex (&yylval, &yylloc, yyscanner);
2291 }
2292
2293 if (yychar <= YYEOF)
2294 {
2295 yychar = yytoken = YYEOF;
2296 YYDPRINTF ((stderr, "Now at end of input.\n"));
2297 }
2298 else
2299 {
2300 yytoken = YYTRANSLATE (yychar);
2301 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2302 }
2303
2304 /* If the proper action on seeing token YYTOKEN is to reduce or to
2305 detect an error, take that action. */
2306 yyn += yytoken;
2307 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2308 goto yydefault;
2309 yyn = yytable[yyn];
2310 if (yyn <= 0)
2311 {
2312 if (yytable_value_is_error (yyn))
2313 goto yyerrlab;
2314 yyn = -yyn;
2315 goto yyreduce;
2316 }
2317
2318 /* Count tokens shifted since error; after three, turn off error
2319 status. */
2320 if (yyerrstatus)
2321 yyerrstatus--;
2322
2323 /* Shift the lookahead token. */
2324 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2325
2326 /* Discard the shifted token. */
2327 yychar = YYEMPTY;
2328
2329 yystate = yyn;
2330 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2331 *++yyvsp = yylval;
2332 YY_IGNORE_MAYBE_UNINITIALIZED_END
2333 *++yylsp = yylloc;
2334 goto yynewstate;
2335
2336
2337 /*-----------------------------------------------------------.
2338 | yydefault -- do the default action for the current state. |
2339 `-----------------------------------------------------------*/
2340 yydefault:
2341 yyn = yydefact[yystate];
2342 if (yyn == 0)
2343 goto yyerrlab;
2344 goto yyreduce;
2345
2346
2347 /*-----------------------------.
2348 | yyreduce -- Do a reduction. |
2349 `-----------------------------*/
2350 yyreduce:
2351 /* yyn is the number of a rule to reduce with. */
2352 yylen = yyr2[yyn];
2353
2354 /* If YYLEN is nonzero, implement the default value of the action:
2355 '$$ = $1'.
2356
2357 Otherwise, the following line sets YYVAL to garbage.
2358 This behavior is undocumented and Bison
2359 users should not rely upon it. Assigning to YYVAL
2360 unconditionally makes the parser a bit smaller, and it avoids a
2361 GCC warning that YYVAL may be used uninitialized. */
2362 yyval = yyvsp[1-yylen];
2363
2364 /* Default location. */
2365 YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
2366 YY_REDUCE_PRINT (yyn);
2367 switch (yyn)
2368 {
2369 case 2:
2370
2371 {
2372 // The symbol table search was done in the lexical phase
2373 const TVariable *variable = context->getNamedVariable((yylsp[0]), (yyvsp[0].lex).string, (yyvsp[0].lex).symbol);
2374
2375 // don't delete $1.string, it's used by error recovery, and the pool
2376 // pop will reclaim the memory
2377
2378 // Constants which aren't indexable arrays can be propagated by value.
2379 ConstantUnion *constArray = variable->getConstPointer();
2380 if (constArray && variable->getType().getArraySize() <= 1) {
2381 TType t(variable->getType());
2382 (yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(constArray, t, (yylsp[0]));
2383 } else
2384 (yyval.interm.intermTypedNode) = context->intermediate.addSymbol(variable->getUniqueId(),
2385 variable->getName(),
2386 variable->getType(), (yylsp[0]));
2387 }
2388
2389 break;
2390
2391 case 3:
2392
2393 {
2394 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
2395 }
2396
2397 break;
2398
2399 case 4:
2400
2401 {
2402 ConstantUnion *unionArray = new ConstantUnion[1];
2403 unionArray->setIConst((yyvsp[0].lex).i);
2404 (yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtInt, EbpUndefined, EvqConstExpr), (yylsp[0]));
2405 }
2406
2407 break;
2408
2409 case 5:
2410
2411 {
2412 ConstantUnion *unionArray = new ConstantUnion[1];
2413 unionArray->setUConst((yyvsp[0].lex).u);
2414 (yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtUInt, EbpUndefined, EvqConstExpr), (yylsp[0]));
2415 }
2416
2417 break;
2418
2419 case 6:
2420
2421 {
2422 ConstantUnion *unionArray = new ConstantUnion[1];
2423 unionArray->setFConst((yyvsp[0].lex).f);
2424 (yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtFloat, EbpUndefined, EvqConstExpr), (yylsp[0]));
2425 }
2426
2427 break;
2428
2429 case 7:
2430
2431 {
2432 ConstantUnion *unionArray = new ConstantUnion[1];
2433 unionArray->setBConst((yyvsp[0].lex).b);
2434 (yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConstExpr), (yylsp[0]));
2435 }
2436
2437 break;
2438
2439 case 8:
2440
2441 {
2442 (yyval.interm.intermTypedNode) = (yyvsp[-1].interm.intermTypedNode);
2443 }
2444
2445 break;
2446
2447 case 9:
2448
2449 {
2450 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
2451 }
2452
2453 break;
2454
2455 case 10:
2456
2457 {
2458 (yyval.interm.intermTypedNode) = context->addIndexExpression((yyvsp[-3].interm.intermTypedNode), (yylsp[-2]), (yyvsp[-1].interm.intermTypedNode));
2459 }
2460
2461 break;
2462
2463 case 11:
2464
2465 {
2466 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
2467 }
2468
2469 break;
2470
2471 case 12:
2472
2473 {
2474 (yyval.interm.intermTypedNode) = context->addFieldSelectionExpression((yyvsp[-2].interm.intermTypedNode), (yylsp[-1]), *(yyvsp[0].lex).string, (yylsp[0]));
2475 }
2476
2477 break;
2478
2479 case 13:
2480
2481 {
2482 (yyval.interm.intermTypedNode) = context->addUnaryMathLValue(EOpPostIncrement, (yyvsp[-1].interm.intermTypedNode), (yylsp[0]));
2483 }
2484
2485 break;
2486
2487 case 14:
2488
2489 {
2490 (yyval.interm.intermTypedNode) = context->addUnaryMathLValue(EOpPostDecrement, (yyvsp[-1].interm.intermTypedNode), (yylsp[0]));
2491 }
2492
2493 break;
2494
2495 case 15:
2496
2497 {
2498 if (context->integerErrorCheck((yyvsp[0].interm.intermTypedNode), "[]"))
2499 context->recover();
2500 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
2501 }
2502
2503 break;
2504
2505 case 16:
2506
2507 {
2508 bool fatalError = false;
2509 (yyval.interm.intermTypedNode) = context->addFunctionCallOrMethod((yyvsp[0].interm).function, (yyvsp[0].interm).nodePair.node1, (yyvsp[0].interm).nodePair.node2, (yylsp[0]), &fatalError);
2510 if (fatalError)
2511 {
2512 YYERROR;
2513 }
2514 }
2515
2516 break;
2517
2518 case 17:
2519
2520 {
2521 (yyval.interm) = (yyvsp[0].interm);
2522 (yyval.interm).nodePair.node2 = nullptr;
2523 }
2524
2525 break;
2526
2527 case 18:
2528
2529 {
2530 ES3_ONLY("", (yylsp[0]), "methods");
2531 (yyval.interm) = (yyvsp[0].interm);
2532 (yyval.interm).nodePair.node2 = (yyvsp[-2].interm.intermTypedNode);
2533 }
2534
2535 break;
2536
2537 case 19:
2538
2539 {
2540 (yyval.interm) = (yyvsp[-1].interm);
2541 }
2542
2543 break;
2544
2545 case 20:
2546
2547 {
2548 (yyval.interm) = (yyvsp[-1].interm);
2549 }
2550
2551 break;
2552
2553 case 21:
2554
2555 {
2556 (yyval.interm).function = (yyvsp[-1].interm.function);
2557 (yyval.interm).nodePair.node1 = nullptr;
2558 }
2559
2560 break;
2561
2562 case 22:
2563
2564 {
2565 (yyval.interm).function = (yyvsp[0].interm.function);
2566 (yyval.interm).nodePair.node1 = nullptr;
2567 }
2568
2569 break;
2570
2571 case 23:
2572
2573 {
2574 TParameter param = { 0, new TType((yyvsp[0].interm.intermTypedNode)->getType()) };
2575 (yyvsp[-1].interm.function)->addParameter(param);
2576 (yyval.interm).function = (yyvsp[-1].interm.function);
2577 (yyval.interm).nodePair.node1 = context->intermediate.makeAggregate((yyvsp[0].interm.intermTypedNode), (yylsp[0]));
2578 }
2579
2580 break;
2581
2582 case 24:
2583
2584 {
2585 TParameter param = { 0, new TType((yyvsp[0].interm.intermTypedNode)->getType()) };
2586 (yyvsp[-2].interm).function->addParameter(param);
2587 (yyval.interm).function = (yyvsp[-2].interm).function;
2588 (yyval.interm).nodePair.node1 = context->intermediate.growAggregate((yyvsp[-2].interm).intermNode, (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2589 }
2590
2591 break;
2592
2593 case 25:
2594
2595 {
2596 (yyval.interm.function) = (yyvsp[-1].interm.function);
2597 }
2598
2599 break;
2600
2601 case 26:
2602
2603 {
2604 if ((yyvsp[0].interm.type).array) {
2605 ES3_ONLY("[]", (yylsp[0]), "array constructor");
2606 }
2607 (yyval.interm.function) = context->addConstructorFunc((yyvsp[0].interm.type));
2608 }
2609
2610 break;
2611
2612 case 27:
2613
2614 {
2615 if (context->reservedErrorCheck((yylsp[0]), *(yyvsp[0].lex).string))
2616 context->recover();
2617 TType type(EbtVoid, EbpUndefined);
2618 TFunction *function = new TFunction((yyvsp[0].lex).string, type);
2619 (yyval.interm.function) = function;
2620 }
2621
2622 break;
2623
2624 case 28:
2625
2626 {
2627 if (context->reservedErrorCheck((yylsp[0]), *(yyvsp[0].lex).string))
2628 context->recover();
2629 TType type(EbtVoid, EbpUndefined);
2630 TFunction *function = new TFunction((yyvsp[0].lex).string, type);
2631 (yyval.interm.function) = function;
2632 }
2633
2634 break;
2635
2636 case 29:
2637
2638 {
2639 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
2640 }
2641
2642 break;
2643
2644 case 30:
2645
2646 {
2647 (yyval.interm.intermTypedNode) = context->addUnaryMathLValue(EOpPreIncrement, (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2648 }
2649
2650 break;
2651
2652 case 31:
2653
2654 {
2655 (yyval.interm.intermTypedNode) = context->addUnaryMathLValue(EOpPreDecrement, (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2656 }
2657
2658 break;
2659
2660 case 32:
2661
2662 {
2663 if ((yyvsp[-1].interm).op != EOpNull) {
2664 (yyval.interm.intermTypedNode) = context->addUnaryMath((yyvsp[-1].interm).op, (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2665 } else
2666 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
2667 }
2668
2669 break;
2670
2671 case 33:
2672
2673 { (yyval.interm).op = EOpNull; }
2674
2675 break;
2676
2677 case 34:
2678
2679 { (yyval.interm).op = EOpNegative; }
2680
2681 break;
2682
2683 case 35:
2684
2685 { (yyval.interm).op = EOpLogicalNot; }
2686
2687 break;
2688
2689 case 36:
2690
2691 {
2692 ES3_ONLY("~", (yylsp[0]), "bit-wise operator");
2693 (yyval.interm).op = EOpBitwiseNot;
2694 }
2695
2696 break;
2697
2698 case 37:
2699
2700 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
2701
2702 break;
2703
2704 case 38:
2705
2706 {
2707 FRAG_VERT_ONLY("*", (yylsp[-1]));
2708 (yyval.interm.intermTypedNode) = context->addBinaryMath(EOpMul, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2709 }
2710
2711 break;
2712
2713 case 39:
2714
2715 {
2716 FRAG_VERT_ONLY("/", (yylsp[-1]));
2717 (yyval.interm.intermTypedNode) = context->addBinaryMath(EOpDiv, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2718 }
2719
2720 break;
2721
2722 case 40:
2723
2724 {
2725 FRAG_VERT_ONLY("%", (yylsp[-1]));
2726 ES3_ONLY("%", (yylsp[-1]), "integer modulus operator");
2727 (yyval.interm.intermTypedNode) = context->addBinaryMath(EOpIMod, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2728 }
2729
2730 break;
2731
2732 case 41:
2733
2734 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
2735
2736 break;
2737
2738 case 42:
2739
2740 {
2741 (yyval.interm.intermTypedNode) = context->addBinaryMath(EOpAdd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2742 }
2743
2744 break;
2745
2746 case 43:
2747
2748 {
2749 (yyval.interm.intermTypedNode) = context->addBinaryMath(EOpSub, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2750 }
2751
2752 break;
2753
2754 case 44:
2755
2756 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
2757
2758 break;
2759
2760 case 45:
2761
2762 {
2763 ES3_ONLY("<<", (yylsp[-1]), "bit-wise operator");
2764 (yyval.interm.intermTypedNode) = context->addBinaryMath(EOpBitShiftLeft, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2765 }
2766
2767 break;
2768
2769 case 46:
2770
2771 {
2772 ES3_ONLY(">>", (yylsp[-1]), "bit-wise operator");
2773 (yyval.interm.intermTypedNode) = context->addBinaryMath(EOpBitShiftRight, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2774 }
2775
2776 break;
2777
2778 case 47:
2779
2780 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
2781
2782 break;
2783
2784 case 48:
2785
2786 {
2787 (yyval.interm.intermTypedNode) = context->addBinaryMathBooleanResult(EOpLessThan, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2788 }
2789
2790 break;
2791
2792 case 49:
2793
2794 {
2795 (yyval.interm.intermTypedNode) = context->addBinaryMathBooleanResult(EOpGreaterThan, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2796 }
2797
2798 break;
2799
2800 case 50:
2801
2802 {
2803 (yyval.interm.intermTypedNode) = context->addBinaryMathBooleanResult(EOpLessThanEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2804 }
2805
2806 break;
2807
2808 case 51:
2809
2810 {
2811 (yyval.interm.intermTypedNode) = context->addBinaryMathBooleanResult(EOpGreaterThanEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2812 }
2813
2814 break;
2815
2816 case 52:
2817
2818 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
2819
2820 break;
2821
2822 case 53:
2823
2824 {
2825 (yyval.interm.intermTypedNode) = context->addBinaryMathBooleanResult(EOpEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2826 }
2827
2828 break;
2829
2830 case 54:
2831
2832 {
2833 (yyval.interm.intermTypedNode) = context->addBinaryMathBooleanResult(EOpNotEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2834 }
2835
2836 break;
2837
2838 case 55:
2839
2840 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
2841
2842 break;
2843
2844 case 56:
2845
2846 {
2847 ES3_ONLY("&", (yylsp[-1]), "bit-wise operator");
2848 (yyval.interm.intermTypedNode) = context->addBinaryMath(EOpBitwiseAnd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2849 }
2850
2851 break;
2852
2853 case 57:
2854
2855 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
2856
2857 break;
2858
2859 case 58:
2860
2861 {
2862 ES3_ONLY("^", (yylsp[-1]), "bit-wise operator");
2863 (yyval.interm.intermTypedNode) = context->addBinaryMath(EOpBitwiseXor, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2864 }
2865
2866 break;
2867
2868 case 59:
2869
2870 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
2871
2872 break;
2873
2874 case 60:
2875
2876 {
2877 ES3_ONLY("|", (yylsp[-1]), "bit-wise operator");
2878 (yyval.interm.intermTypedNode) = context->addBinaryMath(EOpBitwiseOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2879 }
2880
2881 break;
2882
2883 case 61:
2884
2885 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
2886
2887 break;
2888
2889 case 62:
2890
2891 {
2892 (yyval.interm.intermTypedNode) = context->addBinaryMathBooleanResult(EOpLogicalAnd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2893 }
2894
2895 break;
2896
2897 case 63:
2898
2899 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
2900
2901 break;
2902
2903 case 64:
2904
2905 {
2906 (yyval.interm.intermTypedNode) = context->addBinaryMathBooleanResult(EOpLogicalXor, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2907 }
2908
2909 break;
2910
2911 case 65:
2912
2913 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
2914
2915 break;
2916
2917 case 66:
2918
2919 {
2920 (yyval.interm.intermTypedNode) = context->addBinaryMathBooleanResult(EOpLogicalOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2921 }
2922
2923 break;
2924
2925 case 67:
2926
2927 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
2928
2929 break;
2930
2931 case 68:
2932
2933 {
2934 (yyval.interm.intermTypedNode) = context->addTernarySelection((yyvsp[-4].interm.intermTypedNode), (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-3]));
2935 }
2936
2937 break;
2938
2939 case 69:
2940
2941 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
2942
2943 break;
2944
2945 case 70:
2946
2947 {
2948 if (context->lValueErrorCheck((yylsp[-1]), "assign", (yyvsp[-2].interm.intermTypedNode)))
2949 context->recover();
2950 (yyval.interm.intermTypedNode) = context->addAssign((yyvsp[-1].interm).op, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
2951 }
2952
2953 break;
2954
2955 case 71:
2956
2957 { (yyval.interm).op = EOpAssign; }
2958
2959 break;
2960
2961 case 72:
2962
2963 { FRAG_VERT_ONLY("*=", (yylsp[0])); (yyval.interm).op = EOpMulAssign; }
2964
2965 break;
2966
2967 case 73:
2968
2969 { FRAG_VERT_ONLY("/=", (yylsp[0])); (yyval.interm).op = EOpDivAssign; }
2970
2971 break;
2972
2973 case 74:
2974
2975 { ES3_ONLY("%=", (yylsp[0]), "integer modulus operator");
2976 FRAG_VERT_ONLY("%=", (yylsp[0])); (yyval.interm).op = EOpIModAssign; }
2977
2978 break;
2979
2980 case 75:
2981
2982 { (yyval.interm).op = EOpAddAssign; }
2983
2984 break;
2985
2986 case 76:
2987
2988 { (yyval.interm).op = EOpSubAssign; }
2989
2990 break;
2991
2992 case 77:
2993
2994 { ES3_ONLY("<<=", (yylsp[0]), "bit-wise operator");
2995 FRAG_VERT_ONLY("<<=", (yylsp[0]));
2996 (yyval.interm).op = EOpBitShiftLeftAssign; }
2997
2998 break;
2999
3000 case 78:
3001
3002 { ES3_ONLY(">>=", (yylsp[0]), "bit-wise operator");
3003 FRAG_VERT_ONLY(">>=", (yylsp[0]));
3004 (yyval.interm).op = EOpBitShiftRightAssign; }
3005
3006 break;
3007
3008 case 79:
3009
3010 { ES3_ONLY("&=", (yylsp[0]), "bit-wise operator");
3011 FRAG_VERT_ONLY("&=", (yylsp[0]));
3012 (yyval.interm).op = EOpBitwiseAndAssign; }
3013
3014 break;
3015
3016 case 80:
3017
3018 { ES3_ONLY("^=", (yylsp[0]), "bit-wise operator");
3019 FRAG_VERT_ONLY("^=", (yylsp[0]));
3020 (yyval.interm).op = EOpBitwiseXorAssign; }
3021
3022 break;
3023
3024 case 81:
3025
3026 { ES3_ONLY("|=", (yylsp[0]), "bit-wise operator");
3027 FRAG_VERT_ONLY("|=", (yylsp[0]));
3028 (yyval.interm).op = EOpBitwiseOrAssign; }
3029
3030 break;
3031
3032 case 82:
3033
3034 {
3035 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
3036 }
3037
3038 break;
3039
3040 case 83:
3041
3042 {
3043 (yyval.interm.intermTypedNode) = context->intermediate.addComma((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yylsp[-1]));
3044 if ((yyval.interm.intermTypedNode) == 0) {
3045 context->binaryOpError((yylsp[-1]), ",", (yyvsp[-2].interm.intermTypedNode)->getCompleteString(), (yyvsp[0].interm.intermTypedNode)->getCompleteString());
3046 context->recover();
3047 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
3048 }
3049 }
3050
3051 break;
3052
3053 case 84:
3054
3055 {
3056 if (context->constErrorCheck((yyvsp[0].interm.intermTypedNode)))
3057 context->recover();
3058 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
3059 }
3060
3061 break;
3062
3063 case 85:
3064
3065 {
3066 if (context->enterStructDeclaration((yylsp[-1]), *(yyvsp[-1].lex).string))
3067 context->recover();
3068 (yyval.lex) = (yyvsp[-1].lex);
3069 }
3070
3071 break;
3072
3073 case 86:
3074
3075 {
3076 (yyval.interm.intermNode) = context->addFunctionPrototypeDeclaration(*((yyvsp[-1].interm).function), (yylsp[-1]));
3077 }
3078
3079 break;
3080
3081 case 87:
3082
3083 {
3084 TIntermAggregate *aggNode = (yyvsp[-1].interm).intermAggregate;
3085 if (aggNode && aggNode->getOp() == EOpNull)
3086 aggNode->setOp(EOpDeclaration);
3087 (yyval.interm.intermNode) = aggNode;
3088 }
3089
3090 break;
3091
3092 case 88:
3093
3094 {
3095 if (!context->symbolTable.setDefaultPrecision( (yyvsp[-1].interm.type), (yyvsp[-2].interm.precision) )) {
3096 context->error((yylsp[-3]), "illegal type argument for default precision qualifier", getBasicString((yyvsp[-1].interm.type).type));
3097 context->recover();
3098 }
3099 (yyval.interm.intermNode) = 0;
3100 }
3101
3102 break;
3103
3104 case 89:
3105
3106 {
3107 ES3_ONLY(getQualifierString((yyvsp[-4].interm.type).qualifier), (yylsp[-4]), "interface blocks");
3108 (yyval.interm.intermNode) = context->addInterfaceBlock((yyvsp[-4].interm.type), (yylsp[-3]), *(yyvsp[-3].lex).string, (yyvsp[-2].interm.fieldList), NULL, (yylsp[-4]), NULL, (yylsp[-4]));
3109 }
3110
3111 break;
3112
3113 case 90:
3114
3115 {
3116 ES3_ONLY(getQualifierString((yyvsp[-5].interm.type).qualifier), (yylsp[-5]), "interface blocks");
3117 (yyval.interm.intermNode) = context->addInterfaceBlock((yyvsp[-5].interm.type), (yylsp[-4]), *(yyvsp[-4].lex).string, (yyvsp[-3].interm.fieldList), (yyvsp[-1].lex).string, (yylsp[-1]), NULL, (yylsp[-5]));
3118 }
3119
3120 break;
3121
3122 case 91:
3123
3124 {
3125 ES3_ONLY(getQualifierString((yyvsp[-8].interm.type).qualifier), (yylsp[-8]), "interface blocks");
3126 (yyval.interm.intermNode) = context->addInterfaceBlock((yyvsp[-8].interm.type), (yylsp[-7]), *(yyvsp[-7].lex).string, (yyvsp[-6].interm.fieldList), (yyvsp[-4].lex).string, (yylsp[-4]), (yyvsp[-2].interm.intermTypedNode), (yylsp[-3]));
3127 }
3128
3129 break;
3130
3131 case 92:
3132
3133 {
3134 context->parseGlobalLayoutQualifier((yyvsp[-1].interm.type));
3135 (yyval.interm.intermNode) = 0;
3136 }
3137
3138 break;
3139
3140 case 93:
3141
3142 {
3143 (yyval.interm).function = context->parseFunctionDeclarator((yylsp[0]), (yyvsp[-1].interm.function));
3144 }
3145
3146 break;
3147
3148 case 94:
3149
3150 {
3151 (yyval.interm.function) = (yyvsp[0].interm.function);
3152 }
3153
3154 break;
3155
3156 case 95:
3157
3158 {
3159 (yyval.interm.function) = (yyvsp[0].interm.function);
3160 }
3161
3162 break;
3163
3164 case 96:
3165
3166 {
3167 // Add the parameter
3168 (yyval.interm.function) = (yyvsp[-1].interm.function);
3169 if ((yyvsp[0].interm).param.type->getBasicType() != EbtVoid)
3170 (yyvsp[-1].interm.function)->addParameter((yyvsp[0].interm).param);
3171 else
3172 delete (yyvsp[0].interm).param.type;
3173 }
3174
3175 break;
3176
3177 case 97:
3178
3179 {
3180 //
3181 // Only first parameter of one-parameter functions can be void
3182 // The check for named parameters not being void is done in parameter_declarator
3183 //
3184 if ((yyvsp[0].interm).param.type->getBasicType() == EbtVoid) {
3185 //
3186 // This parameter > first is void
3187 //
3188 context->error((yylsp[-1]), "cannot be an argument type except for '(void)'", "void");
3189 context->recover();
3190 delete (yyvsp[0].interm).param.type;
3191 } else {
3192 // Add the parameter
3193 (yyval.interm.function) = (yyvsp[-2].interm.function);
3194 (yyvsp[-2].interm.function)->addParameter((yyvsp[0].interm).param);
3195 }
3196 }
3197
3198 break;
3199
3200 case 98:
3201
3202 {
3203 if ((yyvsp[-2].interm.type).qualifier != EvqGlobal && (yyvsp[-2].interm.type).qualifier != EvqTemporary) {
3204 context->error((yylsp[-1]), "no qualifiers allowed for function return", getQualifierString((yyvsp[-2].interm.type).qualifier));
3205 context->recover();
3206 }
3207 if (!(yyvsp[-2].interm.type).layoutQualifier.isEmpty())
3208 {
3209 context->error((yylsp[-1]), "no qualifiers allowed for function return", "layout");
3210 context->recover();
3211 }
3212 // make sure a sampler is not involved as well...
3213 if (context->samplerErrorCheck((yylsp[-1]), (yyvsp[-2].interm.type), "samplers can't be function return values"))
3214 context->recover();
3215
3216 // Add the function as a prototype after parsing it (we do not support recursion)
3217 TFunction *function;
3218 TType type((yyvsp[-2].interm.type));
3219 function = new TFunction((yyvsp[-1].lex).string, type);
3220 (yyval.interm.function) = function;
3221
3222 context->symbolTable.push();
3223 }
3224
3225 break;
3226
3227 case 99:
3228
3229 {
3230 if ((yyvsp[-1].interm.type).type == EbtVoid) {
3231 context->error((yylsp[0]), "illegal use of type 'void'", (yyvsp[0].lex).string->c_str());
3232 context->recover();
3233 }
3234 if (context->reservedErrorCheck((yylsp[0]), *(yyvsp[0].lex).string))
3235 context->recover();
3236 TParameter param = {(yyvsp[0].lex).string, new TType((yyvsp[-1].interm.type))};
3237 (yyval.interm).param = param;
3238 }
3239
3240 break;
3241
3242 case 100:
3243
3244 {
3245 // Check that we can make an array out of this type
3246 if (context->arrayTypeErrorCheck((yylsp[-2]), (yyvsp[-4].interm.type)))
3247 context->recover();
3248
3249 if (context->reservedErrorCheck((yylsp[-3]), *(yyvsp[-3].lex).string))
3250 context->recover();
3251
3252 int size = 0;
3253 if (context->arraySizeErrorCheck((yylsp[-2]), (yyvsp[-1].interm.intermTypedNode), size))
3254 context->recover();
3255 (yyvsp[-4].interm.type).setArray(true, size);
3256
3257 TType* type = new TType((yyvsp[-4].interm.type));
3258 TParameter param = { (yyvsp[-3].lex).string, type };
3259 (yyval.interm).param = param;
3260 }
3261
3262 break;
3263
3264 case 101:
3265
3266 {
3267 (yyval.interm) = (yyvsp[0].interm);
3268 if (context->paramErrorCheck((yylsp[0]), (yyvsp[-2].interm.qualifier), (yyvsp[-1].interm.qualifier), (yyval.interm).param.type))
3269 context->recover();
3270 }
3271
3272 break;
3273
3274 case 102:
3275
3276 {
3277 (yyval.interm) = (yyvsp[0].interm);
3278 if (context->parameterSamplerErrorCheck((yylsp[0]), (yyvsp[-1].interm.qualifier), *(yyvsp[0].interm).param.type))
3279 context->recover();
3280 if (context->paramErrorCheck((yylsp[0]), EvqTemporary, (yyvsp[-1].interm.qualifier), (yyval.interm).param.type))
3281 context->recover();
3282 }
3283
3284 break;
3285
3286 case 103:
3287
3288 {
3289 (yyval.interm) = (yyvsp[0].interm);
3290 if (context->paramErrorCheck((yylsp[0]), (yyvsp[-2].interm.qualifier), (yyvsp[-1].interm.qualifier), (yyval.interm).param.type))
3291 context->recover();
3292 }
3293
3294 break;
3295
3296 case 104:
3297
3298 {
3299 (yyval.interm) = (yyvsp[0].interm);
3300 if (context->parameterSamplerErrorCheck((yylsp[0]), (yyvsp[-1].interm.qualifier), *(yyvsp[0].interm).param.type))
3301 context->recover();
3302 if (context->paramErrorCheck((yylsp[0]), EvqTemporary, (yyvsp[-1].interm.qualifier), (yyval.interm).param.type))
3303 context->recover();
3304 }
3305
3306 break;
3307
3308 case 105:
3309
3310 {
3311 (yyval.interm.qualifier) = EvqIn;
3312 }
3313
3314 break;
3315
3316 case 106:
3317
3318 {
3319 (yyval.interm.qualifier) = EvqIn;
3320 }
3321
3322 break;
3323
3324 case 107:
3325
3326 {
3327 (yyval.interm.qualifier) = EvqOut;
3328 }
3329
3330 break;
3331
3332 case 108:
3333
3334 {
3335 (yyval.interm.qualifier) = EvqInOut;
3336 }
3337
3338 break;
3339
3340 case 109:
3341
3342 {
3343 TParameter param = { 0, new TType((yyvsp[0].interm.type)) };
3344 (yyval.interm).param = param;
3345 }
3346
3347 break;
3348
3349 case 110:
3350
3351 {
3352 (yyval.interm) = (yyvsp[0].interm);
3353 }
3354
3355 break;
3356
3357 case 111:
3358
3359 {
3360 (yyval.interm) = (yyvsp[-2].interm);
3361 (yyval.interm).intermAggregate = context->parseDeclarator((yyval.interm).type, (yyvsp[-2].interm).intermAggregate, (yylsp[0]), *(yyvsp[0].lex).string);
3362 }
3363
3364 break;
3365
3366 case 112:
3367
3368 {
3369 (yyval.interm) = (yyvsp[-5].interm);
3370 (yyval.interm).intermAggregate = context->parseArrayDeclarator((yyval.interm).type, (yyvsp[-5].interm).intermAggregate, (yylsp[-3]), *(yyvsp[-3].lex).string, (yylsp[-2]), (yyvsp[-1].interm.intermTypedNode));
3371 }
3372
3373 break;
3374
3375 case 113:
3376
3377 {
3378 ES3_ONLY("[]", (yylsp[-4]), "implicitly sized array");
3379 (yyval.interm) = (yyvsp[-6].interm);
3380 (yyval.interm).intermAggregate = context->parseArrayInitDeclarator((yyval.interm).type, (yyvsp[-6].interm).intermAggregate, (yylsp[-4]), *(yyvsp[-4].lex).string, (yylsp[-3]), nullptr, (yylsp[-1]), (yyvsp[0].interm.intermTypedNode));
3381 }
3382
3383 break;
3384
3385 case 114:
3386
3387 {
3388 ES3_ONLY("=", (yylsp[-1]), "first-class arrays (array initializer)");
3389 (yyval.interm) = (yyvsp[-7].interm);
3390 (yyval.interm).intermAggregate = context->parseArrayInitDeclarator((yyval.interm).type, (yyvsp[-7].interm).intermAggregate, (yylsp[-5]), *(yyvsp[-5].lex).string, (yylsp[-4]), (yyvsp[-3].interm.intermTypedNode), (yylsp[-1]), (yyvsp[0].interm.intermTypedNode));
3391 }
3392
3393 break;
3394
3395 case 115:
3396
3397 {
3398 (yyval.interm) = (yyvsp[-4].interm);
3399 (yyval.interm).intermAggregate = context->parseInitDeclarator((yyval.interm).type, (yyvsp[-4].interm).intermAggregate, (yylsp[-2]), *(yyvsp[-2].lex).string, (yylsp[-1]), (yyvsp[0].interm.intermTypedNode));
3400 }
3401
3402 break;
3403
3404 case 116:
3405
3406 {
3407 (yyval.interm).type = (yyvsp[0].interm.type);
3408 (yyval.interm).intermAggregate = context->parseSingleDeclaration((yyval.interm).type, (yylsp[0]), "");
3409 }
3410
3411 break;
3412
3413 case 117:
3414
3415 {
3416 (yyval.interm).type = (yyvsp[-1].interm.type);
3417 (yyval.interm).intermAggregate = context->parseSingleDeclaration((yyval.interm).type, (yylsp[0]), *(yyvsp[0].lex).string);
3418 }
3419
3420 break;
3421
3422 case 118:
3423
3424 {
3425 (yyval.interm).type = (yyvsp[-4].interm.type);
3426 (yyval.interm).intermAggregate = context->parseSingleArrayDeclaration((yyval.interm).type, (yylsp[-3]), *(yyvsp[-3].lex).string, (yylsp[-2]), (yyvsp[-1].interm.intermTypedNode));
3427 }
3428
3429 break;
3430
3431 case 119:
3432
3433 {
3434 ES3_ONLY("[]", (yylsp[-3]), "implicitly sized array");
3435 (yyval.interm).type = (yyvsp[-5].interm.type);
3436 (yyval.interm).intermAggregate = context->parseSingleArrayInitDeclaration((yyval.interm).type, (yylsp[-4]), *(yyvsp[-4].lex).string, (yylsp[-3]), nullptr, (yylsp[-1]), (yyvsp[0].interm.intermTypedNode));
3437 }
3438
3439 break;
3440
3441 case 120:
3442
3443 {
3444 ES3_ONLY("=", (yylsp[-1]), "first-class arrays (array initializer)");
3445 (yyval.interm).type = (yyvsp[-6].interm.type);
3446 (yyval.interm).intermAggregate = context->parseSingleArrayInitDeclaration((yyval.interm).type, (yylsp[-5]), *(yyvsp[-5].lex).string, (yylsp[-4]), (yyvsp[-3].interm.intermTypedNode), (yylsp[-1]), (yyvsp[0].interm.intermTypedNode));
3447 }
3448
3449 break;
3450
3451 case 121:
3452
3453 {
3454 (yyval.interm).type = (yyvsp[-3].interm.type);
3455 (yyval.interm).intermAggregate = context->parseSingleInitDeclaration((yyval.interm).type, (yylsp[-2]), *(yyvsp[-2].lex).string, (yylsp[-1]), (yyvsp[0].interm.intermTypedNode));
3456 }
3457
3458 break;
3459
3460 case 122:
3461
3462 {
3463 // $$.type is not used in invariant declarations.
3464 (yyval.interm).intermAggregate = context->parseInvariantDeclaration((yylsp[-1]), (yylsp[0]), (yyvsp[0].lex).string, (yyvsp[0].lex).symbol);
3465 }
3466
3467 break;
3468
3469 case 123:
3470
3471 {
3472 (yyval.interm.type) = (yyvsp[0].interm.type);
3473
3474 if ((yyvsp[0].interm.type).array) {
3475 ES3_ONLY("[]", (yylsp[0]), "first-class-array");
3476 if (context->getShaderVersion() != 300) {
3477 (yyvsp[0].interm.type).clearArrayness();
3478 }
3479 }
3480 }
3481
3482 break;
3483
3484 case 124:
3485
3486 {
3487 (yyval.interm.type) = context->addFullySpecifiedType((yyvsp[-1].interm.type).qualifier, (yyvsp[-1].interm.type).invariant, (yyvsp[-1].interm.type).layoutQualifier, (yyvsp[0].interm.type));
3488 }
3489
3490 break;
3491
3492 case 125:
3493
3494 {
3495 (yyval.interm.type).qualifier = EvqSmooth;
3496 }
3497
3498 break;
3499
3500 case 126:
3501
3502 {
3503 (yyval.interm.type).qualifier = EvqFlat;
3504 }
3505
3506 break;
3507
3508 case 127:
3509
3510 {
3511 (yyval.interm.qualifier) = EvqConstReadOnly;
3512 }
3513
3514 break;
3515
3516 case 128:
3517
3518 {
3519 VERTEX_ONLY("attribute", (yylsp[0]));
3520 ES2_ONLY("attribute", (yylsp[0]));
3521 if (context->globalErrorCheck((yylsp[0]), context->symbolTable.atGlobalLevel(), "attribute"))
3522 context->recover();
3523 (yyval.interm.type).setBasic(EbtVoid, EvqAttribute, (yylsp[0]));
3524 }
3525
3526 break;
3527
3528 case 129:
3529
3530 {
3531 ES2_ONLY("varying", (yylsp[0]));
3532 if (context->globalErrorCheck((yylsp[0]), context->symbolTable.atGlobalLevel(), "varying"))
3533 context->recover();
3534 if (context->getShaderType() == GL_VERTEX_SHADER)
3535 (yyval.interm.type).setBasic(EbtVoid, EvqVaryingOut, (yylsp[0]));
3536 else
3537 (yyval.interm.type).setBasic(EbtVoid, EvqVaryingIn, (yylsp[0]));
3538 }
3539
3540 break;
3541
3542 case 130:
3543
3544 {
3545 ES2_ONLY("varying", (yylsp[-1]));
3546 if (context->globalErrorCheck((yylsp[-1]), context->symbolTable.atGlobalLevel(), "invariant varying"))
3547 context->recover();
3548 if (context->getShaderType() == GL_VERTEX_SHADER)
3549 (yyval.interm.type).setBasic(EbtVoid, EvqInvariantVaryingOut, (yylsp[-1]));
3550 else
3551 (yyval.interm.type).setBasic(EbtVoid, EvqInvariantVaryingIn, (yylsp[-1]));
3552 }
3553
3554 break;
3555
3556 case 131:
3557
3558 {
3559 if ((yyvsp[0].interm.type).qualifier != EvqConstExpr && !context->symbolTable.atGlobalLevel())
3560 {
3561 context->error((yylsp[0]), "Local variables can only use the const storage qualifier.", getQualifierString((yyvsp[0].interm.type).qualifier));
3562 context->recover();
3563 }
3564 (yyval.interm.type).setBasic(EbtVoid, (yyvsp[0].interm.type).qualifier, (yylsp[0]));
3565 }
3566
3567 break;
3568
3569 case 132:
3570
3571 {
3572 (yyval.interm.type) = context->joinInterpolationQualifiers((yylsp[-1]), (yyvsp[-1].interm.type).qualifier, (yylsp[0]), (yyvsp[0].interm.type).qualifier);
3573 }
3574
3575 break;
3576
3577 case 133:
3578
3579 {
3580 context->error((yylsp[0]), "interpolation qualifier requires a fragment 'in' or vertex 'out' storage qualifier", getQualifierString((yyvsp[0].interm.type).qualifier));
3581 context->recover();
3582
3583 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
3584 (yyval.interm.type).setBasic(EbtVoid, qual, (yylsp[0]));
3585 }
3586
3587 break;
3588
3589 case 134:
3590
3591 {
3592 (yyval.interm.type).qualifier = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
3593 (yyval.interm.type).layoutQualifier = (yyvsp[0].interm.layoutQualifier);
3594 }
3595
3596 break;
3597
3598 case 135:
3599
3600 {
3601 (yyval.interm.type).setBasic(EbtVoid, (yyvsp[0].interm.type).qualifier, (yylsp[0]));
3602 (yyval.interm.type).layoutQualifier = (yyvsp[-1].interm.layoutQualifier);
3603 }
3604
3605 break;
3606
3607 case 136:
3608
3609 {
3610 context->es3InvariantErrorCheck((yyvsp[0].interm.type).qualifier, (yylsp[-1]));
3611 (yyval.interm.type).setBasic(EbtVoid, (yyvsp[0].interm.type).qualifier, (yylsp[0]));
3612 (yyval.interm.type).invariant = true;
3613 }
3614
3615 break;
3616
3617 case 137:
3618
3619 {
3620 context->es3InvariantErrorCheck((yyvsp[0].interm.type).qualifier, (yylsp[-2]));
3621 (yyval.interm.type) = context->joinInterpolationQualifiers((yylsp[-1]), (yyvsp[-1].interm.type).qualifier, (yylsp[0]), (yyvsp[0].interm.type).qualifier);
3622 (yyval.interm.type).invariant = true;
3623 }
3624
3625 break;
3626
3627 case 138:
3628
3629 {
3630 (yyval.interm.type).qualifier = EvqConstExpr;
3631 }
3632
3633 break;
3634
3635 case 139:
3636
3637 {
3638 ES3_ONLY("in", (yylsp[0]), "storage qualifier");
3639 (yyval.interm.type).qualifier = (context->getShaderType() == GL_FRAGMENT_SHADER) ? EvqFragmentIn : EvqVertexIn;
3640 }
3641
3642 break;
3643
3644 case 140:
3645
3646 {
3647 ES3_ONLY("out", (yylsp[0]), "storage qualifier");
3648 (yyval.interm.type).qualifier = (context->getShaderType() == GL_FRAGMENT_SHADER) ? EvqFragmentOut : EvqVertexOut;
3649 }
3650
3651 break;
3652
3653 case 141:
3654
3655 {
3656 ES3_ONLY("centroid in", (yylsp[-1]), "storage qualifier");
3657 if (context->getShaderType() == GL_VERTEX_SHADER)
3658 {
3659 context->error((yylsp[-1]), "invalid storage qualifier", "it is an error to use 'centroid in' in the vertex shader");
3660 context->recover();
3661 }
3662 (yyval.interm.type).qualifier = (context->getShaderType() == GL_FRAGMENT_SHADER) ? EvqCentroidIn : EvqVertexIn;
3663 }
3664
3665 break;
3666
3667 case 142:
3668
3669 {
3670 ES3_ONLY("centroid out", (yylsp[-1]), "storage qualifier");
3671 if (context->getShaderType() == GL_FRAGMENT_SHADER)
3672 {
3673 context->error((yylsp[-1]), "invalid storage qualifier", "it is an error to use 'centroid out' in the fragment shader");
3674 context->recover();
3675 }
3676 (yyval.interm.type).qualifier = (context->getShaderType() == GL_FRAGMENT_SHADER) ? EvqFragmentOut : EvqCentroidOut;
3677 }
3678
3679 break;
3680
3681 case 143:
3682
3683 {
3684 if (context->globalErrorCheck((yylsp[0]), context->symbolTable.atGlobalLevel(), "uniform"))
3685 context->recover();
3686 (yyval.interm.type).qualifier = EvqUniform;
3687 }
3688
3689 break;
3690
3691 case 144:
3692
3693 {
3694 (yyval.interm.type) = (yyvsp[0].interm.type);
3695
3696 if ((yyval.interm.type).precision == EbpUndefined) {
3697 (yyval.interm.type).precision = context->symbolTable.getDefaultPrecision((yyvsp[0].interm.type).type);
3698 if (context->precisionErrorCheck((yylsp[0]), (yyval.interm.type).precision, (yyvsp[0].interm.type).type)) {
3699 context->recover();
3700 }
3701 }
3702 }
3703
3704 break;
3705
3706 case 145:
3707
3708 {
3709 (yyval.interm.type) = (yyvsp[0].interm.type);
3710 (yyval.interm.type).precision = (yyvsp[-1].interm.precision);
3711
3712 if (!SupportsPrecision((yyvsp[0].interm.type).type)) {
3713 context->error((yylsp[-1]), "illegal type for precision qualifier", getBasicString((yyvsp[0].interm.type).type));
3714 context->recover();
3715 }
3716 }
3717
3718 break;
3719
3720 case 146:
3721
3722 {
3723 (yyval.interm.precision) = EbpHigh;
3724 }
3725
3726 break;
3727
3728 case 147:
3729
3730 {
3731 (yyval.interm.precision) = EbpMedium;
3732 }
3733
3734 break;
3735
3736 case 148:
3737
3738 {
3739 (yyval.interm.precision) = EbpLow;
3740 }
3741
3742 break;
3743
3744 case 149:
3745
3746 {
3747 ES3_ONLY("layout", (yylsp[-3]), "qualifier");
3748 (yyval.interm.layoutQualifier) = (yyvsp[-1].interm.layoutQualifier);
3749 }
3750
3751 break;
3752
3753 case 150:
3754
3755 {
3756 (yyval.interm.layoutQualifier) = (yyvsp[0].interm.layoutQualifier);
3757 }
3758
3759 break;
3760
3761 case 151:
3762
3763 {
3764 (yyval.interm.layoutQualifier) = context->joinLayoutQualifiers((yyvsp[-2].interm.layoutQualifier), (yyvsp[0].interm.layoutQualifier));
3765 }
3766
3767 break;
3768
3769 case 152:
3770
3771 {
3772 (yyval.interm.layoutQualifier) = context->parseLayoutQualifier(*(yyvsp[0].lex).string, (yylsp[0]));
3773 }
3774
3775 break;
3776
3777 case 153:
3778
3779 {
3780 (yyval.interm.layoutQualifier) = context->parseLayoutQualifier(*(yyvsp[-2].lex).string, (yylsp[-2]), (yyvsp[0].lex).i, (yylsp[0]));
3781 }
3782
3783 break;
3784
3785 case 154:
3786
3787 {
3788 (yyval.interm.layoutQualifier) = context->parseLayoutQualifier(*(yyvsp[-2].lex).string, (yylsp[-2]), (yyvsp[0].lex).i, (yylsp[0]));
3789 }
3790
3791 break;
3792
3793 case 155:
3794
3795 {
3796 (yyval.interm.type) = (yyvsp[0].interm.type);
3797 }
3798
3799 break;
3800
3801 case 156:
3802
3803 {
3804 ES3_ONLY("[]", (yylsp[-1]), "implicitly sized array");
3805 (yyval.interm.type) = (yyvsp[-2].interm.type);
3806 (yyval.interm.type).setArray(true, 0);
3807 }
3808
3809 break;
3810
3811 case 157:
3812
3813 {
3814 (yyval.interm.type) = (yyvsp[-3].interm.type);
3815
3816 if (context->arrayTypeErrorCheck((yylsp[-2]), (yyvsp[-3].interm.type)))
3817 context->recover();
3818 else {
3819 int size = 0;
3820 if (context->arraySizeErrorCheck((yylsp[-2]), (yyvsp[-1].interm.intermTypedNode), size))
3821 context->recover();
3822 (yyval.interm.type).setArray(true, size);
3823 }
3824 }
3825
3826 break;
3827
3828 case 158:
3829
3830 {
3831 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
3832 (yyval.interm.type).setBasic(EbtVoid, qual, (yylsp[0]));
3833 }
3834
3835 break;
3836
3837 case 159:
3838
3839 {
3840 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
3841 (yyval.interm.type).setBasic(EbtFloat, qual, (yylsp[0]));
3842 }
3843
3844 break;
3845
3846 case 160:
3847
3848 {
3849 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
3850 (yyval.interm.type).setBasic(EbtInt, qual, (yylsp[0]));
3851 }
3852
3853 break;
3854
3855 case 161:
3856
3857 {
3858 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
3859 (yyval.interm.type).setBasic(EbtUInt, qual, (yylsp[0]));
3860 }
3861
3862 break;
3863
3864 case 162:
3865
3866 {
3867 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
3868 (yyval.interm.type).setBasic(EbtBool, qual, (yylsp[0]));
3869 }
3870
3871 break;
3872
3873 case 163:
3874
3875 {
3876 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
3877 (yyval.interm.type).setBasic(EbtFloat, qual, (yylsp[0]));
3878 (yyval.interm.type).setAggregate(2);
3879 }
3880
3881 break;
3882
3883 case 164:
3884
3885 {
3886 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
3887 (yyval.interm.type).setBasic(EbtFloat, qual, (yylsp[0]));
3888 (yyval.interm.type).setAggregate(3);
3889 }
3890
3891 break;
3892
3893 case 165:
3894
3895 {
3896 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
3897 (yyval.interm.type).setBasic(EbtFloat, qual, (yylsp[0]));
3898 (yyval.interm.type).setAggregate(4);
3899 }
3900
3901 break;
3902
3903 case 166:
3904
3905 {
3906 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
3907 (yyval.interm.type).setBasic(EbtBool, qual, (yylsp[0]));
3908 (yyval.interm.type).setAggregate(2);
3909 }
3910
3911 break;
3912
3913 case 167:
3914
3915 {
3916 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
3917 (yyval.interm.type).setBasic(EbtBool, qual, (yylsp[0]));
3918 (yyval.interm.type).setAggregate(3);
3919 }
3920
3921 break;
3922
3923 case 168:
3924
3925 {
3926 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
3927 (yyval.interm.type).setBasic(EbtBool, qual, (yylsp[0]));
3928 (yyval.interm.type).setAggregate(4);
3929 }
3930
3931 break;
3932
3933 case 169:
3934
3935 {
3936 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
3937 (yyval.interm.type).setBasic(EbtInt, qual, (yylsp[0]));
3938 (yyval.interm.type).setAggregate(2);
3939 }
3940
3941 break;
3942
3943 case 170:
3944
3945 {
3946 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
3947 (yyval.interm.type).setBasic(EbtInt, qual, (yylsp[0]));
3948 (yyval.interm.type).setAggregate(3);
3949 }
3950
3951 break;
3952
3953 case 171:
3954
3955 {
3956 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
3957 (yyval.interm.type).setBasic(EbtInt, qual, (yylsp[0]));
3958 (yyval.interm.type).setAggregate(4);
3959 }
3960
3961 break;
3962
3963 case 172:
3964
3965 {
3966 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
3967 (yyval.interm.type).setBasic(EbtUInt, qual, (yylsp[0]));
3968 (yyval.interm.type).setAggregate(2);
3969 }
3970
3971 break;
3972
3973 case 173:
3974
3975 {
3976 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
3977 (yyval.interm.type).setBasic(EbtUInt, qual, (yylsp[0]));
3978 (yyval.interm.type).setAggregate(3);
3979 }
3980
3981 break;
3982
3983 case 174:
3984
3985 {
3986 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
3987 (yyval.interm.type).setBasic(EbtUInt, qual, (yylsp[0]));
3988 (yyval.interm.type).setAggregate(4);
3989 }
3990
3991 break;
3992
3993 case 175:
3994
3995 {
3996 FRAG_VERT_ONLY("mat2", (yylsp[0]));
3997 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
3998 (yyval.interm.type).setBasic(EbtFloat, qual, (yylsp[0]));
3999 (yyval.interm.type).setMatrix(2, 2);
4000 }
4001
4002 break;
4003
4004 case 176:
4005
4006 {
4007 FRAG_VERT_ONLY("mat3", (yylsp[0]));
4008 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
4009 (yyval.interm.type).setBasic(EbtFloat, qual, (yylsp[0]));
4010 (yyval.interm.type).setMatrix(3, 3);
4011 }
4012
4013 break;
4014
4015 case 177:
4016
4017 {
4018 FRAG_VERT_ONLY("mat4", (yylsp[0]));
4019 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
4020 (yyval.interm.type).setBasic(EbtFloat, qual, (yylsp[0]));
4021 (yyval.interm.type).setMatrix(4, 4);
4022 }
4023
4024 break;
4025
4026 case 178:
4027
4028 {
4029 FRAG_VERT_ONLY("mat2x3", (yylsp[0]));
4030 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
4031 (yyval.interm.type).setBasic(EbtFloat, qual, (yylsp[0]));
4032 (yyval.interm.type).setMatrix(2, 3);
4033 }
4034
4035 break;
4036
4037 case 179:
4038
4039 {
4040 FRAG_VERT_ONLY("mat3x2", (yylsp[0]));
4041 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
4042 (yyval.interm.type).setBasic(EbtFloat, qual, (yylsp[0]));
4043 (yyval.interm.type).setMatrix(3, 2);
4044 }
4045
4046 break;
4047
4048 case 180:
4049
4050 {
4051 FRAG_VERT_ONLY("mat2x4", (yylsp[0]));
4052 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
4053 (yyval.interm.type).setBasic(EbtFloat, qual, (yylsp[0]));
4054 (yyval.interm.type).setMatrix(2, 4);
4055 }
4056
4057 break;
4058
4059 case 181:
4060
4061 {
4062 FRAG_VERT_ONLY("mat4x2", (yylsp[0]));
4063 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
4064 (yyval.interm.type).setBasic(EbtFloat, qual, (yylsp[0]));
4065 (yyval.interm.type).setMatrix(4, 2);
4066 }
4067
4068 break;
4069
4070 case 182:
4071
4072 {
4073 FRAG_VERT_ONLY("mat3x4", (yylsp[0]));
4074 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
4075 (yyval.interm.type).setBasic(EbtFloat, qual, (yylsp[0]));
4076 (yyval.interm.type).setMatrix(3, 4);
4077 }
4078
4079 break;
4080
4081 case 183:
4082
4083 {
4084 FRAG_VERT_ONLY("mat4x3", (yylsp[0]));
4085 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
4086 (yyval.interm.type).setBasic(EbtFloat, qual, (yylsp[0]));
4087 (yyval.interm.type).setMatrix(4, 3);
4088 }
4089
4090 break;
4091
4092 case 184:
4093
4094 {
4095 FRAG_VERT_ONLY("sampler2D", (yylsp[0]));
4096 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
4097 (yyval.interm.type).setBasic(EbtSampler2D, qual, (yylsp[0]));
4098 }
4099
4100 break;
4101
4102 case 185:
4103
4104 {
4105 FRAG_VERT_ONLY("samplerCube", (yylsp[0]));
4106 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
4107 (yyval.interm.type).setBasic(EbtSamplerCube, qual, (yylsp[0]));
4108 }
4109
4110 break;
4111
4112 case 186:
4113
4114 {
4115 if (!context->supportsExtension("GL_OES_EGL_image_external")) {
4116 context->error((yylsp[0]), "unsupported type", "samplerExternalOES", "");
4117 context->recover();
4118 }
4119 FRAG_VERT_ONLY("samplerExternalOES", (yylsp[0]));
4120 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
4121 (yyval.interm.type).setBasic(EbtSamplerExternalOES, qual, (yylsp[0]));
4122 }
4123
4124 break;
4125
4126 case 187:
4127
4128 {
4129 if (!context->supportsExtension("GL_ARB_texture_rectangle")) {
4130 context->error((yylsp[0]), "unsupported type", "sampler2DRect", "");
4131 context->recover();
4132 }
4133 FRAG_VERT_ONLY("sampler2DRect", (yylsp[0]));
4134 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
4135 (yyval.interm.type).setBasic(EbtSampler2DRect, qual, (yylsp[0]));
4136 }
4137
4138 break;
4139
4140 case 188:
4141
4142 {
4143 FRAG_VERT_ONLY("sampler3D", (yylsp[0]));
4144 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
4145 (yyval.interm.type).setBasic(EbtSampler3D, qual, (yylsp[0]));
4146 }
4147
4148 break;
4149
4150 case 189:
4151
4152 {
4153 FRAG_VERT_ONLY("sampler2DArray", (yylsp[0]));
4154 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
4155 (yyval.interm.type).setBasic(EbtSampler2DArray, qual, (yylsp[0]));
4156 }
4157
4158 break;
4159
4160 case 190:
4161
4162 {
4163 FRAG_VERT_ONLY("isampler2D", (yylsp[0]));
4164 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
4165 (yyval.interm.type).setBasic(EbtISampler2D, qual, (yylsp[0]));
4166 }
4167
4168 break;
4169
4170 case 191:
4171
4172 {
4173 FRAG_VERT_ONLY("isampler3D", (yylsp[0]));
4174 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
4175 (yyval.interm.type).setBasic(EbtISampler3D, qual, (yylsp[0]));
4176 }
4177
4178 break;
4179
4180 case 192:
4181
4182 {
4183 FRAG_VERT_ONLY("isamplerCube", (yylsp[0]));
4184 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
4185 (yyval.interm.type).setBasic(EbtISamplerCube, qual, (yylsp[0]));
4186 }
4187
4188 break;
4189
4190 case 193:
4191
4192 {
4193 FRAG_VERT_ONLY("isampler2DArray", (yylsp[0]));
4194 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
4195 (yyval.interm.type).setBasic(EbtISampler2DArray, qual, (yylsp[0]));
4196 }
4197
4198 break;
4199
4200 case 194:
4201
4202 {
4203 FRAG_VERT_ONLY("usampler2D", (yylsp[0]));
4204 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
4205 (yyval.interm.type).setBasic(EbtUSampler2D, qual, (yylsp[0]));
4206 }
4207
4208 break;
4209
4210 case 195:
4211
4212 {
4213 FRAG_VERT_ONLY("usampler3D", (yylsp[0]));
4214 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
4215 (yyval.interm.type).setBasic(EbtUSampler3D, qual, (yylsp[0]));
4216 }
4217
4218 break;
4219
4220 case 196:
4221
4222 {
4223 FRAG_VERT_ONLY("usamplerCube", (yylsp[0]));
4224 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
4225 (yyval.interm.type).setBasic(EbtUSamplerCube, qual, (yylsp[0]));
4226 }
4227
4228 break;
4229
4230 case 197:
4231
4232 {
4233 FRAG_VERT_ONLY("usampler2DArray", (yylsp[0]));
4234 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
4235 (yyval.interm.type).setBasic(EbtUSampler2DArray, qual, (yylsp[0]));
4236 }
4237
4238 break;
4239
4240 case 198:
4241
4242 {
4243 FRAG_VERT_ONLY("sampler2DShadow", (yylsp[0]));
4244 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
4245 (yyval.interm.type).setBasic(EbtSampler2DShadow, qual, (yylsp[0]));
4246 }
4247
4248 break;
4249
4250 case 199:
4251
4252 {
4253 FRAG_VERT_ONLY("samplerCubeShadow", (yylsp[0]));
4254 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
4255 (yyval.interm.type).setBasic(EbtSamplerCubeShadow, qual, (yylsp[0]));
4256 }
4257
4258 break;
4259
4260 case 200:
4261
4262 {
4263 FRAG_VERT_ONLY("sampler2DArrayShadow", (yylsp[0]));
4264 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
4265 (yyval.interm.type).setBasic(EbtSampler2DArrayShadow, qual, (yylsp[0]));
4266 }
4267
4268 break;
4269
4270 case 201:
4271
4272 {
4273 FRAG_VERT_ONLY("struct", (yylsp[0]));
4274 (yyval.interm.type) = (yyvsp[0].interm.type);
4275 (yyval.interm.type).qualifier = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
4276 }
4277
4278 break;
4279
4280 case 202:
4281
4282 {
4283 //
4284 // This is for user defined type names. The lexical phase looked up the
4285 // type.
4286 //
4287 TType& structure = static_cast<TVariable*>((yyvsp[0].lex).symbol)->getType();
4288 TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
4289 (yyval.interm.type).setBasic(EbtStruct, qual, (yylsp[0]));
4290 (yyval.interm.type).userDef = &structure;
4291 }
4292
4293 break;
4294
4295 case 203:
4296
4297 { if (context->enterStructDeclaration((yylsp[-1]), *(yyvsp[-1].lex).string)) context->recover(); }
4298
4299 break;
4300
4301 case 204:
4302
4303 {
4304 (yyval.interm.type) = context->addStructure((yylsp[-5]), (yylsp[-4]), (yyvsp[-4].lex).string, (yyvsp[-1].interm.fieldList));
4305 }
4306
4307 break;
4308
4309 case 205:
4310
4311 { if (context->enterStructDeclaration((yylsp[0]), *(yyvsp[0].lex).string)) context->recover(); }
4312
4313 break;
4314
4315 case 206:
4316
4317 {
4318 (yyval.interm.type) = context->addStructure((yylsp[-4]), (yylsp[-4]), NewPoolTString(""), (yyvsp[-1].interm.fieldList));
4319 }
4320
4321 break;
4322
4323 case 207:
4324
4325 {
4326 (yyval.interm.fieldList) = (yyvsp[0].interm.fieldList);
4327 }
4328
4329 break;
4330
4331 case 208:
4332
4333 {
4334 (yyval.interm.fieldList) = (yyvsp[-1].interm.fieldList);
4335 for (unsigned int i = 0; i < (yyvsp[0].interm.fieldList)->size(); ++i) {
4336 TField* field = (*(yyvsp[0].interm.fieldList))[i];
4337 for (unsigned int j = 0; j < (yyval.interm.fieldList)->size(); ++j) {
4338 if ((*(yyval.interm.fieldList))[j]->name() == field->name()) {
4339 context->error((*(yyvsp[0].interm.fieldList))[i]->line(), "duplicate field name in structure:", "struct", field->name().c_str());
4340 context->recover();
4341 }
4342 }
4343 (yyval.interm.fieldList)->push_back((*(yyvsp[0].interm.fieldList))[i]);
4344 }
4345 }
4346
4347 break;
4348
4349 case 209:
4350
4351 {
4352 (yyval.interm.fieldList) = context->addStructDeclaratorList((yyvsp[-2].interm.type), (yyvsp[-1].interm.fieldList));
4353 }
4354
4355 break;
4356
4357 case 210:
4358
4359 {
4360 // ES3 Only, but errors should be handled elsewhere
4361 (yyvsp[-2].interm.type).qualifier = (yyvsp[-3].interm.type).qualifier;
4362 (yyvsp[-2].interm.type).layoutQualifier = (yyvsp[-3].interm.type).layoutQualifier;
4363 (yyval.interm.fieldList) = context->addStructDeclaratorList((yyvsp[-2].interm.type), (yyvsp[-1].interm.fieldList));
4364 }
4365
4366 break;
4367
4368 case 211:
4369
4370 {
4371 (yyval.interm.fieldList) = NewPoolTFieldList();
4372 (yyval.interm.fieldList)->push_back((yyvsp[0].interm.field));
4373 }
4374
4375 break;
4376
4377 case 212:
4378
4379 {
4380 (yyval.interm.fieldList)->push_back((yyvsp[0].interm.field));
4381 }
4382
4383 break;
4384
4385 case 213:
4386
4387 {
4388 if (context->reservedErrorCheck((yylsp[0]), *(yyvsp[0].lex).string))
4389 context->recover();
4390
4391 TType* type = new TType(EbtVoid, EbpUndefined);
4392 (yyval.interm.field) = new TField(type, (yyvsp[0].lex).string, (yylsp[0]));
4393 }
4394
4395 break;
4396
4397 case 214:
4398
4399 {
4400 if (context->reservedErrorCheck((yylsp[-3]), *(yyvsp[-3].lex).string))
4401 context->recover();
4402
4403 TType* type = new TType(EbtVoid, EbpUndefined);
4404 int size = 0;
4405 if (context->arraySizeErrorCheck((yyvsp[-1].interm.intermTypedNode)->getLine(), (yyvsp[-1].interm.intermTypedNode), size))
4406 context->recover();
4407 type->setArraySize(size);
4408
4409 (yyval.interm.field) = new TField(type, (yyvsp[-3].lex).string, (yylsp[-3]));
4410 }
4411
4412 break;
4413
4414 case 215:
4415
4416 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); }
4417
4418 break;
4419
4420 case 216:
4421
4422 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
4423
4424 break;
4425
4426 case 217:
4427
4428 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermAggregate); }
4429
4430 break;
4431
4432 case 218:
4433
4434 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
4435
4436 break;
4437
4438 case 219:
4439
4440 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
4441
4442 break;
4443
4444 case 220:
4445
4446 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
4447
4448 break;
4449
4450 case 221:
4451
4452 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
4453
4454 break;
4455
4456 case 222:
4457
4458 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermSwitch); }
4459
4460 break;
4461
4462 case 223:
4463
4464 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermCase); }
4465
4466 break;
4467
4468 case 224:
4469
4470 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
4471
4472 break;
4473
4474 case 225:
4475
4476 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
4477
4478 break;
4479
4480 case 226:
4481
4482 { (yyval.interm.intermAggregate) = 0; }
4483
4484 break;
4485
4486 case 227:
4487
4488 { context->symbolTable.push(); }
4489
4490 break;
4491
4492 case 228:
4493
4494 { context->symbolTable.pop(); }
4495
4496 break;
4497
4498 case 229:
4499
4500 {
4501 if ((yyvsp[-2].interm.intermAggregate) != 0) {
4502 (yyvsp[-2].interm.intermAggregate)->setOp(EOpSequence);
4503 (yyvsp[-2].interm.intermAggregate)->setEndLine((yylsp[0]));
4504 }
4505 (yyval.interm.intermAggregate) = (yyvsp[-2].interm.intermAggregate);
4506 }
4507
4508 break;
4509
4510 case 230:
4511
4512 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermAggregate); }
4513
4514 break;
4515
4516 case 231:
4517
4518 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
4519
4520 break;
4521
4522 case 232:
4523
4524 { context->symbolTable.push(); }
4525
4526 break;
4527
4528 case 233:
4529
4530 { context->symbolTable.pop(); (yyval.interm.intermNode) = (yyvsp[0].interm.intermAggregate); }
4531
4532 break;
4533
4534 case 234:
4535
4536 { context->symbolTable.push(); }
4537
4538 break;
4539
4540 case 235:
4541
4542 { context->symbolTable.pop(); (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); }
4543
4544 break;
4545
4546 case 236:
4547
4548 {
4549 (yyval.interm.intermAggregate) = 0;
4550 }
4551
4552 break;
4553
4554 case 237:
4555
4556 {
4557 if ((yyvsp[-1].interm.intermAggregate)) {
4558 (yyvsp[-1].interm.intermAggregate)->setOp(EOpSequence);
4559 (yyvsp[-1].interm.intermAggregate)->setEndLine((yylsp[0]));
4560 }
4561 (yyval.interm.intermAggregate) = (yyvsp[-1].interm.intermAggregate);
4562 }
4563
4564 break;
4565
4566 case 238:
4567
4568 {
4569 (yyval.interm.intermAggregate) = context->intermediate.makeAggregate((yyvsp[0].interm.intermNode), (yyloc));
4570 }
4571
4572 break;
4573
4574 case 239:
4575
4576 {
4577 (yyval.interm.intermAggregate) = context->intermediate.growAggregate((yyvsp[-1].interm.intermAggregate), (yyvsp[0].interm.intermNode), (yyloc));
4578 }
4579
4580 break;
4581
4582 case 240:
4583
4584 { (yyval.interm.intermNode) = 0; }
4585
4586 break;
4587
4588 case 241:
4589
4590 { (yyval.interm.intermNode) = static_cast<TIntermNode*>((yyvsp[-1].interm.intermTypedNode)); }
4591
4592 break;
4593
4594 case 242:
4595
4596 {
4597 if (context->boolErrorCheck((yylsp[-4]), (yyvsp[-2].interm.intermTypedNode)))
4598 context->recover();
4599 (yyval.interm.intermNode) = context->intermediate.addSelection((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.nodePair), (yylsp[-4]));
4600 }
4601
4602 break;
4603
4604 case 243:
4605
4606 {
4607 (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermNode);
4608 (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermNode);
4609 }
4610
4611 break;
4612
4613 case 244:
4614
4615 {
4616 (yyval.interm.nodePair).node1 = (yyvsp[0].interm.intermNode);
4617 (yyval.interm.nodePair).node2 = 0;
4618 }
4619
4620 break;
4621
4622 case 245:
4623
4624 { context->incrSwitchNestingLevel(); }
4625
4626 break;
4627
4628 case 246:
4629
4630 {
4631 (yyval.interm.intermSwitch) = context->addSwitch((yyvsp[-3].interm.intermTypedNode), (yyvsp[0].interm.intermAggregate), (yylsp[-5]));
4632 context->decrSwitchNestingLevel();
4633 }
4634
4635 break;
4636
4637 case 247:
4638
4639 {
4640 (yyval.interm.intermCase) = context->addCase((yyvsp[-1].interm.intermTypedNode), (yylsp[-2]));
4641 }
4642
4643 break;
4644
4645 case 248:
4646
4647 {
4648 (yyval.interm.intermCase) = context->addDefault((yylsp[-1]));
4649 }
4650
4651 break;
4652
4653 case 249:
4654
4655 {
4656 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
4657 if (context->boolErrorCheck((yyvsp[0].interm.intermTypedNode)->getLine(), (yyvsp[0].interm.intermTypedNode)))
4658 context->recover();
4659 }
4660
4661 break;
4662
4663 case 250:
4664
4665 {
4666 TIntermNode *intermNode;
4667 if (context->boolErrorCheck((yylsp[-2]), (yyvsp[-3].interm.type)))
4668 context->recover();
4669
4670 if (!context->executeInitializer((yylsp[-2]), *(yyvsp[-2].lex).string, (yyvsp[-3].interm.type), (yyvsp[0].interm.intermTypedNode), &intermNode))
4671 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
4672 else {
4673 context->recover();
4674 (yyval.interm.intermTypedNode) = 0;
4675 }
4676 }
4677
4678 break;
4679
4680 case 251:
4681
4682 { context->symbolTable.push(); context->incrLoopNestingLevel(); }
4683
4684 break;
4685
4686 case 252:
4687
4688 {
4689 context->symbolTable.pop();
4690 (yyval.interm.intermNode) = context->intermediate.addLoop(ELoopWhile, 0, (yyvsp[-2].interm.intermTypedNode), 0, (yyvsp[0].interm.intermNode), (yylsp[-5]));
4691 context->decrLoopNestingLevel();
4692 }
4693
4694 break;
4695
4696 case 253:
4697
4698 { context->incrLoopNestingLevel(); }
4699
4700 break;
4701
4702 case 254:
4703
4704 {
4705 if (context->boolErrorCheck((yylsp[0]), (yyvsp[-2].interm.intermTypedNode)))
4706 context->recover();
4707
4708 (yyval.interm.intermNode) = context->intermediate.addLoop(ELoopDoWhile, 0, (yyvsp[-2].interm.intermTypedNode), 0, (yyvsp[-5].interm.intermNode), (yylsp[-4]));
4709 context->decrLoopNestingLevel();
4710 }
4711
4712 break;
4713
4714 case 255:
4715
4716 { context->symbolTable.push(); context->incrLoopNestingLevel(); }
4717
4718 break;
4719
4720 case 256:
4721
4722 {
4723 context->symbolTable.pop();
4724 (yyval.interm.intermNode) = context->intermediate.addLoop(ELoopFor, (yyvsp[-3].interm.intermNode), reinterpret_cast<TIntermTyped*>((yyvsp[-2].interm.nodePair).node1), reinterpret_cast<TIntermTyped*>((yyvsp[-2].interm.nodePair).node2), (yyvsp[0].interm.intermNode), (yylsp[-6]));
4725 context->decrLoopNestingLevel();
4726 }
4727
4728 break;
4729
4730 case 257:
4731
4732 {
4733 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
4734 }
4735
4736 break;
4737
4738 case 258:
4739
4740 {
4741 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
4742 }
4743
4744 break;
4745
4746 case 259:
4747
4748 {
4749 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode);
4750 }
4751
4752 break;
4753
4754 case 260:
4755
4756 {
4757 (yyval.interm.intermTypedNode) = 0;
4758 }
4759
4760 break;
4761
4762 case 261:
4763
4764 {
4765 (yyval.interm.nodePair).node1 = (yyvsp[-1].interm.intermTypedNode);
4766 (yyval.interm.nodePair).node2 = 0;
4767 }
4768
4769 break;
4770
4771 case 262:
4772
4773 {
4774 (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermTypedNode);
4775 (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermTypedNode);
4776 }
4777
4778 break;
4779
4780 case 263:
4781
4782 {
4783 (yyval.interm.intermNode) = context->addBranch(EOpContinue, (yylsp[-1]));
4784 }
4785
4786 break;
4787
4788 case 264:
4789
4790 {
4791 (yyval.interm.intermNode) = context->addBranch(EOpBreak, (yylsp[-1]));
4792 }
4793
4794 break;
4795
4796 case 265:
4797
4798 {
4799 (yyval.interm.intermNode) = context->addBranch(EOpReturn, (yylsp[-1]));
4800 }
4801
4802 break;
4803
4804 case 266:
4805
4806 {
4807 (yyval.interm.intermNode) = context->addBranch(EOpReturn, (yyvsp[-1].interm.intermTypedNode), (yylsp[-2]));
4808 }
4809
4810 break;
4811
4812 case 267:
4813
4814 {
4815 FRAG_ONLY("discard", (yylsp[-1]));
4816 (yyval.interm.intermNode) = context->addBranch(EOpKill, (yylsp[-1]));
4817 }
4818
4819 break;
4820
4821 case 268:
4822
4823 {
4824 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
4825 context->setTreeRoot((yyval.interm.intermNode));
4826 }
4827
4828 break;
4829
4830 case 269:
4831
4832 {
4833 (yyval.interm.intermNode) = context->intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode), (yyloc));
4834 context->setTreeRoot((yyval.interm.intermNode));
4835 }
4836
4837 break;
4838
4839 case 270:
4840
4841 {
4842 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
4843 }
4844
4845 break;
4846
4847 case 271:
4848
4849 {
4850 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode);
4851 }
4852
4853 break;
4854
4855 case 272:
4856
4857 {
4858 context->parseFunctionPrototype((yylsp[0]), (yyvsp[0].interm).function, &(yyvsp[0].interm).intermAggregate);
4859 }
4860
4861 break;
4862
4863 case 273:
4864
4865 {
4866 (yyval.interm.intermNode) = context->addFunctionDefinition(*((yyvsp[-2].interm).function), (yyvsp[-2].interm).intermAggregate, (yyvsp[0].interm.intermAggregate), (yylsp[-2]));
4867 }
4868
4869 break;
4870
4871
4872
4873 default: break;
4874 }
4875 /* User semantic actions sometimes alter yychar, and that requires
4876 that yytoken be updated with the new translation. We take the
4877 approach of translating immediately before every use of yytoken.
4878 One alternative is translating here after every semantic action,
4879 but that translation would be missed if the semantic action invokes
4880 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
4881 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
4882 incorrect destructor might then be invoked immediately. In the
4883 case of YYERROR or YYBACKUP, subsequent parser actions might lead
4884 to an incorrect destructor call or verbose syntax error message
4885 before the lookahead is translated. */
4886 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
4887
4888 YYPOPSTACK (yylen);
4889 yylen = 0;
4890 YY_STACK_PRINT (yyss, yyssp);
4891
4892 *++yyvsp = yyval;
4893 *++yylsp = yyloc;
4894
4895 /* Now 'shift' the result of the reduction. Determine what state
4896 that goes to, based on the state we popped back to and the rule
4897 number reduced by. */
4898
4899 yyn = yyr1[yyn];
4900
4901 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
4902 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
4903 yystate = yytable[yystate];
4904 else
4905 yystate = yydefgoto[yyn - YYNTOKENS];
4906
4907 goto yynewstate;
4908
4909
4910 /*--------------------------------------.
4911 | yyerrlab -- here on detecting error. |
4912 `--------------------------------------*/
4913 yyerrlab:
4914 /* Make sure we have latest lookahead translation. See comments at
4915 user semantic actions for why this is necessary. */
4916 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
4917
4918 /* If not already recovering from an error, report this error. */
4919 if (!yyerrstatus)
4920 {
4921 ++yynerrs;
4922 #if ! YYERROR_VERBOSE
4923 yyerror (&yylloc, context, yyscanner, YY_("syntax error"));
4924 #else
4925 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
4926 yyssp, yytoken)
4927 {
4928 char const *yymsgp = YY_("syntax error");
4929 int yysyntax_error_status;
4930 yysyntax_error_status = YYSYNTAX_ERROR;
4931 if (yysyntax_error_status == 0)
4932 yymsgp = yymsg;
4933 else if (yysyntax_error_status == 1)
4934 {
4935 if (yymsg != yymsgbuf)
4936 YYSTACK_FREE (yymsg);
4937 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
4938 if (!yymsg)
4939 {
4940 yymsg = yymsgbuf;
4941 yymsg_alloc = sizeof yymsgbuf;
4942 yysyntax_error_status = 2;
4943 }
4944 else
4945 {
4946 yysyntax_error_status = YYSYNTAX_ERROR;
4947 yymsgp = yymsg;
4948 }
4949 }
4950 yyerror (&yylloc, context, yyscanner, yymsgp);
4951 if (yysyntax_error_status == 2)
4952 goto yyexhaustedlab;
4953 }
4954 # undef YYSYNTAX_ERROR
4955 #endif
4956 }
4957
4958 yyerror_range[1] = yylloc;
4959
4960 if (yyerrstatus == 3)
4961 {
4962 /* If just tried and failed to reuse lookahead token after an
4963 error, discard it. */
4964
4965 if (yychar <= YYEOF)
4966 {
4967 /* Return failure if at end of input. */
4968 if (yychar == YYEOF)
4969 YYABORT;
4970 }
4971 else
4972 {
4973 yydestruct ("Error: discarding",
4974 yytoken, &yylval, &yylloc, context, yyscanner);
4975 yychar = YYEMPTY;
4976 }
4977 }
4978
4979 /* Else will try to reuse lookahead token after shifting the error
4980 token. */
4981 goto yyerrlab1;
4982
4983
4984 /*---------------------------------------------------.
4985 | yyerrorlab -- error raised explicitly by YYERROR. |
4986 `---------------------------------------------------*/
4987 yyerrorlab:
4988
4989 /* Pacify compilers like GCC when the user code never invokes
4990 YYERROR and the label yyerrorlab therefore never appears in user
4991 code. */
4992 if (/*CONSTCOND*/ 0)
4993 goto yyerrorlab;
4994
4995 yyerror_range[1] = yylsp[1-yylen];
4996 /* Do not reclaim the symbols of the rule whose action triggered
4997 this YYERROR. */
4998 YYPOPSTACK (yylen);
4999 yylen = 0;
5000 YY_STACK_PRINT (yyss, yyssp);
5001 yystate = *yyssp;
5002 goto yyerrlab1;
5003
5004
5005 /*-------------------------------------------------------------.
5006 | yyerrlab1 -- common code for both syntax error and YYERROR. |
5007 `-------------------------------------------------------------*/
5008 yyerrlab1:
5009 yyerrstatus = 3; /* Each real token shifted decrements this. */
5010
5011 for (;;)
5012 {
5013 yyn = yypact[yystate];
5014 if (!yypact_value_is_default (yyn))
5015 {
5016 yyn += YYTERROR;
5017 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
5018 {
5019 yyn = yytable[yyn];
5020 if (0 < yyn)
5021 break;
5022 }
5023 }
5024
5025 /* Pop the current state because it cannot handle the error token. */
5026 if (yyssp == yyss)
5027 YYABORT;
5028
5029 yyerror_range[1] = *yylsp;
5030 yydestruct ("Error: popping",
5031 yystos[yystate], yyvsp, yylsp, context, yyscanner);
5032 YYPOPSTACK (1);
5033 yystate = *yyssp;
5034 YY_STACK_PRINT (yyss, yyssp);
5035 }
5036
5037 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
5038 *++yyvsp = yylval;
5039 YY_IGNORE_MAYBE_UNINITIALIZED_END
5040
5041 yyerror_range[2] = yylloc;
5042 /* Using YYLLOC is tempting, but would change the location of
5043 the lookahead. YYLOC is available though. */
5044 YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
5045 *++yylsp = yyloc;
5046
5047 /* Shift the error token. */
5048 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
5049
5050 yystate = yyn;
5051 goto yynewstate;
5052
5053
5054 /*-------------------------------------.
5055 | yyacceptlab -- YYACCEPT comes here. |
5056 `-------------------------------------*/
5057 yyacceptlab:
5058 yyresult = 0;
5059 goto yyreturn;
5060
5061 /*-----------------------------------.
5062 | yyabortlab -- YYABORT comes here. |
5063 `-----------------------------------*/
5064 yyabortlab:
5065 yyresult = 1;
5066 goto yyreturn;
5067
5068 #if !defined yyoverflow || YYERROR_VERBOSE
5069 /*-------------------------------------------------.
5070 | yyexhaustedlab -- memory exhaustion comes here. |
5071 `-------------------------------------------------*/
5072 yyexhaustedlab:
5073 yyerror (&yylloc, context, yyscanner, YY_("memory exhausted"));
5074 yyresult = 2;
5075 /* Fall through. */
5076 #endif
5077
5078 yyreturn:
5079 if (yychar != YYEMPTY)
5080 {
5081 /* Make sure we have latest lookahead translation. See comments at
5082 user semantic actions for why this is necessary. */
5083 yytoken = YYTRANSLATE (yychar);
5084 yydestruct ("Cleanup: discarding lookahead",
5085 yytoken, &yylval, &yylloc, context, yyscanner);
5086 }
5087 /* Do not reclaim the symbols of the rule whose action triggered
5088 this YYABORT or YYACCEPT. */
5089 YYPOPSTACK (yylen);
5090 YY_STACK_PRINT (yyss, yyssp);
5091 while (yyssp != yyss)
5092 {
5093 yydestruct ("Cleanup: popping",
5094 yystos[*yyssp], yyvsp, yylsp, context, yyscanner);
5095 YYPOPSTACK (1);
5096 }
5097 #ifndef yyoverflow
5098 if (yyss != yyssa)
5099 YYSTACK_FREE (yyss);
5100 #endif
5101 #if YYERROR_VERBOSE
5102 if (yymsg != yymsgbuf)
5103 YYSTACK_FREE (yymsg);
5104 #endif
5105 return yyresult;
5106 }
5107
5108
5109
glslang_parse(TParseContext * context)5110 int glslang_parse(TParseContext* context) {
5111 return yyparse(context, context->getScanner());
5112 }
5113