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 #line 41 "MachineIndependent/glslang.y" /* yacc.c:339 */ 66 67 68 /* Based on: 69 ANSI C Yacc grammar 70 71 In 1985, Jeff Lee published his Yacc grammar (which is accompanied by a 72 matching Lex specification) for the April 30, 1985 draft version of the 73 ANSI C standard. Tom Stockfisch reposted it to net.sources in 1987; that 74 original, as mentioned in the answer to question 17.25 of the comp.lang.c 75 FAQ, can be ftp'ed from ftp.uu.net, file usenet/net.sources/ansi.c.grammar.Z. 76 77 I intend to keep this version as close to the current C Standard grammar as 78 possible; please let me know if you discover discrepancies. 79 80 Jutta Degener, 1995 81 */ 82 83 #include "SymbolTable.h" 84 #include "ParseHelper.h" 85 #include "../Public/ShaderLang.h" 86 87 using namespace glslang; 88 89 90 #line 91 "MachineIndependent/glslang_tab.cpp" /* yacc.c:339 */ 91 92 # ifndef YY_NULLPTR 93 # if defined __cplusplus && 201103L <= __cplusplus 94 # define YY_NULLPTR nullptr 95 # else 96 # define YY_NULLPTR 0 97 # endif 98 # endif 99 100 /* Enabling verbose error messages. */ 101 #ifdef YYERROR_VERBOSE 102 # undef YYERROR_VERBOSE 103 # define YYERROR_VERBOSE 1 104 #else 105 # define YYERROR_VERBOSE 1 106 #endif 107 108 /* In a future release of Bison, this section will be replaced 109 by #include "glslang_tab.cpp.h". */ 110 #ifndef YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED 111 # define YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED 112 /* Debug traces. */ 113 #ifndef YYDEBUG 114 # define YYDEBUG 1 115 #endif 116 #if YYDEBUG 117 extern int yydebug; 118 #endif 119 120 /* Token type. */ 121 #ifndef YYTOKENTYPE 122 # define YYTOKENTYPE 123 enum yytokentype 124 { 125 ATTRIBUTE = 258, 126 VARYING = 259, 127 CONST = 260, 128 BOOL = 261, 129 FLOAT = 262, 130 DOUBLE = 263, 131 INT = 264, 132 UINT = 265, 133 INT64_T = 266, 134 UINT64_T = 267, 135 INT16_T = 268, 136 UINT16_T = 269, 137 FLOAT16_T = 270, 138 BREAK = 271, 139 CONTINUE = 272, 140 DO = 273, 141 ELSE = 274, 142 FOR = 275, 143 IF = 276, 144 DISCARD = 277, 145 RETURN = 278, 146 SWITCH = 279, 147 CASE = 280, 148 DEFAULT = 281, 149 SUBROUTINE = 282, 150 BVEC2 = 283, 151 BVEC3 = 284, 152 BVEC4 = 285, 153 IVEC2 = 286, 154 IVEC3 = 287, 155 IVEC4 = 288, 156 I64VEC2 = 289, 157 I64VEC3 = 290, 158 I64VEC4 = 291, 159 UVEC2 = 292, 160 UVEC3 = 293, 161 UVEC4 = 294, 162 U64VEC2 = 295, 163 U64VEC3 = 296, 164 U64VEC4 = 297, 165 VEC2 = 298, 166 VEC3 = 299, 167 VEC4 = 300, 168 MAT2 = 301, 169 MAT3 = 302, 170 MAT4 = 303, 171 CENTROID = 304, 172 IN = 305, 173 OUT = 306, 174 INOUT = 307, 175 UNIFORM = 308, 176 PATCH = 309, 177 SAMPLE = 310, 178 BUFFER = 311, 179 SHARED = 312, 180 COHERENT = 313, 181 VOLATILE = 314, 182 RESTRICT = 315, 183 READONLY = 316, 184 WRITEONLY = 317, 185 DVEC2 = 318, 186 DVEC3 = 319, 187 DVEC4 = 320, 188 DMAT2 = 321, 189 DMAT3 = 322, 190 DMAT4 = 323, 191 F16VEC2 = 324, 192 F16VEC3 = 325, 193 F16VEC4 = 326, 194 F16MAT2 = 327, 195 F16MAT3 = 328, 196 F16MAT4 = 329, 197 I16VEC2 = 330, 198 I16VEC3 = 331, 199 I16VEC4 = 332, 200 U16VEC2 = 333, 201 U16VEC3 = 334, 202 U16VEC4 = 335, 203 NOPERSPECTIVE = 336, 204 FLAT = 337, 205 SMOOTH = 338, 206 LAYOUT = 339, 207 __EXPLICITINTERPAMD = 340, 208 MAT2X2 = 341, 209 MAT2X3 = 342, 210 MAT2X4 = 343, 211 MAT3X2 = 344, 212 MAT3X3 = 345, 213 MAT3X4 = 346, 214 MAT4X2 = 347, 215 MAT4X3 = 348, 216 MAT4X4 = 349, 217 DMAT2X2 = 350, 218 DMAT2X3 = 351, 219 DMAT2X4 = 352, 220 DMAT3X2 = 353, 221 DMAT3X3 = 354, 222 DMAT3X4 = 355, 223 DMAT4X2 = 356, 224 DMAT4X3 = 357, 225 DMAT4X4 = 358, 226 F16MAT2X2 = 359, 227 F16MAT2X3 = 360, 228 F16MAT2X4 = 361, 229 F16MAT3X2 = 362, 230 F16MAT3X3 = 363, 231 F16MAT3X4 = 364, 232 F16MAT4X2 = 365, 233 F16MAT4X3 = 366, 234 F16MAT4X4 = 367, 235 ATOMIC_UINT = 368, 236 SAMPLER1D = 369, 237 SAMPLER2D = 370, 238 SAMPLER3D = 371, 239 SAMPLERCUBE = 372, 240 SAMPLER1DSHADOW = 373, 241 SAMPLER2DSHADOW = 374, 242 SAMPLERCUBESHADOW = 375, 243 SAMPLER1DARRAY = 376, 244 SAMPLER2DARRAY = 377, 245 SAMPLER1DARRAYSHADOW = 378, 246 SAMPLER2DARRAYSHADOW = 379, 247 ISAMPLER1D = 380, 248 ISAMPLER2D = 381, 249 ISAMPLER3D = 382, 250 ISAMPLERCUBE = 383, 251 ISAMPLER1DARRAY = 384, 252 ISAMPLER2DARRAY = 385, 253 USAMPLER1D = 386, 254 USAMPLER2D = 387, 255 USAMPLER3D = 388, 256 USAMPLERCUBE = 389, 257 USAMPLER1DARRAY = 390, 258 USAMPLER2DARRAY = 391, 259 SAMPLER2DRECT = 392, 260 SAMPLER2DRECTSHADOW = 393, 261 ISAMPLER2DRECT = 394, 262 USAMPLER2DRECT = 395, 263 SAMPLERBUFFER = 396, 264 ISAMPLERBUFFER = 397, 265 USAMPLERBUFFER = 398, 266 SAMPLERCUBEARRAY = 399, 267 SAMPLERCUBEARRAYSHADOW = 400, 268 ISAMPLERCUBEARRAY = 401, 269 USAMPLERCUBEARRAY = 402, 270 SAMPLER2DMS = 403, 271 ISAMPLER2DMS = 404, 272 USAMPLER2DMS = 405, 273 SAMPLER2DMSARRAY = 406, 274 ISAMPLER2DMSARRAY = 407, 275 USAMPLER2DMSARRAY = 408, 276 SAMPLEREXTERNALOES = 409, 277 SAMPLER = 410, 278 SAMPLERSHADOW = 411, 279 TEXTURE1D = 412, 280 TEXTURE2D = 413, 281 TEXTURE3D = 414, 282 TEXTURECUBE = 415, 283 TEXTURE1DARRAY = 416, 284 TEXTURE2DARRAY = 417, 285 ITEXTURE1D = 418, 286 ITEXTURE2D = 419, 287 ITEXTURE3D = 420, 288 ITEXTURECUBE = 421, 289 ITEXTURE1DARRAY = 422, 290 ITEXTURE2DARRAY = 423, 291 UTEXTURE1D = 424, 292 UTEXTURE2D = 425, 293 UTEXTURE3D = 426, 294 UTEXTURECUBE = 427, 295 UTEXTURE1DARRAY = 428, 296 UTEXTURE2DARRAY = 429, 297 TEXTURE2DRECT = 430, 298 ITEXTURE2DRECT = 431, 299 UTEXTURE2DRECT = 432, 300 TEXTUREBUFFER = 433, 301 ITEXTUREBUFFER = 434, 302 UTEXTUREBUFFER = 435, 303 TEXTURECUBEARRAY = 436, 304 ITEXTURECUBEARRAY = 437, 305 UTEXTURECUBEARRAY = 438, 306 TEXTURE2DMS = 439, 307 ITEXTURE2DMS = 440, 308 UTEXTURE2DMS = 441, 309 TEXTURE2DMSARRAY = 442, 310 ITEXTURE2DMSARRAY = 443, 311 UTEXTURE2DMSARRAY = 444, 312 SUBPASSINPUT = 445, 313 SUBPASSINPUTMS = 446, 314 ISUBPASSINPUT = 447, 315 ISUBPASSINPUTMS = 448, 316 USUBPASSINPUT = 449, 317 USUBPASSINPUTMS = 450, 318 IMAGE1D = 451, 319 IIMAGE1D = 452, 320 UIMAGE1D = 453, 321 IMAGE2D = 454, 322 IIMAGE2D = 455, 323 UIMAGE2D = 456, 324 IMAGE3D = 457, 325 IIMAGE3D = 458, 326 UIMAGE3D = 459, 327 IMAGE2DRECT = 460, 328 IIMAGE2DRECT = 461, 329 UIMAGE2DRECT = 462, 330 IMAGECUBE = 463, 331 IIMAGECUBE = 464, 332 UIMAGECUBE = 465, 333 IMAGEBUFFER = 466, 334 IIMAGEBUFFER = 467, 335 UIMAGEBUFFER = 468, 336 IMAGE1DARRAY = 469, 337 IIMAGE1DARRAY = 470, 338 UIMAGE1DARRAY = 471, 339 IMAGE2DARRAY = 472, 340 IIMAGE2DARRAY = 473, 341 UIMAGE2DARRAY = 474, 342 IMAGECUBEARRAY = 475, 343 IIMAGECUBEARRAY = 476, 344 UIMAGECUBEARRAY = 477, 345 IMAGE2DMS = 478, 346 IIMAGE2DMS = 479, 347 UIMAGE2DMS = 480, 348 IMAGE2DMSARRAY = 481, 349 IIMAGE2DMSARRAY = 482, 350 UIMAGE2DMSARRAY = 483, 351 STRUCT = 484, 352 VOID = 485, 353 WHILE = 486, 354 IDENTIFIER = 487, 355 TYPE_NAME = 488, 356 FLOATCONSTANT = 489, 357 DOUBLECONSTANT = 490, 358 INTCONSTANT = 491, 359 UINTCONSTANT = 492, 360 INT64CONSTANT = 493, 361 UINT64CONSTANT = 494, 362 INT16CONSTANT = 495, 363 UINT16CONSTANT = 496, 364 BOOLCONSTANT = 497, 365 FLOAT16CONSTANT = 498, 366 LEFT_OP = 499, 367 RIGHT_OP = 500, 368 INC_OP = 501, 369 DEC_OP = 502, 370 LE_OP = 503, 371 GE_OP = 504, 372 EQ_OP = 505, 373 NE_OP = 506, 374 AND_OP = 507, 375 OR_OP = 508, 376 XOR_OP = 509, 377 MUL_ASSIGN = 510, 378 DIV_ASSIGN = 511, 379 ADD_ASSIGN = 512, 380 MOD_ASSIGN = 513, 381 LEFT_ASSIGN = 514, 382 RIGHT_ASSIGN = 515, 383 AND_ASSIGN = 516, 384 XOR_ASSIGN = 517, 385 OR_ASSIGN = 518, 386 SUB_ASSIGN = 519, 387 LEFT_PAREN = 520, 388 RIGHT_PAREN = 521, 389 LEFT_BRACKET = 522, 390 RIGHT_BRACKET = 523, 391 LEFT_BRACE = 524, 392 RIGHT_BRACE = 525, 393 DOT = 526, 394 COMMA = 527, 395 COLON = 528, 396 EQUAL = 529, 397 SEMICOLON = 530, 398 BANG = 531, 399 DASH = 532, 400 TILDE = 533, 401 PLUS = 534, 402 STAR = 535, 403 SLASH = 536, 404 PERCENT = 537, 405 LEFT_ANGLE = 538, 406 RIGHT_ANGLE = 539, 407 VERTICAL_BAR = 540, 408 CARET = 541, 409 AMPERSAND = 542, 410 QUESTION = 543, 411 INVARIANT = 544, 412 PRECISE = 545, 413 HIGH_PRECISION = 546, 414 MEDIUM_PRECISION = 547, 415 LOW_PRECISION = 548, 416 PRECISION = 549, 417 PACKED = 550, 418 RESOURCE = 551, 419 SUPERP = 552 420 }; 421 #endif 422 423 /* Value type. */ 424 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 425 426 union YYSTYPE 427 { 428 #line 68 "MachineIndependent/glslang.y" /* yacc.c:355 */ 429 430 struct { 431 glslang::TSourceLoc loc; 432 union { 433 glslang::TString *string; 434 int i; 435 unsigned int u; 436 long long i64; 437 unsigned long long u64; 438 bool b; 439 double d; 440 }; 441 glslang::TSymbol* symbol; 442 } lex; 443 struct { 444 glslang::TSourceLoc loc; 445 glslang::TOperator op; 446 union { 447 TIntermNode* intermNode; 448 glslang::TIntermNodePair nodePair; 449 glslang::TIntermTyped* intermTypedNode; 450 }; 451 union { 452 glslang::TPublicType type; 453 glslang::TFunction* function; 454 glslang::TParameter param; 455 glslang::TTypeLoc typeLine; 456 glslang::TTypeList* typeList; 457 glslang::TArraySizes* arraySizes; 458 glslang::TIdentifierList* identifierList; 459 }; 460 } interm; 461 462 #line 463 "MachineIndependent/glslang_tab.cpp" /* yacc.c:355 */ 463 }; 464 465 typedef union YYSTYPE YYSTYPE; 466 # define YYSTYPE_IS_TRIVIAL 1 467 # define YYSTYPE_IS_DECLARED 1 468 #endif 469 470 471 472 int yyparse (glslang::TParseContext* pParseContext); 473 474 #endif /* !YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED */ 475 476 /* Copy the second part of user declarations. */ 477 #line 102 "MachineIndependent/glslang.y" /* yacc.c:358 */ 478 479 480 /* windows only pragma */ 481 #ifdef _MSC_VER 482 #pragma warning(disable : 4065) 483 #pragma warning(disable : 4127) 484 #pragma warning(disable : 4244) 485 #endif 486 487 #define parseContext (*pParseContext) 488 #define yyerror(context, msg) context->parserError(msg) 489 490 extern int yylex(YYSTYPE*, TParseContext&); 491 492 493 #line 494 "MachineIndependent/glslang_tab.cpp" /* yacc.c:358 */ 494 495 #ifdef short 496 # undef short 497 #endif 498 499 #ifdef YYTYPE_UINT8 500 typedef YYTYPE_UINT8 yytype_uint8; 501 #else 502 typedef unsigned char yytype_uint8; 503 #endif 504 505 #ifdef YYTYPE_INT8 506 typedef YYTYPE_INT8 yytype_int8; 507 #else 508 typedef signed char yytype_int8; 509 #endif 510 511 #ifdef YYTYPE_UINT16 512 typedef YYTYPE_UINT16 yytype_uint16; 513 #else 514 typedef unsigned short int yytype_uint16; 515 #endif 516 517 #ifdef YYTYPE_INT16 518 typedef YYTYPE_INT16 yytype_int16; 519 #else 520 typedef short int yytype_int16; 521 #endif 522 523 #ifndef YYSIZE_T 524 # ifdef __SIZE_TYPE__ 525 # define YYSIZE_T __SIZE_TYPE__ 526 # elif defined size_t 527 # define YYSIZE_T size_t 528 # elif ! defined YYSIZE_T 529 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 530 # define YYSIZE_T size_t 531 # else 532 # define YYSIZE_T unsigned int 533 # endif 534 #endif 535 536 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 537 538 #ifndef YY_ 539 # if defined YYENABLE_NLS && YYENABLE_NLS 540 # if ENABLE_NLS 541 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 542 # define YY_(Msgid) dgettext ("bison-runtime", Msgid) 543 # endif 544 # endif 545 # ifndef YY_ 546 # define YY_(Msgid) Msgid 547 # endif 548 #endif 549 550 #ifndef YY_ATTRIBUTE 551 # if (defined __GNUC__ \ 552 && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \ 553 || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C 554 # define YY_ATTRIBUTE(Spec) __attribute__(Spec) 555 # else 556 # define YY_ATTRIBUTE(Spec) /* empty */ 557 # endif 558 #endif 559 560 #ifndef YY_ATTRIBUTE_PURE 561 # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__)) 562 #endif 563 564 #ifndef YY_ATTRIBUTE_UNUSED 565 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__)) 566 #endif 567 568 #if !defined _Noreturn \ 569 && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112) 570 # if defined _MSC_VER && 1200 <= _MSC_VER 571 # define _Noreturn __declspec (noreturn) 572 # else 573 # define _Noreturn YY_ATTRIBUTE ((__noreturn__)) 574 # endif 575 #endif 576 577 /* Suppress unused-variable warnings by "using" E. */ 578 #if ! defined lint || defined __GNUC__ 579 # define YYUSE(E) ((void) (E)) 580 #else 581 # define YYUSE(E) /* empty */ 582 #endif 583 584 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ 585 /* Suppress an incorrect diagnostic about yylval being uninitialized. */ 586 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ 587 _Pragma ("GCC diagnostic push") \ 588 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\ 589 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") 590 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \ 591 _Pragma ("GCC diagnostic pop") 592 #else 593 # define YY_INITIAL_VALUE(Value) Value 594 #endif 595 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 596 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 597 # define YY_IGNORE_MAYBE_UNINITIALIZED_END 598 #endif 599 #ifndef YY_INITIAL_VALUE 600 # define YY_INITIAL_VALUE(Value) /* Nothing. */ 601 #endif 602 603 604 #if ! defined yyoverflow || YYERROR_VERBOSE 605 606 /* The parser invokes alloca or malloc; define the necessary symbols. */ 607 608 # ifdef YYSTACK_USE_ALLOCA 609 # if YYSTACK_USE_ALLOCA 610 # ifdef __GNUC__ 611 # define YYSTACK_ALLOC __builtin_alloca 612 # elif defined __BUILTIN_VA_ARG_INCR 613 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 614 # elif defined _AIX 615 # define YYSTACK_ALLOC __alloca 616 # elif defined _MSC_VER 617 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 618 # define alloca _alloca 619 # else 620 # define YYSTACK_ALLOC alloca 621 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS 622 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 623 /* Use EXIT_SUCCESS as a witness for stdlib.h. */ 624 # ifndef EXIT_SUCCESS 625 # define EXIT_SUCCESS 0 626 # endif 627 # endif 628 # endif 629 # endif 630 # endif 631 632 # ifdef YYSTACK_ALLOC 633 /* Pacify GCC's 'empty if-body' warning. */ 634 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) 635 # ifndef YYSTACK_ALLOC_MAXIMUM 636 /* The OS might guarantee only one guard page at the bottom of the stack, 637 and a page size can be as small as 4096 bytes. So we cannot safely 638 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 639 to allow for a few compiler-allocated temporary stack slots. */ 640 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 641 # endif 642 # else 643 # define YYSTACK_ALLOC YYMALLOC 644 # define YYSTACK_FREE YYFREE 645 # ifndef YYSTACK_ALLOC_MAXIMUM 646 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 647 # endif 648 # if (defined __cplusplus && ! defined EXIT_SUCCESS \ 649 && ! ((defined YYMALLOC || defined malloc) \ 650 && (defined YYFREE || defined free))) 651 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 652 # ifndef EXIT_SUCCESS 653 # define EXIT_SUCCESS 0 654 # endif 655 # endif 656 # ifndef YYMALLOC 657 # define YYMALLOC malloc 658 # if ! defined malloc && ! defined EXIT_SUCCESS 659 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 660 # endif 661 # endif 662 # ifndef YYFREE 663 # define YYFREE free 664 # if ! defined free && ! defined EXIT_SUCCESS 665 void free (void *); /* INFRINGES ON USER NAME SPACE */ 666 # endif 667 # endif 668 # endif 669 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 670 671 672 #if (! defined yyoverflow \ 673 && (! defined __cplusplus \ 674 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 675 676 /* A type that is properly aligned for any stack member. */ 677 union yyalloc 678 { 679 yytype_int16 yyss_alloc; 680 YYSTYPE yyvs_alloc; 681 }; 682 683 /* The size of the maximum gap between one aligned stack and the next. */ 684 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 685 686 /* The size of an array large to enough to hold all stacks, each with 687 N elements. */ 688 # define YYSTACK_BYTES(N) \ 689 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 690 + YYSTACK_GAP_MAXIMUM) 691 692 # define YYCOPY_NEEDED 1 693 694 /* Relocate STACK from its old location to the new one. The 695 local variables YYSIZE and YYSTACKSIZE give the old and new number of 696 elements in the stack, and YYPTR gives the new location of the 697 stack. Advance YYPTR to a properly aligned location for the next 698 stack. */ 699 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 700 do \ 701 { \ 702 YYSIZE_T yynewbytes; \ 703 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 704 Stack = &yyptr->Stack_alloc; \ 705 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 706 yyptr += yynewbytes / sizeof (*yyptr); \ 707 } \ 708 while (0) 709 710 #endif 711 712 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED 713 /* Copy COUNT objects from SRC to DST. The source and destination do 714 not overlap. */ 715 # ifndef YYCOPY 716 # if defined __GNUC__ && 1 < __GNUC__ 717 # define YYCOPY(Dst, Src, Count) \ 718 __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src))) 719 # else 720 # define YYCOPY(Dst, Src, Count) \ 721 do \ 722 { \ 723 YYSIZE_T yyi; \ 724 for (yyi = 0; yyi < (Count); yyi++) \ 725 (Dst)[yyi] = (Src)[yyi]; \ 726 } \ 727 while (0) 728 # endif 729 # endif 730 #endif /* !YYCOPY_NEEDED */ 731 732 /* YYFINAL -- State number of the termination state. */ 733 #define YYFINAL 274 734 /* YYLAST -- Last index in YYTABLE. */ 735 #define YYLAST 6614 736 737 /* YYNTOKENS -- Number of terminals. */ 738 #define YYNTOKENS 298 739 /* YYNNTS -- Number of nonterminals. */ 740 #define YYNNTS 100 741 /* YYNRULES -- Number of rules. */ 742 #define YYNRULES 450 743 /* YYNSTATES -- Number of states. */ 744 #define YYNSTATES 582 745 746 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned 747 by yylex, with out-of-bounds checking. */ 748 #define YYUNDEFTOK 2 749 #define YYMAXUTOK 552 750 751 #define YYTRANSLATE(YYX) \ 752 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 753 754 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM 755 as returned by yylex, without out-of-bounds checking. */ 756 static const yytype_uint16 yytranslate[] = 757 { 758 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 759 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 760 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 761 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 762 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 763 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 764 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 765 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 766 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 767 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 768 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 769 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 770 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 771 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 772 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 773 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 774 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 775 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 776 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 777 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 778 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 779 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 780 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 781 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 782 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 783 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 784 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 785 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 786 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 787 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 788 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 789 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 790 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 791 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 792 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 793 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 794 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 795 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 796 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 797 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 798 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 799 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 800 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 801 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 802 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 803 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 804 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 805 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 806 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 807 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 808 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 809 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 810 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 811 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 812 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 813 295, 296, 297 814 }; 815 816 #if YYDEBUG 817 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ 818 static const yytype_uint16 yyrline[] = 819 { 820 0, 253, 253, 259, 262, 265, 269, 273, 277, 283, 821 289, 292, 296, 302, 305, 313, 316, 319, 322, 325, 822 330, 338, 345, 352, 358, 362, 369, 372, 378, 385, 823 395, 403, 408, 438, 444, 448, 452, 472, 473, 474, 824 475, 481, 482, 487, 492, 501, 502, 507, 515, 516, 825 522, 531, 532, 537, 542, 547, 555, 556, 564, 575, 826 576, 585, 586, 595, 596, 605, 606, 614, 615, 623, 827 624, 632, 633, 633, 651, 652, 667, 671, 675, 679, 828 684, 688, 692, 696, 700, 704, 708, 715, 718, 729, 829 736, 741, 746, 754, 758, 762, 766, 771, 776, 785, 830 785, 796, 800, 807, 814, 817, 824, 832, 852, 870, 831 885, 908, 919, 929, 939, 949, 958, 961, 965, 969, 832 974, 982, 987, 992, 997, 1002, 1011, 1022, 1049, 1058, 833 1065, 1072, 1079, 1091, 1097, 1100, 1107, 1111, 1115, 1123, 834 1132, 1135, 1146, 1149, 1152, 1156, 1160, 1164, 1171, 1175, 835 1187, 1201, 1206, 1212, 1218, 1225, 1231, 1236, 1241, 1246, 836 1254, 1258, 1262, 1266, 1270, 1274, 1280, 1289, 1292, 1300, 837 1304, 1313, 1318, 1326, 1330, 1340, 1344, 1348, 1353, 1360, 838 1364, 1369, 1374, 1379, 1386, 1393, 1397, 1402, 1407, 1412, 839 1418, 1424, 1430, 1438, 1446, 1454, 1459, 1464, 1469, 1474, 840 1479, 1484, 1490, 1496, 1502, 1510, 1518, 1526, 1532, 1538, 841 1544, 1550, 1556, 1562, 1570, 1578, 1586, 1591, 1596, 1601, 842 1606, 1611, 1616, 1621, 1626, 1631, 1636, 1641, 1646, 1652, 843 1658, 1664, 1670, 1676, 1682, 1688, 1694, 1700, 1706, 1712, 844 1718, 1726, 1734, 1742, 1750, 1758, 1766, 1774, 1782, 1790, 845 1798, 1806, 1814, 1819, 1824, 1829, 1834, 1839, 1844, 1849, 846 1854, 1859, 1864, 1869, 1874, 1879, 1884, 1889, 1894, 1899, 847 1904, 1909, 1914, 1919, 1924, 1929, 1934, 1939, 1944, 1949, 848 1954, 1959, 1964, 1969, 1974, 1979, 1984, 1989, 1994, 1999, 849 2004, 2009, 2014, 2019, 2024, 2029, 2034, 2039, 2044, 2049, 850 2054, 2059, 2064, 2069, 2074, 2079, 2084, 2089, 2094, 2099, 851 2104, 2109, 2114, 2119, 2124, 2129, 2134, 2139, 2144, 2149, 852 2154, 2159, 2164, 2169, 2174, 2179, 2184, 2189, 2194, 2199, 853 2204, 2209, 2214, 2219, 2224, 2229, 2234, 2239, 2244, 2249, 854 2254, 2259, 2264, 2269, 2274, 2279, 2284, 2289, 2294, 2299, 855 2304, 2309, 2314, 2319, 2324, 2329, 2334, 2339, 2344, 2349, 856 2354, 2359, 2365, 2371, 2377, 2383, 2389, 2395, 2401, 2406, 857 2422, 2427, 2432, 2440, 2440, 2451, 2451, 2461, 2464, 2477, 858 2495, 2519, 2523, 2529, 2534, 2545, 2548, 2554, 2563, 2566, 859 2572, 2576, 2577, 2583, 2584, 2585, 2586, 2587, 2588, 2589, 860 2593, 2594, 2598, 2594, 2610, 2611, 2615, 2615, 2622, 2622, 861 2636, 2639, 2647, 2655, 2666, 2667, 2671, 2678, 2682, 2690, 862 2694, 2707, 2707, 2727, 2730, 2736, 2748, 2760, 2760, 2775, 863 2775, 2791, 2791, 2812, 2815, 2821, 2824, 2830, 2834, 2841, 864 2846, 2851, 2858, 2861, 2870, 2874, 2883, 2886, 2889, 2897, 865 2897 866 }; 867 #endif 868 869 #if YYDEBUG || YYERROR_VERBOSE || 1 870 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 871 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 872 static const char *const yytname[] = 873 { 874 "$end", "error", "$undefined", "ATTRIBUTE", "VARYING", "CONST", "BOOL", 875 "FLOAT", "DOUBLE", "INT", "UINT", "INT64_T", "UINT64_T", "INT16_T", 876 "UINT16_T", "FLOAT16_T", "BREAK", "CONTINUE", "DO", "ELSE", "FOR", "IF", 877 "DISCARD", "RETURN", "SWITCH", "CASE", "DEFAULT", "SUBROUTINE", "BVEC2", 878 "BVEC3", "BVEC4", "IVEC2", "IVEC3", "IVEC4", "I64VEC2", "I64VEC3", 879 "I64VEC4", "UVEC2", "UVEC3", "UVEC4", "U64VEC2", "U64VEC3", "U64VEC4", 880 "VEC2", "VEC3", "VEC4", "MAT2", "MAT3", "MAT4", "CENTROID", "IN", "OUT", 881 "INOUT", "UNIFORM", "PATCH", "SAMPLE", "BUFFER", "SHARED", "COHERENT", 882 "VOLATILE", "RESTRICT", "READONLY", "WRITEONLY", "DVEC2", "DVEC3", 883 "DVEC4", "DMAT2", "DMAT3", "DMAT4", "F16VEC2", "F16VEC3", "F16VEC4", 884 "F16MAT2", "F16MAT3", "F16MAT4", "I16VEC2", "I16VEC3", "I16VEC4", 885 "U16VEC2", "U16VEC3", "U16VEC4", "NOPERSPECTIVE", "FLAT", "SMOOTH", 886 "LAYOUT", "__EXPLICITINTERPAMD", "MAT2X2", "MAT2X3", "MAT2X4", "MAT3X2", 887 "MAT3X3", "MAT3X4", "MAT4X2", "MAT4X3", "MAT4X4", "DMAT2X2", "DMAT2X3", 888 "DMAT2X4", "DMAT3X2", "DMAT3X3", "DMAT3X4", "DMAT4X2", "DMAT4X3", 889 "DMAT4X4", "F16MAT2X2", "F16MAT2X3", "F16MAT2X4", "F16MAT3X2", 890 "F16MAT3X3", "F16MAT3X4", "F16MAT4X2", "F16MAT4X3", "F16MAT4X4", 891 "ATOMIC_UINT", "SAMPLER1D", "SAMPLER2D", "SAMPLER3D", "SAMPLERCUBE", 892 "SAMPLER1DSHADOW", "SAMPLER2DSHADOW", "SAMPLERCUBESHADOW", 893 "SAMPLER1DARRAY", "SAMPLER2DARRAY", "SAMPLER1DARRAYSHADOW", 894 "SAMPLER2DARRAYSHADOW", "ISAMPLER1D", "ISAMPLER2D", "ISAMPLER3D", 895 "ISAMPLERCUBE", "ISAMPLER1DARRAY", "ISAMPLER2DARRAY", "USAMPLER1D", 896 "USAMPLER2D", "USAMPLER3D", "USAMPLERCUBE", "USAMPLER1DARRAY", 897 "USAMPLER2DARRAY", "SAMPLER2DRECT", "SAMPLER2DRECTSHADOW", 898 "ISAMPLER2DRECT", "USAMPLER2DRECT", "SAMPLERBUFFER", "ISAMPLERBUFFER", 899 "USAMPLERBUFFER", "SAMPLERCUBEARRAY", "SAMPLERCUBEARRAYSHADOW", 900 "ISAMPLERCUBEARRAY", "USAMPLERCUBEARRAY", "SAMPLER2DMS", "ISAMPLER2DMS", 901 "USAMPLER2DMS", "SAMPLER2DMSARRAY", "ISAMPLER2DMSARRAY", 902 "USAMPLER2DMSARRAY", "SAMPLEREXTERNALOES", "SAMPLER", "SAMPLERSHADOW", 903 "TEXTURE1D", "TEXTURE2D", "TEXTURE3D", "TEXTURECUBE", "TEXTURE1DARRAY", 904 "TEXTURE2DARRAY", "ITEXTURE1D", "ITEXTURE2D", "ITEXTURE3D", 905 "ITEXTURECUBE", "ITEXTURE1DARRAY", "ITEXTURE2DARRAY", "UTEXTURE1D", 906 "UTEXTURE2D", "UTEXTURE3D", "UTEXTURECUBE", "UTEXTURE1DARRAY", 907 "UTEXTURE2DARRAY", "TEXTURE2DRECT", "ITEXTURE2DRECT", "UTEXTURE2DRECT", 908 "TEXTUREBUFFER", "ITEXTUREBUFFER", "UTEXTUREBUFFER", "TEXTURECUBEARRAY", 909 "ITEXTURECUBEARRAY", "UTEXTURECUBEARRAY", "TEXTURE2DMS", "ITEXTURE2DMS", 910 "UTEXTURE2DMS", "TEXTURE2DMSARRAY", "ITEXTURE2DMSARRAY", 911 "UTEXTURE2DMSARRAY", "SUBPASSINPUT", "SUBPASSINPUTMS", "ISUBPASSINPUT", 912 "ISUBPASSINPUTMS", "USUBPASSINPUT", "USUBPASSINPUTMS", "IMAGE1D", 913 "IIMAGE1D", "UIMAGE1D", "IMAGE2D", "IIMAGE2D", "UIMAGE2D", "IMAGE3D", 914 "IIMAGE3D", "UIMAGE3D", "IMAGE2DRECT", "IIMAGE2DRECT", "UIMAGE2DRECT", 915 "IMAGECUBE", "IIMAGECUBE", "UIMAGECUBE", "IMAGEBUFFER", "IIMAGEBUFFER", 916 "UIMAGEBUFFER", "IMAGE1DARRAY", "IIMAGE1DARRAY", "UIMAGE1DARRAY", 917 "IMAGE2DARRAY", "IIMAGE2DARRAY", "UIMAGE2DARRAY", "IMAGECUBEARRAY", 918 "IIMAGECUBEARRAY", "UIMAGECUBEARRAY", "IMAGE2DMS", "IIMAGE2DMS", 919 "UIMAGE2DMS", "IMAGE2DMSARRAY", "IIMAGE2DMSARRAY", "UIMAGE2DMSARRAY", 920 "STRUCT", "VOID", "WHILE", "IDENTIFIER", "TYPE_NAME", "FLOATCONSTANT", 921 "DOUBLECONSTANT", "INTCONSTANT", "UINTCONSTANT", "INT64CONSTANT", 922 "UINT64CONSTANT", "INT16CONSTANT", "UINT16CONSTANT", "BOOLCONSTANT", 923 "FLOAT16CONSTANT", "LEFT_OP", "RIGHT_OP", "INC_OP", "DEC_OP", "LE_OP", 924 "GE_OP", "EQ_OP", "NE_OP", "AND_OP", "OR_OP", "XOR_OP", "MUL_ASSIGN", 925 "DIV_ASSIGN", "ADD_ASSIGN", "MOD_ASSIGN", "LEFT_ASSIGN", "RIGHT_ASSIGN", 926 "AND_ASSIGN", "XOR_ASSIGN", "OR_ASSIGN", "SUB_ASSIGN", "LEFT_PAREN", 927 "RIGHT_PAREN", "LEFT_BRACKET", "RIGHT_BRACKET", "LEFT_BRACE", 928 "RIGHT_BRACE", "DOT", "COMMA", "COLON", "EQUAL", "SEMICOLON", "BANG", 929 "DASH", "TILDE", "PLUS", "STAR", "SLASH", "PERCENT", "LEFT_ANGLE", 930 "RIGHT_ANGLE", "VERTICAL_BAR", "CARET", "AMPERSAND", "QUESTION", 931 "INVARIANT", "PRECISE", "HIGH_PRECISION", "MEDIUM_PRECISION", 932 "LOW_PRECISION", "PRECISION", "PACKED", "RESOURCE", "SUPERP", "$accept", 933 "variable_identifier", "primary_expression", "postfix_expression", 934 "integer_expression", "function_call", "function_call_or_method", 935 "function_call_generic", "function_call_header_no_parameters", 936 "function_call_header_with_parameters", "function_call_header", 937 "function_identifier", "unary_expression", "unary_operator", 938 "multiplicative_expression", "additive_expression", "shift_expression", 939 "relational_expression", "equality_expression", "and_expression", 940 "exclusive_or_expression", "inclusive_or_expression", 941 "logical_and_expression", "logical_xor_expression", 942 "logical_or_expression", "conditional_expression", "$@1", 943 "assignment_expression", "assignment_operator", "expression", 944 "constant_expression", "declaration", "block_structure", "$@2", 945 "identifier_list", "function_prototype", "function_declarator", 946 "function_header_with_parameters", "function_header", 947 "parameter_declarator", "parameter_declaration", 948 "parameter_type_specifier", "init_declarator_list", "single_declaration", 949 "fully_specified_type", "invariant_qualifier", "interpolation_qualifier", 950 "layout_qualifier", "layout_qualifier_id_list", "layout_qualifier_id", 951 "precise_qualifier", "type_qualifier", "single_type_qualifier", 952 "storage_qualifier", "type_name_list", "type_specifier", 953 "array_specifier", "type_specifier_nonarray", "precision_qualifier", 954 "struct_specifier", "$@3", "$@4", "struct_declaration_list", 955 "struct_declaration", "struct_declarator_list", "struct_declarator", 956 "initializer", "initializer_list", "declaration_statement", "statement", 957 "simple_statement", "compound_statement", "$@5", "$@6", 958 "statement_no_new_scope", "statement_scoped", "$@7", "$@8", 959 "compound_statement_no_new_scope", "statement_list", 960 "expression_statement", "selection_statement", 961 "selection_rest_statement", "condition", "switch_statement", "$@9", 962 "switch_statement_list", "case_label", "iteration_statement", "$@10", 963 "$@11", "$@12", "for_init_statement", "conditionopt", 964 "for_rest_statement", "jump_statement", "translation_unit", 965 "external_declaration", "function_definition", "$@13", YY_NULLPTR 966 }; 967 #endif 968 969 # ifdef YYPRINT 970 /* YYTOKNUM[NUM] -- (External) token number corresponding to the 971 (internal) symbol number NUM (which must be that of a token). */ 972 static const yytype_uint16 yytoknum[] = 973 { 974 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 975 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 976 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 977 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 978 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 979 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 980 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 981 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 982 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 983 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 984 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 985 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 986 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 987 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 988 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 989 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 990 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 991 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 992 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 993 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 994 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 995 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 996 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 997 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 998 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 999 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 1000 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 1001 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 1002 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 1003 545, 546, 547, 548, 549, 550, 551, 552 1004 }; 1005 # endif 1006 1007 #define YYPACT_NINF -525 1008 1009 #define yypact_value_is_default(Yystate) \ 1010 (!!((Yystate) == (-525))) 1011 1012 #define YYTABLE_NINF -407 1013 1014 #define yytable_value_is_error(Yytable_value) \ 1015 0 1016 1017 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 1018 STATE-NUM. */ 1019 static const yytype_int16 yypact[] = 1020 { 1021 2619, -525, -525, -525, -525, -525, -525, -525, -525, -525, 1022 -525, -525, -525, -525, -243, -525, -525, -525, -525, -525, 1023 -525, -525, -525, -525, -525, -525, -525, -525, -525, -525, 1024 -525, -525, -525, -525, -525, -525, -525, -525, -525, -525, 1025 -525, -525, -525, -525, -525, -525, -525, -525, -525, -525, 1026 -525, -525, -525, -525, -525, -525, -525, -525, -525, -525, 1027 -525, -525, -525, -525, -525, -525, -525, -525, -525, -525, 1028 -525, -228, -525, -525, -525, -525, -525, -525, -525, -525, 1029 -525, -525, -525, -525, -525, -525, -525, -525, -525, -525, 1030 -525, -525, -525, -525, -525, -525, -525, -525, -525, -525, 1031 -525, -525, -525, -525, -525, -525, -525, -525, -525, -525, 1032 -525, -525, -525, -525, -525, -525, -525, -525, -525, -525, 1033 -525, -525, -525, -525, -525, -525, -525, -525, -525, -525, 1034 -525, -525, -525, -525, -525, -525, -525, -525, -525, -525, 1035 -525, -525, -525, -525, -525, -525, -525, -525, -525, -525, 1036 -525, -525, -525, -525, -525, -525, -525, -525, -525, -525, 1037 -525, -525, -525, -525, -525, -525, -525, -525, -525, -525, 1038 -525, -525, -525, -525, -525, -525, -525, -525, -525, -525, 1039 -525, -525, -525, -525, -525, -525, -525, -525, -525, -525, 1040 -525, -525, -525, -525, -525, -525, -525, -525, -525, -525, 1041 -525, -525, -525, -525, -525, -525, -525, -525, -525, -525, 1042 -525, -525, -525, -525, -525, -525, -215, -525, -525, -525, 1043 -525, -525, -525, -525, -525, -157, -525, -216, -218, -205, 1044 -141, 4260, -165, -525, -94, -525, -525, -525, -525, 3183, 1045 -525, -525, -525, -117, -525, -525, 575, -525, -525, -80, 1046 -48, -114, -525, 6381, -242, -525, -525, -113, -525, 4260, 1047 -525, -525, -525, 4260, -75, -74, -525, -235, -190, -525, 1048 -525, -525, 4765, -108, -525, -525, -525, -186, -525, -112, 1049 -178, -525, -525, 4260, -115, -525, -226, 867, -525, -525, 1050 -525, -525, -117, -229, -525, 5039, -224, -525, -71, -525, 1051 -158, -525, -525, -525, -525, -525, -525, -525, -525, -525, 1052 -525, -525, 5861, 5861, 5861, -525, -525, -525, -525, -525, 1053 -525, -525, -223, -525, -525, -525, -102, -177, 6121, -100, 1054 -525, 5861, -204, -171, -132, -221, -199, -124, -120, -111, 1055 -84, -83, -233, -98, -525, 5313, -525, -60, 5861, -525, 1056 -48, 4260, 4260, -59, 3456, -525, -525, -525, -99, -97, 1057 -525, -90, -88, -96, 5587, -85, 5861, -92, -79, -81, 1058 -525, -525, -191, -525, -525, -153, -525, -218, -78, -525, 1059 -525, -525, -525, 1159, -525, -525, -525, -525, -525, -525, 1060 -108, 5039, -193, 5039, -525, -525, 5039, 4260, -525, -47, 1061 -525, -525, -525, -176, -525, -525, 5861, -42, -525, -525, 1062 5861, -73, -525, -525, -525, 5861, 5861, 5861, 5861, 5861, 1063 5861, 5861, 5861, 5861, 5861, 5861, 5861, 5861, 5861, 5861, 1064 5861, 5861, 5861, 5861, -525, -525, -525, -76, -525, -525, 1065 -525, -525, 3724, -59, -117, -152, -525, -525, -525, -525, 1066 -525, 1451, -525, 5861, -525, -525, -143, 5861, -180, -525, 1067 -525, -525, 1451, -525, -525, -525, -525, -525, -525, -525, 1068 -525, -525, -525, -525, 5861, 5861, -525, -525, -525, -525, 1069 5039, -525, -133, -525, 3992, -525, -525, -72, -77, -525, 1070 -525, -525, -525, -525, -204, -204, -171, -171, -132, -132, 1071 -132, -132, -221, -221, -199, -124, -120, -111, -84, -83, 1072 5861, -525, -525, -142, -108, -59, -525, -37, 2327, -175, 1073 -525, -163, -525, 2892, 1451, -525, -525, -525, -525, 4491, 1074 -525, -525, -129, -525, -525, -68, -525, -525, 2892, -70, 1075 -525, -77, -32, 4260, -63, -66, -525, -525, 5861, 5861, 1076 -525, -69, -61, 188, -58, 2035, -525, -56, -57, 1743, 1077 -525, -525, -161, 5861, 1743, -70, -525, -525, 1451, 5039, 1078 -525, -525, -525, -67, -77, -525, -525, 1451, -54, -525, 1079 -525, -525 1080 }; 1081 1082 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. 1083 Performed when YYTABLE does not specify something else to do. Zero 1084 means the default is an error. */ 1085 static const yytype_uint16 yydefact[] = 1086 { 1087 0, 149, 150, 148, 185, 176, 177, 179, 180, 181, 1088 182, 183, 184, 178, 165, 195, 196, 197, 198, 199, 1089 200, 201, 202, 203, 207, 208, 209, 210, 211, 212, 1090 186, 187, 188, 216, 217, 218, 154, 152, 153, 151, 1091 157, 155, 156, 158, 159, 160, 161, 162, 163, 164, 1092 189, 190, 191, 228, 229, 230, 192, 193, 194, 240, 1093 241, 242, 204, 205, 206, 213, 214, 215, 131, 130, 1094 129, 0, 132, 219, 220, 221, 222, 223, 224, 225, 1095 226, 227, 231, 232, 233, 234, 235, 236, 237, 238, 1096 239, 243, 244, 245, 246, 247, 248, 249, 250, 251, 1097 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 1098 262, 263, 266, 267, 268, 269, 270, 271, 273, 274, 1099 275, 276, 277, 278, 280, 281, 282, 283, 284, 285, 1100 286, 264, 265, 272, 279, 287, 288, 289, 290, 291, 1101 292, 361, 293, 294, 295, 296, 297, 298, 299, 300, 1102 302, 303, 304, 305, 306, 307, 309, 310, 311, 312, 1103 313, 314, 316, 317, 318, 319, 320, 321, 301, 308, 1104 315, 322, 323, 324, 325, 326, 327, 362, 363, 364, 1105 365, 366, 367, 328, 329, 330, 331, 332, 333, 334, 1106 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 1107 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 1108 355, 356, 357, 358, 359, 360, 0, 175, 369, 448, 1109 128, 139, 370, 371, 372, 0, 447, 0, 449, 0, 1110 105, 104, 0, 116, 121, 146, 145, 143, 147, 0, 1111 140, 142, 126, 169, 144, 368, 0, 444, 446, 0, 1112 0, 0, 375, 0, 0, 93, 90, 0, 103, 0, 1113 112, 106, 114, 0, 115, 0, 91, 122, 0, 96, 1114 141, 127, 0, 170, 1, 445, 167, 0, 138, 136, 1115 0, 134, 373, 0, 0, 94, 0, 0, 450, 107, 1116 111, 113, 109, 117, 108, 0, 123, 99, 0, 97, 1117 0, 2, 10, 11, 4, 5, 6, 7, 8, 9, 1118 13, 12, 0, 0, 0, 171, 39, 38, 40, 37, 1119 3, 15, 33, 17, 22, 23, 0, 0, 27, 0, 1120 41, 0, 45, 48, 51, 56, 59, 61, 63, 65, 1121 67, 69, 71, 0, 31, 0, 166, 0, 0, 133, 1122 0, 0, 0, 0, 0, 377, 92, 95, 0, 0, 1123 429, 0, 0, 0, 0, 0, 0, 0, 0, 401, 1124 410, 414, 41, 74, 87, 0, 390, 0, 126, 393, 1125 412, 392, 391, 0, 394, 395, 396, 397, 398, 399, 1126 110, 0, 118, 0, 385, 125, 0, 0, 101, 0, 1127 98, 34, 35, 0, 19, 20, 0, 0, 25, 24, 1128 0, 175, 28, 30, 36, 0, 0, 0, 0, 0, 1129 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1130 0, 0, 0, 0, 72, 172, 173, 0, 168, 89, 1131 137, 135, 0, 0, 383, 0, 381, 376, 378, 440, 1132 439, 0, 431, 0, 443, 441, 0, 0, 0, 426, 1133 427, 400, 0, 77, 78, 80, 79, 82, 83, 84, 1134 85, 86, 81, 76, 0, 0, 415, 411, 413, 120, 1135 0, 388, 0, 124, 0, 102, 14, 0, 21, 18, 1136 29, 42, 43, 44, 47, 46, 49, 50, 54, 55, 1137 52, 53, 57, 58, 60, 62, 64, 66, 68, 70, 1138 0, 174, 374, 0, 384, 0, 379, 0, 0, 0, 1139 442, 0, 425, 0, 402, 75, 88, 119, 386, 0, 1140 100, 16, 0, 380, 382, 0, 434, 433, 436, 408, 1141 421, 419, 0, 0, 0, 0, 387, 389, 0, 0, 1142 435, 0, 0, 418, 0, 0, 416, 0, 0, 0, 1143 403, 73, 0, 437, 0, 408, 407, 409, 423, 0, 1144 405, 428, 404, 0, 438, 432, 417, 424, 0, 420, 1145 430, 422 1146 }; 1147 1148 /* YYPGOTO[NTERM-NUM]. */ 1149 static const yytype_int16 yypgoto[] = 1150 { 1151 -525, -525, -525, -525, -525, -525, -525, -525, -525, -525, 1152 -525, -525, -103, -525, -278, -274, -297, -273, -214, -211, 1153 -210, -212, -209, -208, -525, -261, -525, -292, -525, -308, 1154 -525, 4, -525, -525, -525, 5, -525, -525, -525, -41, 1155 -38, -39, -525, -525, -504, -525, -525, -525, -525, -123, 1156 -525, -230, -237, -525, -525, 0, -246, -525, 1, -525, 1157 -525, -525, -337, -342, -207, -286, -378, -525, -285, -376, 1158 -524, -322, -525, -525, -330, -327, -525, -525, -22, -452, 1159 -275, -525, -525, -298, -525, -525, -525, -525, -525, -525, 1160 -525, -525, -525, -525, -525, -525, -525, -2, -525, -525 1161 }; 1162 1163 /* YYDEFGOTO[NTERM-NUM]. */ 1164 static const yytype_int16 yydefgoto[] = 1165 { 1166 -1, 320, 321, 322, 487, 323, 324, 325, 326, 327, 1167 328, 329, 372, 331, 332, 333, 334, 335, 336, 337, 1168 338, 339, 340, 341, 342, 373, 510, 374, 474, 375, 1169 440, 376, 227, 397, 300, 377, 229, 230, 231, 260, 1170 261, 262, 232, 233, 234, 235, 236, 237, 280, 281, 1171 238, 239, 240, 241, 277, 344, 273, 243, 244, 245, 1172 351, 283, 354, 355, 445, 446, 395, 482, 379, 380, 1173 381, 382, 462, 545, 571, 553, 554, 555, 572, 383, 1174 384, 385, 556, 544, 386, 557, 578, 387, 388, 523, 1175 451, 518, 538, 551, 552, 389, 246, 247, 248, 257 1176 }; 1177 1178 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If 1179 positive, shift that token. If negative, reduce the rule whose 1180 number is the opposite. If YYTABLE_NINF, syntax error. */ 1181 static const yytype_int16 yytable[] = 1182 { 1183 242, 263, 270, 394, 226, 228, 403, 478, 286, 278, 1184 524, 343, 448, 479, 442, 481, 254, 251, 483, 542, 1185 433, 296, 249, 404, 405, 272, 270, 422, 423, 263, 1186 294, 567, 272, 285, 542, 570, 412, 250, 272, 295, 1187 570, 345, -32, 345, 406, 391, 390, 392, 407, 357, 1188 396, 426, 427, 352, 252, 434, 456, 256, 458, 255, 1189 484, 258, 424, 425, 463, 464, 465, 466, 467, 468, 1190 469, 470, 471, 472, 345, 517, 415, 416, 417, 297, 1191 346, 480, 298, 473, 437, 299, 347, 439, 349, 409, 1192 486, 539, 475, 522, 350, 410, 475, 475, 488, 394, 1193 448, 394, 527, 540, 394, 573, 418, 265, 419, 475, 1194 266, 475, 420, 421, 399, 270, 577, 400, 490, 475, 1195 515, 352, 476, 516, 352, 498, 499, 500, 501, 475, 1196 515, 259, 520, 533, 222, 223, 224, 528, 267, 529, 1197 494, 495, 448, 475, 548, 519, 496, 497, 478, 521, 1198 272, 547, 276, 502, 503, 282, 287, 292, 293, 345, 1199 356, 398, 348, 428, 408, 413, 429, 352, 431, 330, 1200 435, 432, 438, 444, 430, 452, 449, 453, 450, 454, 1201 457, 459, 525, 526, 279, 485, 460, -31, 394, 461, 1202 489, 579, 511, -26, 535, 475, 531, 549, 514, -406, 1203 558, 478, 532, 559, 560, 564, 563, 565, 580, 401, 1204 402, 369, 352, 568, 504, 541, 581, 569, 505, 507, 1205 506, 289, 290, 508, 291, 509, 253, 441, 414, 534, 1206 541, 264, 566, 536, 575, 288, 513, 394, 576, 271, 1207 550, 562, 330, 537, 275, 330, 242, 0, 0, 0, 1208 226, 228, 0, 284, 352, 574, 561, 0, 0, 264, 1209 0, 0, 0, 264, 0, 0, 0, 0, 0, 0, 1210 0, 0, 0, 0, 0, 0, 0, 394, 0, 0, 1211 0, 0, 0, 353, 0, 0, 0, 378, 0, 0, 1212 0, 0, 0, 543, 0, 0, 0, 0, 0, 0, 1213 0, 0, 0, 0, 0, 0, 270, 0, 543, 0, 1214 0, 0, 491, 492, 493, 330, 330, 330, 330, 330, 1215 330, 330, 330, 330, 330, 330, 330, 330, 330, 330, 1216 330, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1217 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1218 0, 353, 443, 0, 353, 0, 0, 0, 0, 0, 1219 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1220 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1221 0, 0, 0, 378, 0, 0, 0, 0, 0, 0, 1222 0, 0, 0, 0, 0, 0, 0, 353, 0, 0, 1223 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1224 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1225 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1226 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1227 0, 0, 353, 0, 0, 0, 0, 0, 0, 0, 1228 0, 378, 0, 0, 0, 0, 0, 0, 0, 0, 1229 0, 0, 378, 0, 0, 0, 0, 0, 0, 0, 1230 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1231 0, 0, 0, 0, 353, 0, 0, 0, 0, 0, 1232 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1233 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1234 0, 0, 0, 0, 0, 0, 0, 0, 378, 0, 1235 0, 0, 0, 378, 378, 0, 0, 0, 0, 0, 1236 0, 0, 0, 0, 0, 0, 0, 0, 378, 0, 1237 0, 0, 0, 271, 0, 0, 0, 0, 0, 0, 1238 0, 0, 0, 0, 0, 378, 0, 0, 0, 378, 1239 0, 0, 0, 0, 378, 0, 0, 0, 378, 0, 1240 0, 0, 0, 0, 0, 274, 0, 378, 1, 2, 1241 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 1242 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1243 0, 0, 14, 15, 16, 17, 18, 19, 20, 21, 1244 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 1245 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 1246 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 1247 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 1248 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 1249 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 1250 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 1251 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 1252 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 1253 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 1254 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 1255 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 1256 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 1257 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 1258 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 1259 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 1260 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 1261 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 1262 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 1263 212, 213, 214, 215, 216, 217, 0, 0, 218, 0, 1264 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1265 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1266 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1267 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1268 219, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1269 0, 0, 0, 0, 220, 221, 222, 223, 224, 225, 1270 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1271 11, 12, 13, 358, 359, 360, 0, 361, 362, 363, 1272 364, 365, 366, 367, 14, 15, 16, 17, 18, 19, 1273 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 1274 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 1275 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 1276 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 1277 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 1278 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 1279 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 1280 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 1281 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 1282 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 1283 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 1284 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 1285 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 1286 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 1287 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 1288 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 1289 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 1290 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 1291 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 1292 210, 211, 212, 213, 214, 215, 216, 217, 368, 301, 1293 218, 302, 303, 304, 305, 306, 307, 308, 309, 310, 1294 311, 0, 0, 312, 313, 0, 0, 0, 0, 0, 1295 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1296 0, 0, 314, 0, 0, 0, 369, 370, 0, 0, 1297 0, 0, 371, 316, 317, 318, 319, 0, 0, 0, 1298 0, 0, 0, 0, 0, 0, 220, 221, 222, 223, 1299 224, 225, 1, 2, 3, 4, 5, 6, 7, 8, 1300 9, 10, 11, 12, 13, 358, 359, 360, 0, 361, 1301 362, 363, 364, 365, 366, 367, 14, 15, 16, 17, 1302 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 1303 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 1304 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 1305 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 1306 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 1307 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 1308 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 1309 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 1310 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 1311 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 1312 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 1313 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 1314 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 1315 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 1316 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 1317 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 1318 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 1319 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 1320 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 1321 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 1322 368, 301, 218, 302, 303, 304, 305, 306, 307, 308, 1323 309, 310, 311, 0, 0, 312, 313, 0, 0, 0, 1324 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1325 0, 0, 0, 0, 314, 0, 0, 0, 369, 477, 1326 0, 0, 0, 0, 371, 316, 317, 318, 319, 0, 1327 0, 0, 0, 0, 0, 0, 0, 0, 220, 221, 1328 222, 223, 224, 225, 1, 2, 3, 4, 5, 6, 1329 7, 8, 9, 10, 11, 12, 13, 358, 359, 360, 1330 0, 361, 362, 363, 364, 365, 366, 367, 14, 15, 1331 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 1332 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 1333 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 1334 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 1335 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 1336 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 1337 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 1338 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 1339 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 1340 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 1341 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 1342 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 1343 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 1344 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 1345 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 1346 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 1347 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 1348 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 1349 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 1350 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 1351 216, 217, 368, 301, 218, 302, 303, 304, 305, 306, 1352 307, 308, 309, 310, 311, 0, 0, 312, 313, 0, 1353 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1354 0, 0, 0, 0, 0, 0, 314, 0, 0, 0, 1355 369, 0, 0, 0, 0, 0, 371, 316, 317, 318, 1356 319, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1357 220, 221, 222, 223, 224, 225, 1, 2, 3, 4, 1358 5, 6, 7, 8, 9, 10, 11, 12, 13, 358, 1359 359, 360, 0, 361, 362, 363, 364, 365, 366, 367, 1360 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 1361 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 1362 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 1363 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 1364 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 1365 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 1366 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 1367 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 1368 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 1369 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 1370 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 1371 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 1372 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 1373 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 1374 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 1375 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 1376 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 1377 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 1378 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 1379 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 1380 214, 215, 216, 217, 368, 301, 218, 302, 303, 304, 1381 305, 306, 307, 308, 309, 310, 311, 0, 0, 312, 1382 313, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1383 0, 0, 0, 0, 0, 0, 0, 0, 314, 0, 1384 0, 0, 287, 0, 0, 0, 0, 0, 371, 316, 1385 317, 318, 319, 0, 0, 0, 0, 0, 0, 0, 1386 0, 0, 220, 221, 222, 223, 224, 225, 1, 2, 1387 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 1388 13, 358, 359, 360, 0, 361, 362, 363, 364, 365, 1389 366, 367, 14, 15, 16, 17, 18, 19, 20, 21, 1390 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 1391 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 1392 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 1393 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 1394 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 1395 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 1396 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 1397 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 1398 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 1399 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 1400 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 1401 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 1402 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 1403 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 1404 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 1405 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 1406 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 1407 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 1408 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 1409 212, 213, 214, 215, 216, 217, 368, 301, 218, 302, 1410 303, 304, 305, 306, 307, 308, 309, 310, 311, 0, 1411 0, 312, 313, 0, 0, 0, 0, 0, 0, 0, 1412 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1413 314, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1414 371, 316, 317, 318, 319, 0, 0, 0, 0, 0, 1415 0, 0, 0, 0, 220, 221, 222, 223, 224, 225, 1416 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1417 11, 12, 13, 0, 0, 0, 0, 0, 0, 0, 1418 0, 0, 0, 0, 14, 15, 16, 17, 18, 19, 1419 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 1420 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 1421 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 1422 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 1423 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 1424 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 1425 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 1426 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 1427 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 1428 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 1429 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 1430 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 1431 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 1432 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 1433 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 1434 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 1435 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 1436 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 1437 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 1438 210, 211, 212, 213, 214, 215, 216, 217, 0, 301, 1439 218, 302, 303, 304, 305, 306, 307, 308, 309, 310, 1440 311, 0, 0, 312, 313, 0, 0, 0, 0, 0, 1441 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1442 0, 0, 314, 0, 0, 0, 0, 0, 0, 0, 1443 0, 0, 371, 316, 317, 318, 319, 0, 0, 0, 1444 0, 0, 0, 0, 0, 0, 220, 221, 222, 223, 1445 224, 225, 1, 2, 3, 4, 5, 6, 7, 8, 1446 9, 10, 11, 12, 13, 0, 0, 0, 0, 0, 1447 0, 0, 0, 0, 0, 0, 14, 15, 16, 17, 1448 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 1449 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 1450 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 1451 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 1452 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 1453 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 1454 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 1455 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 1456 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 1457 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 1458 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 1459 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 1460 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 1461 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 1462 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 1463 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 1464 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 1465 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 1466 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 1467 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 1468 0, 0, 218, 0, 0, 0, 0, 0, 0, 0, 1469 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1470 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1471 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1472 0, 0, 0, 0, 219, 1, 2, 3, 4, 5, 1473 6, 7, 8, 9, 10, 11, 12, 13, 220, 221, 1474 222, 223, 224, 225, 0, 0, 0, 0, 0, 14, 1475 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 1476 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 1477 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 1478 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 1479 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 1480 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 1481 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 1482 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 1483 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 1484 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 1485 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 1486 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 1487 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 1488 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 1489 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 1490 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 1491 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 1492 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 1493 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 1494 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 1495 215, 216, 217, 0, 301, 218, 302, 303, 304, 305, 1496 306, 307, 308, 309, 310, 311, 0, 0, 312, 313, 1497 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1498 0, 0, 0, 0, 0, 0, 0, 314, 0, 0, 1499 0, 0, 0, 0, 0, 0, 0, 0, 316, 317, 1500 318, 319, 0, 0, 0, 0, 0, 0, 0, 0, 1501 0, 220, 221, 222, 223, 224, 1, 2, 3, 4, 1502 5, 6, 7, 8, 9, 10, 11, 12, 13, 0, 1503 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1504 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 1505 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 1506 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 1507 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 1508 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 1509 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 1510 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 1511 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 1512 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 1513 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 1514 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 1515 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 1516 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 1517 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 1518 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 1519 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 1520 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 1521 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 1522 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 1523 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 1524 214, 215, 216, 217, 0, 268, 218, 0, 0, 0, 1525 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1526 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1527 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1528 0, 0, 0, 0, 0, 0, 0, 0, 269, 1, 1529 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 1530 12, 13, 220, 221, 222, 223, 224, 0, 0, 0, 1531 0, 0, 0, 14, 15, 16, 17, 18, 19, 20, 1532 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 1533 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 1534 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 1535 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 1536 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 1537 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 1538 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 1539 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 1540 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 1541 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 1542 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 1543 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 1544 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 1545 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 1546 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 1547 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 1548 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 1549 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 1550 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 1551 211, 212, 213, 214, 215, 216, 217, 0, 0, 218, 1552 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1553 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1554 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1555 0, 0, 0, 0, 0, 0, 447, 1, 2, 3, 1556 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1557 0, 0, 0, 0, 0, 220, 221, 222, 223, 224, 1558 0, 14, 15, 16, 17, 18, 19, 20, 21, 22, 1559 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 1560 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 1561 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 1562 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 1563 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 1564 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 1565 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 1566 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 1567 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 1568 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 1569 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 1570 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 1571 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 1572 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 1573 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 1574 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 1575 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 1576 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 1577 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 1578 213, 214, 215, 216, 217, 0, 0, 218, 0, 0, 1579 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1580 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1581 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1582 0, 0, 0, 0, 512, 1, 2, 3, 4, 5, 1583 6, 7, 8, 9, 10, 11, 12, 13, 0, 0, 1584 0, 0, 0, 220, 221, 222, 223, 224, 0, 14, 1585 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 1586 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 1587 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 1588 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 1589 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 1590 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 1591 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 1592 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 1593 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 1594 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 1595 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 1596 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 1597 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 1598 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 1599 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 1600 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 1601 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 1602 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 1603 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 1604 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 1605 215, 216, 217, 0, 0, 218, 0, 0, 0, 0, 1606 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1607 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1608 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1609 0, 0, 530, 1, 2, 3, 4, 5, 6, 7, 1610 8, 9, 10, 11, 12, 13, 0, 0, 0, 0, 1611 0, 220, 221, 222, 223, 224, 0, 14, 15, 16, 1612 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 1613 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 1614 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 1615 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 1616 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 1617 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 1618 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 1619 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 1620 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 1621 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 1622 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 1623 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 1624 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 1625 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 1626 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 1627 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 1628 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 1629 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 1630 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 1631 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 1632 217, 0, 0, 218, 0, 0, 0, 4, 5, 6, 1633 7, 8, 9, 10, 11, 12, 13, 0, 0, 0, 1634 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 1635 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 1636 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 1637 0, 0, 0, 0, 0, 0, 0, 0, 0, 220, 1638 221, 222, 223, 224, 50, 51, 52, 53, 54, 55, 1639 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 1640 66, 67, 0, 0, 0, 0, 0, 73, 74, 75, 1641 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 1642 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 1643 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 1644 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 1645 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 1646 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 1647 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 1648 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 1649 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 1650 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 1651 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 1652 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 1653 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 1654 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 1655 216, 217, 0, 301, 218, 302, 303, 304, 305, 306, 1656 307, 308, 309, 310, 311, 0, 0, 312, 313, 0, 1657 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1658 0, 0, 0, 0, 0, 0, 314, 0, 0, 0, 1659 393, 546, 0, 0, 0, 0, 0, 316, 317, 318, 1660 319, 4, 5, 6, 7, 8, 9, 10, 11, 12, 1661 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1662 0, 0, 0, 15, 16, 17, 18, 19, 20, 21, 1663 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 1664 32, 33, 34, 35, 0, 0, 0, 0, 0, 0, 1665 0, 0, 0, 0, 0, 0, 0, 0, 50, 51, 1666 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 1667 62, 63, 64, 65, 66, 67, 0, 0, 0, 0, 1668 0, 73, 74, 75, 76, 77, 78, 79, 80, 81, 1669 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 1670 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 1671 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 1672 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 1673 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 1674 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 1675 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 1676 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 1677 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 1678 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 1679 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 1680 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 1681 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 1682 212, 213, 214, 215, 216, 217, 0, 301, 218, 302, 1683 303, 304, 305, 306, 307, 308, 309, 310, 311, 0, 1684 0, 312, 313, 0, 0, 0, 0, 0, 0, 0, 1685 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1686 314, 0, 0, 315, 0, 0, 0, 0, 0, 0, 1687 0, 316, 317, 318, 319, 4, 5, 6, 7, 8, 1688 9, 10, 11, 12, 13, 0, 0, 0, 0, 0, 1689 0, 0, 0, 0, 0, 0, 0, 15, 16, 17, 1690 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 1691 28, 29, 30, 31, 32, 33, 34, 35, 0, 0, 1692 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1693 0, 0, 50, 51, 52, 53, 54, 55, 56, 57, 1694 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 1695 0, 0, 0, 0, 0, 73, 74, 75, 76, 77, 1696 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 1697 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 1698 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 1699 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 1700 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 1701 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 1702 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 1703 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 1704 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 1705 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 1706 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 1707 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 1708 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 1709 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 1710 0, 301, 218, 302, 303, 304, 305, 306, 307, 308, 1711 309, 310, 311, 0, 0, 312, 313, 0, 0, 0, 1712 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1713 0, 0, 0, 0, 314, 0, 0, 0, 393, 0, 1714 0, 0, 0, 0, 0, 316, 317, 318, 319, 4, 1715 5, 6, 7, 8, 9, 10, 11, 12, 13, 0, 1716 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1717 0, 15, 16, 17, 18, 19, 20, 21, 22, 23, 1718 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 1719 34, 35, 0, 0, 0, 0, 0, 0, 0, 0, 1720 0, 0, 0, 0, 0, 0, 50, 51, 52, 53, 1721 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 1722 64, 65, 66, 67, 0, 0, 0, 0, 0, 73, 1723 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 1724 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 1725 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 1726 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 1727 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 1728 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 1729 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 1730 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 1731 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 1732 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 1733 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 1734 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 1735 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 1736 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 1737 214, 215, 216, 217, 0, 301, 218, 302, 303, 304, 1738 305, 306, 307, 308, 309, 310, 311, 0, 0, 312, 1739 313, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1740 0, 0, 0, 0, 0, 0, 0, 0, 314, 0, 1741 0, 436, 0, 0, 0, 0, 0, 0, 0, 316, 1742 317, 318, 319, 4, 5, 6, 7, 8, 9, 10, 1743 11, 12, 13, 0, 0, 0, 0, 0, 0, 0, 1744 0, 0, 0, 0, 0, 15, 16, 17, 18, 19, 1745 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 1746 30, 31, 32, 33, 34, 35, 0, 0, 0, 0, 1747 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1748 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 1749 60, 61, 62, 63, 64, 65, 66, 67, 0, 0, 1750 0, 0, 0, 73, 74, 75, 76, 77, 78, 79, 1751 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 1752 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 1753 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 1754 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 1755 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 1756 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 1757 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 1758 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 1759 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 1760 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 1761 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 1762 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 1763 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 1764 210, 211, 212, 213, 214, 215, 216, 217, 0, 301, 1765 218, 302, 303, 304, 305, 306, 307, 308, 309, 310, 1766 311, 0, 0, 312, 313, 0, 0, 0, 0, 0, 1767 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1768 0, 0, 314, 0, 0, 0, 0, 0, 0, 0, 1769 0, 0, 455, 316, 317, 318, 319, 4, 5, 6, 1770 7, 8, 9, 10, 11, 12, 13, 0, 0, 0, 1771 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 1772 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 1773 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 1774 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1775 0, 0, 0, 0, 50, 51, 52, 53, 54, 55, 1776 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 1777 66, 67, 0, 0, 0, 0, 0, 73, 74, 75, 1778 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 1779 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 1780 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 1781 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 1782 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 1783 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 1784 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 1785 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 1786 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 1787 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 1788 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 1789 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 1790 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 1791 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 1792 216, 217, 0, 301, 218, 302, 303, 304, 305, 306, 1793 307, 308, 309, 310, 311, 0, 0, 312, 313, 0, 1794 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1795 0, 0, 0, 0, 0, 0, 314, 4, 5, 6, 1796 7, 8, 9, 10, 11, 12, 13, 316, 317, 318, 1797 319, 0, 0, 0, 0, 0, 0, 0, 0, 15, 1798 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 1799 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 1800 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1801 0, 0, 0, 0, 50, 51, 52, 53, 54, 55, 1802 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 1803 66, 67, 0, 0, 0, 0, 0, 73, 74, 75, 1804 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 1805 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 1806 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 1807 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 1808 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 1809 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 1810 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 1811 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 1812 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 1813 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 1814 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 1815 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 1816 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 1817 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 1818 216, 411, 0, 301, 218, 302, 303, 304, 305, 306, 1819 307, 308, 309, 310, 311, 0, 0, 312, 313, 0, 1820 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1821 0, 0, 0, 0, 0, 0, 314, 4, 5, 6, 1822 7, 8, 9, 10, 11, 12, 13, 316, 317, 318, 1823 319, 0, 0, 0, 0, 0, 0, 0, 0, 15, 1824 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 1825 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 1826 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1827 0, 0, 0, 0, 50, 51, 52, 53, 54, 55, 1828 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 1829 66, 67, 0, 0, 0, 0, 0, 73, 74, 75, 1830 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 1831 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 1832 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 1833 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 1834 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 1835 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 1836 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 1837 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 1838 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 1839 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 1840 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 1841 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 1842 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 1843 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 1844 216, 217, 0, 0, 218 1845 }; 1846 1847 static const yytype_int16 yycheck[] = 1848 { 1849 0, 231, 239, 295, 0, 0, 314, 383, 254, 57, 1850 462, 272, 354, 391, 351, 393, 232, 232, 396, 523, 1851 253, 267, 265, 246, 247, 267, 263, 248, 249, 259, 1852 265, 555, 267, 275, 538, 559, 328, 265, 267, 274, 1853 564, 267, 265, 267, 267, 274, 292, 293, 271, 275, 1854 274, 250, 251, 283, 269, 288, 364, 275, 366, 275, 1855 397, 266, 283, 284, 255, 256, 257, 258, 259, 260, 1856 261, 262, 263, 264, 267, 451, 280, 281, 282, 269, 1857 266, 274, 272, 274, 345, 275, 272, 348, 266, 266, 1858 266, 266, 272, 273, 272, 272, 272, 272, 406, 391, 1859 442, 393, 480, 266, 396, 266, 277, 272, 279, 272, 1860 275, 272, 244, 245, 272, 352, 568, 275, 410, 272, 1861 272, 351, 275, 275, 354, 422, 423, 424, 425, 272, 1862 272, 272, 275, 275, 291, 292, 293, 270, 232, 272, 1863 418, 419, 484, 272, 273, 453, 420, 421, 524, 457, 1864 267, 529, 232, 426, 427, 269, 269, 232, 232, 267, 1865 275, 232, 274, 287, 266, 265, 286, 397, 252, 272, 1866 268, 254, 232, 232, 285, 265, 275, 265, 275, 275, 1867 265, 273, 474, 475, 232, 232, 265, 265, 480, 270, 1868 232, 569, 268, 266, 231, 272, 268, 265, 444, 269, 1869 232, 577, 510, 266, 270, 266, 275, 19, 275, 312, 1870 313, 269, 442, 269, 428, 523, 270, 274, 429, 431, 1871 430, 259, 263, 432, 263, 433, 225, 350, 331, 515, 1872 538, 231, 554, 518, 564, 257, 443, 529, 565, 239, 1873 538, 549, 345, 518, 246, 348, 246, -1, -1, -1, 1874 246, 246, -1, 253, 484, 563, 548, -1, -1, 259, 1875 -1, -1, -1, 263, -1, -1, -1, -1, -1, -1, 1876 -1, -1, -1, -1, -1, -1, -1, 569, -1, -1, 1877 -1, -1, -1, 283, -1, -1, -1, 287, -1, -1, 1878 -1, -1, -1, 523, -1, -1, -1, -1, -1, -1, 1879 -1, -1, -1, -1, -1, -1, 543, -1, 538, -1, 1880 -1, -1, 415, 416, 417, 418, 419, 420, 421, 422, 1881 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 1882 433, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1883 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1884 -1, 351, 352, -1, 354, -1, -1, -1, -1, -1, 1885 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1886 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1887 -1, -1, -1, 383, -1, -1, -1, -1, -1, -1, 1888 -1, -1, -1, -1, -1, -1, -1, 397, -1, -1, 1889 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1890 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1891 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1892 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1893 -1, -1, 442, -1, -1, -1, -1, -1, -1, -1, 1894 -1, 451, -1, -1, -1, -1, -1, -1, -1, -1, 1895 -1, -1, 462, -1, -1, -1, -1, -1, -1, -1, 1896 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1897 -1, -1, -1, -1, 484, -1, -1, -1, -1, -1, 1898 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1899 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1900 -1, -1, -1, -1, -1, -1, -1, -1, 518, -1, 1901 -1, -1, -1, 523, 524, -1, -1, -1, -1, -1, 1902 -1, -1, -1, -1, -1, -1, -1, -1, 538, -1, 1903 -1, -1, -1, 543, -1, -1, -1, -1, -1, -1, 1904 -1, -1, -1, -1, -1, 555, -1, -1, -1, 559, 1905 -1, -1, -1, -1, 564, -1, -1, -1, 568, -1, 1906 -1, -1, -1, -1, -1, 0, -1, 577, 3, 4, 1907 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 1908 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1909 -1, -1, 27, 28, 29, 30, 31, 32, 33, 34, 1910 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 1911 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 1912 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 1913 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 1914 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 1915 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 1916 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 1917 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 1918 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 1919 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 1920 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 1921 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 1922 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 1923 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 1924 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 1925 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 1926 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 1927 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 1928 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 1929 225, 226, 227, 228, 229, 230, -1, -1, 233, -1, 1930 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1931 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1932 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1933 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1934 275, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1935 -1, -1, -1, -1, 289, 290, 291, 292, 293, 294, 1936 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 1937 13, 14, 15, 16, 17, 18, -1, 20, 21, 22, 1938 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 1939 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 1940 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 1941 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 1942 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 1943 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 1944 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 1945 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 1946 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 1947 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 1948 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 1949 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 1950 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 1951 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 1952 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 1953 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 1954 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 1955 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 1956 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 1957 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 1958 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 1959 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 1960 243, -1, -1, 246, 247, -1, -1, -1, -1, -1, 1961 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1962 -1, -1, 265, -1, -1, -1, 269, 270, -1, -1, 1963 -1, -1, 275, 276, 277, 278, 279, -1, -1, -1, 1964 -1, -1, -1, -1, -1, -1, 289, 290, 291, 292, 1965 293, 294, 3, 4, 5, 6, 7, 8, 9, 10, 1966 11, 12, 13, 14, 15, 16, 17, 18, -1, 20, 1967 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 1968 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 1969 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 1970 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 1971 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 1972 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 1973 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 1974 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 1975 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 1976 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 1977 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 1978 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 1979 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 1980 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 1981 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 1982 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 1983 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 1984 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 1985 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 1986 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 1987 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 1988 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 1989 241, 242, 243, -1, -1, 246, 247, -1, -1, -1, 1990 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1991 -1, -1, -1, -1, 265, -1, -1, -1, 269, 270, 1992 -1, -1, -1, -1, 275, 276, 277, 278, 279, -1, 1993 -1, -1, -1, -1, -1, -1, -1, -1, 289, 290, 1994 291, 292, 293, 294, 3, 4, 5, 6, 7, 8, 1995 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 1996 -1, 20, 21, 22, 23, 24, 25, 26, 27, 28, 1997 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 1998 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 1999 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 2000 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 2001 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 2002 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 2003 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 2004 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 2005 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 2006 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 2007 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 2008 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 2009 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 2010 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 2011 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 2012 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 2013 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 2014 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 2015 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 2016 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 2017 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 2018 239, 240, 241, 242, 243, -1, -1, 246, 247, -1, 2019 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2020 -1, -1, -1, -1, -1, -1, 265, -1, -1, -1, 2021 269, -1, -1, -1, -1, -1, 275, 276, 277, 278, 2022 279, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2023 289, 290, 291, 292, 293, 294, 3, 4, 5, 6, 2024 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 2025 17, 18, -1, 20, 21, 22, 23, 24, 25, 26, 2026 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 2027 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 2028 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 2029 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 2030 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 2031 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 2032 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 2033 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 2034 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 2035 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 2036 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 2037 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 2038 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 2039 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 2040 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 2041 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 2042 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 2043 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 2044 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 2045 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 2046 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 2047 237, 238, 239, 240, 241, 242, 243, -1, -1, 246, 2048 247, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2049 -1, -1, -1, -1, -1, -1, -1, -1, 265, -1, 2050 -1, -1, 269, -1, -1, -1, -1, -1, 275, 276, 2051 277, 278, 279, -1, -1, -1, -1, -1, -1, -1, 2052 -1, -1, 289, 290, 291, 292, 293, 294, 3, 4, 2053 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 2054 15, 16, 17, 18, -1, 20, 21, 22, 23, 24, 2055 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 2056 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 2057 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 2058 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 2059 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 2060 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 2061 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 2062 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 2063 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 2064 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 2065 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 2066 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 2067 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 2068 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 2069 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 2070 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 2071 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 2072 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 2073 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 2074 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 2075 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 2076 235, 236, 237, 238, 239, 240, 241, 242, 243, -1, 2077 -1, 246, 247, -1, -1, -1, -1, -1, -1, -1, 2078 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2079 265, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2080 275, 276, 277, 278, 279, -1, -1, -1, -1, -1, 2081 -1, -1, -1, -1, 289, 290, 291, 292, 293, 294, 2082 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 2083 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, 2084 -1, -1, -1, -1, 27, 28, 29, 30, 31, 32, 2085 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 2086 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 2087 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 2088 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 2089 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 2090 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 2091 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 2092 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 2093 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 2094 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 2095 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 2096 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 2097 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 2098 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 2099 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 2100 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 2101 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 2102 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 2103 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 2104 223, 224, 225, 226, 227, 228, 229, 230, -1, 232, 2105 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 2106 243, -1, -1, 246, 247, -1, -1, -1, -1, -1, 2107 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2108 -1, -1, 265, -1, -1, -1, -1, -1, -1, -1, 2109 -1, -1, 275, 276, 277, 278, 279, -1, -1, -1, 2110 -1, -1, -1, -1, -1, -1, 289, 290, 291, 292, 2111 293, 294, 3, 4, 5, 6, 7, 8, 9, 10, 2112 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, 2113 -1, -1, -1, -1, -1, -1, 27, 28, 29, 30, 2114 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 2115 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 2116 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 2117 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 2118 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 2119 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 2120 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 2121 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 2122 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 2123 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 2124 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 2125 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 2126 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 2127 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 2128 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 2129 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 2130 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 2131 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 2132 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 2133 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 2134 -1, -1, 233, -1, -1, -1, -1, -1, -1, -1, 2135 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2136 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2137 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2138 -1, -1, -1, -1, 275, 3, 4, 5, 6, 7, 2139 8, 9, 10, 11, 12, 13, 14, 15, 289, 290, 2140 291, 292, 293, 294, -1, -1, -1, -1, -1, 27, 2141 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 2142 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 2143 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 2144 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 2145 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 2146 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 2147 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 2148 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 2149 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 2150 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 2151 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 2152 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 2153 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 2154 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 2155 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 2156 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 2157 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 2158 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 2159 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 2160 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 2161 228, 229, 230, -1, 232, 233, 234, 235, 236, 237, 2162 238, 239, 240, 241, 242, 243, -1, -1, 246, 247, 2163 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2164 -1, -1, -1, -1, -1, -1, -1, 265, -1, -1, 2165 -1, -1, -1, -1, -1, -1, -1, -1, 276, 277, 2166 278, 279, -1, -1, -1, -1, -1, -1, -1, -1, 2167 -1, 289, 290, 291, 292, 293, 3, 4, 5, 6, 2168 7, 8, 9, 10, 11, 12, 13, 14, 15, -1, 2169 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2170 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 2171 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 2172 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 2173 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 2174 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 2175 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 2176 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 2177 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 2178 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 2179 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 2180 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 2181 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 2182 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 2183 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 2184 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 2185 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 2186 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 2187 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 2188 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 2189 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 2190 227, 228, 229, 230, -1, 232, 233, -1, -1, -1, 2191 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2192 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2193 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2194 -1, -1, -1, -1, -1, -1, -1, -1, 275, 3, 2195 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 2196 14, 15, 289, 290, 291, 292, 293, -1, -1, -1, 2197 -1, -1, -1, 27, 28, 29, 30, 31, 32, 33, 2198 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 2199 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 2200 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 2201 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 2202 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 2203 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 2204 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 2205 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 2206 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 2207 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 2208 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 2209 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 2210 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 2211 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 2212 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 2213 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 2214 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 2215 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 2216 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 2217 224, 225, 226, 227, 228, 229, 230, -1, -1, 233, 2218 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2219 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2220 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2221 -1, -1, -1, -1, -1, -1, 270, 3, 4, 5, 2222 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 2223 -1, -1, -1, -1, -1, 289, 290, 291, 292, 293, 2224 -1, 27, 28, 29, 30, 31, 32, 33, 34, 35, 2225 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 2226 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 2227 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 2228 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 2229 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 2230 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 2231 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 2232 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 2233 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 2234 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 2235 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 2236 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 2237 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 2238 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 2239 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 2240 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 2241 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 2242 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 2243 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 2244 226, 227, 228, 229, 230, -1, -1, 233, -1, -1, 2245 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2246 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2247 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2248 -1, -1, -1, -1, 270, 3, 4, 5, 6, 7, 2249 8, 9, 10, 11, 12, 13, 14, 15, -1, -1, 2250 -1, -1, -1, 289, 290, 291, 292, 293, -1, 27, 2251 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 2252 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 2253 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 2254 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 2255 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 2256 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 2257 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 2258 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 2259 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 2260 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 2261 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 2262 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 2263 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 2264 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 2265 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 2266 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 2267 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 2268 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 2269 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 2270 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 2271 228, 229, 230, -1, -1, 233, -1, -1, -1, -1, 2272 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2273 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2274 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2275 -1, -1, 270, 3, 4, 5, 6, 7, 8, 9, 2276 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, 2277 -1, 289, 290, 291, 292, 293, -1, 27, 28, 29, 2278 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 2279 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 2280 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 2281 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 2282 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 2283 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 2284 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2285 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 2286 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 2287 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 2288 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 2289 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 2290 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 2291 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 2292 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 2293 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 2294 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 2295 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 2296 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 2297 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 2298 230, -1, -1, 233, -1, -1, -1, 6, 7, 8, 2299 9, 10, 11, 12, 13, 14, 15, -1, -1, -1, 2300 -1, -1, -1, -1, -1, -1, -1, -1, -1, 28, 2301 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 2302 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 2303 -1, -1, -1, -1, -1, -1, -1, -1, -1, 289, 2304 290, 291, 292, 293, 63, 64, 65, 66, 67, 68, 2305 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 2306 79, 80, -1, -1, -1, -1, -1, 86, 87, 88, 2307 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 2308 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 2309 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 2310 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 2311 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 2312 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 2313 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 2314 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 2315 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 2316 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 2317 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 2318 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 2319 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 2320 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 2321 229, 230, -1, 232, 233, 234, 235, 236, 237, 238, 2322 239, 240, 241, 242, 243, -1, -1, 246, 247, -1, 2323 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2324 -1, -1, -1, -1, -1, -1, 265, -1, -1, -1, 2325 269, 270, -1, -1, -1, -1, -1, 276, 277, 278, 2326 279, 6, 7, 8, 9, 10, 11, 12, 13, 14, 2327 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2328 -1, -1, -1, 28, 29, 30, 31, 32, 33, 34, 2329 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 2330 45, 46, 47, 48, -1, -1, -1, -1, -1, -1, 2331 -1, -1, -1, -1, -1, -1, -1, -1, 63, 64, 2332 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 2333 75, 76, 77, 78, 79, 80, -1, -1, -1, -1, 2334 -1, 86, 87, 88, 89, 90, 91, 92, 93, 94, 2335 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 2336 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 2337 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 2338 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 2339 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 2340 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 2341 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 2342 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 2343 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 2344 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 2345 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 2346 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 2347 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 2348 225, 226, 227, 228, 229, 230, -1, 232, 233, 234, 2349 235, 236, 237, 238, 239, 240, 241, 242, 243, -1, 2350 -1, 246, 247, -1, -1, -1, -1, -1, -1, -1, 2351 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2352 265, -1, -1, 268, -1, -1, -1, -1, -1, -1, 2353 -1, 276, 277, 278, 279, 6, 7, 8, 9, 10, 2354 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, 2355 -1, -1, -1, -1, -1, -1, -1, 28, 29, 30, 2356 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 2357 41, 42, 43, 44, 45, 46, 47, 48, -1, -1, 2358 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2359 -1, -1, 63, 64, 65, 66, 67, 68, 69, 70, 2360 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 2361 -1, -1, -1, -1, -1, 86, 87, 88, 89, 90, 2362 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 2363 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 2364 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 2365 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 2366 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 2367 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 2368 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 2369 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 2370 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 2371 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 2372 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 2373 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 2374 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 2375 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 2376 -1, 232, 233, 234, 235, 236, 237, 238, 239, 240, 2377 241, 242, 243, -1, -1, 246, 247, -1, -1, -1, 2378 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2379 -1, -1, -1, -1, 265, -1, -1, -1, 269, -1, 2380 -1, -1, -1, -1, -1, 276, 277, 278, 279, 6, 2381 7, 8, 9, 10, 11, 12, 13, 14, 15, -1, 2382 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2383 -1, 28, 29, 30, 31, 32, 33, 34, 35, 36, 2384 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 2385 47, 48, -1, -1, -1, -1, -1, -1, -1, -1, 2386 -1, -1, -1, -1, -1, -1, 63, 64, 65, 66, 2387 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 2388 77, 78, 79, 80, -1, -1, -1, -1, -1, 86, 2389 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 2390 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 2391 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 2392 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 2393 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 2394 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 2395 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 2396 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 2397 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 2398 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 2399 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 2400 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 2401 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 2402 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 2403 227, 228, 229, 230, -1, 232, 233, 234, 235, 236, 2404 237, 238, 239, 240, 241, 242, 243, -1, -1, 246, 2405 247, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2406 -1, -1, -1, -1, -1, -1, -1, -1, 265, -1, 2407 -1, 268, -1, -1, -1, -1, -1, -1, -1, 276, 2408 277, 278, 279, 6, 7, 8, 9, 10, 11, 12, 2409 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, 2410 -1, -1, -1, -1, -1, 28, 29, 30, 31, 32, 2411 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 2412 43, 44, 45, 46, 47, 48, -1, -1, -1, -1, 2413 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2414 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 2415 73, 74, 75, 76, 77, 78, 79, 80, -1, -1, 2416 -1, -1, -1, 86, 87, 88, 89, 90, 91, 92, 2417 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 2418 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 2419 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 2420 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 2421 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 2422 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 2423 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 2424 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 2425 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 2426 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 2427 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 2428 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 2429 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 2430 223, 224, 225, 226, 227, 228, 229, 230, -1, 232, 2431 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 2432 243, -1, -1, 246, 247, -1, -1, -1, -1, -1, 2433 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2434 -1, -1, 265, -1, -1, -1, -1, -1, -1, -1, 2435 -1, -1, 275, 276, 277, 278, 279, 6, 7, 8, 2436 9, 10, 11, 12, 13, 14, 15, -1, -1, -1, 2437 -1, -1, -1, -1, -1, -1, -1, -1, -1, 28, 2438 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 2439 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 2440 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2441 -1, -1, -1, -1, 63, 64, 65, 66, 67, 68, 2442 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 2443 79, 80, -1, -1, -1, -1, -1, 86, 87, 88, 2444 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 2445 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 2446 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 2447 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 2448 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 2449 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 2450 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 2451 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 2452 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 2453 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 2454 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 2455 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 2456 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 2457 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 2458 229, 230, -1, 232, 233, 234, 235, 236, 237, 238, 2459 239, 240, 241, 242, 243, -1, -1, 246, 247, -1, 2460 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2461 -1, -1, -1, -1, -1, -1, 265, 6, 7, 8, 2462 9, 10, 11, 12, 13, 14, 15, 276, 277, 278, 2463 279, -1, -1, -1, -1, -1, -1, -1, -1, 28, 2464 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 2465 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 2466 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2467 -1, -1, -1, -1, 63, 64, 65, 66, 67, 68, 2468 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 2469 79, 80, -1, -1, -1, -1, -1, 86, 87, 88, 2470 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 2471 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 2472 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 2473 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 2474 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 2475 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 2476 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 2477 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 2478 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 2479 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 2480 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 2481 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 2482 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 2483 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 2484 229, 230, -1, 232, 233, 234, 235, 236, 237, 238, 2485 239, 240, 241, 242, 243, -1, -1, 246, 247, -1, 2486 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2487 -1, -1, -1, -1, -1, -1, 265, 6, 7, 8, 2488 9, 10, 11, 12, 13, 14, 15, 276, 277, 278, 2489 279, -1, -1, -1, -1, -1, -1, -1, -1, 28, 2490 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 2491 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 2492 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2493 -1, -1, -1, -1, 63, 64, 65, 66, 67, 68, 2494 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 2495 79, 80, -1, -1, -1, -1, -1, 86, 87, 88, 2496 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 2497 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 2498 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 2499 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 2500 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 2501 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 2502 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 2503 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 2504 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 2505 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 2506 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 2507 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 2508 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 2509 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 2510 229, 230, -1, -1, 233 2511 }; 2512 2513 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 2514 symbol of state STATE-NUM. */ 2515 static const yytype_uint16 yystos[] = 2516 { 2517 0, 3, 4, 5, 6, 7, 8, 9, 10, 11, 2518 12, 13, 14, 15, 27, 28, 29, 30, 31, 32, 2519 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 2520 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 2521 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 2522 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 2523 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 2524 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 2525 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 2526 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 2527 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 2528 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 2529 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 2530 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 2531 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 2532 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 2533 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 2534 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 2535 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 2536 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 2537 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 2538 223, 224, 225, 226, 227, 228, 229, 230, 233, 275, 2539 289, 290, 291, 292, 293, 294, 329, 330, 333, 334, 2540 335, 336, 340, 341, 342, 343, 344, 345, 348, 349, 2541 350, 351, 353, 355, 356, 357, 394, 395, 396, 265, 2542 265, 232, 269, 356, 232, 275, 275, 397, 266, 272, 2543 337, 338, 339, 349, 353, 272, 275, 232, 232, 275, 2544 350, 353, 267, 354, 0, 395, 232, 352, 57, 232, 2545 346, 347, 269, 359, 353, 275, 354, 269, 376, 338, 2546 337, 339, 232, 232, 265, 274, 354, 269, 272, 275, 2547 332, 232, 234, 235, 236, 237, 238, 239, 240, 241, 2548 242, 243, 246, 247, 265, 268, 276, 277, 278, 279, 2549 299, 300, 301, 303, 304, 305, 306, 307, 308, 309, 2550 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 2551 320, 321, 322, 323, 353, 267, 266, 272, 274, 266, 2552 272, 358, 349, 353, 360, 361, 275, 275, 16, 17, 2553 18, 20, 21, 22, 23, 24, 25, 26, 231, 269, 2554 270, 275, 310, 323, 325, 327, 329, 333, 353, 366, 2555 367, 368, 369, 377, 378, 379, 382, 385, 386, 393, 2556 354, 274, 354, 269, 325, 364, 274, 331, 232, 272, 2557 275, 310, 310, 327, 246, 247, 267, 271, 266, 266, 2558 272, 230, 325, 265, 310, 280, 281, 282, 277, 279, 2559 244, 245, 248, 249, 283, 284, 250, 251, 287, 286, 2560 285, 252, 254, 253, 288, 268, 268, 323, 232, 323, 2561 328, 347, 360, 353, 232, 362, 363, 270, 361, 275, 2562 275, 388, 265, 265, 275, 275, 327, 265, 327, 273, 2563 265, 270, 370, 255, 256, 257, 258, 259, 260, 261, 2564 262, 263, 264, 274, 326, 272, 275, 270, 367, 364, 2565 274, 364, 365, 364, 360, 232, 266, 302, 327, 232, 2566 325, 310, 310, 310, 312, 312, 313, 313, 314, 314, 2567 314, 314, 315, 315, 316, 317, 318, 319, 320, 321, 2568 324, 268, 270, 362, 354, 272, 275, 367, 389, 327, 2569 275, 327, 273, 387, 377, 325, 325, 364, 270, 272, 2570 270, 268, 327, 275, 363, 231, 366, 378, 390, 266, 2571 266, 327, 342, 349, 381, 371, 270, 364, 273, 265, 2572 381, 391, 392, 373, 374, 375, 380, 383, 232, 266, 2573 270, 325, 327, 275, 266, 19, 369, 368, 269, 274, 2574 368, 372, 376, 266, 327, 372, 373, 377, 384, 364, 2575 275, 270 2576 }; 2577 2578 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 2579 static const yytype_uint16 yyr1[] = 2580 { 2581 0, 298, 299, 300, 300, 300, 300, 300, 300, 300, 2582 300, 300, 300, 300, 300, 301, 301, 301, 301, 301, 2583 301, 302, 303, 304, 305, 305, 306, 306, 307, 307, 2584 308, 309, 309, 310, 310, 310, 310, 311, 311, 311, 2585 311, 312, 312, 312, 312, 313, 313, 313, 314, 314, 2586 314, 315, 315, 315, 315, 315, 316, 316, 316, 317, 2587 317, 318, 318, 319, 319, 320, 320, 321, 321, 322, 2588 322, 323, 324, 323, 325, 325, 326, 326, 326, 326, 2589 326, 326, 326, 326, 326, 326, 326, 327, 327, 328, 2590 329, 329, 329, 329, 329, 329, 329, 329, 329, 331, 2591 330, 332, 332, 333, 334, 334, 335, 335, 336, 337, 2592 337, 338, 338, 338, 338, 339, 340, 340, 340, 340, 2593 340, 341, 341, 341, 341, 341, 342, 342, 343, 344, 2594 344, 344, 344, 345, 346, 346, 347, 347, 347, 348, 2595 349, 349, 350, 350, 350, 350, 350, 350, 351, 351, 2596 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, 2597 351, 351, 351, 351, 351, 351, 351, 352, 352, 353, 2598 353, 354, 354, 354, 354, 355, 355, 355, 355, 355, 2599 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, 2600 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, 2601 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, 2602 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, 2603 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, 2604 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, 2605 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, 2606 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, 2607 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, 2608 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, 2609 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, 2610 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, 2611 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, 2612 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, 2613 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, 2614 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, 2615 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, 2616 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, 2617 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, 2618 356, 356, 356, 358, 357, 359, 357, 360, 360, 361, 2619 361, 362, 362, 363, 363, 364, 364, 364, 365, 365, 2620 366, 367, 367, 368, 368, 368, 368, 368, 368, 368, 2621 369, 370, 371, 369, 372, 372, 374, 373, 375, 373, 2622 376, 376, 377, 377, 378, 378, 379, 380, 380, 381, 2623 381, 383, 382, 384, 384, 385, 385, 387, 386, 388, 2624 386, 389, 386, 390, 390, 391, 391, 392, 392, 393, 2625 393, 393, 393, 393, 394, 394, 395, 395, 395, 397, 2626 396 2627 }; 2628 2629 /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */ 2630 static const yytype_uint8 yyr2[] = 2631 { 2632 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2633 1, 1, 1, 1, 3, 1, 4, 1, 3, 2, 2634 2, 1, 1, 1, 2, 2, 2, 1, 2, 3, 2635 2, 1, 1, 1, 2, 2, 2, 1, 1, 1, 2636 1, 1, 3, 3, 3, 1, 3, 3, 1, 3, 2637 3, 1, 3, 3, 3, 3, 1, 3, 3, 1, 2638 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 2639 3, 1, 0, 6, 1, 3, 1, 1, 1, 1, 2640 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 2641 2, 2, 4, 2, 3, 4, 2, 3, 4, 0, 2642 6, 2, 3, 2, 1, 1, 2, 3, 3, 2, 2643 3, 2, 1, 2, 1, 1, 1, 3, 4, 6, 2644 5, 1, 2, 3, 5, 4, 1, 2, 1, 1, 2645 1, 1, 1, 4, 1, 3, 1, 3, 1, 1, 2646 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2647 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2648 1, 1, 1, 1, 1, 1, 4, 1, 3, 1, 2649 2, 2, 3, 3, 4, 1, 1, 1, 1, 1, 2650 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2651 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2652 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2653 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2654 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2655 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2656 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2657 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2658 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2659 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2660 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2661 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2662 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2663 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2664 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2665 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2666 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2667 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2668 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2669 1, 1, 1, 0, 6, 0, 5, 1, 2, 3, 2670 4, 1, 3, 1, 2, 1, 3, 4, 1, 3, 2671 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2672 2, 0, 0, 5, 1, 1, 0, 2, 0, 2, 2673 2, 3, 1, 2, 1, 2, 5, 3, 1, 1, 2674 4, 0, 8, 0, 1, 3, 2, 0, 6, 0, 2675 8, 0, 7, 1, 1, 1, 0, 2, 3, 2, 2676 2, 2, 3, 2, 1, 2, 1, 1, 1, 0, 2677 3 2678 }; 2679 2680 2681 #define yyerrok (yyerrstatus = 0) 2682 #define yyclearin (yychar = YYEMPTY) 2683 #define YYEMPTY (-2) 2684 #define YYEOF 0 2685 2686 #define YYACCEPT goto yyacceptlab 2687 #define YYABORT goto yyabortlab 2688 #define YYERROR goto yyerrorlab 2689 2690 2691 #define YYRECOVERING() (!!yyerrstatus) 2692 2693 #define YYBACKUP(Token, Value) \ 2694 do \ 2695 if (yychar == YYEMPTY) \ 2696 { \ 2697 yychar = (Token); \ 2698 yylval = (Value); \ 2699 YYPOPSTACK (yylen); \ 2700 yystate = *yyssp; \ 2701 goto yybackup; \ 2702 } \ 2703 else \ 2704 { \ 2705 yyerror (pParseContext, YY_("syntax error: cannot back up")); \ 2706 YYERROR; \ 2707 } \ 2708 while (0) 2709 2710 /* Error token number */ 2711 #define YYTERROR 1 2712 #define YYERRCODE 256 2713 2714 2715 2716 /* Enable debugging if requested. */ 2717 #if YYDEBUG 2718 2719 # ifndef YYFPRINTF 2720 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 2721 # define YYFPRINTF fprintf 2722 # endif 2723 2724 # define YYDPRINTF(Args) \ 2725 do { \ 2726 if (yydebug) \ 2727 YYFPRINTF Args; \ 2728 } while (0) 2729 2730 /* This macro is provided for backward compatibility. */ 2731 #ifndef YY_LOCATION_PRINT 2732 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 2733 #endif 2734 2735 2736 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 2737 do { \ 2738 if (yydebug) \ 2739 { \ 2740 YYFPRINTF (stderr, "%s ", Title); \ 2741 yy_symbol_print (stderr, \ 2742 Type, Value, pParseContext); \ 2743 YYFPRINTF (stderr, "\n"); \ 2744 } \ 2745 } while (0) 2746 2747 2748 /*----------------------------------------. 2749 | Print this symbol's value on YYOUTPUT. | 2750 `----------------------------------------*/ 2751 2752 static void 2753 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, glslang::TParseContext* pParseContext) 2754 { 2755 FILE *yyo = yyoutput; 2756 YYUSE (yyo); 2757 YYUSE (pParseContext); 2758 if (!yyvaluep) 2759 return; 2760 # ifdef YYPRINT 2761 if (yytype < YYNTOKENS) 2762 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 2763 # endif 2764 YYUSE (yytype); 2765 } 2766 2767 2768 /*--------------------------------. 2769 | Print this symbol on YYOUTPUT. | 2770 `--------------------------------*/ 2771 2772 static void 2773 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, glslang::TParseContext* pParseContext) 2774 { 2775 YYFPRINTF (yyoutput, "%s %s (", 2776 yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]); 2777 2778 yy_symbol_value_print (yyoutput, yytype, yyvaluep, pParseContext); 2779 YYFPRINTF (yyoutput, ")"); 2780 } 2781 2782 /*------------------------------------------------------------------. 2783 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 2784 | TOP (included). | 2785 `------------------------------------------------------------------*/ 2786 2787 static void 2788 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 2789 { 2790 YYFPRINTF (stderr, "Stack now"); 2791 for (; yybottom <= yytop; yybottom++) 2792 { 2793 int yybot = *yybottom; 2794 YYFPRINTF (stderr, " %d", yybot); 2795 } 2796 YYFPRINTF (stderr, "\n"); 2797 } 2798 2799 # define YY_STACK_PRINT(Bottom, Top) \ 2800 do { \ 2801 if (yydebug) \ 2802 yy_stack_print ((Bottom), (Top)); \ 2803 } while (0) 2804 2805 2806 /*------------------------------------------------. 2807 | Report that the YYRULE is going to be reduced. | 2808 `------------------------------------------------*/ 2809 2810 static void 2811 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, glslang::TParseContext* pParseContext) 2812 { 2813 unsigned long int yylno = yyrline[yyrule]; 2814 int yynrhs = yyr2[yyrule]; 2815 int yyi; 2816 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 2817 yyrule - 1, yylno); 2818 /* The symbols being reduced. */ 2819 for (yyi = 0; yyi < yynrhs; yyi++) 2820 { 2821 YYFPRINTF (stderr, " $%d = ", yyi + 1); 2822 yy_symbol_print (stderr, 2823 yystos[yyssp[yyi + 1 - yynrhs]], 2824 &(yyvsp[(yyi + 1) - (yynrhs)]) 2825 , pParseContext); 2826 YYFPRINTF (stderr, "\n"); 2827 } 2828 } 2829 2830 # define YY_REDUCE_PRINT(Rule) \ 2831 do { \ 2832 if (yydebug) \ 2833 yy_reduce_print (yyssp, yyvsp, Rule, pParseContext); \ 2834 } while (0) 2835 2836 /* Nonzero means print parse trace. It is left uninitialized so that 2837 multiple parsers can coexist. */ 2838 int yydebug; 2839 #else /* !YYDEBUG */ 2840 # define YYDPRINTF(Args) 2841 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 2842 # define YY_STACK_PRINT(Bottom, Top) 2843 # define YY_REDUCE_PRINT(Rule) 2844 #endif /* !YYDEBUG */ 2845 2846 2847 /* YYINITDEPTH -- initial size of the parser's stacks. */ 2848 #ifndef YYINITDEPTH 2849 # define YYINITDEPTH 200 2850 #endif 2851 2852 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 2853 if the built-in stack extension method is used). 2854 2855 Do not make this value too large; the results are undefined if 2856 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 2857 evaluated with infinite-precision integer arithmetic. */ 2858 2859 #ifndef YYMAXDEPTH 2860 # define YYMAXDEPTH 10000 2861 #endif 2862 2863 2864 #if YYERROR_VERBOSE 2865 2866 # ifndef yystrlen 2867 # if defined __GLIBC__ && defined _STRING_H 2868 # define yystrlen strlen 2869 # else 2870 /* Return the length of YYSTR. */ 2871 static YYSIZE_T 2872 yystrlen (const char *yystr) 2873 { 2874 YYSIZE_T yylen; 2875 for (yylen = 0; yystr[yylen]; yylen++) 2876 continue; 2877 return yylen; 2878 } 2879 # endif 2880 # endif 2881 2882 # ifndef yystpcpy 2883 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 2884 # define yystpcpy stpcpy 2885 # else 2886 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 2887 YYDEST. */ 2888 static char * 2889 yystpcpy (char *yydest, const char *yysrc) 2890 { 2891 char *yyd = yydest; 2892 const char *yys = yysrc; 2893 2894 while ((*yyd++ = *yys++) != '\0') 2895 continue; 2896 2897 return yyd - 1; 2898 } 2899 # endif 2900 # endif 2901 2902 # ifndef yytnamerr 2903 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 2904 quotes and backslashes, so that it's suitable for yyerror. The 2905 heuristic is that double-quoting is unnecessary unless the string 2906 contains an apostrophe, a comma, or backslash (other than 2907 backslash-backslash). YYSTR is taken from yytname. If YYRES is 2908 null, do not copy; instead, return the length of what the result 2909 would have been. */ 2910 static YYSIZE_T 2911 yytnamerr (char *yyres, const char *yystr) 2912 { 2913 if (*yystr == '"') 2914 { 2915 YYSIZE_T yyn = 0; 2916 char const *yyp = yystr; 2917 2918 for (;;) 2919 switch (*++yyp) 2920 { 2921 case '\'': 2922 case ',': 2923 goto do_not_strip_quotes; 2924 2925 case '\\': 2926 if (*++yyp != '\\') 2927 goto do_not_strip_quotes; 2928 /* Fall through. */ 2929 default: 2930 if (yyres) 2931 yyres[yyn] = *yyp; 2932 yyn++; 2933 break; 2934 2935 case '"': 2936 if (yyres) 2937 yyres[yyn] = '\0'; 2938 return yyn; 2939 } 2940 do_not_strip_quotes: ; 2941 } 2942 2943 if (! yyres) 2944 return yystrlen (yystr); 2945 2946 return yystpcpy (yyres, yystr) - yyres; 2947 } 2948 # endif 2949 2950 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message 2951 about the unexpected token YYTOKEN for the state stack whose top is 2952 YYSSP. 2953 2954 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is 2955 not large enough to hold the message. In that case, also set 2956 *YYMSG_ALLOC to the required number of bytes. Return 2 if the 2957 required number of bytes is too large to store. */ 2958 static int 2959 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, 2960 yytype_int16 *yyssp, int yytoken) 2961 { 2962 YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); 2963 YYSIZE_T yysize = yysize0; 2964 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 2965 /* Internationalized format string. */ 2966 const char *yyformat = YY_NULLPTR; 2967 /* Arguments of yyformat. */ 2968 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 2969 /* Number of reported tokens (one for the "unexpected", one per 2970 "expected"). */ 2971 int yycount = 0; 2972 2973 /* There are many possibilities here to consider: 2974 - If this state is a consistent state with a default action, then 2975 the only way this function was invoked is if the default action 2976 is an error action. In that case, don't check for expected 2977 tokens because there are none. 2978 - The only way there can be no lookahead present (in yychar) is if 2979 this state is a consistent state with a default action. Thus, 2980 detecting the absence of a lookahead is sufficient to determine 2981 that there is no unexpected or expected token to report. In that 2982 case, just report a simple "syntax error". 2983 - Don't assume there isn't a lookahead just because this state is a 2984 consistent state with a default action. There might have been a 2985 previous inconsistent state, consistent state with a non-default 2986 action, or user semantic action that manipulated yychar. 2987 - Of course, the expected token list depends on states to have 2988 correct lookahead information, and it depends on the parser not 2989 to perform extra reductions after fetching a lookahead from the 2990 scanner and before detecting a syntax error. Thus, state merging 2991 (from LALR or IELR) and default reductions corrupt the expected 2992 token list. However, the list is correct for canonical LR with 2993 one exception: it will still contain any token that will not be 2994 accepted due to an error action in a later state. 2995 */ 2996 if (yytoken != YYEMPTY) 2997 { 2998 int yyn = yypact[*yyssp]; 2999 yyarg[yycount++] = yytname[yytoken]; 3000 if (!yypact_value_is_default (yyn)) 3001 { 3002 /* Start YYX at -YYN if negative to avoid negative indexes in 3003 YYCHECK. In other words, skip the first -YYN actions for 3004 this state because they are default actions. */ 3005 int yyxbegin = yyn < 0 ? -yyn : 0; 3006 /* Stay within bounds of both yycheck and yytname. */ 3007 int yychecklim = YYLAST - yyn + 1; 3008 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 3009 int yyx; 3010 3011 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 3012 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR 3013 && !yytable_value_is_error (yytable[yyx + yyn])) 3014 { 3015 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 3016 { 3017 yycount = 1; 3018 yysize = yysize0; 3019 break; 3020 } 3021 yyarg[yycount++] = yytname[yyx]; 3022 { 3023 YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); 3024 if (! (yysize <= yysize1 3025 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 3026 return 2; 3027 yysize = yysize1; 3028 } 3029 } 3030 } 3031 } 3032 3033 switch (yycount) 3034 { 3035 # define YYCASE_(N, S) \ 3036 case N: \ 3037 yyformat = S; \ 3038 break 3039 YYCASE_(0, YY_("syntax error")); 3040 YYCASE_(1, YY_("syntax error, unexpected %s")); 3041 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); 3042 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); 3043 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); 3044 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); 3045 # undef YYCASE_ 3046 } 3047 3048 { 3049 YYSIZE_T yysize1 = yysize + yystrlen (yyformat); 3050 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 3051 return 2; 3052 yysize = yysize1; 3053 } 3054 3055 if (*yymsg_alloc < yysize) 3056 { 3057 *yymsg_alloc = 2 * yysize; 3058 if (! (yysize <= *yymsg_alloc 3059 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) 3060 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; 3061 return 1; 3062 } 3063 3064 /* Avoid sprintf, as that infringes on the user's name space. 3065 Don't have undefined behavior even if the translation 3066 produced a string with the wrong number of "%s"s. */ 3067 { 3068 char *yyp = *yymsg; 3069 int yyi = 0; 3070 while ((*yyp = *yyformat) != '\0') 3071 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) 3072 { 3073 yyp += yytnamerr (yyp, yyarg[yyi++]); 3074 yyformat += 2; 3075 } 3076 else 3077 { 3078 yyp++; 3079 yyformat++; 3080 } 3081 } 3082 return 0; 3083 } 3084 #endif /* YYERROR_VERBOSE */ 3085 3086 /*-----------------------------------------------. 3087 | Release the memory associated to this symbol. | 3088 `-----------------------------------------------*/ 3089 3090 static void 3091 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, glslang::TParseContext* pParseContext) 3092 { 3093 YYUSE (yyvaluep); 3094 YYUSE (pParseContext); 3095 if (!yymsg) 3096 yymsg = "Deleting"; 3097 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 3098 3099 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 3100 YYUSE (yytype); 3101 YY_IGNORE_MAYBE_UNINITIALIZED_END 3102 } 3103 3104 3105 3106 3107 /*----------. 3108 | yyparse. | 3109 `----------*/ 3110 3111 int 3112 yyparse (glslang::TParseContext* pParseContext) 3113 { 3114 /* The lookahead symbol. */ 3115 int yychar; 3116 3117 3118 /* The semantic value of the lookahead symbol. */ 3119 /* Default value used for initialization, for pacifying older GCCs 3120 or non-GCC compilers. */ 3121 YY_INITIAL_VALUE (static YYSTYPE yyval_default;) 3122 YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); 3123 3124 /* Number of syntax errors so far. */ 3125 int yynerrs; 3126 3127 int yystate; 3128 /* Number of tokens to shift before error messages enabled. */ 3129 int yyerrstatus; 3130 3131 /* The stacks and their tools: 3132 'yyss': related to states. 3133 'yyvs': related to semantic values. 3134 3135 Refer to the stacks through separate pointers, to allow yyoverflow 3136 to reallocate them elsewhere. */ 3137 3138 /* The state stack. */ 3139 yytype_int16 yyssa[YYINITDEPTH]; 3140 yytype_int16 *yyss; 3141 yytype_int16 *yyssp; 3142 3143 /* The semantic value stack. */ 3144 YYSTYPE yyvsa[YYINITDEPTH]; 3145 YYSTYPE *yyvs; 3146 YYSTYPE *yyvsp; 3147 3148 YYSIZE_T yystacksize; 3149 3150 int yyn; 3151 int yyresult; 3152 /* Lookahead token as an internal (translated) token number. */ 3153 int yytoken = 0; 3154 /* The variables used to return semantic value and location from the 3155 action routines. */ 3156 YYSTYPE yyval; 3157 3158 #if YYERROR_VERBOSE 3159 /* Buffer for error messages, and its allocated size. */ 3160 char yymsgbuf[128]; 3161 char *yymsg = yymsgbuf; 3162 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 3163 #endif 3164 3165 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 3166 3167 /* The number of symbols on the RHS of the reduced rule. 3168 Keep to zero when no symbol should be popped. */ 3169 int yylen = 0; 3170 3171 yyssp = yyss = yyssa; 3172 yyvsp = yyvs = yyvsa; 3173 yystacksize = YYINITDEPTH; 3174 3175 YYDPRINTF ((stderr, "Starting parse\n")); 3176 3177 yystate = 0; 3178 yyerrstatus = 0; 3179 yynerrs = 0; 3180 yychar = YYEMPTY; /* Cause a token to be read. */ 3181 goto yysetstate; 3182 3183 /*------------------------------------------------------------. 3184 | yynewstate -- Push a new state, which is found in yystate. | 3185 `------------------------------------------------------------*/ 3186 yynewstate: 3187 /* In all cases, when you get here, the value and location stacks 3188 have just been pushed. So pushing a state here evens the stacks. */ 3189 yyssp++; 3190 3191 yysetstate: 3192 *yyssp = yystate; 3193 3194 if (yyss + yystacksize - 1 <= yyssp) 3195 { 3196 /* Get the current used size of the three stacks, in elements. */ 3197 YYSIZE_T yysize = yyssp - yyss + 1; 3198 3199 #ifdef yyoverflow 3200 { 3201 /* Give user a chance to reallocate the stack. Use copies of 3202 these so that the &'s don't force the real ones into 3203 memory. */ 3204 YYSTYPE *yyvs1 = yyvs; 3205 yytype_int16 *yyss1 = yyss; 3206 3207 /* Each stack pointer address is followed by the size of the 3208 data in use in that stack, in bytes. This used to be a 3209 conditional around just the two extra args, but that might 3210 be undefined if yyoverflow is a macro. */ 3211 yyoverflow (YY_("memory exhausted"), 3212 &yyss1, yysize * sizeof (*yyssp), 3213 &yyvs1, yysize * sizeof (*yyvsp), 3214 &yystacksize); 3215 3216 yyss = yyss1; 3217 yyvs = yyvs1; 3218 } 3219 #else /* no yyoverflow */ 3220 # ifndef YYSTACK_RELOCATE 3221 goto yyexhaustedlab; 3222 # else 3223 /* Extend the stack our own way. */ 3224 if (YYMAXDEPTH <= yystacksize) 3225 goto yyexhaustedlab; 3226 yystacksize *= 2; 3227 if (YYMAXDEPTH < yystacksize) 3228 yystacksize = YYMAXDEPTH; 3229 3230 { 3231 yytype_int16 *yyss1 = yyss; 3232 union yyalloc *yyptr = 3233 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 3234 if (! yyptr) 3235 goto yyexhaustedlab; 3236 YYSTACK_RELOCATE (yyss_alloc, yyss); 3237 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 3238 # undef YYSTACK_RELOCATE 3239 if (yyss1 != yyssa) 3240 YYSTACK_FREE (yyss1); 3241 } 3242 # endif 3243 #endif /* no yyoverflow */ 3244 3245 yyssp = yyss + yysize - 1; 3246 yyvsp = yyvs + yysize - 1; 3247 3248 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 3249 (unsigned long int) yystacksize)); 3250 3251 if (yyss + yystacksize - 1 <= yyssp) 3252 YYABORT; 3253 } 3254 3255 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 3256 3257 if (yystate == YYFINAL) 3258 YYACCEPT; 3259 3260 goto yybackup; 3261 3262 /*-----------. 3263 | yybackup. | 3264 `-----------*/ 3265 yybackup: 3266 3267 /* Do appropriate processing given the current state. Read a 3268 lookahead token if we need one and don't already have one. */ 3269 3270 /* First try to decide what to do without reference to lookahead token. */ 3271 yyn = yypact[yystate]; 3272 if (yypact_value_is_default (yyn)) 3273 goto yydefault; 3274 3275 /* Not known => get a lookahead token if don't already have one. */ 3276 3277 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 3278 if (yychar == YYEMPTY) 3279 { 3280 YYDPRINTF ((stderr, "Reading a token: ")); 3281 yychar = yylex (&yylval, parseContext); 3282 } 3283 3284 if (yychar <= YYEOF) 3285 { 3286 yychar = yytoken = YYEOF; 3287 YYDPRINTF ((stderr, "Now at end of input.\n")); 3288 } 3289 else 3290 { 3291 yytoken = YYTRANSLATE (yychar); 3292 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 3293 } 3294 3295 /* If the proper action on seeing token YYTOKEN is to reduce or to 3296 detect an error, take that action. */ 3297 yyn += yytoken; 3298 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 3299 goto yydefault; 3300 yyn = yytable[yyn]; 3301 if (yyn <= 0) 3302 { 3303 if (yytable_value_is_error (yyn)) 3304 goto yyerrlab; 3305 yyn = -yyn; 3306 goto yyreduce; 3307 } 3308 3309 /* Count tokens shifted since error; after three, turn off error 3310 status. */ 3311 if (yyerrstatus) 3312 yyerrstatus--; 3313 3314 /* Shift the lookahead token. */ 3315 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 3316 3317 /* Discard the shifted token. */ 3318 yychar = YYEMPTY; 3319 3320 yystate = yyn; 3321 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 3322 *++yyvsp = yylval; 3323 YY_IGNORE_MAYBE_UNINITIALIZED_END 3324 3325 goto yynewstate; 3326 3327 3328 /*-----------------------------------------------------------. 3329 | yydefault -- do the default action for the current state. | 3330 `-----------------------------------------------------------*/ 3331 yydefault: 3332 yyn = yydefact[yystate]; 3333 if (yyn == 0) 3334 goto yyerrlab; 3335 goto yyreduce; 3336 3337 3338 /*-----------------------------. 3339 | yyreduce -- Do a reduction. | 3340 `-----------------------------*/ 3341 yyreduce: 3342 /* yyn is the number of a rule to reduce with. */ 3343 yylen = yyr2[yyn]; 3344 3345 /* If YYLEN is nonzero, implement the default value of the action: 3346 '$$ = $1'. 3347 3348 Otherwise, the following line sets YYVAL to garbage. 3349 This behavior is undocumented and Bison 3350 users should not rely upon it. Assigning to YYVAL 3351 unconditionally makes the parser a bit smaller, and it avoids a 3352 GCC warning that YYVAL may be used uninitialized. */ 3353 yyval = yyvsp[1-yylen]; 3354 3355 3356 YY_REDUCE_PRINT (yyn); 3357 switch (yyn) 3358 { 3359 case 2: 3360 #line 253 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3361 { 3362 (yyval.interm.intermTypedNode) = parseContext.handleVariable((yyvsp[0].lex).loc, (yyvsp[0].lex).symbol, (yyvsp[0].lex).string); 3363 } 3364 #line 3365 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3365 break; 3366 3367 case 3: 3368 #line 259 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3369 { 3370 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); 3371 } 3372 #line 3373 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3373 break; 3374 3375 case 4: 3376 #line 262 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3377 { 3378 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); 3379 } 3380 #line 3381 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3381 break; 3382 3383 case 5: 3384 #line 265 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3385 { 3386 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned literal"); 3387 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); 3388 } 3389 #line 3390 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3390 break; 3391 3392 case 6: 3393 #line 269 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3394 { 3395 parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer literal"); 3396 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i64, (yyvsp[0].lex).loc, true); 3397 } 3398 #line 3399 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3399 break; 3400 3401 case 7: 3402 #line 273 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3403 { 3404 parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer literal"); 3405 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u64, (yyvsp[0].lex).loc, true); 3406 } 3407 #line 3408 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3408 break; 3409 3410 case 8: 3411 #line 277 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3412 { 3413 #ifdef AMD_EXTENSIONS 3414 parseContext.int16Check((yyvsp[0].lex).loc, "16-bit integer literal"); 3415 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((short)(yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); 3416 #endif 3417 } 3418 #line 3419 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3419 break; 3420 3421 case 9: 3422 #line 283 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3423 { 3424 #ifdef AMD_EXTENSIONS 3425 parseContext.int16Check((yyvsp[0].lex).loc, "16-bit unsigned integer literal"); 3426 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((unsigned short)(yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); 3427 #endif 3428 } 3429 #line 3430 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3430 break; 3431 3432 case 10: 3433 #line 289 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3434 { 3435 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true); 3436 } 3437 #line 3438 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3438 break; 3439 3440 case 11: 3441 #line 292 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3442 { 3443 parseContext.doubleCheck((yyvsp[0].lex).loc, "double literal"); 3444 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtDouble, (yyvsp[0].lex).loc, true); 3445 } 3446 #line 3447 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3447 break; 3448 3449 case 12: 3450 #line 296 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3451 { 3452 #ifdef AMD_EXTENSIONS 3453 parseContext.float16Check((yyvsp[0].lex).loc, "half float literal"); 3454 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat16, (yyvsp[0].lex).loc, true); 3455 #endif 3456 } 3457 #line 3458 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3458 break; 3459 3460 case 13: 3461 #line 302 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3462 { 3463 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true); 3464 } 3465 #line 3466 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3466 break; 3467 3468 case 14: 3469 #line 305 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3470 { 3471 (yyval.interm.intermTypedNode) = (yyvsp[-1].interm.intermTypedNode); 3472 if ((yyval.interm.intermTypedNode)->getAsConstantUnion()) 3473 (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression(); 3474 } 3475 #line 3476 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3476 break; 3477 3478 case 15: 3479 #line 313 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3480 { 3481 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); 3482 } 3483 #line 3484 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3484 break; 3485 3486 case 16: 3487 #line 316 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3488 { 3489 (yyval.interm.intermTypedNode) = parseContext.handleBracketDereference((yyvsp[-2].lex).loc, (yyvsp[-3].interm.intermTypedNode), (yyvsp[-1].interm.intermTypedNode)); 3490 } 3491 #line 3492 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3492 break; 3493 3494 case 17: 3495 #line 319 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3496 { 3497 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); 3498 } 3499 #line 3500 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3500 break; 3501 3502 case 18: 3503 #line 322 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3504 { 3505 (yyval.interm.intermTypedNode) = parseContext.handleDotDereference((yyvsp[0].lex).loc, (yyvsp[-2].interm.intermTypedNode), *(yyvsp[0].lex).string); 3506 } 3507 #line 3508 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3508 break; 3509 3510 case 19: 3511 #line 325 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3512 { 3513 parseContext.variableCheck((yyvsp[-1].interm.intermTypedNode)); 3514 parseContext.lValueErrorCheck((yyvsp[0].lex).loc, "++", (yyvsp[-1].interm.intermTypedNode)); 3515 (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[0].lex).loc, "++", EOpPostIncrement, (yyvsp[-1].interm.intermTypedNode)); 3516 } 3517 #line 3518 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3518 break; 3519 3520 case 20: 3521 #line 330 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3522 { 3523 parseContext.variableCheck((yyvsp[-1].interm.intermTypedNode)); 3524 parseContext.lValueErrorCheck((yyvsp[0].lex).loc, "--", (yyvsp[-1].interm.intermTypedNode)); 3525 (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[0].lex).loc, "--", EOpPostDecrement, (yyvsp[-1].interm.intermTypedNode)); 3526 } 3527 #line 3528 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3528 break; 3529 3530 case 21: 3531 #line 338 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3532 { 3533 parseContext.integerCheck((yyvsp[0].interm.intermTypedNode), "[]"); 3534 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); 3535 } 3536 #line 3537 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3537 break; 3538 3539 case 22: 3540 #line 345 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3541 { 3542 (yyval.interm.intermTypedNode) = parseContext.handleFunctionCall((yyvsp[0].interm).loc, (yyvsp[0].interm).function, (yyvsp[0].interm).intermNode); 3543 delete (yyvsp[0].interm).function; 3544 } 3545 #line 3546 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3546 break; 3547 3548 case 23: 3549 #line 352 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3550 { 3551 (yyval.interm) = (yyvsp[0].interm); 3552 } 3553 #line 3554 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3554 break; 3555 3556 case 24: 3557 #line 358 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3558 { 3559 (yyval.interm) = (yyvsp[-1].interm); 3560 (yyval.interm).loc = (yyvsp[0].lex).loc; 3561 } 3562 #line 3563 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3563 break; 3564 3565 case 25: 3566 #line 362 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3567 { 3568 (yyval.interm) = (yyvsp[-1].interm); 3569 (yyval.interm).loc = (yyvsp[0].lex).loc; 3570 } 3571 #line 3572 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3572 break; 3573 3574 case 26: 3575 #line 369 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3576 { 3577 (yyval.interm) = (yyvsp[-1].interm); 3578 } 3579 #line 3580 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3580 break; 3581 3582 case 27: 3583 #line 372 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3584 { 3585 (yyval.interm) = (yyvsp[0].interm); 3586 } 3587 #line 3588 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3588 break; 3589 3590 case 28: 3591 #line 378 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3592 { 3593 TParameter param = { 0, new TType }; 3594 param.type->shallowCopy((yyvsp[0].interm.intermTypedNode)->getType()); 3595 (yyvsp[-1].interm).function->addParameter(param); 3596 (yyval.interm).function = (yyvsp[-1].interm).function; 3597 (yyval.interm).intermNode = (yyvsp[0].interm.intermTypedNode); 3598 } 3599 #line 3600 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3600 break; 3601 3602 case 29: 3603 #line 385 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3604 { 3605 TParameter param = { 0, new TType }; 3606 param.type->shallowCopy((yyvsp[0].interm.intermTypedNode)->getType()); 3607 (yyvsp[-2].interm).function->addParameter(param); 3608 (yyval.interm).function = (yyvsp[-2].interm).function; 3609 (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-2].interm).intermNode, (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].lex).loc); 3610 } 3611 #line 3612 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3612 break; 3613 3614 case 30: 3615 #line 395 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3616 { 3617 (yyval.interm) = (yyvsp[-1].interm); 3618 } 3619 #line 3620 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3620 break; 3621 3622 case 31: 3623 #line 403 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3624 { 3625 // Constructor 3626 (yyval.interm).intermNode = 0; 3627 (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type)); 3628 } 3629 #line 3630 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3630 break; 3631 3632 case 32: 3633 #line 408 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3634 { 3635 // 3636 // Should be a method or subroutine call, but we haven't recognized the arguments yet. 3637 // 3638 (yyval.interm).function = 0; 3639 (yyval.interm).intermNode = 0; 3640 3641 TIntermMethod* method = (yyvsp[0].interm.intermTypedNode)->getAsMethodNode(); 3642 if (method) { 3643 (yyval.interm).function = new TFunction(&method->getMethodName(), TType(EbtInt), EOpArrayLength); 3644 (yyval.interm).intermNode = method->getObject(); 3645 } else { 3646 TIntermSymbol* symbol = (yyvsp[0].interm.intermTypedNode)->getAsSymbolNode(); 3647 if (symbol) { 3648 parseContext.reservedErrorCheck(symbol->getLoc(), symbol->getName()); 3649 TFunction *function = new TFunction(&symbol->getName(), TType(EbtVoid)); 3650 (yyval.interm).function = function; 3651 } else 3652 parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "function call, method, or subroutine call expected", "", ""); 3653 } 3654 3655 if ((yyval.interm).function == 0) { 3656 // error recover 3657 TString empty(""); 3658 (yyval.interm).function = new TFunction(&empty, TType(EbtVoid), EOpNull); 3659 } 3660 } 3661 #line 3662 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3662 break; 3663 3664 case 33: 3665 #line 438 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3666 { 3667 parseContext.variableCheck((yyvsp[0].interm.intermTypedNode)); 3668 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); 3669 if (TIntermMethod* method = (yyvsp[0].interm.intermTypedNode)->getAsMethodNode()) 3670 parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "incomplete method syntax", method->getMethodName().c_str(), ""); 3671 } 3672 #line 3673 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3673 break; 3674 3675 case 34: 3676 #line 444 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3677 { 3678 parseContext.lValueErrorCheck((yyvsp[-1].lex).loc, "++", (yyvsp[0].interm.intermTypedNode)); 3679 (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].lex).loc, "++", EOpPreIncrement, (yyvsp[0].interm.intermTypedNode)); 3680 } 3681 #line 3682 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3682 break; 3683 3684 case 35: 3685 #line 448 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3686 { 3687 parseContext.lValueErrorCheck((yyvsp[-1].lex).loc, "--", (yyvsp[0].interm.intermTypedNode)); 3688 (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].lex).loc, "--", EOpPreDecrement, (yyvsp[0].interm.intermTypedNode)); 3689 } 3690 #line 3691 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3691 break; 3692 3693 case 36: 3694 #line 452 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3695 { 3696 if ((yyvsp[-1].interm).op != EOpNull) { 3697 char errorOp[2] = {0, 0}; 3698 switch((yyvsp[-1].interm).op) { 3699 case EOpNegative: errorOp[0] = '-'; break; 3700 case EOpLogicalNot: errorOp[0] = '!'; break; 3701 case EOpBitwiseNot: errorOp[0] = '~'; break; 3702 default: break; // some compilers want this 3703 } 3704 (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].interm).loc, errorOp, (yyvsp[-1].interm).op, (yyvsp[0].interm.intermTypedNode)); 3705 } else { 3706 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); 3707 if ((yyval.interm.intermTypedNode)->getAsConstantUnion()) 3708 (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression(); 3709 } 3710 } 3711 #line 3712 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3712 break; 3713 3714 case 37: 3715 #line 472 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3716 { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNull; } 3717 #line 3718 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3718 break; 3719 3720 case 38: 3721 #line 473 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3722 { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNegative; } 3723 #line 3724 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3724 break; 3725 3726 case 39: 3727 #line 474 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3728 { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLogicalNot; } 3729 #line 3730 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3730 break; 3731 3732 case 40: 3733 #line 475 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3734 { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpBitwiseNot; 3735 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise not"); } 3736 #line 3737 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3737 break; 3738 3739 case 41: 3740 #line 481 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3741 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } 3742 #line 3743 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3743 break; 3744 3745 case 42: 3746 #line 482 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3747 { 3748 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "*", EOpMul, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 3749 if ((yyval.interm.intermTypedNode) == 0) 3750 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); 3751 } 3752 #line 3753 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3753 break; 3754 3755 case 43: 3756 #line 487 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3757 { 3758 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "/", EOpDiv, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 3759 if ((yyval.interm.intermTypedNode) == 0) 3760 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); 3761 } 3762 #line 3763 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3763 break; 3764 3765 case 44: 3766 #line 492 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3767 { 3768 parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "%"); 3769 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "%", EOpMod, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 3770 if ((yyval.interm.intermTypedNode) == 0) 3771 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); 3772 } 3773 #line 3774 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3774 break; 3775 3776 case 45: 3777 #line 501 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3778 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } 3779 #line 3780 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3780 break; 3781 3782 case 46: 3783 #line 502 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3784 { 3785 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "+", EOpAdd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 3786 if ((yyval.interm.intermTypedNode) == 0) 3787 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); 3788 } 3789 #line 3790 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3790 break; 3791 3792 case 47: 3793 #line 507 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3794 { 3795 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "-", EOpSub, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 3796 if ((yyval.interm.intermTypedNode) == 0) 3797 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); 3798 } 3799 #line 3800 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3800 break; 3801 3802 case 48: 3803 #line 515 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3804 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } 3805 #line 3806 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3806 break; 3807 3808 case 49: 3809 #line 516 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3810 { 3811 parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bit shift left"); 3812 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<<", EOpLeftShift, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 3813 if ((yyval.interm.intermTypedNode) == 0) 3814 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); 3815 } 3816 #line 3817 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3817 break; 3818 3819 case 50: 3820 #line 522 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3821 { 3822 parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bit shift right"); 3823 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">>", EOpRightShift, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 3824 if ((yyval.interm.intermTypedNode) == 0) 3825 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); 3826 } 3827 #line 3828 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3828 break; 3829 3830 case 51: 3831 #line 531 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3832 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } 3833 #line 3834 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3834 break; 3835 3836 case 52: 3837 #line 532 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3838 { 3839 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<", EOpLessThan, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 3840 if ((yyval.interm.intermTypedNode) == 0) 3841 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); 3842 } 3843 #line 3844 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3844 break; 3845 3846 case 53: 3847 #line 537 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3848 { 3849 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">", EOpGreaterThan, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 3850 if ((yyval.interm.intermTypedNode) == 0) 3851 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); 3852 } 3853 #line 3854 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3854 break; 3855 3856 case 54: 3857 #line 542 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3858 { 3859 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<=", EOpLessThanEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 3860 if ((yyval.interm.intermTypedNode) == 0) 3861 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); 3862 } 3863 #line 3864 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3864 break; 3865 3866 case 55: 3867 #line 547 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3868 { 3869 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">=", EOpGreaterThanEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 3870 if ((yyval.interm.intermTypedNode) == 0) 3871 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); 3872 } 3873 #line 3874 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3874 break; 3875 3876 case 56: 3877 #line 555 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3878 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } 3879 #line 3880 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3880 break; 3881 3882 case 57: 3883 #line 556 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3884 { 3885 parseContext.arrayObjectCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array comparison"); 3886 parseContext.opaqueCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "=="); 3887 parseContext.specializationCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "=="); 3888 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "==", EOpEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 3889 if ((yyval.interm.intermTypedNode) == 0) 3890 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); 3891 } 3892 #line 3893 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3893 break; 3894 3895 case 58: 3896 #line 564 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3897 { 3898 parseContext.arrayObjectCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array comparison"); 3899 parseContext.opaqueCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "!="); 3900 parseContext.specializationCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "!="); 3901 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "!=", EOpNotEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 3902 if ((yyval.interm.intermTypedNode) == 0) 3903 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); 3904 } 3905 #line 3906 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3906 break; 3907 3908 case 59: 3909 #line 575 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3910 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } 3911 #line 3912 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3912 break; 3913 3914 case 60: 3915 #line 576 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3916 { 3917 parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise and"); 3918 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "&", EOpAnd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 3919 if ((yyval.interm.intermTypedNode) == 0) 3920 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); 3921 } 3922 #line 3923 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3923 break; 3924 3925 case 61: 3926 #line 585 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3927 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } 3928 #line 3929 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3929 break; 3930 3931 case 62: 3932 #line 586 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3933 { 3934 parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise exclusive or"); 3935 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "^", EOpExclusiveOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 3936 if ((yyval.interm.intermTypedNode) == 0) 3937 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); 3938 } 3939 #line 3940 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3940 break; 3941 3942 case 63: 3943 #line 595 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3944 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } 3945 #line 3946 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3946 break; 3947 3948 case 64: 3949 #line 596 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3950 { 3951 parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise inclusive or"); 3952 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "|", EOpInclusiveOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 3953 if ((yyval.interm.intermTypedNode) == 0) 3954 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); 3955 } 3956 #line 3957 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3957 break; 3958 3959 case 65: 3960 #line 605 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3961 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } 3962 #line 3963 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3963 break; 3964 3965 case 66: 3966 #line 606 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3967 { 3968 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "&&", EOpLogicalAnd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 3969 if ((yyval.interm.intermTypedNode) == 0) 3970 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); 3971 } 3972 #line 3973 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3973 break; 3974 3975 case 67: 3976 #line 614 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3977 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } 3978 #line 3979 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3979 break; 3980 3981 case 68: 3982 #line 615 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3983 { 3984 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "^^", EOpLogicalXor, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 3985 if ((yyval.interm.intermTypedNode) == 0) 3986 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); 3987 } 3988 #line 3989 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3989 break; 3990 3991 case 69: 3992 #line 623 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3993 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } 3994 #line 3995 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 3995 break; 3996 3997 case 70: 3998 #line 624 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 3999 { 4000 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "||", EOpLogicalOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 4001 if ((yyval.interm.intermTypedNode) == 0) 4002 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); 4003 } 4004 #line 4005 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4005 break; 4006 4007 case 71: 4008 #line 632 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4009 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } 4010 #line 4011 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4011 break; 4012 4013 case 72: 4014 #line 633 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4015 { 4016 ++parseContext.controlFlowNestingLevel; 4017 } 4018 #line 4019 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4019 break; 4020 4021 case 73: 4022 #line 636 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4023 { 4024 --parseContext.controlFlowNestingLevel; 4025 parseContext.boolCheck((yyvsp[-4].lex).loc, (yyvsp[-5].interm.intermTypedNode)); 4026 parseContext.rValueErrorCheck((yyvsp[-4].lex).loc, "?", (yyvsp[-5].interm.intermTypedNode)); 4027 parseContext.rValueErrorCheck((yyvsp[-1].lex).loc, ":", (yyvsp[-2].interm.intermTypedNode)); 4028 parseContext.rValueErrorCheck((yyvsp[-1].lex).loc, ":", (yyvsp[0].interm.intermTypedNode)); 4029 (yyval.interm.intermTypedNode) = parseContext.intermediate.addSelection((yyvsp[-5].interm.intermTypedNode), (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yyvsp[-4].lex).loc); 4030 if ((yyval.interm.intermTypedNode) == 0) { 4031 parseContext.binaryOpError((yyvsp[-4].lex).loc, ":", (yyvsp[-2].interm.intermTypedNode)->getCompleteString(), (yyvsp[0].interm.intermTypedNode)->getCompleteString()); 4032 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); 4033 } 4034 } 4035 #line 4036 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4036 break; 4037 4038 case 74: 4039 #line 651 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4040 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } 4041 #line 4042 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4042 break; 4043 4044 case 75: 4045 #line 652 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4046 { 4047 parseContext.arrayObjectCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array assignment"); 4048 parseContext.opaqueCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "="); 4049 parseContext.specializationCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "="); 4050 parseContext.lValueErrorCheck((yyvsp[-1].interm).loc, "assign", (yyvsp[-2].interm.intermTypedNode)); 4051 parseContext.rValueErrorCheck((yyvsp[-1].interm).loc, "assign", (yyvsp[0].interm.intermTypedNode)); 4052 (yyval.interm.intermTypedNode) = parseContext.intermediate.addAssign((yyvsp[-1].interm).op, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].interm).loc); 4053 if ((yyval.interm.intermTypedNode) == 0) { 4054 parseContext.assignError((yyvsp[-1].interm).loc, "assign", (yyvsp[-2].interm.intermTypedNode)->getCompleteString(), (yyvsp[0].interm.intermTypedNode)->getCompleteString()); 4055 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); 4056 } 4057 } 4058 #line 4059 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4059 break; 4060 4061 case 76: 4062 #line 667 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4063 { 4064 (yyval.interm).loc = (yyvsp[0].lex).loc; 4065 (yyval.interm).op = EOpAssign; 4066 } 4067 #line 4068 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4068 break; 4069 4070 case 77: 4071 #line 671 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4072 { 4073 (yyval.interm).loc = (yyvsp[0].lex).loc; 4074 (yyval.interm).op = EOpMulAssign; 4075 } 4076 #line 4077 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4077 break; 4078 4079 case 78: 4080 #line 675 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4081 { 4082 (yyval.interm).loc = (yyvsp[0].lex).loc; 4083 (yyval.interm).op = EOpDivAssign; 4084 } 4085 #line 4086 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4086 break; 4087 4088 case 79: 4089 #line 679 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4090 { 4091 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "%="); 4092 (yyval.interm).loc = (yyvsp[0].lex).loc; 4093 (yyval.interm).op = EOpModAssign; 4094 } 4095 #line 4096 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4096 break; 4097 4098 case 80: 4099 #line 684 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4100 { 4101 (yyval.interm).loc = (yyvsp[0].lex).loc; 4102 (yyval.interm).op = EOpAddAssign; 4103 } 4104 #line 4105 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4105 break; 4106 4107 case 81: 4108 #line 688 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4109 { 4110 (yyval.interm).loc = (yyvsp[0].lex).loc; 4111 (yyval.interm).op = EOpSubAssign; 4112 } 4113 #line 4114 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4114 break; 4115 4116 case 82: 4117 #line 692 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4118 { 4119 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift left assign"); 4120 (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLeftShiftAssign; 4121 } 4122 #line 4123 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4123 break; 4124 4125 case 83: 4126 #line 696 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4127 { 4128 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift right assign"); 4129 (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpRightShiftAssign; 4130 } 4131 #line 4132 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4132 break; 4133 4134 case 84: 4135 #line 700 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4136 { 4137 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-and assign"); 4138 (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAndAssign; 4139 } 4140 #line 4141 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4141 break; 4142 4143 case 85: 4144 #line 704 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4145 { 4146 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-xor assign"); 4147 (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpExclusiveOrAssign; 4148 } 4149 #line 4150 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4150 break; 4151 4152 case 86: 4153 #line 708 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4154 { 4155 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-or assign"); 4156 (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpInclusiveOrAssign; 4157 } 4158 #line 4159 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4159 break; 4160 4161 case 87: 4162 #line 715 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4163 { 4164 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); 4165 } 4166 #line 4167 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4167 break; 4168 4169 case 88: 4170 #line 718 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4171 { 4172 parseContext.samplerConstructorLocationCheck((yyvsp[-1].lex).loc, ",", (yyvsp[0].interm.intermTypedNode)); 4173 (yyval.interm.intermTypedNode) = parseContext.intermediate.addComma((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].lex).loc); 4174 if ((yyval.interm.intermTypedNode) == 0) { 4175 parseContext.binaryOpError((yyvsp[-1].lex).loc, ",", (yyvsp[-2].interm.intermTypedNode)->getCompleteString(), (yyvsp[0].interm.intermTypedNode)->getCompleteString()); 4176 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); 4177 } 4178 } 4179 #line 4180 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4180 break; 4181 4182 case 89: 4183 #line 729 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4184 { 4185 parseContext.constantValueCheck((yyvsp[0].interm.intermTypedNode), ""); 4186 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); 4187 } 4188 #line 4189 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4189 break; 4190 4191 case 90: 4192 #line 736 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4193 { 4194 parseContext.handleFunctionDeclarator((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).function, true /* prototype */); 4195 (yyval.interm.intermNode) = 0; 4196 // TODO: 4.0 functionality: subroutines: make the identifier a user type for this signature 4197 } 4198 #line 4199 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4199 break; 4200 4201 case 91: 4202 #line 741 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4203 { 4204 if ((yyvsp[-1].interm).intermNode && (yyvsp[-1].interm).intermNode->getAsAggregate()) 4205 (yyvsp[-1].interm).intermNode->getAsAggregate()->setOperator(EOpSequence); 4206 (yyval.interm.intermNode) = (yyvsp[-1].interm).intermNode; 4207 } 4208 #line 4209 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4209 break; 4210 4211 case 92: 4212 #line 746 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4213 { 4214 parseContext.profileRequires((yyvsp[-3].lex).loc, ENoProfile, 130, 0, "precision statement"); 4215 4216 // lazy setting of the previous scope's defaults, has effect only the first time it is called in a particular scope 4217 parseContext.symbolTable.setPreviousDefaultPrecisions(&parseContext.defaultPrecision[0]); 4218 parseContext.setDefaultPrecision((yyvsp[-3].lex).loc, (yyvsp[-1].interm.type), (yyvsp[-2].interm.type).qualifier.precision); 4219 (yyval.interm.intermNode) = 0; 4220 } 4221 #line 4222 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4222 break; 4223 4224 case 93: 4225 #line 754 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4226 { 4227 parseContext.declareBlock((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).typeList); 4228 (yyval.interm.intermNode) = 0; 4229 } 4230 #line 4231 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4231 break; 4232 4233 case 94: 4234 #line 758 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4235 { 4236 parseContext.declareBlock((yyvsp[-2].interm).loc, *(yyvsp[-2].interm).typeList, (yyvsp[-1].lex).string); 4237 (yyval.interm.intermNode) = 0; 4238 } 4239 #line 4240 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4240 break; 4241 4242 case 95: 4243 #line 762 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4244 { 4245 parseContext.declareBlock((yyvsp[-3].interm).loc, *(yyvsp[-3].interm).typeList, (yyvsp[-2].lex).string, (yyvsp[-1].interm).arraySizes); 4246 (yyval.interm.intermNode) = 0; 4247 } 4248 #line 4249 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4249 break; 4250 4251 case 96: 4252 #line 766 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4253 { 4254 parseContext.globalQualifierFixCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier); 4255 parseContext.updateStandaloneQualifierDefaults((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type)); 4256 (yyval.interm.intermNode) = 0; 4257 } 4258 #line 4259 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4259 break; 4260 4261 case 97: 4262 #line 771 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4263 { 4264 parseContext.checkNoShaderLayouts((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).shaderQualifiers); 4265 parseContext.addQualifierToExisting((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).qualifier, *(yyvsp[-1].lex).string); 4266 (yyval.interm.intermNode) = 0; 4267 } 4268 #line 4269 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4269 break; 4270 4271 case 98: 4272 #line 776 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4273 { 4274 parseContext.checkNoShaderLayouts((yyvsp[-3].interm.type).loc, (yyvsp[-3].interm.type).shaderQualifiers); 4275 (yyvsp[-1].interm.identifierList)->push_back((yyvsp[-2].lex).string); 4276 parseContext.addQualifierToExisting((yyvsp[-3].interm.type).loc, (yyvsp[-3].interm.type).qualifier, *(yyvsp[-1].interm.identifierList)); 4277 (yyval.interm.intermNode) = 0; 4278 } 4279 #line 4280 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4280 break; 4281 4282 case 99: 4283 #line 785 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4284 { parseContext.nestedBlockCheck((yyvsp[-2].interm.type).loc); } 4285 #line 4286 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4286 break; 4287 4288 case 100: 4289 #line 785 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4290 { 4291 --parseContext.structNestingLevel; 4292 parseContext.blockName = (yyvsp[-4].lex).string; 4293 parseContext.globalQualifierFixCheck((yyvsp[-5].interm.type).loc, (yyvsp[-5].interm.type).qualifier); 4294 parseContext.checkNoShaderLayouts((yyvsp[-5].interm.type).loc, (yyvsp[-5].interm.type).shaderQualifiers); 4295 parseContext.currentBlockQualifier = (yyvsp[-5].interm.type).qualifier; 4296 (yyval.interm).loc = (yyvsp[-5].interm.type).loc; 4297 (yyval.interm).typeList = (yyvsp[-1].interm.typeList); 4298 } 4299 #line 4300 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4300 break; 4301 4302 case 101: 4303 #line 796 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4304 { 4305 (yyval.interm.identifierList) = new TIdentifierList; 4306 (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string); 4307 } 4308 #line 4309 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4309 break; 4310 4311 case 102: 4312 #line 800 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4313 { 4314 (yyval.interm.identifierList) = (yyvsp[-2].interm.identifierList); 4315 (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string); 4316 } 4317 #line 4318 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4318 break; 4319 4320 case 103: 4321 #line 807 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4322 { 4323 (yyval.interm).function = (yyvsp[-1].interm.function); 4324 (yyval.interm).loc = (yyvsp[0].lex).loc; 4325 } 4326 #line 4327 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4327 break; 4328 4329 case 104: 4330 #line 814 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4331 { 4332 (yyval.interm.function) = (yyvsp[0].interm.function); 4333 } 4334 #line 4335 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4335 break; 4336 4337 case 105: 4338 #line 817 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4339 { 4340 (yyval.interm.function) = (yyvsp[0].interm.function); 4341 } 4342 #line 4343 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4343 break; 4344 4345 case 106: 4346 #line 824 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4347 { 4348 // Add the parameter 4349 (yyval.interm.function) = (yyvsp[-1].interm.function); 4350 if ((yyvsp[0].interm).param.type->getBasicType() != EbtVoid) 4351 (yyvsp[-1].interm.function)->addParameter((yyvsp[0].interm).param); 4352 else 4353 delete (yyvsp[0].interm).param.type; 4354 } 4355 #line 4356 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4356 break; 4357 4358 case 107: 4359 #line 832 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4360 { 4361 // 4362 // Only first parameter of one-parameter functions can be void 4363 // The check for named parameters not being void is done in parameter_declarator 4364 // 4365 if ((yyvsp[0].interm).param.type->getBasicType() == EbtVoid) { 4366 // 4367 // This parameter > first is void 4368 // 4369 parseContext.error((yyvsp[-1].lex).loc, "cannot be an argument type except for '(void)'", "void", ""); 4370 delete (yyvsp[0].interm).param.type; 4371 } else { 4372 // Add the parameter 4373 (yyval.interm.function) = (yyvsp[-2].interm.function); 4374 (yyvsp[-2].interm.function)->addParameter((yyvsp[0].interm).param); 4375 } 4376 } 4377 #line 4378 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4378 break; 4379 4380 case 108: 4381 #line 852 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4382 { 4383 if ((yyvsp[-2].interm.type).qualifier.storage != EvqGlobal && (yyvsp[-2].interm.type).qualifier.storage != EvqTemporary) { 4384 parseContext.error((yyvsp[-1].lex).loc, "no qualifiers allowed for function return", 4385 GetStorageQualifierString((yyvsp[-2].interm.type).qualifier.storage), ""); 4386 } 4387 if ((yyvsp[-2].interm.type).arraySizes) 4388 parseContext.arraySizeRequiredCheck((yyvsp[-2].interm.type).loc, *(yyvsp[-2].interm.type).arraySizes); 4389 4390 // Add the function as a prototype after parsing it (we do not support recursion) 4391 TFunction *function; 4392 TType type((yyvsp[-2].interm.type)); 4393 function = new TFunction((yyvsp[-1].lex).string, type); 4394 (yyval.interm.function) = function; 4395 } 4396 #line 4397 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4397 break; 4398 4399 case 109: 4400 #line 870 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4401 { 4402 if ((yyvsp[-1].interm.type).arraySizes) { 4403 parseContext.profileRequires((yyvsp[-1].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); 4404 parseContext.profileRequires((yyvsp[-1].interm.type).loc, EEsProfile, 300, 0, "arrayed type"); 4405 parseContext.arraySizeRequiredCheck((yyvsp[-1].interm.type).loc, *(yyvsp[-1].interm.type).arraySizes); 4406 } 4407 if ((yyvsp[-1].interm.type).basicType == EbtVoid) { 4408 parseContext.error((yyvsp[0].lex).loc, "illegal use of type 'void'", (yyvsp[0].lex).string->c_str(), ""); 4409 } 4410 parseContext.reservedErrorCheck((yyvsp[0].lex).loc, *(yyvsp[0].lex).string); 4411 4412 TParameter param = {(yyvsp[0].lex).string, new TType((yyvsp[-1].interm.type))}; 4413 (yyval.interm).loc = (yyvsp[0].lex).loc; 4414 (yyval.interm).param = param; 4415 } 4416 #line 4417 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4417 break; 4418 4419 case 110: 4420 #line 885 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4421 { 4422 if ((yyvsp[-2].interm.type).arraySizes) { 4423 parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); 4424 parseContext.profileRequires((yyvsp[-2].interm.type).loc, EEsProfile, 300, 0, "arrayed type"); 4425 parseContext.arraySizeRequiredCheck((yyvsp[-2].interm.type).loc, *(yyvsp[-2].interm.type).arraySizes); 4426 } 4427 parseContext.arrayDimCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.type).arraySizes, (yyvsp[0].interm).arraySizes); 4428 4429 parseContext.arraySizeRequiredCheck((yyvsp[0].interm).loc, *(yyvsp[0].interm).arraySizes); 4430 parseContext.reservedErrorCheck((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string); 4431 4432 (yyvsp[-2].interm.type).arraySizes = (yyvsp[0].interm).arraySizes; 4433 4434 TParameter param = { (yyvsp[-1].lex).string, new TType((yyvsp[-2].interm.type))}; 4435 (yyval.interm).loc = (yyvsp[-1].lex).loc; 4436 (yyval.interm).param = param; 4437 } 4438 #line 4439 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4439 break; 4440 4441 case 111: 4442 #line 908 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4443 { 4444 (yyval.interm) = (yyvsp[0].interm); 4445 if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone) 4446 (yyval.interm).param.type->getQualifier().precision = (yyvsp[-1].interm.type).qualifier.precision; 4447 parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier()); 4448 4449 parseContext.checkNoShaderLayouts((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).shaderQualifiers); 4450 parseContext.parameterTypeCheck((yyvsp[0].interm).loc, (yyvsp[-1].interm.type).qualifier.storage, *(yyval.interm).param.type); 4451 parseContext.paramCheckFix((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, *(yyval.interm).param.type); 4452 4453 } 4454 #line 4455 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4455 break; 4456 4457 case 112: 4458 #line 919 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4459 { 4460 (yyval.interm) = (yyvsp[0].interm); 4461 4462 parseContext.parameterTypeCheck((yyvsp[0].interm).loc, EvqIn, *(yyvsp[0].interm).param.type); 4463 parseContext.paramCheckFix((yyvsp[0].interm).loc, EvqTemporary, *(yyval.interm).param.type); 4464 parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier()); 4465 } 4466 #line 4467 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4467 break; 4468 4469 case 113: 4470 #line 929 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4471 { 4472 (yyval.interm) = (yyvsp[0].interm); 4473 if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone) 4474 (yyval.interm).param.type->getQualifier().precision = (yyvsp[-1].interm.type).qualifier.precision; 4475 parseContext.precisionQualifierCheck((yyvsp[-1].interm.type).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier()); 4476 4477 parseContext.checkNoShaderLayouts((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).shaderQualifiers); 4478 parseContext.parameterTypeCheck((yyvsp[0].interm).loc, (yyvsp[-1].interm.type).qualifier.storage, *(yyval.interm).param.type); 4479 parseContext.paramCheckFix((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, *(yyval.interm).param.type); 4480 } 4481 #line 4482 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4482 break; 4483 4484 case 114: 4485 #line 939 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4486 { 4487 (yyval.interm) = (yyvsp[0].interm); 4488 4489 parseContext.parameterTypeCheck((yyvsp[0].interm).loc, EvqIn, *(yyvsp[0].interm).param.type); 4490 parseContext.paramCheckFix((yyvsp[0].interm).loc, EvqTemporary, *(yyval.interm).param.type); 4491 parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier()); 4492 } 4493 #line 4494 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4494 break; 4495 4496 case 115: 4497 #line 949 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4498 { 4499 TParameter param = { 0, new TType((yyvsp[0].interm.type)) }; 4500 (yyval.interm).param = param; 4501 if ((yyvsp[0].interm.type).arraySizes) 4502 parseContext.arraySizeRequiredCheck((yyvsp[0].interm.type).loc, *(yyvsp[0].interm.type).arraySizes); 4503 } 4504 #line 4505 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4505 break; 4506 4507 case 116: 4508 #line 958 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4509 { 4510 (yyval.interm) = (yyvsp[0].interm); 4511 } 4512 #line 4513 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4513 break; 4514 4515 case 117: 4516 #line 961 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4517 { 4518 (yyval.interm) = (yyvsp[-2].interm); 4519 parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-2].interm).type); 4520 } 4521 #line 4522 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4522 break; 4523 4524 case 118: 4525 #line 965 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4526 { 4527 (yyval.interm) = (yyvsp[-3].interm); 4528 parseContext.declareVariable((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string, (yyvsp[-3].interm).type, (yyvsp[0].interm).arraySizes); 4529 } 4530 #line 4531 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4531 break; 4532 4533 case 119: 4534 #line 969 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4535 { 4536 (yyval.interm).type = (yyvsp[-5].interm).type; 4537 TIntermNode* initNode = parseContext.declareVariable((yyvsp[-3].lex).loc, *(yyvsp[-3].lex).string, (yyvsp[-5].interm).type, (yyvsp[-2].interm).arraySizes, (yyvsp[0].interm.intermTypedNode)); 4538 (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-5].interm).intermNode, initNode, (yyvsp[-1].lex).loc); 4539 } 4540 #line 4541 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4541 break; 4542 4543 case 120: 4544 #line 974 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4545 { 4546 (yyval.interm).type = (yyvsp[-4].interm).type; 4547 TIntermNode* initNode = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-4].interm).type, 0, (yyvsp[0].interm.intermTypedNode)); 4548 (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-4].interm).intermNode, initNode, (yyvsp[-1].lex).loc); 4549 } 4550 #line 4551 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4551 break; 4552 4553 case 121: 4554 #line 982 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4555 { 4556 (yyval.interm).type = (yyvsp[0].interm.type); 4557 (yyval.interm).intermNode = 0; 4558 parseContext.declareTypeDefaults((yyval.interm).loc, (yyval.interm).type); 4559 } 4560 #line 4561 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4561 break; 4562 4563 case 122: 4564 #line 987 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4565 { 4566 (yyval.interm).type = (yyvsp[-1].interm.type); 4567 (yyval.interm).intermNode = 0; 4568 parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-1].interm.type)); 4569 } 4570 #line 4571 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4571 break; 4572 4573 case 123: 4574 #line 992 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4575 { 4576 (yyval.interm).type = (yyvsp[-2].interm.type); 4577 (yyval.interm).intermNode = 0; 4578 parseContext.declareVariable((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string, (yyvsp[-2].interm.type), (yyvsp[0].interm).arraySizes); 4579 } 4580 #line 4581 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4581 break; 4582 4583 case 124: 4584 #line 997 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4585 { 4586 (yyval.interm).type = (yyvsp[-4].interm.type); 4587 TIntermNode* initNode = parseContext.declareVariable((yyvsp[-3].lex).loc, *(yyvsp[-3].lex).string, (yyvsp[-4].interm.type), (yyvsp[-2].interm).arraySizes, (yyvsp[0].interm.intermTypedNode)); 4588 (yyval.interm).intermNode = parseContext.intermediate.growAggregate(0, initNode, (yyvsp[-1].lex).loc); 4589 } 4590 #line 4591 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4591 break; 4592 4593 case 125: 4594 #line 1002 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4595 { 4596 (yyval.interm).type = (yyvsp[-3].interm.type); 4597 TIntermNode* initNode = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-3].interm.type), 0, (yyvsp[0].interm.intermTypedNode)); 4598 (yyval.interm).intermNode = parseContext.intermediate.growAggregate(0, initNode, (yyvsp[-1].lex).loc); 4599 } 4600 #line 4601 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4601 break; 4602 4603 case 126: 4604 #line 1011 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4605 { 4606 (yyval.interm.type) = (yyvsp[0].interm.type); 4607 4608 parseContext.globalQualifierTypeCheck((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).qualifier, (yyval.interm.type)); 4609 if ((yyvsp[0].interm.type).arraySizes) { 4610 parseContext.profileRequires((yyvsp[0].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); 4611 parseContext.profileRequires((yyvsp[0].interm.type).loc, EEsProfile, 300, 0, "arrayed type"); 4612 } 4613 4614 parseContext.precisionQualifierCheck((yyval.interm.type).loc, (yyval.interm.type).basicType, (yyval.interm.type).qualifier); 4615 } 4616 #line 4617 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4617 break; 4618 4619 case 127: 4620 #line 1022 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4621 { 4622 parseContext.globalQualifierFixCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier); 4623 parseContext.globalQualifierTypeCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, (yyvsp[0].interm.type)); 4624 4625 if ((yyvsp[0].interm.type).arraySizes) { 4626 parseContext.profileRequires((yyvsp[0].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); 4627 parseContext.profileRequires((yyvsp[0].interm.type).loc, EEsProfile, 300, 0, "arrayed type"); 4628 } 4629 4630 if ((yyvsp[0].interm.type).arraySizes && parseContext.arrayQualifierError((yyvsp[0].interm.type).loc, (yyvsp[-1].interm.type).qualifier)) 4631 (yyvsp[0].interm.type).arraySizes = 0; 4632 4633 parseContext.checkNoShaderLayouts((yyvsp[0].interm.type).loc, (yyvsp[-1].interm.type).shaderQualifiers); 4634 (yyvsp[0].interm.type).shaderQualifiers.merge((yyvsp[-1].interm.type).shaderQualifiers); 4635 parseContext.mergeQualifiers((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).qualifier, (yyvsp[-1].interm.type).qualifier, true); 4636 parseContext.precisionQualifierCheck((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).basicType, (yyvsp[0].interm.type).qualifier); 4637 4638 (yyval.interm.type) = (yyvsp[0].interm.type); 4639 4640 if (! (yyval.interm.type).qualifier.isInterpolation() && 4641 ((parseContext.language == EShLangVertex && (yyval.interm.type).qualifier.storage == EvqVaryingOut) || 4642 (parseContext.language == EShLangFragment && (yyval.interm.type).qualifier.storage == EvqVaryingIn))) 4643 (yyval.interm.type).qualifier.smooth = true; 4644 } 4645 #line 4646 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4646 break; 4647 4648 case 128: 4649 #line 1049 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4650 { 4651 parseContext.globalCheck((yyvsp[0].lex).loc, "invariant"); 4652 parseContext.profileRequires((yyval.interm.type).loc, ENoProfile, 120, 0, "invariant"); 4653 (yyval.interm.type).init((yyvsp[0].lex).loc); 4654 (yyval.interm.type).qualifier.invariant = true; 4655 } 4656 #line 4657 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4657 break; 4658 4659 case 129: 4660 #line 1058 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4661 { 4662 parseContext.globalCheck((yyvsp[0].lex).loc, "smooth"); 4663 parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "smooth"); 4664 parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 300, 0, "smooth"); 4665 (yyval.interm.type).init((yyvsp[0].lex).loc); 4666 (yyval.interm.type).qualifier.smooth = true; 4667 } 4668 #line 4669 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4669 break; 4670 4671 case 130: 4672 #line 1065 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4673 { 4674 parseContext.globalCheck((yyvsp[0].lex).loc, "flat"); 4675 parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "flat"); 4676 parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 300, 0, "flat"); 4677 (yyval.interm.type).init((yyvsp[0].lex).loc); 4678 (yyval.interm.type).qualifier.flat = true; 4679 } 4680 #line 4681 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4681 break; 4682 4683 case 131: 4684 #line 1072 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4685 { 4686 parseContext.globalCheck((yyvsp[0].lex).loc, "noperspective"); 4687 parseContext.requireProfile((yyvsp[0].lex).loc, ~EEsProfile, "noperspective"); 4688 parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "noperspective"); 4689 (yyval.interm.type).init((yyvsp[0].lex).loc); 4690 (yyval.interm.type).qualifier.nopersp = true; 4691 } 4692 #line 4693 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4693 break; 4694 4695 case 132: 4696 #line 1079 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4697 { 4698 #ifdef AMD_EXTENSIONS 4699 parseContext.globalCheck((yyvsp[0].lex).loc, "__explicitInterpAMD"); 4700 parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 450, E_GL_AMD_shader_explicit_vertex_parameter, "explicit interpolation"); 4701 parseContext.profileRequires((yyvsp[0].lex).loc, ECompatibilityProfile, 450, E_GL_AMD_shader_explicit_vertex_parameter, "explicit interpolation"); 4702 (yyval.interm.type).init((yyvsp[0].lex).loc); 4703 (yyval.interm.type).qualifier.explicitInterp = true; 4704 #endif 4705 } 4706 #line 4707 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4707 break; 4708 4709 case 133: 4710 #line 1091 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4711 { 4712 (yyval.interm.type) = (yyvsp[-1].interm.type); 4713 } 4714 #line 4715 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4715 break; 4716 4717 case 134: 4718 #line 1097 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4719 { 4720 (yyval.interm.type) = (yyvsp[0].interm.type); 4721 } 4722 #line 4723 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4723 break; 4724 4725 case 135: 4726 #line 1100 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4727 { 4728 (yyval.interm.type) = (yyvsp[-2].interm.type); 4729 (yyval.interm.type).shaderQualifiers.merge((yyvsp[0].interm.type).shaderQualifiers); 4730 parseContext.mergeObjectLayoutQualifiers((yyval.interm.type).qualifier, (yyvsp[0].interm.type).qualifier, false); 4731 } 4732 #line 4733 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4733 break; 4734 4735 case 136: 4736 #line 1107 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4737 { 4738 (yyval.interm.type).init((yyvsp[0].lex).loc); 4739 parseContext.setLayoutQualifier((yyvsp[0].lex).loc, (yyval.interm.type), *(yyvsp[0].lex).string); 4740 } 4741 #line 4742 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4742 break; 4743 4744 case 137: 4745 #line 1111 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4746 { 4747 (yyval.interm.type).init((yyvsp[-2].lex).loc); 4748 parseContext.setLayoutQualifier((yyvsp[-2].lex).loc, (yyval.interm.type), *(yyvsp[-2].lex).string, (yyvsp[0].interm.intermTypedNode)); 4749 } 4750 #line 4751 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4751 break; 4752 4753 case 138: 4754 #line 1115 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4755 { // because "shared" is both an identifier and a keyword 4756 (yyval.interm.type).init((yyvsp[0].lex).loc); 4757 TString strShared("shared"); 4758 parseContext.setLayoutQualifier((yyvsp[0].lex).loc, (yyval.interm.type), strShared); 4759 } 4760 #line 4761 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4761 break; 4762 4763 case 139: 4764 #line 1123 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4765 { 4766 parseContext.profileRequires((yyval.interm.type).loc, ECoreProfile | ECompatibilityProfile, 400, E_GL_ARB_gpu_shader5, "precise"); 4767 parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 320, Num_AEP_gpu_shader5, AEP_gpu_shader5, "precise"); 4768 (yyval.interm.type).init((yyvsp[0].lex).loc); 4769 (yyval.interm.type).qualifier.noContraction = true; 4770 } 4771 #line 4772 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4772 break; 4773 4774 case 140: 4775 #line 1132 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4776 { 4777 (yyval.interm.type) = (yyvsp[0].interm.type); 4778 } 4779 #line 4780 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4780 break; 4781 4782 case 141: 4783 #line 1135 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4784 { 4785 (yyval.interm.type) = (yyvsp[-1].interm.type); 4786 if ((yyval.interm.type).basicType == EbtVoid) 4787 (yyval.interm.type).basicType = (yyvsp[0].interm.type).basicType; 4788 4789 (yyval.interm.type).shaderQualifiers.merge((yyvsp[0].interm.type).shaderQualifiers); 4790 parseContext.mergeQualifiers((yyval.interm.type).loc, (yyval.interm.type).qualifier, (yyvsp[0].interm.type).qualifier, false); 4791 } 4792 #line 4793 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4793 break; 4794 4795 case 142: 4796 #line 1146 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4797 { 4798 (yyval.interm.type) = (yyvsp[0].interm.type); 4799 } 4800 #line 4801 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4801 break; 4802 4803 case 143: 4804 #line 1149 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4805 { 4806 (yyval.interm.type) = (yyvsp[0].interm.type); 4807 } 4808 #line 4809 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4809 break; 4810 4811 case 144: 4812 #line 1152 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4813 { 4814 parseContext.checkPrecisionQualifier((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).qualifier.precision); 4815 (yyval.interm.type) = (yyvsp[0].interm.type); 4816 } 4817 #line 4818 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4818 break; 4819 4820 case 145: 4821 #line 1156 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4822 { 4823 // allow inheritance of storage qualifier from block declaration 4824 (yyval.interm.type) = (yyvsp[0].interm.type); 4825 } 4826 #line 4827 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4827 break; 4828 4829 case 146: 4830 #line 1160 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4831 { 4832 // allow inheritance of storage qualifier from block declaration 4833 (yyval.interm.type) = (yyvsp[0].interm.type); 4834 } 4835 #line 4836 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4836 break; 4837 4838 case 147: 4839 #line 1164 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4840 { 4841 // allow inheritance of storage qualifier from block declaration 4842 (yyval.interm.type) = (yyvsp[0].interm.type); 4843 } 4844 #line 4845 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4845 break; 4846 4847 case 148: 4848 #line 1171 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4849 { 4850 (yyval.interm.type).init((yyvsp[0].lex).loc); 4851 (yyval.interm.type).qualifier.storage = EvqConst; // will later turn into EvqConstReadOnly, if the initializer is not constant 4852 } 4853 #line 4854 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4854 break; 4855 4856 case 149: 4857 #line 1175 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4858 { 4859 parseContext.requireStage((yyvsp[0].lex).loc, EShLangVertex, "attribute"); 4860 parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "attribute"); 4861 parseContext.checkDeprecated((yyvsp[0].lex).loc, ENoProfile, 130, "attribute"); 4862 parseContext.requireNotRemoved((yyvsp[0].lex).loc, ECoreProfile, 420, "attribute"); 4863 parseContext.requireNotRemoved((yyvsp[0].lex).loc, EEsProfile, 300, "attribute"); 4864 4865 parseContext.globalCheck((yyvsp[0].lex).loc, "attribute"); 4866 4867 (yyval.interm.type).init((yyvsp[0].lex).loc); 4868 (yyval.interm.type).qualifier.storage = EvqVaryingIn; 4869 } 4870 #line 4871 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4871 break; 4872 4873 case 150: 4874 #line 1187 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4875 { 4876 parseContext.checkDeprecated((yyvsp[0].lex).loc, ENoProfile, 130, "varying"); 4877 parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "varying"); 4878 parseContext.requireNotRemoved((yyvsp[0].lex).loc, ECoreProfile, 420, "varying"); 4879 parseContext.requireNotRemoved((yyvsp[0].lex).loc, EEsProfile, 300, "varying"); 4880 4881 parseContext.globalCheck((yyvsp[0].lex).loc, "varying"); 4882 4883 (yyval.interm.type).init((yyvsp[0].lex).loc); 4884 if (parseContext.language == EShLangVertex) 4885 (yyval.interm.type).qualifier.storage = EvqVaryingOut; 4886 else 4887 (yyval.interm.type).qualifier.storage = EvqVaryingIn; 4888 } 4889 #line 4890 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4890 break; 4891 4892 case 151: 4893 #line 1201 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4894 { 4895 parseContext.globalCheck((yyvsp[0].lex).loc, "inout"); 4896 (yyval.interm.type).init((yyvsp[0].lex).loc); 4897 (yyval.interm.type).qualifier.storage = EvqInOut; 4898 } 4899 #line 4900 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4900 break; 4901 4902 case 152: 4903 #line 1206 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4904 { 4905 parseContext.globalCheck((yyvsp[0].lex).loc, "in"); 4906 (yyval.interm.type).init((yyvsp[0].lex).loc); 4907 // whether this is a parameter "in" or a pipeline "in" will get sorted out a bit later 4908 (yyval.interm.type).qualifier.storage = EvqIn; 4909 } 4910 #line 4911 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4911 break; 4912 4913 case 153: 4914 #line 1212 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4915 { 4916 parseContext.globalCheck((yyvsp[0].lex).loc, "out"); 4917 (yyval.interm.type).init((yyvsp[0].lex).loc); 4918 // whether this is a parameter "out" or a pipeline "out" will get sorted out a bit later 4919 (yyval.interm.type).qualifier.storage = EvqOut; 4920 } 4921 #line 4922 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4922 break; 4923 4924 case 154: 4925 #line 1218 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4926 { 4927 parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 120, 0, "centroid"); 4928 parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 300, 0, "centroid"); 4929 parseContext.globalCheck((yyvsp[0].lex).loc, "centroid"); 4930 (yyval.interm.type).init((yyvsp[0].lex).loc); 4931 (yyval.interm.type).qualifier.centroid = true; 4932 } 4933 #line 4934 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4934 break; 4935 4936 case 155: 4937 #line 1225 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4938 { 4939 parseContext.globalCheck((yyvsp[0].lex).loc, "patch"); 4940 parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangTessControlMask | EShLangTessEvaluationMask), "patch"); 4941 (yyval.interm.type).init((yyvsp[0].lex).loc); 4942 (yyval.interm.type).qualifier.patch = true; 4943 } 4944 #line 4945 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4945 break; 4946 4947 case 156: 4948 #line 1231 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4949 { 4950 parseContext.globalCheck((yyvsp[0].lex).loc, "sample"); 4951 (yyval.interm.type).init((yyvsp[0].lex).loc); 4952 (yyval.interm.type).qualifier.sample = true; 4953 } 4954 #line 4955 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4955 break; 4956 4957 case 157: 4958 #line 1236 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4959 { 4960 parseContext.globalCheck((yyvsp[0].lex).loc, "uniform"); 4961 (yyval.interm.type).init((yyvsp[0].lex).loc); 4962 (yyval.interm.type).qualifier.storage = EvqUniform; 4963 } 4964 #line 4965 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4965 break; 4966 4967 case 158: 4968 #line 1241 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4969 { 4970 parseContext.globalCheck((yyvsp[0].lex).loc, "buffer"); 4971 (yyval.interm.type).init((yyvsp[0].lex).loc); 4972 (yyval.interm.type).qualifier.storage = EvqBuffer; 4973 } 4974 #line 4975 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4975 break; 4976 4977 case 159: 4978 #line 1246 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4979 { 4980 parseContext.globalCheck((yyvsp[0].lex).loc, "shared"); 4981 parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, 430, E_GL_ARB_compute_shader, "shared"); 4982 parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 310, 0, "shared"); 4983 parseContext.requireStage((yyvsp[0].lex).loc, EShLangCompute, "shared"); 4984 (yyval.interm.type).init((yyvsp[0].lex).loc); 4985 (yyval.interm.type).qualifier.storage = EvqShared; 4986 } 4987 #line 4988 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4988 break; 4989 4990 case 160: 4991 #line 1254 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4992 { 4993 (yyval.interm.type).init((yyvsp[0].lex).loc); 4994 (yyval.interm.type).qualifier.coherent = true; 4995 } 4996 #line 4997 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4997 break; 4998 4999 case 161: 5000 #line 1258 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5001 { 5002 (yyval.interm.type).init((yyvsp[0].lex).loc); 5003 (yyval.interm.type).qualifier.volatil = true; 5004 } 5005 #line 5006 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5006 break; 5007 5008 case 162: 5009 #line 1262 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5010 { 5011 (yyval.interm.type).init((yyvsp[0].lex).loc); 5012 (yyval.interm.type).qualifier.restrict = true; 5013 } 5014 #line 5015 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5015 break; 5016 5017 case 163: 5018 #line 1266 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5019 { 5020 (yyval.interm.type).init((yyvsp[0].lex).loc); 5021 (yyval.interm.type).qualifier.readonly = true; 5022 } 5023 #line 5024 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5024 break; 5025 5026 case 164: 5027 #line 1270 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5028 { 5029 (yyval.interm.type).init((yyvsp[0].lex).loc); 5030 (yyval.interm.type).qualifier.writeonly = true; 5031 } 5032 #line 5033 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5033 break; 5034 5035 case 165: 5036 #line 1274 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5037 { 5038 parseContext.spvRemoved((yyvsp[0].lex).loc, "subroutine"); 5039 parseContext.globalCheck((yyvsp[0].lex).loc, "subroutine"); 5040 parseContext.unimplemented((yyvsp[0].lex).loc, "subroutine"); 5041 (yyval.interm.type).init((yyvsp[0].lex).loc); 5042 } 5043 #line 5044 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5044 break; 5045 5046 case 166: 5047 #line 1280 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5048 { 5049 parseContext.spvRemoved((yyvsp[-3].lex).loc, "subroutine"); 5050 parseContext.globalCheck((yyvsp[-3].lex).loc, "subroutine"); 5051 parseContext.unimplemented((yyvsp[-3].lex).loc, "subroutine"); 5052 (yyval.interm.type).init((yyvsp[-3].lex).loc); 5053 } 5054 #line 5055 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5055 break; 5056 5057 case 167: 5058 #line 1289 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5059 { 5060 // TODO 5061 } 5062 #line 5063 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5063 break; 5064 5065 case 168: 5066 #line 1292 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5067 { 5068 // TODO: 4.0 semantics: subroutines 5069 // 1) make sure each identifier is a type declared earlier with SUBROUTINE 5070 // 2) save all of the identifiers for future comparison with the declared function 5071 } 5072 #line 5073 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5073 break; 5074 5075 case 169: 5076 #line 1300 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5077 { 5078 (yyval.interm.type) = (yyvsp[0].interm.type); 5079 (yyval.interm.type).qualifier.precision = parseContext.getDefaultPrecision((yyval.interm.type)); 5080 } 5081 #line 5082 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5082 break; 5083 5084 case 170: 5085 #line 1304 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5086 { 5087 parseContext.arrayDimCheck((yyvsp[0].interm).loc, (yyvsp[0].interm).arraySizes, 0); 5088 (yyval.interm.type) = (yyvsp[-1].interm.type); 5089 (yyval.interm.type).qualifier.precision = parseContext.getDefaultPrecision((yyval.interm.type)); 5090 (yyval.interm.type).arraySizes = (yyvsp[0].interm).arraySizes; 5091 } 5092 #line 5093 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5093 break; 5094 5095 case 171: 5096 #line 1313 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5097 { 5098 (yyval.interm).loc = (yyvsp[-1].lex).loc; 5099 (yyval.interm).arraySizes = new TArraySizes; 5100 (yyval.interm).arraySizes->addInnerSize(); 5101 } 5102 #line 5103 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5103 break; 5104 5105 case 172: 5106 #line 1318 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5107 { 5108 (yyval.interm).loc = (yyvsp[-2].lex).loc; 5109 (yyval.interm).arraySizes = new TArraySizes; 5110 5111 TArraySize size; 5112 parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size); 5113 (yyval.interm).arraySizes->addInnerSize(size); 5114 } 5115 #line 5116 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5116 break; 5117 5118 case 173: 5119 #line 1326 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5120 { 5121 (yyval.interm) = (yyvsp[-2].interm); 5122 (yyval.interm).arraySizes->addInnerSize(); 5123 } 5124 #line 5125 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5125 break; 5126 5127 case 174: 5128 #line 1330 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5129 { 5130 (yyval.interm) = (yyvsp[-3].interm); 5131 5132 TArraySize size; 5133 parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size); 5134 (yyval.interm).arraySizes->addInnerSize(size); 5135 } 5136 #line 5137 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5137 break; 5138 5139 case 175: 5140 #line 1340 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5141 { 5142 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5143 (yyval.interm.type).basicType = EbtVoid; 5144 } 5145 #line 5146 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5146 break; 5147 5148 case 176: 5149 #line 1344 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5150 { 5151 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5152 (yyval.interm.type).basicType = EbtFloat; 5153 } 5154 #line 5155 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5155 break; 5156 5157 case 177: 5158 #line 1348 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5159 { 5160 parseContext.doubleCheck((yyvsp[0].lex).loc, "double"); 5161 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5162 (yyval.interm.type).basicType = EbtDouble; 5163 } 5164 #line 5165 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5165 break; 5166 5167 case 178: 5168 #line 1353 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5169 { 5170 #ifdef AMD_EXTENSIONS 5171 parseContext.float16Check((yyvsp[0].lex).loc, "half float", parseContext.symbolTable.atBuiltInLevel()); 5172 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5173 (yyval.interm.type).basicType = EbtFloat16; 5174 #endif 5175 } 5176 #line 5177 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5177 break; 5178 5179 case 179: 5180 #line 1360 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5181 { 5182 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5183 (yyval.interm.type).basicType = EbtInt; 5184 } 5185 #line 5186 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5186 break; 5187 5188 case 180: 5189 #line 1364 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5190 { 5191 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer"); 5192 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5193 (yyval.interm.type).basicType = EbtUint; 5194 } 5195 #line 5196 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5196 break; 5197 5198 case 181: 5199 #line 1369 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5200 { 5201 parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer", parseContext.symbolTable.atBuiltInLevel()); 5202 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5203 (yyval.interm.type).basicType = EbtInt64; 5204 } 5205 #line 5206 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5206 break; 5207 5208 case 182: 5209 #line 1374 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5210 { 5211 parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel()); 5212 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5213 (yyval.interm.type).basicType = EbtUint64; 5214 } 5215 #line 5216 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5216 break; 5217 5218 case 183: 5219 #line 1379 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5220 { 5221 #ifdef AMD_EXTENSIONS 5222 parseContext.int16Check((yyvsp[0].lex).loc, "16-bit integer", parseContext.symbolTable.atBuiltInLevel()); 5223 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5224 (yyval.interm.type).basicType = EbtInt16; 5225 #endif 5226 } 5227 #line 5228 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5228 break; 5229 5230 case 184: 5231 #line 1386 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5232 { 5233 #ifdef AMD_EXTENSIONS 5234 parseContext.int16Check((yyvsp[0].lex).loc, "16-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel()); 5235 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5236 (yyval.interm.type).basicType = EbtUint16; 5237 #endif 5238 } 5239 #line 5240 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5240 break; 5241 5242 case 185: 5243 #line 1393 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5244 { 5245 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5246 (yyval.interm.type).basicType = EbtBool; 5247 } 5248 #line 5249 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5249 break; 5250 5251 case 186: 5252 #line 1397 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5253 { 5254 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5255 (yyval.interm.type).basicType = EbtFloat; 5256 (yyval.interm.type).setVector(2); 5257 } 5258 #line 5259 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5259 break; 5260 5261 case 187: 5262 #line 1402 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5263 { 5264 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5265 (yyval.interm.type).basicType = EbtFloat; 5266 (yyval.interm.type).setVector(3); 5267 } 5268 #line 5269 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5269 break; 5270 5271 case 188: 5272 #line 1407 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5273 { 5274 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5275 (yyval.interm.type).basicType = EbtFloat; 5276 (yyval.interm.type).setVector(4); 5277 } 5278 #line 5279 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5279 break; 5280 5281 case 189: 5282 #line 1412 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5283 { 5284 parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector"); 5285 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5286 (yyval.interm.type).basicType = EbtDouble; 5287 (yyval.interm.type).setVector(2); 5288 } 5289 #line 5290 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5290 break; 5291 5292 case 190: 5293 #line 1418 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5294 { 5295 parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector"); 5296 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5297 (yyval.interm.type).basicType = EbtDouble; 5298 (yyval.interm.type).setVector(3); 5299 } 5300 #line 5301 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5301 break; 5302 5303 case 191: 5304 #line 1424 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5305 { 5306 parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector"); 5307 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5308 (yyval.interm.type).basicType = EbtDouble; 5309 (yyval.interm.type).setVector(4); 5310 } 5311 #line 5312 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5312 break; 5313 5314 case 192: 5315 #line 1430 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5316 { 5317 #ifdef AMD_EXTENSIONS 5318 parseContext.float16Check((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); 5319 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5320 (yyval.interm.type).basicType = EbtFloat16; 5321 (yyval.interm.type).setVector(2); 5322 #endif 5323 } 5324 #line 5325 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5325 break; 5326 5327 case 193: 5328 #line 1438 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5329 { 5330 #ifdef AMD_EXTENSIONS 5331 parseContext.float16Check((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); 5332 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5333 (yyval.interm.type).basicType = EbtFloat16; 5334 (yyval.interm.type).setVector(3); 5335 #endif 5336 } 5337 #line 5338 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5338 break; 5339 5340 case 194: 5341 #line 1446 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5342 { 5343 #ifdef AMD_EXTENSIONS 5344 parseContext.float16Check((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); 5345 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5346 (yyval.interm.type).basicType = EbtFloat16; 5347 (yyval.interm.type).setVector(4); 5348 #endif 5349 } 5350 #line 5351 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5351 break; 5352 5353 case 195: 5354 #line 1454 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5355 { 5356 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5357 (yyval.interm.type).basicType = EbtBool; 5358 (yyval.interm.type).setVector(2); 5359 } 5360 #line 5361 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5361 break; 5362 5363 case 196: 5364 #line 1459 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5365 { 5366 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5367 (yyval.interm.type).basicType = EbtBool; 5368 (yyval.interm.type).setVector(3); 5369 } 5370 #line 5371 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5371 break; 5372 5373 case 197: 5374 #line 1464 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5375 { 5376 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5377 (yyval.interm.type).basicType = EbtBool; 5378 (yyval.interm.type).setVector(4); 5379 } 5380 #line 5381 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5381 break; 5382 5383 case 198: 5384 #line 1469 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5385 { 5386 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5387 (yyval.interm.type).basicType = EbtInt; 5388 (yyval.interm.type).setVector(2); 5389 } 5390 #line 5391 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5391 break; 5392 5393 case 199: 5394 #line 1474 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5395 { 5396 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5397 (yyval.interm.type).basicType = EbtInt; 5398 (yyval.interm.type).setVector(3); 5399 } 5400 #line 5401 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5401 break; 5402 5403 case 200: 5404 #line 1479 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5405 { 5406 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5407 (yyval.interm.type).basicType = EbtInt; 5408 (yyval.interm.type).setVector(4); 5409 } 5410 #line 5411 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5411 break; 5412 5413 case 201: 5414 #line 1484 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5415 { 5416 parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); 5417 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5418 (yyval.interm.type).basicType = EbtInt64; 5419 (yyval.interm.type).setVector(2); 5420 } 5421 #line 5422 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5422 break; 5423 5424 case 202: 5425 #line 1490 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5426 { 5427 parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); 5428 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5429 (yyval.interm.type).basicType = EbtInt64; 5430 (yyval.interm.type).setVector(3); 5431 } 5432 #line 5433 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5433 break; 5434 5435 case 203: 5436 #line 1496 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5437 { 5438 parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); 5439 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5440 (yyval.interm.type).basicType = EbtInt64; 5441 (yyval.interm.type).setVector(4); 5442 } 5443 #line 5444 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5444 break; 5445 5446 case 204: 5447 #line 1502 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5448 { 5449 #ifdef AMD_EXTENSIONS 5450 parseContext.int16Check((yyvsp[0].lex).loc, "16-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); 5451 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5452 (yyval.interm.type).basicType = EbtInt16; 5453 (yyval.interm.type).setVector(2); 5454 #endif 5455 } 5456 #line 5457 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5457 break; 5458 5459 case 205: 5460 #line 1510 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5461 { 5462 #ifdef AMD_EXTENSIONS 5463 parseContext.int16Check((yyvsp[0].lex).loc, "16-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); 5464 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5465 (yyval.interm.type).basicType = EbtInt16; 5466 (yyval.interm.type).setVector(3); 5467 #endif 5468 } 5469 #line 5470 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5470 break; 5471 5472 case 206: 5473 #line 1518 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5474 { 5475 #ifdef AMD_EXTENSIONS 5476 parseContext.int16Check((yyvsp[0].lex).loc, "16-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); 5477 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5478 (yyval.interm.type).basicType = EbtInt16; 5479 (yyval.interm.type).setVector(4); 5480 #endif 5481 } 5482 #line 5483 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5483 break; 5484 5485 case 207: 5486 #line 1526 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5487 { 5488 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector"); 5489 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5490 (yyval.interm.type).basicType = EbtUint; 5491 (yyval.interm.type).setVector(2); 5492 } 5493 #line 5494 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5494 break; 5495 5496 case 208: 5497 #line 1532 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5498 { 5499 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector"); 5500 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5501 (yyval.interm.type).basicType = EbtUint; 5502 (yyval.interm.type).setVector(3); 5503 } 5504 #line 5505 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5505 break; 5506 5507 case 209: 5508 #line 1538 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5509 { 5510 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector"); 5511 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5512 (yyval.interm.type).basicType = EbtUint; 5513 (yyval.interm.type).setVector(4); 5514 } 5515 #line 5516 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5516 break; 5517 5518 case 210: 5519 #line 1544 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5520 { 5521 parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); 5522 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5523 (yyval.interm.type).basicType = EbtUint64; 5524 (yyval.interm.type).setVector(2); 5525 } 5526 #line 5527 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5527 break; 5528 5529 case 211: 5530 #line 1550 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5531 { 5532 parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); 5533 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5534 (yyval.interm.type).basicType = EbtUint64; 5535 (yyval.interm.type).setVector(3); 5536 } 5537 #line 5538 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5538 break; 5539 5540 case 212: 5541 #line 1556 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5542 { 5543 parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); 5544 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5545 (yyval.interm.type).basicType = EbtUint64; 5546 (yyval.interm.type).setVector(4); 5547 } 5548 #line 5549 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5549 break; 5550 5551 case 213: 5552 #line 1562 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5553 { 5554 #ifdef AMD_EXTENSIONS 5555 parseContext.int16Check((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); 5556 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5557 (yyval.interm.type).basicType = EbtUint16; 5558 (yyval.interm.type).setVector(2); 5559 #endif 5560 } 5561 #line 5562 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5562 break; 5563 5564 case 214: 5565 #line 1570 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5566 { 5567 #ifdef AMD_EXTENSIONS 5568 parseContext.int16Check((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); 5569 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5570 (yyval.interm.type).basicType = EbtUint16; 5571 (yyval.interm.type).setVector(3); 5572 #endif 5573 } 5574 #line 5575 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5575 break; 5576 5577 case 215: 5578 #line 1578 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5579 { 5580 #ifdef AMD_EXTENSIONS 5581 parseContext.int16Check((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); 5582 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5583 (yyval.interm.type).basicType = EbtUint16; 5584 (yyval.interm.type).setVector(4); 5585 #endif 5586 } 5587 #line 5588 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5588 break; 5589 5590 case 216: 5591 #line 1586 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5592 { 5593 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5594 (yyval.interm.type).basicType = EbtFloat; 5595 (yyval.interm.type).setMatrix(2, 2); 5596 } 5597 #line 5598 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5598 break; 5599 5600 case 217: 5601 #line 1591 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5602 { 5603 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5604 (yyval.interm.type).basicType = EbtFloat; 5605 (yyval.interm.type).setMatrix(3, 3); 5606 } 5607 #line 5608 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5608 break; 5609 5610 case 218: 5611 #line 1596 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5612 { 5613 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5614 (yyval.interm.type).basicType = EbtFloat; 5615 (yyval.interm.type).setMatrix(4, 4); 5616 } 5617 #line 5618 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5618 break; 5619 5620 case 219: 5621 #line 1601 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5622 { 5623 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5624 (yyval.interm.type).basicType = EbtFloat; 5625 (yyval.interm.type).setMatrix(2, 2); 5626 } 5627 #line 5628 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5628 break; 5629 5630 case 220: 5631 #line 1606 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5632 { 5633 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5634 (yyval.interm.type).basicType = EbtFloat; 5635 (yyval.interm.type).setMatrix(2, 3); 5636 } 5637 #line 5638 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5638 break; 5639 5640 case 221: 5641 #line 1611 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5642 { 5643 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5644 (yyval.interm.type).basicType = EbtFloat; 5645 (yyval.interm.type).setMatrix(2, 4); 5646 } 5647 #line 5648 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5648 break; 5649 5650 case 222: 5651 #line 1616 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5652 { 5653 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5654 (yyval.interm.type).basicType = EbtFloat; 5655 (yyval.interm.type).setMatrix(3, 2); 5656 } 5657 #line 5658 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5658 break; 5659 5660 case 223: 5661 #line 1621 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5662 { 5663 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5664 (yyval.interm.type).basicType = EbtFloat; 5665 (yyval.interm.type).setMatrix(3, 3); 5666 } 5667 #line 5668 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5668 break; 5669 5670 case 224: 5671 #line 1626 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5672 { 5673 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5674 (yyval.interm.type).basicType = EbtFloat; 5675 (yyval.interm.type).setMatrix(3, 4); 5676 } 5677 #line 5678 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5678 break; 5679 5680 case 225: 5681 #line 1631 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5682 { 5683 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5684 (yyval.interm.type).basicType = EbtFloat; 5685 (yyval.interm.type).setMatrix(4, 2); 5686 } 5687 #line 5688 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5688 break; 5689 5690 case 226: 5691 #line 1636 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5692 { 5693 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5694 (yyval.interm.type).basicType = EbtFloat; 5695 (yyval.interm.type).setMatrix(4, 3); 5696 } 5697 #line 5698 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5698 break; 5699 5700 case 227: 5701 #line 1641 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5702 { 5703 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5704 (yyval.interm.type).basicType = EbtFloat; 5705 (yyval.interm.type).setMatrix(4, 4); 5706 } 5707 #line 5708 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5708 break; 5709 5710 case 228: 5711 #line 1646 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5712 { 5713 parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); 5714 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5715 (yyval.interm.type).basicType = EbtDouble; 5716 (yyval.interm.type).setMatrix(2, 2); 5717 } 5718 #line 5719 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5719 break; 5720 5721 case 229: 5722 #line 1652 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5723 { 5724 parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); 5725 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5726 (yyval.interm.type).basicType = EbtDouble; 5727 (yyval.interm.type).setMatrix(3, 3); 5728 } 5729 #line 5730 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5730 break; 5731 5732 case 230: 5733 #line 1658 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5734 { 5735 parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); 5736 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5737 (yyval.interm.type).basicType = EbtDouble; 5738 (yyval.interm.type).setMatrix(4, 4); 5739 } 5740 #line 5741 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5741 break; 5742 5743 case 231: 5744 #line 1664 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5745 { 5746 parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); 5747 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5748 (yyval.interm.type).basicType = EbtDouble; 5749 (yyval.interm.type).setMatrix(2, 2); 5750 } 5751 #line 5752 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5752 break; 5753 5754 case 232: 5755 #line 1670 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5756 { 5757 parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); 5758 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5759 (yyval.interm.type).basicType = EbtDouble; 5760 (yyval.interm.type).setMatrix(2, 3); 5761 } 5762 #line 5763 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5763 break; 5764 5765 case 233: 5766 #line 1676 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5767 { 5768 parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); 5769 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5770 (yyval.interm.type).basicType = EbtDouble; 5771 (yyval.interm.type).setMatrix(2, 4); 5772 } 5773 #line 5774 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5774 break; 5775 5776 case 234: 5777 #line 1682 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5778 { 5779 parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); 5780 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5781 (yyval.interm.type).basicType = EbtDouble; 5782 (yyval.interm.type).setMatrix(3, 2); 5783 } 5784 #line 5785 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5785 break; 5786 5787 case 235: 5788 #line 1688 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5789 { 5790 parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); 5791 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5792 (yyval.interm.type).basicType = EbtDouble; 5793 (yyval.interm.type).setMatrix(3, 3); 5794 } 5795 #line 5796 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5796 break; 5797 5798 case 236: 5799 #line 1694 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5800 { 5801 parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); 5802 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5803 (yyval.interm.type).basicType = EbtDouble; 5804 (yyval.interm.type).setMatrix(3, 4); 5805 } 5806 #line 5807 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5807 break; 5808 5809 case 237: 5810 #line 1700 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5811 { 5812 parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); 5813 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5814 (yyval.interm.type).basicType = EbtDouble; 5815 (yyval.interm.type).setMatrix(4, 2); 5816 } 5817 #line 5818 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5818 break; 5819 5820 case 238: 5821 #line 1706 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5822 { 5823 parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); 5824 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5825 (yyval.interm.type).basicType = EbtDouble; 5826 (yyval.interm.type).setMatrix(4, 3); 5827 } 5828 #line 5829 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5829 break; 5830 5831 case 239: 5832 #line 1712 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5833 { 5834 parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); 5835 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5836 (yyval.interm.type).basicType = EbtDouble; 5837 (yyval.interm.type).setMatrix(4, 4); 5838 } 5839 #line 5840 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5840 break; 5841 5842 case 240: 5843 #line 1718 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5844 { 5845 #ifdef AMD_EXTENSIONS 5846 parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); 5847 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5848 (yyval.interm.type).basicType = EbtFloat16; 5849 (yyval.interm.type).setMatrix(2, 2); 5850 #endif 5851 } 5852 #line 5853 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5853 break; 5854 5855 case 241: 5856 #line 1726 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5857 { 5858 #ifdef AMD_EXTENSIONS 5859 parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); 5860 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5861 (yyval.interm.type).basicType = EbtFloat16; 5862 (yyval.interm.type).setMatrix(3, 3); 5863 #endif 5864 } 5865 #line 5866 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5866 break; 5867 5868 case 242: 5869 #line 1734 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5870 { 5871 #ifdef AMD_EXTENSIONS 5872 parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); 5873 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5874 (yyval.interm.type).basicType = EbtFloat16; 5875 (yyval.interm.type).setMatrix(4, 4); 5876 #endif 5877 } 5878 #line 5879 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5879 break; 5880 5881 case 243: 5882 #line 1742 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5883 { 5884 #ifdef AMD_EXTENSIONS 5885 parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); 5886 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5887 (yyval.interm.type).basicType = EbtFloat16; 5888 (yyval.interm.type).setMatrix(2, 2); 5889 #endif 5890 } 5891 #line 5892 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5892 break; 5893 5894 case 244: 5895 #line 1750 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5896 { 5897 #ifdef AMD_EXTENSIONS 5898 parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); 5899 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5900 (yyval.interm.type).basicType = EbtFloat16; 5901 (yyval.interm.type).setMatrix(2, 3); 5902 #endif 5903 } 5904 #line 5905 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5905 break; 5906 5907 case 245: 5908 #line 1758 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5909 { 5910 #ifdef AMD_EXTENSIONS 5911 parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); 5912 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5913 (yyval.interm.type).basicType = EbtFloat16; 5914 (yyval.interm.type).setMatrix(2, 4); 5915 #endif 5916 } 5917 #line 5918 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5918 break; 5919 5920 case 246: 5921 #line 1766 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5922 { 5923 #ifdef AMD_EXTENSIONS 5924 parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); 5925 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5926 (yyval.interm.type).basicType = EbtFloat16; 5927 (yyval.interm.type).setMatrix(3, 2); 5928 #endif 5929 } 5930 #line 5931 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5931 break; 5932 5933 case 247: 5934 #line 1774 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5935 { 5936 #ifdef AMD_EXTENSIONS 5937 parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); 5938 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5939 (yyval.interm.type).basicType = EbtFloat16; 5940 (yyval.interm.type).setMatrix(3, 3); 5941 #endif 5942 } 5943 #line 5944 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5944 break; 5945 5946 case 248: 5947 #line 1782 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5948 { 5949 #ifdef AMD_EXTENSIONS 5950 parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); 5951 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5952 (yyval.interm.type).basicType = EbtFloat16; 5953 (yyval.interm.type).setMatrix(3, 4); 5954 #endif 5955 } 5956 #line 5957 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5957 break; 5958 5959 case 249: 5960 #line 1790 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5961 { 5962 #ifdef AMD_EXTENSIONS 5963 parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); 5964 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5965 (yyval.interm.type).basicType = EbtFloat16; 5966 (yyval.interm.type).setMatrix(4, 2); 5967 #endif 5968 } 5969 #line 5970 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5970 break; 5971 5972 case 250: 5973 #line 1798 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5974 { 5975 #ifdef AMD_EXTENSIONS 5976 parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); 5977 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5978 (yyval.interm.type).basicType = EbtFloat16; 5979 (yyval.interm.type).setMatrix(4, 3); 5980 #endif 5981 } 5982 #line 5983 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5983 break; 5984 5985 case 251: 5986 #line 1806 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5987 { 5988 #ifdef AMD_EXTENSIONS 5989 parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); 5990 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 5991 (yyval.interm.type).basicType = EbtFloat16; 5992 (yyval.interm.type).setMatrix(4, 4); 5993 #endif 5994 } 5995 #line 5996 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5996 break; 5997 5998 case 252: 5999 #line 1814 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6000 { 6001 parseContext.vulkanRemoved((yyvsp[0].lex).loc, "atomic counter types"); 6002 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6003 (yyval.interm.type).basicType = EbtAtomicUint; 6004 } 6005 #line 6006 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6006 break; 6007 6008 case 253: 6009 #line 1819 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6010 { 6011 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6012 (yyval.interm.type).basicType = EbtSampler; 6013 (yyval.interm.type).sampler.set(EbtFloat, Esd1D); 6014 } 6015 #line 6016 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6016 break; 6017 6018 case 254: 6019 #line 1824 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6020 { 6021 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6022 (yyval.interm.type).basicType = EbtSampler; 6023 (yyval.interm.type).sampler.set(EbtFloat, Esd2D); 6024 } 6025 #line 6026 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6026 break; 6027 6028 case 255: 6029 #line 1829 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6030 { 6031 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6032 (yyval.interm.type).basicType = EbtSampler; 6033 (yyval.interm.type).sampler.set(EbtFloat, Esd3D); 6034 } 6035 #line 6036 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6036 break; 6037 6038 case 256: 6039 #line 1834 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6040 { 6041 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6042 (yyval.interm.type).basicType = EbtSampler; 6043 (yyval.interm.type).sampler.set(EbtFloat, EsdCube); 6044 } 6045 #line 6046 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6046 break; 6047 6048 case 257: 6049 #line 1839 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6050 { 6051 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6052 (yyval.interm.type).basicType = EbtSampler; 6053 (yyval.interm.type).sampler.set(EbtFloat, Esd1D, false, true); 6054 } 6055 #line 6056 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6056 break; 6057 6058 case 258: 6059 #line 1844 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6060 { 6061 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6062 (yyval.interm.type).basicType = EbtSampler; 6063 (yyval.interm.type).sampler.set(EbtFloat, Esd2D, false, true); 6064 } 6065 #line 6066 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6066 break; 6067 6068 case 259: 6069 #line 1849 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6070 { 6071 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6072 (yyval.interm.type).basicType = EbtSampler; 6073 (yyval.interm.type).sampler.set(EbtFloat, EsdCube, false, true); 6074 } 6075 #line 6076 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6076 break; 6077 6078 case 260: 6079 #line 1854 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6080 { 6081 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6082 (yyval.interm.type).basicType = EbtSampler; 6083 (yyval.interm.type).sampler.set(EbtFloat, Esd1D, true); 6084 } 6085 #line 6086 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6086 break; 6087 6088 case 261: 6089 #line 1859 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6090 { 6091 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6092 (yyval.interm.type).basicType = EbtSampler; 6093 (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true); 6094 } 6095 #line 6096 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6096 break; 6097 6098 case 262: 6099 #line 1864 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6100 { 6101 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6102 (yyval.interm.type).basicType = EbtSampler; 6103 (yyval.interm.type).sampler.set(EbtFloat, Esd1D, true, true); 6104 } 6105 #line 6106 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6106 break; 6107 6108 case 263: 6109 #line 1869 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6110 { 6111 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6112 (yyval.interm.type).basicType = EbtSampler; 6113 (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true, true); 6114 } 6115 #line 6116 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6116 break; 6117 6118 case 264: 6119 #line 1874 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6120 { 6121 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6122 (yyval.interm.type).basicType = EbtSampler; 6123 (yyval.interm.type).sampler.set(EbtFloat, EsdCube, true); 6124 } 6125 #line 6126 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6126 break; 6127 6128 case 265: 6129 #line 1879 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6130 { 6131 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6132 (yyval.interm.type).basicType = EbtSampler; 6133 (yyval.interm.type).sampler.set(EbtFloat, EsdCube, true, true); 6134 } 6135 #line 6136 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6136 break; 6137 6138 case 266: 6139 #line 1884 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6140 { 6141 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6142 (yyval.interm.type).basicType = EbtSampler; 6143 (yyval.interm.type).sampler.set(EbtInt, Esd1D); 6144 } 6145 #line 6146 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6146 break; 6147 6148 case 267: 6149 #line 1889 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6150 { 6151 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6152 (yyval.interm.type).basicType = EbtSampler; 6153 (yyval.interm.type).sampler.set(EbtInt, Esd2D); 6154 } 6155 #line 6156 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6156 break; 6157 6158 case 268: 6159 #line 1894 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6160 { 6161 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6162 (yyval.interm.type).basicType = EbtSampler; 6163 (yyval.interm.type).sampler.set(EbtInt, Esd3D); 6164 } 6165 #line 6166 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6166 break; 6167 6168 case 269: 6169 #line 1899 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6170 { 6171 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6172 (yyval.interm.type).basicType = EbtSampler; 6173 (yyval.interm.type).sampler.set(EbtInt, EsdCube); 6174 } 6175 #line 6176 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6176 break; 6177 6178 case 270: 6179 #line 1904 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6180 { 6181 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6182 (yyval.interm.type).basicType = EbtSampler; 6183 (yyval.interm.type).sampler.set(EbtInt, Esd1D, true); 6184 } 6185 #line 6186 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6186 break; 6187 6188 case 271: 6189 #line 1909 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6190 { 6191 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6192 (yyval.interm.type).basicType = EbtSampler; 6193 (yyval.interm.type).sampler.set(EbtInt, Esd2D, true); 6194 } 6195 #line 6196 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6196 break; 6197 6198 case 272: 6199 #line 1914 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6200 { 6201 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6202 (yyval.interm.type).basicType = EbtSampler; 6203 (yyval.interm.type).sampler.set(EbtInt, EsdCube, true); 6204 } 6205 #line 6206 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6206 break; 6207 6208 case 273: 6209 #line 1919 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6210 { 6211 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6212 (yyval.interm.type).basicType = EbtSampler; 6213 (yyval.interm.type).sampler.set(EbtUint, Esd1D); 6214 } 6215 #line 6216 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6216 break; 6217 6218 case 274: 6219 #line 1924 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6220 { 6221 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6222 (yyval.interm.type).basicType = EbtSampler; 6223 (yyval.interm.type).sampler.set(EbtUint, Esd2D); 6224 } 6225 #line 6226 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6226 break; 6227 6228 case 275: 6229 #line 1929 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6230 { 6231 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6232 (yyval.interm.type).basicType = EbtSampler; 6233 (yyval.interm.type).sampler.set(EbtUint, Esd3D); 6234 } 6235 #line 6236 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6236 break; 6237 6238 case 276: 6239 #line 1934 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6240 { 6241 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6242 (yyval.interm.type).basicType = EbtSampler; 6243 (yyval.interm.type).sampler.set(EbtUint, EsdCube); 6244 } 6245 #line 6246 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6246 break; 6247 6248 case 277: 6249 #line 1939 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6250 { 6251 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6252 (yyval.interm.type).basicType = EbtSampler; 6253 (yyval.interm.type).sampler.set(EbtUint, Esd1D, true); 6254 } 6255 #line 6256 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6256 break; 6257 6258 case 278: 6259 #line 1944 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6260 { 6261 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6262 (yyval.interm.type).basicType = EbtSampler; 6263 (yyval.interm.type).sampler.set(EbtUint, Esd2D, true); 6264 } 6265 #line 6266 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6266 break; 6267 6268 case 279: 6269 #line 1949 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6270 { 6271 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6272 (yyval.interm.type).basicType = EbtSampler; 6273 (yyval.interm.type).sampler.set(EbtUint, EsdCube, true); 6274 } 6275 #line 6276 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6276 break; 6277 6278 case 280: 6279 #line 1954 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6280 { 6281 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6282 (yyval.interm.type).basicType = EbtSampler; 6283 (yyval.interm.type).sampler.set(EbtFloat, EsdRect); 6284 } 6285 #line 6286 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6286 break; 6287 6288 case 281: 6289 #line 1959 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6290 { 6291 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6292 (yyval.interm.type).basicType = EbtSampler; 6293 (yyval.interm.type).sampler.set(EbtFloat, EsdRect, false, true); 6294 } 6295 #line 6296 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6296 break; 6297 6298 case 282: 6299 #line 1964 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6300 { 6301 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6302 (yyval.interm.type).basicType = EbtSampler; 6303 (yyval.interm.type).sampler.set(EbtInt, EsdRect); 6304 } 6305 #line 6306 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6306 break; 6307 6308 case 283: 6309 #line 1969 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6310 { 6311 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6312 (yyval.interm.type).basicType = EbtSampler; 6313 (yyval.interm.type).sampler.set(EbtUint, EsdRect); 6314 } 6315 #line 6316 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6316 break; 6317 6318 case 284: 6319 #line 1974 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6320 { 6321 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6322 (yyval.interm.type).basicType = EbtSampler; 6323 (yyval.interm.type).sampler.set(EbtFloat, EsdBuffer); 6324 } 6325 #line 6326 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6326 break; 6327 6328 case 285: 6329 #line 1979 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6330 { 6331 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6332 (yyval.interm.type).basicType = EbtSampler; 6333 (yyval.interm.type).sampler.set(EbtInt, EsdBuffer); 6334 } 6335 #line 6336 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6336 break; 6337 6338 case 286: 6339 #line 1984 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6340 { 6341 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6342 (yyval.interm.type).basicType = EbtSampler; 6343 (yyval.interm.type).sampler.set(EbtUint, EsdBuffer); 6344 } 6345 #line 6346 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6346 break; 6347 6348 case 287: 6349 #line 1989 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6350 { 6351 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6352 (yyval.interm.type).basicType = EbtSampler; 6353 (yyval.interm.type).sampler.set(EbtFloat, Esd2D, false, false, true); 6354 } 6355 #line 6356 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6356 break; 6357 6358 case 288: 6359 #line 1994 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6360 { 6361 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6362 (yyval.interm.type).basicType = EbtSampler; 6363 (yyval.interm.type).sampler.set(EbtInt, Esd2D, false, false, true); 6364 } 6365 #line 6366 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6366 break; 6367 6368 case 289: 6369 #line 1999 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6370 { 6371 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6372 (yyval.interm.type).basicType = EbtSampler; 6373 (yyval.interm.type).sampler.set(EbtUint, Esd2D, false, false, true); 6374 } 6375 #line 6376 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6376 break; 6377 6378 case 290: 6379 #line 2004 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6380 { 6381 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6382 (yyval.interm.type).basicType = EbtSampler; 6383 (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true, false, true); 6384 } 6385 #line 6386 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6386 break; 6387 6388 case 291: 6389 #line 2009 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6390 { 6391 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6392 (yyval.interm.type).basicType = EbtSampler; 6393 (yyval.interm.type).sampler.set(EbtInt, Esd2D, true, false, true); 6394 } 6395 #line 6396 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6396 break; 6397 6398 case 292: 6399 #line 2014 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6400 { 6401 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6402 (yyval.interm.type).basicType = EbtSampler; 6403 (yyval.interm.type).sampler.set(EbtUint, Esd2D, true, false, true); 6404 } 6405 #line 6406 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6406 break; 6407 6408 case 293: 6409 #line 2019 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6410 { 6411 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6412 (yyval.interm.type).basicType = EbtSampler; 6413 (yyval.interm.type).sampler.setPureSampler(false); 6414 } 6415 #line 6416 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6416 break; 6417 6418 case 294: 6419 #line 2024 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6420 { 6421 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6422 (yyval.interm.type).basicType = EbtSampler; 6423 (yyval.interm.type).sampler.setPureSampler(true); 6424 } 6425 #line 6426 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6426 break; 6427 6428 case 295: 6429 #line 2029 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6430 { 6431 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6432 (yyval.interm.type).basicType = EbtSampler; 6433 (yyval.interm.type).sampler.setTexture(EbtFloat, Esd1D); 6434 } 6435 #line 6436 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6436 break; 6437 6438 case 296: 6439 #line 2034 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6440 { 6441 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6442 (yyval.interm.type).basicType = EbtSampler; 6443 (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D); 6444 } 6445 #line 6446 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6446 break; 6447 6448 case 297: 6449 #line 2039 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6450 { 6451 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6452 (yyval.interm.type).basicType = EbtSampler; 6453 (yyval.interm.type).sampler.setTexture(EbtFloat, Esd3D); 6454 } 6455 #line 6456 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6456 break; 6457 6458 case 298: 6459 #line 2044 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6460 { 6461 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6462 (yyval.interm.type).basicType = EbtSampler; 6463 (yyval.interm.type).sampler.setTexture(EbtFloat, EsdCube); 6464 } 6465 #line 6466 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6466 break; 6467 6468 case 299: 6469 #line 2049 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6470 { 6471 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6472 (yyval.interm.type).basicType = EbtSampler; 6473 (yyval.interm.type).sampler.setTexture(EbtFloat, Esd1D, true); 6474 } 6475 #line 6476 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6476 break; 6477 6478 case 300: 6479 #line 2054 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6480 { 6481 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6482 (yyval.interm.type).basicType = EbtSampler; 6483 (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, true); 6484 } 6485 #line 6486 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6486 break; 6487 6488 case 301: 6489 #line 2059 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6490 { 6491 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6492 (yyval.interm.type).basicType = EbtSampler; 6493 (yyval.interm.type).sampler.setTexture(EbtFloat, EsdCube, true); 6494 } 6495 #line 6496 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6496 break; 6497 6498 case 302: 6499 #line 2064 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6500 { 6501 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6502 (yyval.interm.type).basicType = EbtSampler; 6503 (yyval.interm.type).sampler.setTexture(EbtInt, Esd1D); 6504 } 6505 #line 6506 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6506 break; 6507 6508 case 303: 6509 #line 2069 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6510 { 6511 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6512 (yyval.interm.type).basicType = EbtSampler; 6513 (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D); 6514 } 6515 #line 6516 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6516 break; 6517 6518 case 304: 6519 #line 2074 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6520 { 6521 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6522 (yyval.interm.type).basicType = EbtSampler; 6523 (yyval.interm.type).sampler.setTexture(EbtInt, Esd3D); 6524 } 6525 #line 6526 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6526 break; 6527 6528 case 305: 6529 #line 2079 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6530 { 6531 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6532 (yyval.interm.type).basicType = EbtSampler; 6533 (yyval.interm.type).sampler.setTexture(EbtInt, EsdCube); 6534 } 6535 #line 6536 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6536 break; 6537 6538 case 306: 6539 #line 2084 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6540 { 6541 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6542 (yyval.interm.type).basicType = EbtSampler; 6543 (yyval.interm.type).sampler.setTexture(EbtInt, Esd1D, true); 6544 } 6545 #line 6546 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6546 break; 6547 6548 case 307: 6549 #line 2089 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6550 { 6551 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6552 (yyval.interm.type).basicType = EbtSampler; 6553 (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, true); 6554 } 6555 #line 6556 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6556 break; 6557 6558 case 308: 6559 #line 2094 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6560 { 6561 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6562 (yyval.interm.type).basicType = EbtSampler; 6563 (yyval.interm.type).sampler.setTexture(EbtInt, EsdCube, true); 6564 } 6565 #line 6566 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6566 break; 6567 6568 case 309: 6569 #line 2099 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6570 { 6571 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6572 (yyval.interm.type).basicType = EbtSampler; 6573 (yyval.interm.type).sampler.setTexture(EbtUint, Esd1D); 6574 } 6575 #line 6576 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6576 break; 6577 6578 case 310: 6579 #line 2104 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6580 { 6581 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6582 (yyval.interm.type).basicType = EbtSampler; 6583 (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D); 6584 } 6585 #line 6586 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6586 break; 6587 6588 case 311: 6589 #line 2109 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6590 { 6591 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6592 (yyval.interm.type).basicType = EbtSampler; 6593 (yyval.interm.type).sampler.setTexture(EbtUint, Esd3D); 6594 } 6595 #line 6596 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6596 break; 6597 6598 case 312: 6599 #line 2114 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6600 { 6601 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6602 (yyval.interm.type).basicType = EbtSampler; 6603 (yyval.interm.type).sampler.setTexture(EbtUint, EsdCube); 6604 } 6605 #line 6606 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6606 break; 6607 6608 case 313: 6609 #line 2119 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6610 { 6611 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6612 (yyval.interm.type).basicType = EbtSampler; 6613 (yyval.interm.type).sampler.setTexture(EbtUint, Esd1D, true); 6614 } 6615 #line 6616 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6616 break; 6617 6618 case 314: 6619 #line 2124 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6620 { 6621 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6622 (yyval.interm.type).basicType = EbtSampler; 6623 (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, true); 6624 } 6625 #line 6626 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6626 break; 6627 6628 case 315: 6629 #line 2129 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6630 { 6631 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6632 (yyval.interm.type).basicType = EbtSampler; 6633 (yyval.interm.type).sampler.setTexture(EbtUint, EsdCube, true); 6634 } 6635 #line 6636 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6636 break; 6637 6638 case 316: 6639 #line 2134 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6640 { 6641 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6642 (yyval.interm.type).basicType = EbtSampler; 6643 (yyval.interm.type).sampler.setTexture(EbtFloat, EsdRect); 6644 } 6645 #line 6646 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6646 break; 6647 6648 case 317: 6649 #line 2139 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6650 { 6651 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6652 (yyval.interm.type).basicType = EbtSampler; 6653 (yyval.interm.type).sampler.setTexture(EbtInt, EsdRect); 6654 } 6655 #line 6656 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6656 break; 6657 6658 case 318: 6659 #line 2144 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6660 { 6661 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6662 (yyval.interm.type).basicType = EbtSampler; 6663 (yyval.interm.type).sampler.setTexture(EbtUint, EsdRect); 6664 } 6665 #line 6666 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6666 break; 6667 6668 case 319: 6669 #line 2149 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6670 { 6671 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6672 (yyval.interm.type).basicType = EbtSampler; 6673 (yyval.interm.type).sampler.setTexture(EbtFloat, EsdBuffer); 6674 } 6675 #line 6676 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6676 break; 6677 6678 case 320: 6679 #line 2154 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6680 { 6681 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6682 (yyval.interm.type).basicType = EbtSampler; 6683 (yyval.interm.type).sampler.setTexture(EbtInt, EsdBuffer); 6684 } 6685 #line 6686 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6686 break; 6687 6688 case 321: 6689 #line 2159 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6690 { 6691 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6692 (yyval.interm.type).basicType = EbtSampler; 6693 (yyval.interm.type).sampler.setTexture(EbtUint, EsdBuffer); 6694 } 6695 #line 6696 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6696 break; 6697 6698 case 322: 6699 #line 2164 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6700 { 6701 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6702 (yyval.interm.type).basicType = EbtSampler; 6703 (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, false, false, true); 6704 } 6705 #line 6706 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6706 break; 6707 6708 case 323: 6709 #line 2169 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6710 { 6711 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6712 (yyval.interm.type).basicType = EbtSampler; 6713 (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, false, false, true); 6714 } 6715 #line 6716 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6716 break; 6717 6718 case 324: 6719 #line 2174 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6720 { 6721 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6722 (yyval.interm.type).basicType = EbtSampler; 6723 (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, false, false, true); 6724 } 6725 #line 6726 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6726 break; 6727 6728 case 325: 6729 #line 2179 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6730 { 6731 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6732 (yyval.interm.type).basicType = EbtSampler; 6733 (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, true, false, true); 6734 } 6735 #line 6736 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6736 break; 6737 6738 case 326: 6739 #line 2184 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6740 { 6741 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6742 (yyval.interm.type).basicType = EbtSampler; 6743 (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, true, false, true); 6744 } 6745 #line 6746 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6746 break; 6747 6748 case 327: 6749 #line 2189 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6750 { 6751 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6752 (yyval.interm.type).basicType = EbtSampler; 6753 (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, true, false, true); 6754 } 6755 #line 6756 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6756 break; 6757 6758 case 328: 6759 #line 2194 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6760 { 6761 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6762 (yyval.interm.type).basicType = EbtSampler; 6763 (yyval.interm.type).sampler.setImage(EbtFloat, Esd1D); 6764 } 6765 #line 6766 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6766 break; 6767 6768 case 329: 6769 #line 2199 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6770 { 6771 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6772 (yyval.interm.type).basicType = EbtSampler; 6773 (yyval.interm.type).sampler.setImage(EbtInt, Esd1D); 6774 } 6775 #line 6776 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6776 break; 6777 6778 case 330: 6779 #line 2204 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6780 { 6781 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6782 (yyval.interm.type).basicType = EbtSampler; 6783 (yyval.interm.type).sampler.setImage(EbtUint, Esd1D); 6784 } 6785 #line 6786 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6786 break; 6787 6788 case 331: 6789 #line 2209 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6790 { 6791 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6792 (yyval.interm.type).basicType = EbtSampler; 6793 (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D); 6794 } 6795 #line 6796 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6796 break; 6797 6798 case 332: 6799 #line 2214 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6800 { 6801 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6802 (yyval.interm.type).basicType = EbtSampler; 6803 (yyval.interm.type).sampler.setImage(EbtInt, Esd2D); 6804 } 6805 #line 6806 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6806 break; 6807 6808 case 333: 6809 #line 2219 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6810 { 6811 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6812 (yyval.interm.type).basicType = EbtSampler; 6813 (yyval.interm.type).sampler.setImage(EbtUint, Esd2D); 6814 } 6815 #line 6816 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6816 break; 6817 6818 case 334: 6819 #line 2224 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6820 { 6821 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6822 (yyval.interm.type).basicType = EbtSampler; 6823 (yyval.interm.type).sampler.setImage(EbtFloat, Esd3D); 6824 } 6825 #line 6826 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6826 break; 6827 6828 case 335: 6829 #line 2229 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6830 { 6831 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6832 (yyval.interm.type).basicType = EbtSampler; 6833 (yyval.interm.type).sampler.setImage(EbtInt, Esd3D); 6834 } 6835 #line 6836 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6836 break; 6837 6838 case 336: 6839 #line 2234 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6840 { 6841 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6842 (yyval.interm.type).basicType = EbtSampler; 6843 (yyval.interm.type).sampler.setImage(EbtUint, Esd3D); 6844 } 6845 #line 6846 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6846 break; 6847 6848 case 337: 6849 #line 2239 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6850 { 6851 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6852 (yyval.interm.type).basicType = EbtSampler; 6853 (yyval.interm.type).sampler.setImage(EbtFloat, EsdRect); 6854 } 6855 #line 6856 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6856 break; 6857 6858 case 338: 6859 #line 2244 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6860 { 6861 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6862 (yyval.interm.type).basicType = EbtSampler; 6863 (yyval.interm.type).sampler.setImage(EbtInt, EsdRect); 6864 } 6865 #line 6866 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6866 break; 6867 6868 case 339: 6869 #line 2249 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6870 { 6871 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6872 (yyval.interm.type).basicType = EbtSampler; 6873 (yyval.interm.type).sampler.setImage(EbtUint, EsdRect); 6874 } 6875 #line 6876 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6876 break; 6877 6878 case 340: 6879 #line 2254 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6880 { 6881 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6882 (yyval.interm.type).basicType = EbtSampler; 6883 (yyval.interm.type).sampler.setImage(EbtFloat, EsdCube); 6884 } 6885 #line 6886 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6886 break; 6887 6888 case 341: 6889 #line 2259 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6890 { 6891 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6892 (yyval.interm.type).basicType = EbtSampler; 6893 (yyval.interm.type).sampler.setImage(EbtInt, EsdCube); 6894 } 6895 #line 6896 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6896 break; 6897 6898 case 342: 6899 #line 2264 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6900 { 6901 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6902 (yyval.interm.type).basicType = EbtSampler; 6903 (yyval.interm.type).sampler.setImage(EbtUint, EsdCube); 6904 } 6905 #line 6906 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6906 break; 6907 6908 case 343: 6909 #line 2269 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6910 { 6911 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6912 (yyval.interm.type).basicType = EbtSampler; 6913 (yyval.interm.type).sampler.setImage(EbtFloat, EsdBuffer); 6914 } 6915 #line 6916 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6916 break; 6917 6918 case 344: 6919 #line 2274 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6920 { 6921 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6922 (yyval.interm.type).basicType = EbtSampler; 6923 (yyval.interm.type).sampler.setImage(EbtInt, EsdBuffer); 6924 } 6925 #line 6926 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6926 break; 6927 6928 case 345: 6929 #line 2279 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6930 { 6931 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6932 (yyval.interm.type).basicType = EbtSampler; 6933 (yyval.interm.type).sampler.setImage(EbtUint, EsdBuffer); 6934 } 6935 #line 6936 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6936 break; 6937 6938 case 346: 6939 #line 2284 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6940 { 6941 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6942 (yyval.interm.type).basicType = EbtSampler; 6943 (yyval.interm.type).sampler.setImage(EbtFloat, Esd1D, true); 6944 } 6945 #line 6946 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6946 break; 6947 6948 case 347: 6949 #line 2289 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6950 { 6951 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6952 (yyval.interm.type).basicType = EbtSampler; 6953 (yyval.interm.type).sampler.setImage(EbtInt, Esd1D, true); 6954 } 6955 #line 6956 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6956 break; 6957 6958 case 348: 6959 #line 2294 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6960 { 6961 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6962 (yyval.interm.type).basicType = EbtSampler; 6963 (yyval.interm.type).sampler.setImage(EbtUint, Esd1D, true); 6964 } 6965 #line 6966 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6966 break; 6967 6968 case 349: 6969 #line 2299 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6970 { 6971 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6972 (yyval.interm.type).basicType = EbtSampler; 6973 (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, true); 6974 } 6975 #line 6976 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6976 break; 6977 6978 case 350: 6979 #line 2304 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6980 { 6981 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6982 (yyval.interm.type).basicType = EbtSampler; 6983 (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, true); 6984 } 6985 #line 6986 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6986 break; 6987 6988 case 351: 6989 #line 2309 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6990 { 6991 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6992 (yyval.interm.type).basicType = EbtSampler; 6993 (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, true); 6994 } 6995 #line 6996 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6996 break; 6997 6998 case 352: 6999 #line 2314 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7000 { 7001 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7002 (yyval.interm.type).basicType = EbtSampler; 7003 (yyval.interm.type).sampler.setImage(EbtFloat, EsdCube, true); 7004 } 7005 #line 7006 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7006 break; 7007 7008 case 353: 7009 #line 2319 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7010 { 7011 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7012 (yyval.interm.type).basicType = EbtSampler; 7013 (yyval.interm.type).sampler.setImage(EbtInt, EsdCube, true); 7014 } 7015 #line 7016 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7016 break; 7017 7018 case 354: 7019 #line 2324 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7020 { 7021 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7022 (yyval.interm.type).basicType = EbtSampler; 7023 (yyval.interm.type).sampler.setImage(EbtUint, EsdCube, true); 7024 } 7025 #line 7026 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7026 break; 7027 7028 case 355: 7029 #line 2329 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7030 { 7031 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7032 (yyval.interm.type).basicType = EbtSampler; 7033 (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, false, false, true); 7034 } 7035 #line 7036 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7036 break; 7037 7038 case 356: 7039 #line 2334 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7040 { 7041 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7042 (yyval.interm.type).basicType = EbtSampler; 7043 (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, false, false, true); 7044 } 7045 #line 7046 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7046 break; 7047 7048 case 357: 7049 #line 2339 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7050 { 7051 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7052 (yyval.interm.type).basicType = EbtSampler; 7053 (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, false, false, true); 7054 } 7055 #line 7056 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7056 break; 7057 7058 case 358: 7059 #line 2344 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7060 { 7061 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7062 (yyval.interm.type).basicType = EbtSampler; 7063 (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, true, false, true); 7064 } 7065 #line 7066 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7066 break; 7067 7068 case 359: 7069 #line 2349 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7070 { 7071 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7072 (yyval.interm.type).basicType = EbtSampler; 7073 (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, true, false, true); 7074 } 7075 #line 7076 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7076 break; 7077 7078 case 360: 7079 #line 2354 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7080 { 7081 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7082 (yyval.interm.type).basicType = EbtSampler; 7083 (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, true, false, true); 7084 } 7085 #line 7086 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7086 break; 7087 7088 case 361: 7089 #line 2359 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7090 { // GL_OES_EGL_image_external 7091 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7092 (yyval.interm.type).basicType = EbtSampler; 7093 (yyval.interm.type).sampler.set(EbtFloat, Esd2D); 7094 (yyval.interm.type).sampler.external = true; 7095 } 7096 #line 7097 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7097 break; 7098 7099 case 362: 7100 #line 2365 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7101 { 7102 parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); 7103 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7104 (yyval.interm.type).basicType = EbtSampler; 7105 (yyval.interm.type).sampler.setSubpass(EbtFloat); 7106 } 7107 #line 7108 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7108 break; 7109 7110 case 363: 7111 #line 2371 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7112 { 7113 parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); 7114 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7115 (yyval.interm.type).basicType = EbtSampler; 7116 (yyval.interm.type).sampler.setSubpass(EbtFloat, true); 7117 } 7118 #line 7119 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7119 break; 7120 7121 case 364: 7122 #line 2377 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7123 { 7124 parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); 7125 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7126 (yyval.interm.type).basicType = EbtSampler; 7127 (yyval.interm.type).sampler.setSubpass(EbtInt); 7128 } 7129 #line 7130 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7130 break; 7131 7132 case 365: 7133 #line 2383 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7134 { 7135 parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); 7136 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7137 (yyval.interm.type).basicType = EbtSampler; 7138 (yyval.interm.type).sampler.setSubpass(EbtInt, true); 7139 } 7140 #line 7141 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7141 break; 7142 7143 case 366: 7144 #line 2389 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7145 { 7146 parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); 7147 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7148 (yyval.interm.type).basicType = EbtSampler; 7149 (yyval.interm.type).sampler.setSubpass(EbtUint); 7150 } 7151 #line 7152 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7152 break; 7153 7154 case 367: 7155 #line 2395 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7156 { 7157 parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); 7158 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7159 (yyval.interm.type).basicType = EbtSampler; 7160 (yyval.interm.type).sampler.setSubpass(EbtUint, true); 7161 } 7162 #line 7163 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7163 break; 7164 7165 case 368: 7166 #line 2401 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7167 { 7168 (yyval.interm.type) = (yyvsp[0].interm.type); 7169 (yyval.interm.type).qualifier.storage = parseContext.symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary; 7170 parseContext.structTypeCheck((yyval.interm.type).loc, (yyval.interm.type)); 7171 } 7172 #line 7173 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7173 break; 7174 7175 case 369: 7176 #line 2406 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7177 { 7178 // 7179 // This is for user defined type names. The lexical phase looked up the 7180 // type. 7181 // 7182 if (const TVariable* variable = ((yyvsp[0].lex).symbol)->getAsVariable()) { 7183 const TType& structure = variable->getType(); 7184 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7185 (yyval.interm.type).basicType = EbtStruct; 7186 (yyval.interm.type).userDef = &structure; 7187 } else 7188 parseContext.error((yyvsp[0].lex).loc, "expected type name", (yyvsp[0].lex).string->c_str(), ""); 7189 } 7190 #line 7191 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7191 break; 7192 7193 case 370: 7194 #line 2422 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7195 { 7196 parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "highp precision qualifier"); 7197 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7198 parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqHigh); 7199 } 7200 #line 7201 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7201 break; 7202 7203 case 371: 7204 #line 2427 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7205 { 7206 parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "mediump precision qualifier"); 7207 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7208 parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqMedium); 7209 } 7210 #line 7211 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7211 break; 7212 7213 case 372: 7214 #line 2432 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7215 { 7216 parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "lowp precision qualifier"); 7217 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7218 parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqLow); 7219 } 7220 #line 7221 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7221 break; 7222 7223 case 373: 7224 #line 2440 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7225 { parseContext.nestedStructCheck((yyvsp[-2].lex).loc); } 7226 #line 7227 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7227 break; 7228 7229 case 374: 7230 #line 2440 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7231 { 7232 TType* structure = new TType((yyvsp[-1].interm.typeList), *(yyvsp[-4].lex).string); 7233 parseContext.structArrayCheck((yyvsp[-4].lex).loc, *structure); 7234 TVariable* userTypeDef = new TVariable((yyvsp[-4].lex).string, *structure, true); 7235 if (! parseContext.symbolTable.insert(*userTypeDef)) 7236 parseContext.error((yyvsp[-4].lex).loc, "redefinition", (yyvsp[-4].lex).string->c_str(), "struct"); 7237 (yyval.interm.type).init((yyvsp[-5].lex).loc); 7238 (yyval.interm.type).basicType = EbtStruct; 7239 (yyval.interm.type).userDef = structure; 7240 --parseContext.structNestingLevel; 7241 } 7242 #line 7243 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7243 break; 7244 7245 case 375: 7246 #line 2451 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7247 { parseContext.nestedStructCheck((yyvsp[-1].lex).loc); } 7248 #line 7249 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7249 break; 7250 7251 case 376: 7252 #line 2451 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7253 { 7254 TType* structure = new TType((yyvsp[-1].interm.typeList), TString("")); 7255 (yyval.interm.type).init((yyvsp[-4].lex).loc); 7256 (yyval.interm.type).basicType = EbtStruct; 7257 (yyval.interm.type).userDef = structure; 7258 --parseContext.structNestingLevel; 7259 } 7260 #line 7261 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7261 break; 7262 7263 case 377: 7264 #line 2461 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7265 { 7266 (yyval.interm.typeList) = (yyvsp[0].interm.typeList); 7267 } 7268 #line 7269 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7269 break; 7270 7271 case 378: 7272 #line 2464 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7273 { 7274 (yyval.interm.typeList) = (yyvsp[-1].interm.typeList); 7275 for (unsigned int i = 0; i < (yyvsp[0].interm.typeList)->size(); ++i) { 7276 for (unsigned int j = 0; j < (yyval.interm.typeList)->size(); ++j) { 7277 if ((*(yyval.interm.typeList))[j].type->getFieldName() == (*(yyvsp[0].interm.typeList))[i].type->getFieldName()) 7278 parseContext.error((*(yyvsp[0].interm.typeList))[i].loc, "duplicate member name:", "", (*(yyvsp[0].interm.typeList))[i].type->getFieldName().c_str()); 7279 } 7280 (yyval.interm.typeList)->push_back((*(yyvsp[0].interm.typeList))[i]); 7281 } 7282 } 7283 #line 7284 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7284 break; 7285 7286 case 379: 7287 #line 2477 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7288 { 7289 if ((yyvsp[-2].interm.type).arraySizes) { 7290 parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); 7291 parseContext.profileRequires((yyvsp[-2].interm.type).loc, EEsProfile, 300, 0, "arrayed type"); 7292 if (parseContext.profile == EEsProfile) 7293 parseContext.arraySizeRequiredCheck((yyvsp[-2].interm.type).loc, *(yyvsp[-2].interm.type).arraySizes); 7294 } 7295 7296 (yyval.interm.typeList) = (yyvsp[-1].interm.typeList); 7297 7298 parseContext.voidErrorCheck((yyvsp[-2].interm.type).loc, (*(yyvsp[-1].interm.typeList))[0].type->getFieldName(), (yyvsp[-2].interm.type).basicType); 7299 parseContext.precisionQualifierCheck((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).basicType, (yyvsp[-2].interm.type).qualifier); 7300 7301 for (unsigned int i = 0; i < (yyval.interm.typeList)->size(); ++i) { 7302 parseContext.arrayDimCheck((yyvsp[-2].interm.type).loc, (*(yyval.interm.typeList))[i].type, (yyvsp[-2].interm.type).arraySizes); 7303 (*(yyval.interm.typeList))[i].type->mergeType((yyvsp[-2].interm.type)); 7304 } 7305 } 7306 #line 7307 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7307 break; 7308 7309 case 380: 7310 #line 2495 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7311 { 7312 parseContext.globalQualifierFixCheck((yyvsp[-3].interm.type).loc, (yyvsp[-3].interm.type).qualifier); 7313 if ((yyvsp[-2].interm.type).arraySizes) { 7314 parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); 7315 parseContext.profileRequires((yyvsp[-2].interm.type).loc, EEsProfile, 300, 0, "arrayed type"); 7316 if (parseContext.profile == EEsProfile) 7317 parseContext.arraySizeRequiredCheck((yyvsp[-2].interm.type).loc, *(yyvsp[-2].interm.type).arraySizes); 7318 } 7319 7320 (yyval.interm.typeList) = (yyvsp[-1].interm.typeList); 7321 7322 parseContext.checkNoShaderLayouts((yyvsp[-3].interm.type).loc, (yyvsp[-3].interm.type).shaderQualifiers); 7323 parseContext.voidErrorCheck((yyvsp[-2].interm.type).loc, (*(yyvsp[-1].interm.typeList))[0].type->getFieldName(), (yyvsp[-2].interm.type).basicType); 7324 parseContext.mergeQualifiers((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).qualifier, (yyvsp[-3].interm.type).qualifier, true); 7325 parseContext.precisionQualifierCheck((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).basicType, (yyvsp[-2].interm.type).qualifier); 7326 7327 for (unsigned int i = 0; i < (yyval.interm.typeList)->size(); ++i) { 7328 parseContext.arrayDimCheck((yyvsp[-3].interm.type).loc, (*(yyval.interm.typeList))[i].type, (yyvsp[-2].interm.type).arraySizes); 7329 (*(yyval.interm.typeList))[i].type->mergeType((yyvsp[-2].interm.type)); 7330 } 7331 } 7332 #line 7333 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7333 break; 7334 7335 case 381: 7336 #line 2519 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7337 { 7338 (yyval.interm.typeList) = new TTypeList; 7339 (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine)); 7340 } 7341 #line 7342 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7342 break; 7343 7344 case 382: 7345 #line 2523 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7346 { 7347 (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine)); 7348 } 7349 #line 7350 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7350 break; 7351 7352 case 383: 7353 #line 2529 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7354 { 7355 (yyval.interm.typeLine).type = new TType(EbtVoid); 7356 (yyval.interm.typeLine).loc = (yyvsp[0].lex).loc; 7357 (yyval.interm.typeLine).type->setFieldName(*(yyvsp[0].lex).string); 7358 } 7359 #line 7360 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7360 break; 7361 7362 case 384: 7363 #line 2534 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7364 { 7365 parseContext.arrayDimCheck((yyvsp[-1].lex).loc, (yyvsp[0].interm).arraySizes, 0); 7366 7367 (yyval.interm.typeLine).type = new TType(EbtVoid); 7368 (yyval.interm.typeLine).loc = (yyvsp[-1].lex).loc; 7369 (yyval.interm.typeLine).type->setFieldName(*(yyvsp[-1].lex).string); 7370 (yyval.interm.typeLine).type->newArraySizes(*(yyvsp[0].interm).arraySizes); 7371 } 7372 #line 7373 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7373 break; 7374 7375 case 385: 7376 #line 2545 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7377 { 7378 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); 7379 } 7380 #line 7381 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7381 break; 7382 7383 case 386: 7384 #line 2548 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7385 { 7386 const char* initFeature = "{ } style initializers"; 7387 parseContext.requireProfile((yyvsp[-2].lex).loc, ~EEsProfile, initFeature); 7388 parseContext.profileRequires((yyvsp[-2].lex).loc, ~EEsProfile, 420, E_GL_ARB_shading_language_420pack, initFeature); 7389 (yyval.interm.intermTypedNode) = (yyvsp[-1].interm.intermTypedNode); 7390 } 7391 #line 7392 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7392 break; 7393 7394 case 387: 7395 #line 2554 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7396 { 7397 const char* initFeature = "{ } style initializers"; 7398 parseContext.requireProfile((yyvsp[-3].lex).loc, ~EEsProfile, initFeature); 7399 parseContext.profileRequires((yyvsp[-3].lex).loc, ~EEsProfile, 420, E_GL_ARB_shading_language_420pack, initFeature); 7400 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); 7401 } 7402 #line 7403 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7403 break; 7404 7405 case 388: 7406 #line 2563 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7407 { 7408 (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate(0, (yyvsp[0].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)->getLoc()); 7409 } 7410 #line 7411 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7411 break; 7412 7413 case 389: 7414 #line 2566 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7415 { 7416 (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 7417 } 7418 #line 7419 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7419 break; 7420 7421 case 390: 7422 #line 2572 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7423 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } 7424 #line 7425 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7425 break; 7426 7427 case 391: 7428 #line 2576 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7429 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } 7430 #line 7431 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7431 break; 7432 7433 case 392: 7434 #line 2577 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7435 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } 7436 #line 7437 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7437 break; 7438 7439 case 393: 7440 #line 2583 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7441 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } 7442 #line 7443 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7443 break; 7444 7445 case 394: 7446 #line 2584 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7447 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } 7448 #line 7449 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7449 break; 7450 7451 case 395: 7452 #line 2585 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7453 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } 7454 #line 7455 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7455 break; 7456 7457 case 396: 7458 #line 2586 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7459 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } 7460 #line 7461 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7461 break; 7462 7463 case 397: 7464 #line 2587 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7465 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } 7466 #line 7467 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7467 break; 7468 7469 case 398: 7470 #line 2588 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7471 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } 7472 #line 7473 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7473 break; 7474 7475 case 399: 7476 #line 2589 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7477 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } 7478 #line 7479 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7479 break; 7480 7481 case 400: 7482 #line 2593 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7483 { (yyval.interm.intermNode) = 0; } 7484 #line 7485 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7485 break; 7486 7487 case 401: 7488 #line 2594 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7489 { 7490 parseContext.symbolTable.push(); 7491 ++parseContext.statementNestingLevel; 7492 } 7493 #line 7494 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7494 break; 7495 7496 case 402: 7497 #line 2598 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7498 { 7499 parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); 7500 --parseContext.statementNestingLevel; 7501 } 7502 #line 7503 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7503 break; 7504 7505 case 403: 7506 #line 2602 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7507 { 7508 if ((yyvsp[-2].interm.intermNode) && (yyvsp[-2].interm.intermNode)->getAsAggregate()) 7509 (yyvsp[-2].interm.intermNode)->getAsAggregate()->setOperator(EOpSequence); 7510 (yyval.interm.intermNode) = (yyvsp[-2].interm.intermNode); 7511 } 7512 #line 7513 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7513 break; 7514 7515 case 404: 7516 #line 2610 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7517 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } 7518 #line 7519 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7519 break; 7520 7521 case 405: 7522 #line 2611 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7523 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } 7524 #line 7525 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7525 break; 7526 7527 case 406: 7528 #line 2615 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7529 { 7530 ++parseContext.controlFlowNestingLevel; 7531 } 7532 #line 7533 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7533 break; 7534 7535 case 407: 7536 #line 2618 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7537 { 7538 --parseContext.controlFlowNestingLevel; 7539 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); 7540 } 7541 #line 7542 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7542 break; 7543 7544 case 408: 7545 #line 2622 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7546 { 7547 parseContext.symbolTable.push(); 7548 ++parseContext.statementNestingLevel; 7549 ++parseContext.controlFlowNestingLevel; 7550 } 7551 #line 7552 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7552 break; 7553 7554 case 409: 7555 #line 2627 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7556 { 7557 parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); 7558 --parseContext.statementNestingLevel; 7559 --parseContext.controlFlowNestingLevel; 7560 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); 7561 } 7562 #line 7563 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7563 break; 7564 7565 case 410: 7566 #line 2636 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7567 { 7568 (yyval.interm.intermNode) = 0; 7569 } 7570 #line 7571 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7571 break; 7572 7573 case 411: 7574 #line 2639 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7575 { 7576 if ((yyvsp[-1].interm.intermNode) && (yyvsp[-1].interm.intermNode)->getAsAggregate()) 7577 (yyvsp[-1].interm.intermNode)->getAsAggregate()->setOperator(EOpSequence); 7578 (yyval.interm.intermNode) = (yyvsp[-1].interm.intermNode); 7579 } 7580 #line 7581 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7581 break; 7582 7583 case 412: 7584 #line 2647 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7585 { 7586 (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermNode)); 7587 if ((yyvsp[0].interm.intermNode) && (yyvsp[0].interm.intermNode)->getAsBranchNode() && ((yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpCase || 7588 (yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpDefault)) { 7589 parseContext.wrapupSwitchSubsequence(0, (yyvsp[0].interm.intermNode)); 7590 (yyval.interm.intermNode) = 0; // start a fresh subsequence for what's after this case 7591 } 7592 } 7593 #line 7594 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7594 break; 7595 7596 case 413: 7597 #line 2655 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7598 { 7599 if ((yyvsp[0].interm.intermNode) && (yyvsp[0].interm.intermNode)->getAsBranchNode() && ((yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpCase || 7600 (yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpDefault)) { 7601 parseContext.wrapupSwitchSubsequence((yyvsp[-1].interm.intermNode) ? (yyvsp[-1].interm.intermNode)->getAsAggregate() : 0, (yyvsp[0].interm.intermNode)); 7602 (yyval.interm.intermNode) = 0; // start a fresh subsequence for what's after this case 7603 } else 7604 (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode)); 7605 } 7606 #line 7607 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7607 break; 7608 7609 case 414: 7610 #line 2666 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7611 { (yyval.interm.intermNode) = 0; } 7612 #line 7613 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7613 break; 7614 7615 case 415: 7616 #line 2667 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7617 { (yyval.interm.intermNode) = static_cast<TIntermNode*>((yyvsp[-1].interm.intermTypedNode)); } 7618 #line 7619 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7619 break; 7620 7621 case 416: 7622 #line 2671 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7623 { 7624 parseContext.boolCheck((yyvsp[-4].lex).loc, (yyvsp[-2].interm.intermTypedNode)); 7625 (yyval.interm.intermNode) = parseContext.intermediate.addSelection((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.nodePair), (yyvsp[-4].lex).loc); 7626 } 7627 #line 7628 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7628 break; 7629 7630 case 417: 7631 #line 2678 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7632 { 7633 (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermNode); 7634 (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermNode); 7635 } 7636 #line 7637 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7637 break; 7638 7639 case 418: 7640 #line 2682 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7641 { 7642 (yyval.interm.nodePair).node1 = (yyvsp[0].interm.intermNode); 7643 (yyval.interm.nodePair).node2 = 0; 7644 } 7645 #line 7646 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7646 break; 7647 7648 case 419: 7649 #line 2690 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7650 { 7651 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); 7652 parseContext.boolCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode)); 7653 } 7654 #line 7655 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7655 break; 7656 7657 case 420: 7658 #line 2694 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7659 { 7660 parseContext.boolCheck((yyvsp[-2].lex).loc, (yyvsp[-3].interm.type)); 7661 7662 TType type((yyvsp[-3].interm.type)); 7663 TIntermNode* initNode = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-3].interm.type), 0, (yyvsp[0].interm.intermTypedNode)); 7664 if (initNode) 7665 (yyval.interm.intermTypedNode) = initNode->getAsTyped(); 7666 else 7667 (yyval.interm.intermTypedNode) = 0; 7668 } 7669 #line 7670 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7670 break; 7671 7672 case 421: 7673 #line 2707 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7674 { 7675 // start new switch sequence on the switch stack 7676 ++parseContext.controlFlowNestingLevel; 7677 ++parseContext.statementNestingLevel; 7678 parseContext.switchSequenceStack.push_back(new TIntermSequence); 7679 parseContext.switchLevel.push_back(parseContext.statementNestingLevel); 7680 parseContext.symbolTable.push(); 7681 } 7682 #line 7683 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7683 break; 7684 7685 case 422: 7686 #line 2715 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7687 { 7688 (yyval.interm.intermNode) = parseContext.addSwitch((yyvsp[-7].lex).loc, (yyvsp[-5].interm.intermTypedNode), (yyvsp[-1].interm.intermNode) ? (yyvsp[-1].interm.intermNode)->getAsAggregate() : 0); 7689 delete parseContext.switchSequenceStack.back(); 7690 parseContext.switchSequenceStack.pop_back(); 7691 parseContext.switchLevel.pop_back(); 7692 parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); 7693 --parseContext.statementNestingLevel; 7694 --parseContext.controlFlowNestingLevel; 7695 } 7696 #line 7697 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7697 break; 7698 7699 case 423: 7700 #line 2727 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7701 { 7702 (yyval.interm.intermNode) = 0; 7703 } 7704 #line 7705 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7705 break; 7706 7707 case 424: 7708 #line 2730 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7709 { 7710 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); 7711 } 7712 #line 7713 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7713 break; 7714 7715 case 425: 7716 #line 2736 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7717 { 7718 (yyval.interm.intermNode) = 0; 7719 if (parseContext.switchLevel.size() == 0) 7720 parseContext.error((yyvsp[-2].lex).loc, "cannot appear outside switch statement", "case", ""); 7721 else if (parseContext.switchLevel.back() != parseContext.statementNestingLevel) 7722 parseContext.error((yyvsp[-2].lex).loc, "cannot be nested inside control flow", "case", ""); 7723 else { 7724 parseContext.constantValueCheck((yyvsp[-1].interm.intermTypedNode), "case"); 7725 parseContext.integerCheck((yyvsp[-1].interm.intermTypedNode), "case"); 7726 (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpCase, (yyvsp[-1].interm.intermTypedNode), (yyvsp[-2].lex).loc); 7727 } 7728 } 7729 #line 7730 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7730 break; 7731 7732 case 426: 7733 #line 2748 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7734 { 7735 (yyval.interm.intermNode) = 0; 7736 if (parseContext.switchLevel.size() == 0) 7737 parseContext.error((yyvsp[-1].lex).loc, "cannot appear outside switch statement", "default", ""); 7738 else if (parseContext.switchLevel.back() != parseContext.statementNestingLevel) 7739 parseContext.error((yyvsp[-1].lex).loc, "cannot be nested inside control flow", "default", ""); 7740 else 7741 (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpDefault, (yyvsp[-1].lex).loc); 7742 } 7743 #line 7744 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7744 break; 7745 7746 case 427: 7747 #line 2760 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7748 { 7749 if (! parseContext.limits.whileLoops) 7750 parseContext.error((yyvsp[-1].lex).loc, "while loops not available", "limitation", ""); 7751 parseContext.symbolTable.push(); 7752 ++parseContext.loopNestingLevel; 7753 ++parseContext.statementNestingLevel; 7754 ++parseContext.controlFlowNestingLevel; 7755 } 7756 #line 7757 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7757 break; 7758 7759 case 428: 7760 #line 2768 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7761 { 7762 parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); 7763 (yyval.interm.intermNode) = parseContext.intermediate.addLoop((yyvsp[0].interm.intermNode), (yyvsp[-2].interm.intermTypedNode), 0, true, (yyvsp[-5].lex).loc); 7764 --parseContext.loopNestingLevel; 7765 --parseContext.statementNestingLevel; 7766 --parseContext.controlFlowNestingLevel; 7767 } 7768 #line 7769 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7769 break; 7770 7771 case 429: 7772 #line 2775 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7773 { 7774 ++parseContext.loopNestingLevel; 7775 ++parseContext.statementNestingLevel; 7776 ++parseContext.controlFlowNestingLevel; 7777 } 7778 #line 7779 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7779 break; 7780 7781 case 430: 7782 #line 2780 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7783 { 7784 if (! parseContext.limits.whileLoops) 7785 parseContext.error((yyvsp[-7].lex).loc, "do-while loops not available", "limitation", ""); 7786 7787 parseContext.boolCheck((yyvsp[0].lex).loc, (yyvsp[-2].interm.intermTypedNode)); 7788 7789 (yyval.interm.intermNode) = parseContext.intermediate.addLoop((yyvsp[-5].interm.intermNode), (yyvsp[-2].interm.intermTypedNode), 0, false, (yyvsp[-4].lex).loc); 7790 --parseContext.loopNestingLevel; 7791 --parseContext.statementNestingLevel; 7792 --parseContext.controlFlowNestingLevel; 7793 } 7794 #line 7795 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7795 break; 7796 7797 case 431: 7798 #line 2791 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7799 { 7800 parseContext.symbolTable.push(); 7801 ++parseContext.loopNestingLevel; 7802 ++parseContext.statementNestingLevel; 7803 ++parseContext.controlFlowNestingLevel; 7804 } 7805 #line 7806 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7806 break; 7807 7808 case 432: 7809 #line 2797 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7810 { 7811 parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); 7812 (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[-3].interm.intermNode), (yyvsp[-5].lex).loc); 7813 TIntermLoop* forLoop = parseContext.intermediate.addLoop((yyvsp[0].interm.intermNode), reinterpret_cast<TIntermTyped*>((yyvsp[-2].interm.nodePair).node1), reinterpret_cast<TIntermTyped*>((yyvsp[-2].interm.nodePair).node2), true, (yyvsp[-6].lex).loc); 7814 if (! parseContext.limits.nonInductiveForLoops) 7815 parseContext.inductiveLoopCheck((yyvsp[-6].lex).loc, (yyvsp[-3].interm.intermNode), forLoop); 7816 (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyval.interm.intermNode), forLoop, (yyvsp[-6].lex).loc); 7817 (yyval.interm.intermNode)->getAsAggregate()->setOperator(EOpSequence); 7818 --parseContext.loopNestingLevel; 7819 --parseContext.statementNestingLevel; 7820 --parseContext.controlFlowNestingLevel; 7821 } 7822 #line 7823 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7823 break; 7824 7825 case 433: 7826 #line 2812 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7827 { 7828 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); 7829 } 7830 #line 7831 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7831 break; 7832 7833 case 434: 7834 #line 2815 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7835 { 7836 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); 7837 } 7838 #line 7839 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7839 break; 7840 7841 case 435: 7842 #line 2821 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7843 { 7844 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); 7845 } 7846 #line 7847 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7847 break; 7848 7849 case 436: 7850 #line 2824 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7851 { 7852 (yyval.interm.intermTypedNode) = 0; 7853 } 7854 #line 7855 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7855 break; 7856 7857 case 437: 7858 #line 2830 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7859 { 7860 (yyval.interm.nodePair).node1 = (yyvsp[-1].interm.intermTypedNode); 7861 (yyval.interm.nodePair).node2 = 0; 7862 } 7863 #line 7864 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7864 break; 7865 7866 case 438: 7867 #line 2834 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7868 { 7869 (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermTypedNode); 7870 (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermTypedNode); 7871 } 7872 #line 7873 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7873 break; 7874 7875 case 439: 7876 #line 2841 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7877 { 7878 if (parseContext.loopNestingLevel <= 0) 7879 parseContext.error((yyvsp[-1].lex).loc, "continue statement only allowed in loops", "", ""); 7880 (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpContinue, (yyvsp[-1].lex).loc); 7881 } 7882 #line 7883 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7883 break; 7884 7885 case 440: 7886 #line 2846 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7887 { 7888 if (parseContext.loopNestingLevel + parseContext.switchSequenceStack.size() <= 0) 7889 parseContext.error((yyvsp[-1].lex).loc, "break statement only allowed in switch and loops", "", ""); 7890 (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpBreak, (yyvsp[-1].lex).loc); 7891 } 7892 #line 7893 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7893 break; 7894 7895 case 441: 7896 #line 2851 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7897 { 7898 (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpReturn, (yyvsp[-1].lex).loc); 7899 if (parseContext.currentFunctionType->getBasicType() != EbtVoid) 7900 parseContext.error((yyvsp[-1].lex).loc, "non-void function must return a value", "return", ""); 7901 if (parseContext.inMain) 7902 parseContext.postEntryPointReturn = true; 7903 } 7904 #line 7905 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7905 break; 7906 7907 case 442: 7908 #line 2858 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7909 { 7910 (yyval.interm.intermNode) = parseContext.handleReturnValue((yyvsp[-2].lex).loc, (yyvsp[-1].interm.intermTypedNode)); 7911 } 7912 #line 7913 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7913 break; 7914 7915 case 443: 7916 #line 2861 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7917 { 7918 parseContext.requireStage((yyvsp[-1].lex).loc, EShLangFragment, "discard"); 7919 (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpKill, (yyvsp[-1].lex).loc); 7920 } 7921 #line 7922 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7922 break; 7923 7924 case 444: 7925 #line 2870 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7926 { 7927 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); 7928 parseContext.intermediate.setTreeRoot((yyval.interm.intermNode)); 7929 } 7930 #line 7931 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7931 break; 7932 7933 case 445: 7934 #line 2874 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7935 { 7936 if ((yyvsp[0].interm.intermNode) != nullptr) { 7937 (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode)); 7938 parseContext.intermediate.setTreeRoot((yyval.interm.intermNode)); 7939 } 7940 } 7941 #line 7942 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7942 break; 7943 7944 case 446: 7945 #line 2883 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7946 { 7947 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); 7948 } 7949 #line 7950 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7950 break; 7951 7952 case 447: 7953 #line 2886 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7954 { 7955 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); 7956 } 7957 #line 7958 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7958 break; 7959 7960 case 448: 7961 #line 2889 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7962 { 7963 parseContext.requireProfile((yyvsp[0].lex).loc, ~EEsProfile, "extraneous semicolon"); 7964 parseContext.profileRequires((yyvsp[0].lex).loc, ~EEsProfile, 460, nullptr, "extraneous semicolon"); 7965 (yyval.interm.intermNode) = nullptr; 7966 } 7967 #line 7968 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7968 break; 7969 7970 case 449: 7971 #line 2897 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7972 { 7973 (yyvsp[0].interm).function = parseContext.handleFunctionDeclarator((yyvsp[0].interm).loc, *(yyvsp[0].interm).function, false /* not prototype */); 7974 (yyvsp[0].interm).intermNode = parseContext.handleFunctionDefinition((yyvsp[0].interm).loc, *(yyvsp[0].interm).function); 7975 } 7976 #line 7977 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7977 break; 7978 7979 case 450: 7980 #line 2901 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7981 { 7982 // May be best done as post process phase on intermediate code 7983 if (parseContext.currentFunctionType->getBasicType() != EbtVoid && ! parseContext.functionReturnsValue) 7984 parseContext.error((yyvsp[-2].interm).loc, "function does not return a value:", "", (yyvsp[-2].interm).function->getName().c_str()); 7985 parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); 7986 (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm).intermNode, (yyvsp[0].interm.intermNode)); 7987 parseContext.intermediate.setAggregateOperator((yyval.interm.intermNode), EOpFunction, (yyvsp[-2].interm).function->getType(), (yyvsp[-2].interm).loc); 7988 (yyval.interm.intermNode)->getAsAggregate()->setName((yyvsp[-2].interm).function->getMangledName().c_str()); 7989 7990 // store the pragma information for debug and optimize and other vendor specific 7991 // information. This information can be queried from the parse tree 7992 (yyval.interm.intermNode)->getAsAggregate()->setOptimize(parseContext.contextPragma.optimize); 7993 (yyval.interm.intermNode)->getAsAggregate()->setDebug(parseContext.contextPragma.debug); 7994 (yyval.interm.intermNode)->getAsAggregate()->addToPragmaTable(parseContext.contextPragma.pragmaTable); 7995 } 7996 #line 7997 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7997 break; 7998 7999 8000 #line 8001 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8001 default: break; 8002 } 8003 /* User semantic actions sometimes alter yychar, and that requires 8004 that yytoken be updated with the new translation. We take the 8005 approach of translating immediately before every use of yytoken. 8006 One alternative is translating here after every semantic action, 8007 but that translation would be missed if the semantic action invokes 8008 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 8009 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 8010 incorrect destructor might then be invoked immediately. In the 8011 case of YYERROR or YYBACKUP, subsequent parser actions might lead 8012 to an incorrect destructor call or verbose syntax error message 8013 before the lookahead is translated. */ 8014 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 8015 8016 YYPOPSTACK (yylen); 8017 yylen = 0; 8018 YY_STACK_PRINT (yyss, yyssp); 8019 8020 *++yyvsp = yyval; 8021 8022 /* Now 'shift' the result of the reduction. Determine what state 8023 that goes to, based on the state we popped back to and the rule 8024 number reduced by. */ 8025 8026 yyn = yyr1[yyn]; 8027 8028 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 8029 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 8030 yystate = yytable[yystate]; 8031 else 8032 yystate = yydefgoto[yyn - YYNTOKENS]; 8033 8034 goto yynewstate; 8035 8036 8037 /*--------------------------------------. 8038 | yyerrlab -- here on detecting error. | 8039 `--------------------------------------*/ 8040 yyerrlab: 8041 /* Make sure we have latest lookahead translation. See comments at 8042 user semantic actions for why this is necessary. */ 8043 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); 8044 8045 /* If not already recovering from an error, report this error. */ 8046 if (!yyerrstatus) 8047 { 8048 ++yynerrs; 8049 #if ! YYERROR_VERBOSE 8050 yyerror (pParseContext, YY_("syntax error")); 8051 #else 8052 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 8053 yyssp, yytoken) 8054 { 8055 char const *yymsgp = YY_("syntax error"); 8056 int yysyntax_error_status; 8057 yysyntax_error_status = YYSYNTAX_ERROR; 8058 if (yysyntax_error_status == 0) 8059 yymsgp = yymsg; 8060 else if (yysyntax_error_status == 1) 8061 { 8062 if (yymsg != yymsgbuf) 8063 YYSTACK_FREE (yymsg); 8064 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); 8065 if (!yymsg) 8066 { 8067 yymsg = yymsgbuf; 8068 yymsg_alloc = sizeof yymsgbuf; 8069 yysyntax_error_status = 2; 8070 } 8071 else 8072 { 8073 yysyntax_error_status = YYSYNTAX_ERROR; 8074 yymsgp = yymsg; 8075 } 8076 } 8077 yyerror (pParseContext, yymsgp); 8078 if (yysyntax_error_status == 2) 8079 goto yyexhaustedlab; 8080 } 8081 # undef YYSYNTAX_ERROR 8082 #endif 8083 } 8084 8085 8086 8087 if (yyerrstatus == 3) 8088 { 8089 /* If just tried and failed to reuse lookahead token after an 8090 error, discard it. */ 8091 8092 if (yychar <= YYEOF) 8093 { 8094 /* Return failure if at end of input. */ 8095 if (yychar == YYEOF) 8096 YYABORT; 8097 } 8098 else 8099 { 8100 yydestruct ("Error: discarding", 8101 yytoken, &yylval, pParseContext); 8102 yychar = YYEMPTY; 8103 } 8104 } 8105 8106 /* Else will try to reuse lookahead token after shifting the error 8107 token. */ 8108 goto yyerrlab1; 8109 8110 8111 /*---------------------------------------------------. 8112 | yyerrorlab -- error raised explicitly by YYERROR. | 8113 `---------------------------------------------------*/ 8114 yyerrorlab: 8115 8116 /* Pacify compilers like GCC when the user code never invokes 8117 YYERROR and the label yyerrorlab therefore never appears in user 8118 code. */ 8119 if (/*CONSTCOND*/ 0) 8120 goto yyerrorlab; 8121 8122 /* Do not reclaim the symbols of the rule whose action triggered 8123 this YYERROR. */ 8124 YYPOPSTACK (yylen); 8125 yylen = 0; 8126 YY_STACK_PRINT (yyss, yyssp); 8127 yystate = *yyssp; 8128 goto yyerrlab1; 8129 8130 8131 /*-------------------------------------------------------------. 8132 | yyerrlab1 -- common code for both syntax error and YYERROR. | 8133 `-------------------------------------------------------------*/ 8134 yyerrlab1: 8135 yyerrstatus = 3; /* Each real token shifted decrements this. */ 8136 8137 for (;;) 8138 { 8139 yyn = yypact[yystate]; 8140 if (!yypact_value_is_default (yyn)) 8141 { 8142 yyn += YYTERROR; 8143 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 8144 { 8145 yyn = yytable[yyn]; 8146 if (0 < yyn) 8147 break; 8148 } 8149 } 8150 8151 /* Pop the current state because it cannot handle the error token. */ 8152 if (yyssp == yyss) 8153 YYABORT; 8154 8155 8156 yydestruct ("Error: popping", 8157 yystos[yystate], yyvsp, pParseContext); 8158 YYPOPSTACK (1); 8159 yystate = *yyssp; 8160 YY_STACK_PRINT (yyss, yyssp); 8161 } 8162 8163 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 8164 *++yyvsp = yylval; 8165 YY_IGNORE_MAYBE_UNINITIALIZED_END 8166 8167 8168 /* Shift the error token. */ 8169 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 8170 8171 yystate = yyn; 8172 goto yynewstate; 8173 8174 8175 /*-------------------------------------. 8176 | yyacceptlab -- YYACCEPT comes here. | 8177 `-------------------------------------*/ 8178 yyacceptlab: 8179 yyresult = 0; 8180 goto yyreturn; 8181 8182 /*-----------------------------------. 8183 | yyabortlab -- YYABORT comes here. | 8184 `-----------------------------------*/ 8185 yyabortlab: 8186 yyresult = 1; 8187 goto yyreturn; 8188 8189 #if !defined yyoverflow || YYERROR_VERBOSE 8190 /*-------------------------------------------------. 8191 | yyexhaustedlab -- memory exhaustion comes here. | 8192 `-------------------------------------------------*/ 8193 yyexhaustedlab: 8194 yyerror (pParseContext, YY_("memory exhausted")); 8195 yyresult = 2; 8196 /* Fall through. */ 8197 #endif 8198 8199 yyreturn: 8200 if (yychar != YYEMPTY) 8201 { 8202 /* Make sure we have latest lookahead translation. See comments at 8203 user semantic actions for why this is necessary. */ 8204 yytoken = YYTRANSLATE (yychar); 8205 yydestruct ("Cleanup: discarding lookahead", 8206 yytoken, &yylval, pParseContext); 8207 } 8208 /* Do not reclaim the symbols of the rule whose action triggered 8209 this YYABORT or YYACCEPT. */ 8210 YYPOPSTACK (yylen); 8211 YY_STACK_PRINT (yyss, yyssp); 8212 while (yyssp != yyss) 8213 { 8214 yydestruct ("Cleanup: popping", 8215 yystos[*yyssp], yyvsp, pParseContext); 8216 YYPOPSTACK (1); 8217 } 8218 #ifndef yyoverflow 8219 if (yyss != yyssa) 8220 YYSTACK_FREE (yyss); 8221 #endif 8222 #if YYERROR_VERBOSE 8223 if (yymsg != yymsgbuf) 8224 YYSTACK_FREE (yymsg); 8225 #endif 8226 return yyresult; 8227 } 8228 #line 2918 "MachineIndependent/glslang.y" /* yacc.c:1906 */ 8229 8230
