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 42 "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 #include "attribute.h" 87 88 using namespace glslang; 89 90 91 #line 92 "MachineIndependent/glslang_tab.cpp" /* yacc.c:339 */ 92 93 # ifndef YY_NULLPTR 94 # if defined __cplusplus && 201103L <= __cplusplus 95 # define YY_NULLPTR nullptr 96 # else 97 # define YY_NULLPTR 0 98 # endif 99 # endif 100 101 /* Enabling verbose error messages. */ 102 #ifdef YYERROR_VERBOSE 103 # undef YYERROR_VERBOSE 104 # define YYERROR_VERBOSE 1 105 #else 106 # define YYERROR_VERBOSE 1 107 #endif 108 109 /* In a future release of Bison, this section will be replaced 110 by #include "glslang_tab.cpp.h". */ 111 #ifndef YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED 112 # define YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED 113 /* Debug traces. */ 114 #ifndef YYDEBUG 115 # define YYDEBUG 1 116 #endif 117 #if YYDEBUG 118 extern int yydebug; 119 #endif 120 121 /* Token type. */ 122 #ifndef YYTOKENTYPE 123 # define YYTOKENTYPE 124 enum yytokentype 125 { 126 ATTRIBUTE = 258, 127 VARYING = 259, 128 FLOAT16_T = 260, 129 FLOAT = 261, 130 FLOAT32_T = 262, 131 DOUBLE = 263, 132 FLOAT64_T = 264, 133 CONST = 265, 134 BOOL = 266, 135 INT = 267, 136 UINT = 268, 137 INT64_T = 269, 138 UINT64_T = 270, 139 INT32_T = 271, 140 UINT32_T = 272, 141 INT16_T = 273, 142 UINT16_T = 274, 143 INT8_T = 275, 144 UINT8_T = 276, 145 BREAK = 277, 146 CONTINUE = 278, 147 DO = 279, 148 ELSE = 280, 149 FOR = 281, 150 IF = 282, 151 DISCARD = 283, 152 RETURN = 284, 153 SWITCH = 285, 154 CASE = 286, 155 DEFAULT = 287, 156 SUBROUTINE = 288, 157 BVEC2 = 289, 158 BVEC3 = 290, 159 BVEC4 = 291, 160 IVEC2 = 292, 161 IVEC3 = 293, 162 IVEC4 = 294, 163 UVEC2 = 295, 164 UVEC3 = 296, 165 UVEC4 = 297, 166 I64VEC2 = 298, 167 I64VEC3 = 299, 168 I64VEC4 = 300, 169 U64VEC2 = 301, 170 U64VEC3 = 302, 171 U64VEC4 = 303, 172 I32VEC2 = 304, 173 I32VEC3 = 305, 174 I32VEC4 = 306, 175 U32VEC2 = 307, 176 U32VEC3 = 308, 177 U32VEC4 = 309, 178 I16VEC2 = 310, 179 I16VEC3 = 311, 180 I16VEC4 = 312, 181 U16VEC2 = 313, 182 U16VEC3 = 314, 183 U16VEC4 = 315, 184 I8VEC2 = 316, 185 I8VEC3 = 317, 186 I8VEC4 = 318, 187 U8VEC2 = 319, 188 U8VEC3 = 320, 189 U8VEC4 = 321, 190 VEC2 = 322, 191 VEC3 = 323, 192 VEC4 = 324, 193 MAT2 = 325, 194 MAT3 = 326, 195 MAT4 = 327, 196 CENTROID = 328, 197 IN = 329, 198 OUT = 330, 199 INOUT = 331, 200 UNIFORM = 332, 201 PATCH = 333, 202 SAMPLE = 334, 203 BUFFER = 335, 204 SHARED = 336, 205 NONUNIFORM = 337, 206 PAYLOADNV = 338, 207 PAYLOADINNV = 339, 208 HITATTRNV = 340, 209 CALLDATANV = 341, 210 CALLDATAINNV = 342, 211 COHERENT = 343, 212 VOLATILE = 344, 213 RESTRICT = 345, 214 READONLY = 346, 215 WRITEONLY = 347, 216 DEVICECOHERENT = 348, 217 QUEUEFAMILYCOHERENT = 349, 218 WORKGROUPCOHERENT = 350, 219 SUBGROUPCOHERENT = 351, 220 NONPRIVATE = 352, 221 DVEC2 = 353, 222 DVEC3 = 354, 223 DVEC4 = 355, 224 DMAT2 = 356, 225 DMAT3 = 357, 226 DMAT4 = 358, 227 F16VEC2 = 359, 228 F16VEC3 = 360, 229 F16VEC4 = 361, 230 F16MAT2 = 362, 231 F16MAT3 = 363, 232 F16MAT4 = 364, 233 F32VEC2 = 365, 234 F32VEC3 = 366, 235 F32VEC4 = 367, 236 F32MAT2 = 368, 237 F32MAT3 = 369, 238 F32MAT4 = 370, 239 F64VEC2 = 371, 240 F64VEC3 = 372, 241 F64VEC4 = 373, 242 F64MAT2 = 374, 243 F64MAT3 = 375, 244 F64MAT4 = 376, 245 NOPERSPECTIVE = 377, 246 FLAT = 378, 247 SMOOTH = 379, 248 LAYOUT = 380, 249 EXPLICITINTERPAMD = 381, 250 PERVERTEXNV = 382, 251 PERPRIMITIVENV = 383, 252 PERVIEWNV = 384, 253 PERTASKNV = 385, 254 MAT2X2 = 386, 255 MAT2X3 = 387, 256 MAT2X4 = 388, 257 MAT3X2 = 389, 258 MAT3X3 = 390, 259 MAT3X4 = 391, 260 MAT4X2 = 392, 261 MAT4X3 = 393, 262 MAT4X4 = 394, 263 DMAT2X2 = 395, 264 DMAT2X3 = 396, 265 DMAT2X4 = 397, 266 DMAT3X2 = 398, 267 DMAT3X3 = 399, 268 DMAT3X4 = 400, 269 DMAT4X2 = 401, 270 DMAT4X3 = 402, 271 DMAT4X4 = 403, 272 F16MAT2X2 = 404, 273 F16MAT2X3 = 405, 274 F16MAT2X4 = 406, 275 F16MAT3X2 = 407, 276 F16MAT3X3 = 408, 277 F16MAT3X4 = 409, 278 F16MAT4X2 = 410, 279 F16MAT4X3 = 411, 280 F16MAT4X4 = 412, 281 F32MAT2X2 = 413, 282 F32MAT2X3 = 414, 283 F32MAT2X4 = 415, 284 F32MAT3X2 = 416, 285 F32MAT3X3 = 417, 286 F32MAT3X4 = 418, 287 F32MAT4X2 = 419, 288 F32MAT4X3 = 420, 289 F32MAT4X4 = 421, 290 F64MAT2X2 = 422, 291 F64MAT2X3 = 423, 292 F64MAT2X4 = 424, 293 F64MAT3X2 = 425, 294 F64MAT3X3 = 426, 295 F64MAT3X4 = 427, 296 F64MAT4X2 = 428, 297 F64MAT4X3 = 429, 298 F64MAT4X4 = 430, 299 ATOMIC_UINT = 431, 300 ACCSTRUCTNV = 432, 301 SAMPLER1D = 433, 302 SAMPLER2D = 434, 303 SAMPLER3D = 435, 304 SAMPLERCUBE = 436, 305 SAMPLER1DSHADOW = 437, 306 SAMPLER2DSHADOW = 438, 307 SAMPLERCUBESHADOW = 439, 308 SAMPLER1DARRAY = 440, 309 SAMPLER2DARRAY = 441, 310 SAMPLER1DARRAYSHADOW = 442, 311 SAMPLER2DARRAYSHADOW = 443, 312 ISAMPLER1D = 444, 313 ISAMPLER2D = 445, 314 ISAMPLER3D = 446, 315 ISAMPLERCUBE = 447, 316 ISAMPLER1DARRAY = 448, 317 ISAMPLER2DARRAY = 449, 318 USAMPLER1D = 450, 319 USAMPLER2D = 451, 320 USAMPLER3D = 452, 321 USAMPLERCUBE = 453, 322 USAMPLER1DARRAY = 454, 323 USAMPLER2DARRAY = 455, 324 SAMPLER2DRECT = 456, 325 SAMPLER2DRECTSHADOW = 457, 326 ISAMPLER2DRECT = 458, 327 USAMPLER2DRECT = 459, 328 SAMPLERBUFFER = 460, 329 ISAMPLERBUFFER = 461, 330 USAMPLERBUFFER = 462, 331 SAMPLERCUBEARRAY = 463, 332 SAMPLERCUBEARRAYSHADOW = 464, 333 ISAMPLERCUBEARRAY = 465, 334 USAMPLERCUBEARRAY = 466, 335 SAMPLER2DMS = 467, 336 ISAMPLER2DMS = 468, 337 USAMPLER2DMS = 469, 338 SAMPLER2DMSARRAY = 470, 339 ISAMPLER2DMSARRAY = 471, 340 USAMPLER2DMSARRAY = 472, 341 SAMPLEREXTERNALOES = 473, 342 F16SAMPLER1D = 474, 343 F16SAMPLER2D = 475, 344 F16SAMPLER3D = 476, 345 F16SAMPLER2DRECT = 477, 346 F16SAMPLERCUBE = 478, 347 F16SAMPLER1DARRAY = 479, 348 F16SAMPLER2DARRAY = 480, 349 F16SAMPLERCUBEARRAY = 481, 350 F16SAMPLERBUFFER = 482, 351 F16SAMPLER2DMS = 483, 352 F16SAMPLER2DMSARRAY = 484, 353 F16SAMPLER1DSHADOW = 485, 354 F16SAMPLER2DSHADOW = 486, 355 F16SAMPLER1DARRAYSHADOW = 487, 356 F16SAMPLER2DARRAYSHADOW = 488, 357 F16SAMPLER2DRECTSHADOW = 489, 358 F16SAMPLERCUBESHADOW = 490, 359 F16SAMPLERCUBEARRAYSHADOW = 491, 360 SAMPLER = 492, 361 SAMPLERSHADOW = 493, 362 TEXTURE1D = 494, 363 TEXTURE2D = 495, 364 TEXTURE3D = 496, 365 TEXTURECUBE = 497, 366 TEXTURE1DARRAY = 498, 367 TEXTURE2DARRAY = 499, 368 ITEXTURE1D = 500, 369 ITEXTURE2D = 501, 370 ITEXTURE3D = 502, 371 ITEXTURECUBE = 503, 372 ITEXTURE1DARRAY = 504, 373 ITEXTURE2DARRAY = 505, 374 UTEXTURE1D = 506, 375 UTEXTURE2D = 507, 376 UTEXTURE3D = 508, 377 UTEXTURECUBE = 509, 378 UTEXTURE1DARRAY = 510, 379 UTEXTURE2DARRAY = 511, 380 TEXTURE2DRECT = 512, 381 ITEXTURE2DRECT = 513, 382 UTEXTURE2DRECT = 514, 383 TEXTUREBUFFER = 515, 384 ITEXTUREBUFFER = 516, 385 UTEXTUREBUFFER = 517, 386 TEXTURECUBEARRAY = 518, 387 ITEXTURECUBEARRAY = 519, 388 UTEXTURECUBEARRAY = 520, 389 TEXTURE2DMS = 521, 390 ITEXTURE2DMS = 522, 391 UTEXTURE2DMS = 523, 392 TEXTURE2DMSARRAY = 524, 393 ITEXTURE2DMSARRAY = 525, 394 UTEXTURE2DMSARRAY = 526, 395 F16TEXTURE1D = 527, 396 F16TEXTURE2D = 528, 397 F16TEXTURE3D = 529, 398 F16TEXTURE2DRECT = 530, 399 F16TEXTURECUBE = 531, 400 F16TEXTURE1DARRAY = 532, 401 F16TEXTURE2DARRAY = 533, 402 F16TEXTURECUBEARRAY = 534, 403 F16TEXTUREBUFFER = 535, 404 F16TEXTURE2DMS = 536, 405 F16TEXTURE2DMSARRAY = 537, 406 SUBPASSINPUT = 538, 407 SUBPASSINPUTMS = 539, 408 ISUBPASSINPUT = 540, 409 ISUBPASSINPUTMS = 541, 410 USUBPASSINPUT = 542, 411 USUBPASSINPUTMS = 543, 412 F16SUBPASSINPUT = 544, 413 F16SUBPASSINPUTMS = 545, 414 IMAGE1D = 546, 415 IIMAGE1D = 547, 416 UIMAGE1D = 548, 417 IMAGE2D = 549, 418 IIMAGE2D = 550, 419 UIMAGE2D = 551, 420 IMAGE3D = 552, 421 IIMAGE3D = 553, 422 UIMAGE3D = 554, 423 IMAGE2DRECT = 555, 424 IIMAGE2DRECT = 556, 425 UIMAGE2DRECT = 557, 426 IMAGECUBE = 558, 427 IIMAGECUBE = 559, 428 UIMAGECUBE = 560, 429 IMAGEBUFFER = 561, 430 IIMAGEBUFFER = 562, 431 UIMAGEBUFFER = 563, 432 IMAGE1DARRAY = 564, 433 IIMAGE1DARRAY = 565, 434 UIMAGE1DARRAY = 566, 435 IMAGE2DARRAY = 567, 436 IIMAGE2DARRAY = 568, 437 UIMAGE2DARRAY = 569, 438 IMAGECUBEARRAY = 570, 439 IIMAGECUBEARRAY = 571, 440 UIMAGECUBEARRAY = 572, 441 IMAGE2DMS = 573, 442 IIMAGE2DMS = 574, 443 UIMAGE2DMS = 575, 444 IMAGE2DMSARRAY = 576, 445 IIMAGE2DMSARRAY = 577, 446 UIMAGE2DMSARRAY = 578, 447 F16IMAGE1D = 579, 448 F16IMAGE2D = 580, 449 F16IMAGE3D = 581, 450 F16IMAGE2DRECT = 582, 451 F16IMAGECUBE = 583, 452 F16IMAGE1DARRAY = 584, 453 F16IMAGE2DARRAY = 585, 454 F16IMAGECUBEARRAY = 586, 455 F16IMAGEBUFFER = 587, 456 F16IMAGE2DMS = 588, 457 F16IMAGE2DMSARRAY = 589, 458 STRUCT = 590, 459 VOID = 591, 460 WHILE = 592, 461 IDENTIFIER = 593, 462 TYPE_NAME = 594, 463 FLOATCONSTANT = 595, 464 DOUBLECONSTANT = 596, 465 INT16CONSTANT = 597, 466 UINT16CONSTANT = 598, 467 INT32CONSTANT = 599, 468 UINT32CONSTANT = 600, 469 INTCONSTANT = 601, 470 UINTCONSTANT = 602, 471 INT64CONSTANT = 603, 472 UINT64CONSTANT = 604, 473 BOOLCONSTANT = 605, 474 FLOAT16CONSTANT = 606, 475 LEFT_OP = 607, 476 RIGHT_OP = 608, 477 INC_OP = 609, 478 DEC_OP = 610, 479 LE_OP = 611, 480 GE_OP = 612, 481 EQ_OP = 613, 482 NE_OP = 614, 483 AND_OP = 615, 484 OR_OP = 616, 485 XOR_OP = 617, 486 MUL_ASSIGN = 618, 487 DIV_ASSIGN = 619, 488 ADD_ASSIGN = 620, 489 MOD_ASSIGN = 621, 490 LEFT_ASSIGN = 622, 491 RIGHT_ASSIGN = 623, 492 AND_ASSIGN = 624, 493 XOR_ASSIGN = 625, 494 OR_ASSIGN = 626, 495 SUB_ASSIGN = 627, 496 LEFT_PAREN = 628, 497 RIGHT_PAREN = 629, 498 LEFT_BRACKET = 630, 499 RIGHT_BRACKET = 631, 500 LEFT_BRACE = 632, 501 RIGHT_BRACE = 633, 502 DOT = 634, 503 COMMA = 635, 504 COLON = 636, 505 EQUAL = 637, 506 SEMICOLON = 638, 507 BANG = 639, 508 DASH = 640, 509 TILDE = 641, 510 PLUS = 642, 511 STAR = 643, 512 SLASH = 644, 513 PERCENT = 645, 514 LEFT_ANGLE = 646, 515 RIGHT_ANGLE = 647, 516 VERTICAL_BAR = 648, 517 CARET = 649, 518 AMPERSAND = 650, 519 QUESTION = 651, 520 INVARIANT = 652, 521 PRECISE = 653, 522 HIGH_PRECISION = 654, 523 MEDIUM_PRECISION = 655, 524 LOW_PRECISION = 656, 525 PRECISION = 657, 526 PACKED = 658, 527 RESOURCE = 659, 528 SUPERP = 660 529 }; 530 #endif 531 532 /* Value type. */ 533 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 534 535 union YYSTYPE 536 { 537 #line 70 "MachineIndependent/glslang.y" /* yacc.c:355 */ 538 539 struct { 540 glslang::TSourceLoc loc; 541 union { 542 glslang::TString *string; 543 int i; 544 unsigned int u; 545 long long i64; 546 unsigned long long u64; 547 bool b; 548 double d; 549 }; 550 glslang::TSymbol* symbol; 551 } lex; 552 struct { 553 glslang::TSourceLoc loc; 554 glslang::TOperator op; 555 union { 556 TIntermNode* intermNode; 557 glslang::TIntermNodePair nodePair; 558 glslang::TIntermTyped* intermTypedNode; 559 glslang::TAttributes* attributes; 560 }; 561 union { 562 glslang::TPublicType type; 563 glslang::TFunction* function; 564 glslang::TParameter param; 565 glslang::TTypeLoc typeLine; 566 glslang::TTypeList* typeList; 567 glslang::TArraySizes* arraySizes; 568 glslang::TIdentifierList* identifierList; 569 }; 570 } interm; 571 572 #line 573 "MachineIndependent/glslang_tab.cpp" /* yacc.c:355 */ 573 }; 574 575 typedef union YYSTYPE YYSTYPE; 576 # define YYSTYPE_IS_TRIVIAL 1 577 # define YYSTYPE_IS_DECLARED 1 578 #endif 579 580 581 582 int yyparse (glslang::TParseContext* pParseContext); 583 584 #endif /* !YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED */ 585 586 /* Copy the second part of user declarations. */ 587 #line 105 "MachineIndependent/glslang.y" /* yacc.c:358 */ 588 589 590 /* windows only pragma */ 591 #ifdef _MSC_VER 592 #pragma warning(disable : 4065) 593 #pragma warning(disable : 4127) 594 #pragma warning(disable : 4244) 595 #endif 596 597 #define parseContext (*pParseContext) 598 #define yyerror(context, msg) context->parserError(msg) 599 600 extern int yylex(YYSTYPE*, TParseContext&); 601 602 603 #line 604 "MachineIndependent/glslang_tab.cpp" /* yacc.c:358 */ 604 605 #ifdef short 606 # undef short 607 #endif 608 609 #ifdef YYTYPE_UINT8 610 typedef YYTYPE_UINT8 yytype_uint8; 611 #else 612 typedef unsigned char yytype_uint8; 613 #endif 614 615 #ifdef YYTYPE_INT8 616 typedef YYTYPE_INT8 yytype_int8; 617 #else 618 typedef signed char yytype_int8; 619 #endif 620 621 #ifdef YYTYPE_UINT16 622 typedef YYTYPE_UINT16 yytype_uint16; 623 #else 624 typedef unsigned short int yytype_uint16; 625 #endif 626 627 #ifdef YYTYPE_INT16 628 typedef YYTYPE_INT16 yytype_int16; 629 #else 630 typedef short int yytype_int16; 631 #endif 632 633 #ifndef YYSIZE_T 634 # ifdef __SIZE_TYPE__ 635 # define YYSIZE_T __SIZE_TYPE__ 636 # elif defined size_t 637 # define YYSIZE_T size_t 638 # elif ! defined YYSIZE_T 639 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 640 # define YYSIZE_T size_t 641 # else 642 # define YYSIZE_T unsigned int 643 # endif 644 #endif 645 646 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 647 648 #ifndef YY_ 649 # if defined YYENABLE_NLS && YYENABLE_NLS 650 # if ENABLE_NLS 651 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 652 # define YY_(Msgid) dgettext ("bison-runtime", Msgid) 653 # endif 654 # endif 655 # ifndef YY_ 656 # define YY_(Msgid) Msgid 657 # endif 658 #endif 659 660 #ifndef YY_ATTRIBUTE 661 # if (defined __GNUC__ \ 662 && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \ 663 || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C 664 # define YY_ATTRIBUTE(Spec) __attribute__(Spec) 665 # else 666 # define YY_ATTRIBUTE(Spec) /* empty */ 667 # endif 668 #endif 669 670 #ifndef YY_ATTRIBUTE_PURE 671 # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__)) 672 #endif 673 674 #ifndef YY_ATTRIBUTE_UNUSED 675 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__)) 676 #endif 677 678 #if !defined _Noreturn \ 679 && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112) 680 # if defined _MSC_VER && 1200 <= _MSC_VER 681 # define _Noreturn __declspec (noreturn) 682 # else 683 # define _Noreturn YY_ATTRIBUTE ((__noreturn__)) 684 # endif 685 #endif 686 687 /* Suppress unused-variable warnings by "using" E. */ 688 #if ! defined lint || defined __GNUC__ 689 # define YYUSE(E) ((void) (E)) 690 #else 691 # define YYUSE(E) /* empty */ 692 #endif 693 694 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ 695 /* Suppress an incorrect diagnostic about yylval being uninitialized. */ 696 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ 697 _Pragma ("GCC diagnostic push") \ 698 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\ 699 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") 700 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \ 701 _Pragma ("GCC diagnostic pop") 702 #else 703 # define YY_INITIAL_VALUE(Value) Value 704 #endif 705 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 706 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 707 # define YY_IGNORE_MAYBE_UNINITIALIZED_END 708 #endif 709 #ifndef YY_INITIAL_VALUE 710 # define YY_INITIAL_VALUE(Value) /* Nothing. */ 711 #endif 712 713 714 #if ! defined yyoverflow || YYERROR_VERBOSE 715 716 /* The parser invokes alloca or malloc; define the necessary symbols. */ 717 718 # ifdef YYSTACK_USE_ALLOCA 719 # if YYSTACK_USE_ALLOCA 720 # ifdef __GNUC__ 721 # define YYSTACK_ALLOC __builtin_alloca 722 # elif defined __BUILTIN_VA_ARG_INCR 723 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 724 # elif defined _AIX 725 # define YYSTACK_ALLOC __alloca 726 # elif defined _MSC_VER 727 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 728 # define alloca _alloca 729 # else 730 # define YYSTACK_ALLOC alloca 731 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS 732 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 733 /* Use EXIT_SUCCESS as a witness for stdlib.h. */ 734 # ifndef EXIT_SUCCESS 735 # define EXIT_SUCCESS 0 736 # endif 737 # endif 738 # endif 739 # endif 740 # endif 741 742 # ifdef YYSTACK_ALLOC 743 /* Pacify GCC's 'empty if-body' warning. */ 744 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) 745 # ifndef YYSTACK_ALLOC_MAXIMUM 746 /* The OS might guarantee only one guard page at the bottom of the stack, 747 and a page size can be as small as 4096 bytes. So we cannot safely 748 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 749 to allow for a few compiler-allocated temporary stack slots. */ 750 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 751 # endif 752 # else 753 # define YYSTACK_ALLOC YYMALLOC 754 # define YYSTACK_FREE YYFREE 755 # ifndef YYSTACK_ALLOC_MAXIMUM 756 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 757 # endif 758 # if (defined __cplusplus && ! defined EXIT_SUCCESS \ 759 && ! ((defined YYMALLOC || defined malloc) \ 760 && (defined YYFREE || defined free))) 761 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 762 # ifndef EXIT_SUCCESS 763 # define EXIT_SUCCESS 0 764 # endif 765 # endif 766 # ifndef YYMALLOC 767 # define YYMALLOC malloc 768 # if ! defined malloc && ! defined EXIT_SUCCESS 769 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 770 # endif 771 # endif 772 # ifndef YYFREE 773 # define YYFREE free 774 # if ! defined free && ! defined EXIT_SUCCESS 775 void free (void *); /* INFRINGES ON USER NAME SPACE */ 776 # endif 777 # endif 778 # endif 779 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 780 781 782 #if (! defined yyoverflow \ 783 && (! defined __cplusplus \ 784 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 785 786 /* A type that is properly aligned for any stack member. */ 787 union yyalloc 788 { 789 yytype_int16 yyss_alloc; 790 YYSTYPE yyvs_alloc; 791 }; 792 793 /* The size of the maximum gap between one aligned stack and the next. */ 794 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 795 796 /* The size of an array large to enough to hold all stacks, each with 797 N elements. */ 798 # define YYSTACK_BYTES(N) \ 799 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 800 + YYSTACK_GAP_MAXIMUM) 801 802 # define YYCOPY_NEEDED 1 803 804 /* Relocate STACK from its old location to the new one. The 805 local variables YYSIZE and YYSTACKSIZE give the old and new number of 806 elements in the stack, and YYPTR gives the new location of the 807 stack. Advance YYPTR to a properly aligned location for the next 808 stack. */ 809 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 810 do \ 811 { \ 812 YYSIZE_T yynewbytes; \ 813 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 814 Stack = &yyptr->Stack_alloc; \ 815 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 816 yyptr += yynewbytes / sizeof (*yyptr); \ 817 } \ 818 while (0) 819 820 #endif 821 822 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED 823 /* Copy COUNT objects from SRC to DST. The source and destination do 824 not overlap. */ 825 # ifndef YYCOPY 826 # if defined __GNUC__ && 1 < __GNUC__ 827 # define YYCOPY(Dst, Src, Count) \ 828 __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src))) 829 # else 830 # define YYCOPY(Dst, Src, Count) \ 831 do \ 832 { \ 833 YYSIZE_T yyi; \ 834 for (yyi = 0; yyi < (Count); yyi++) \ 835 (Dst)[yyi] = (Src)[yyi]; \ 836 } \ 837 while (0) 838 # endif 839 # endif 840 #endif /* !YYCOPY_NEEDED */ 841 842 /* YYFINAL -- State number of the termination state. */ 843 #define YYFINAL 381 844 /* YYLAST -- Last index in YYTABLE. */ 845 #define YYLAST 9294 846 847 /* YYNTOKENS -- Number of terminals. */ 848 #define YYNTOKENS 406 849 /* YYNNTS -- Number of nonterminals. */ 850 #define YYNNTS 107 851 /* YYNRULES -- Number of rules. */ 852 #define YYNRULES 571 853 /* YYNSTATES -- Number of states. */ 854 #define YYNSTATES 712 855 856 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned 857 by yylex, with out-of-bounds checking. */ 858 #define YYUNDEFTOK 2 859 #define YYMAXUTOK 660 860 861 #define YYTRANSLATE(YYX) \ 862 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 863 864 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM 865 as returned by yylex, without out-of-bounds checking. */ 866 static const yytype_uint16 yytranslate[] = 867 { 868 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 869 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 870 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 871 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 872 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 873 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 874 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 875 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 876 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 877 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 878 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 879 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 880 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 881 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 882 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 883 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 884 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 885 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 886 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 887 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 888 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 889 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 890 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 891 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 892 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 893 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 894 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 895 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 896 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 897 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 898 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 899 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 900 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 901 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 902 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 903 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 904 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 905 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 906 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 907 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 908 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 909 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 910 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 911 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 912 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 913 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 914 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 915 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 916 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 917 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 918 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 919 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 920 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 921 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 922 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 923 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 924 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 925 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 926 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 927 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 928 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 929 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 930 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 931 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 932 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 933 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 934 405 935 }; 936 937 #if YYDEBUG 938 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ 939 static const yytype_uint16 yyrline[] = 940 { 941 0, 294, 294, 300, 303, 307, 311, 314, 318, 322, 942 326, 330, 334, 337, 341, 345, 348, 356, 359, 362, 943 365, 368, 373, 381, 388, 395, 401, 405, 412, 415, 944 421, 428, 438, 446, 451, 478, 486, 492, 496, 500, 945 520, 521, 522, 523, 529, 530, 535, 540, 549, 550, 946 555, 563, 564, 570, 579, 580, 585, 590, 595, 603, 947 604, 612, 623, 624, 633, 634, 643, 644, 653, 654, 948 662, 663, 671, 672, 680, 681, 681, 699, 700, 716, 949 720, 724, 728, 733, 737, 741, 745, 749, 753, 757, 950 764, 767, 778, 785, 790, 795, 803, 807, 811, 815, 951 820, 825, 834, 834, 845, 849, 856, 863, 866, 873, 952 881, 901, 924, 939, 964, 975, 985, 995, 1005, 1014, 953 1017, 1021, 1025, 1030, 1038, 1043, 1048, 1053, 1058, 1067, 954 1078, 1105, 1114, 1121, 1128, 1139, 1148, 1158, 1170, 1179, 955 1191, 1197, 1200, 1207, 1211, 1215, 1223, 1232, 1235, 1246, 956 1249, 1252, 1256, 1260, 1264, 1268, 1274, 1278, 1290, 1304, 957 1309, 1315, 1321, 1328, 1334, 1339, 1344, 1349, 1359, 1369, 958 1379, 1389, 1398, 1410, 1414, 1419, 1424, 1429, 1434, 1439, 959 1443, 1447, 1451, 1455, 1461, 1470, 1477, 1480, 1488, 1492, 960 1501, 1506, 1514, 1518, 1528, 1532, 1536, 1541, 1546, 1551, 961 1556, 1560, 1565, 1570, 1575, 1580, 1585, 1590, 1595, 1600, 962 1605, 1609, 1614, 1619, 1624, 1630, 1636, 1642, 1648, 1654, 963 1660, 1666, 1672, 1678, 1684, 1690, 1696, 1701, 1706, 1711, 964 1716, 1721, 1726, 1732, 1738, 1744, 1750, 1756, 1762, 1768, 965 1774, 1780, 1786, 1792, 1798, 1804, 1810, 1816, 1822, 1828, 966 1834, 1840, 1846, 1852, 1858, 1864, 1870, 1876, 1882, 1888, 967 1893, 1898, 1903, 1908, 1913, 1918, 1923, 1928, 1933, 1938, 968 1943, 1948, 1954, 1960, 1966, 1972, 1978, 1984, 1990, 1996, 969 2002, 2008, 2014, 2020, 2026, 2032, 2038, 2044, 2050, 2056, 970 2062, 2068, 2074, 2080, 2086, 2092, 2098, 2104, 2110, 2116, 971 2122, 2128, 2134, 2140, 2146, 2152, 2158, 2164, 2170, 2176, 972 2182, 2188, 2194, 2200, 2206, 2212, 2218, 2224, 2230, 2236, 973 2242, 2247, 2252, 2257, 2262, 2267, 2272, 2277, 2282, 2287, 974 2292, 2297, 2302, 2307, 2312, 2320, 2328, 2336, 2344, 2352, 975 2360, 2368, 2376, 2384, 2392, 2400, 2408, 2416, 2421, 2426, 976 2431, 2436, 2441, 2446, 2451, 2456, 2461, 2466, 2471, 2476, 977 2481, 2486, 2491, 2496, 2504, 2512, 2517, 2522, 2527, 2535, 978 2540, 2545, 2550, 2558, 2563, 2568, 2573, 2581, 2586, 2591, 979 2596, 2601, 2606, 2614, 2619, 2627, 2632, 2640, 2645, 2653, 980 2658, 2666, 2671, 2679, 2684, 2692, 2697, 2702, 2707, 2712, 981 2717, 2722, 2727, 2732, 2737, 2742, 2747, 2752, 2757, 2762, 982 2767, 2775, 2780, 2785, 2790, 2798, 2803, 2808, 2813, 2821, 983 2826, 2831, 2836, 2844, 2849, 2854, 2859, 2867, 2872, 2877, 984 2882, 2890, 2895, 2900, 2905, 2913, 2918, 2923, 2928, 2936, 985 2941, 2946, 2951, 2959, 2964, 2969, 2974, 2982, 2987, 2992, 986 2997, 3005, 3010, 3015, 3020, 3028, 3033, 3038, 3043, 3051, 987 3056, 3061, 3066, 3074, 3079, 3084, 3089, 3097, 3102, 3107, 988 3113, 3119, 3125, 3134, 3143, 3149, 3155, 3161, 3167, 3172, 989 3188, 3193, 3198, 3206, 3206, 3217, 3217, 3227, 3230, 3243, 990 3265, 3292, 3296, 3302, 3307, 3318, 3321, 3327, 3336, 3339, 991 3345, 3349, 3350, 3356, 3357, 3358, 3359, 3360, 3361, 3362, 992 3366, 3367, 3371, 3367, 3383, 3384, 3388, 3388, 3395, 3395, 993 3409, 3412, 3420, 3428, 3439, 3440, 3444, 3447, 3453, 3460, 994 3464, 3472, 3476, 3489, 3492, 3498, 3498, 3518, 3521, 3527, 995 3539, 3551, 3554, 3560, 3560, 3575, 3575, 3591, 3591, 3612, 996 3615, 3621, 3624, 3630, 3634, 3641, 3646, 3651, 3658, 3661, 997 3670, 3674, 3683, 3686, 3689, 3697, 3697, 3719, 3725, 3728, 998 3733, 3736 999 }; 1000 #endif 1001 1002 #if YYDEBUG || YYERROR_VERBOSE || 1 1003 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 1004 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 1005 static const char *const yytname[] = 1006 { 1007 "$end", "error", "$undefined", "ATTRIBUTE", "VARYING", "FLOAT16_T", 1008 "FLOAT", "FLOAT32_T", "DOUBLE", "FLOAT64_T", "CONST", "BOOL", "INT", 1009 "UINT", "INT64_T", "UINT64_T", "INT32_T", "UINT32_T", "INT16_T", 1010 "UINT16_T", "INT8_T", "UINT8_T", "BREAK", "CONTINUE", "DO", "ELSE", 1011 "FOR", "IF", "DISCARD", "RETURN", "SWITCH", "CASE", "DEFAULT", 1012 "SUBROUTINE", "BVEC2", "BVEC3", "BVEC4", "IVEC2", "IVEC3", "IVEC4", 1013 "UVEC2", "UVEC3", "UVEC4", "I64VEC2", "I64VEC3", "I64VEC4", "U64VEC2", 1014 "U64VEC3", "U64VEC4", "I32VEC2", "I32VEC3", "I32VEC4", "U32VEC2", 1015 "U32VEC3", "U32VEC4", "I16VEC2", "I16VEC3", "I16VEC4", "U16VEC2", 1016 "U16VEC3", "U16VEC4", "I8VEC2", "I8VEC3", "I8VEC4", "U8VEC2", "U8VEC3", 1017 "U8VEC4", "VEC2", "VEC3", "VEC4", "MAT2", "MAT3", "MAT4", "CENTROID", 1018 "IN", "OUT", "INOUT", "UNIFORM", "PATCH", "SAMPLE", "BUFFER", "SHARED", 1019 "NONUNIFORM", "PAYLOADNV", "PAYLOADINNV", "HITATTRNV", "CALLDATANV", 1020 "CALLDATAINNV", "COHERENT", "VOLATILE", "RESTRICT", "READONLY", 1021 "WRITEONLY", "DEVICECOHERENT", "QUEUEFAMILYCOHERENT", 1022 "WORKGROUPCOHERENT", "SUBGROUPCOHERENT", "NONPRIVATE", "DVEC2", "DVEC3", 1023 "DVEC4", "DMAT2", "DMAT3", "DMAT4", "F16VEC2", "F16VEC3", "F16VEC4", 1024 "F16MAT2", "F16MAT3", "F16MAT4", "F32VEC2", "F32VEC3", "F32VEC4", 1025 "F32MAT2", "F32MAT3", "F32MAT4", "F64VEC2", "F64VEC3", "F64VEC4", 1026 "F64MAT2", "F64MAT3", "F64MAT4", "NOPERSPECTIVE", "FLAT", "SMOOTH", 1027 "LAYOUT", "EXPLICITINTERPAMD", "PERVERTEXNV", "PERPRIMITIVENV", 1028 "PERVIEWNV", "PERTASKNV", "MAT2X2", "MAT2X3", "MAT2X4", "MAT3X2", 1029 "MAT3X3", "MAT3X4", "MAT4X2", "MAT4X3", "MAT4X4", "DMAT2X2", "DMAT2X3", 1030 "DMAT2X4", "DMAT3X2", "DMAT3X3", "DMAT3X4", "DMAT4X2", "DMAT4X3", 1031 "DMAT4X4", "F16MAT2X2", "F16MAT2X3", "F16MAT2X4", "F16MAT3X2", 1032 "F16MAT3X3", "F16MAT3X4", "F16MAT4X2", "F16MAT4X3", "F16MAT4X4", 1033 "F32MAT2X2", "F32MAT2X3", "F32MAT2X4", "F32MAT3X2", "F32MAT3X3", 1034 "F32MAT3X4", "F32MAT4X2", "F32MAT4X3", "F32MAT4X4", "F64MAT2X2", 1035 "F64MAT2X3", "F64MAT2X4", "F64MAT3X2", "F64MAT3X3", "F64MAT3X4", 1036 "F64MAT4X2", "F64MAT4X3", "F64MAT4X4", "ATOMIC_UINT", "ACCSTRUCTNV", 1037 "SAMPLER1D", "SAMPLER2D", "SAMPLER3D", "SAMPLERCUBE", "SAMPLER1DSHADOW", 1038 "SAMPLER2DSHADOW", "SAMPLERCUBESHADOW", "SAMPLER1DARRAY", 1039 "SAMPLER2DARRAY", "SAMPLER1DARRAYSHADOW", "SAMPLER2DARRAYSHADOW", 1040 "ISAMPLER1D", "ISAMPLER2D", "ISAMPLER3D", "ISAMPLERCUBE", 1041 "ISAMPLER1DARRAY", "ISAMPLER2DARRAY", "USAMPLER1D", "USAMPLER2D", 1042 "USAMPLER3D", "USAMPLERCUBE", "USAMPLER1DARRAY", "USAMPLER2DARRAY", 1043 "SAMPLER2DRECT", "SAMPLER2DRECTSHADOW", "ISAMPLER2DRECT", 1044 "USAMPLER2DRECT", "SAMPLERBUFFER", "ISAMPLERBUFFER", "USAMPLERBUFFER", 1045 "SAMPLERCUBEARRAY", "SAMPLERCUBEARRAYSHADOW", "ISAMPLERCUBEARRAY", 1046 "USAMPLERCUBEARRAY", "SAMPLER2DMS", "ISAMPLER2DMS", "USAMPLER2DMS", 1047 "SAMPLER2DMSARRAY", "ISAMPLER2DMSARRAY", "USAMPLER2DMSARRAY", 1048 "SAMPLEREXTERNALOES", "F16SAMPLER1D", "F16SAMPLER2D", "F16SAMPLER3D", 1049 "F16SAMPLER2DRECT", "F16SAMPLERCUBE", "F16SAMPLER1DARRAY", 1050 "F16SAMPLER2DARRAY", "F16SAMPLERCUBEARRAY", "F16SAMPLERBUFFER", 1051 "F16SAMPLER2DMS", "F16SAMPLER2DMSARRAY", "F16SAMPLER1DSHADOW", 1052 "F16SAMPLER2DSHADOW", "F16SAMPLER1DARRAYSHADOW", 1053 "F16SAMPLER2DARRAYSHADOW", "F16SAMPLER2DRECTSHADOW", 1054 "F16SAMPLERCUBESHADOW", "F16SAMPLERCUBEARRAYSHADOW", "SAMPLER", 1055 "SAMPLERSHADOW", "TEXTURE1D", "TEXTURE2D", "TEXTURE3D", "TEXTURECUBE", 1056 "TEXTURE1DARRAY", "TEXTURE2DARRAY", "ITEXTURE1D", "ITEXTURE2D", 1057 "ITEXTURE3D", "ITEXTURECUBE", "ITEXTURE1DARRAY", "ITEXTURE2DARRAY", 1058 "UTEXTURE1D", "UTEXTURE2D", "UTEXTURE3D", "UTEXTURECUBE", 1059 "UTEXTURE1DARRAY", "UTEXTURE2DARRAY", "TEXTURE2DRECT", "ITEXTURE2DRECT", 1060 "UTEXTURE2DRECT", "TEXTUREBUFFER", "ITEXTUREBUFFER", "UTEXTUREBUFFER", 1061 "TEXTURECUBEARRAY", "ITEXTURECUBEARRAY", "UTEXTURECUBEARRAY", 1062 "TEXTURE2DMS", "ITEXTURE2DMS", "UTEXTURE2DMS", "TEXTURE2DMSARRAY", 1063 "ITEXTURE2DMSARRAY", "UTEXTURE2DMSARRAY", "F16TEXTURE1D", "F16TEXTURE2D", 1064 "F16TEXTURE3D", "F16TEXTURE2DRECT", "F16TEXTURECUBE", 1065 "F16TEXTURE1DARRAY", "F16TEXTURE2DARRAY", "F16TEXTURECUBEARRAY", 1066 "F16TEXTUREBUFFER", "F16TEXTURE2DMS", "F16TEXTURE2DMSARRAY", 1067 "SUBPASSINPUT", "SUBPASSINPUTMS", "ISUBPASSINPUT", "ISUBPASSINPUTMS", 1068 "USUBPASSINPUT", "USUBPASSINPUTMS", "F16SUBPASSINPUT", 1069 "F16SUBPASSINPUTMS", "IMAGE1D", "IIMAGE1D", "UIMAGE1D", "IMAGE2D", 1070 "IIMAGE2D", "UIMAGE2D", "IMAGE3D", "IIMAGE3D", "UIMAGE3D", "IMAGE2DRECT", 1071 "IIMAGE2DRECT", "UIMAGE2DRECT", "IMAGECUBE", "IIMAGECUBE", "UIMAGECUBE", 1072 "IMAGEBUFFER", "IIMAGEBUFFER", "UIMAGEBUFFER", "IMAGE1DARRAY", 1073 "IIMAGE1DARRAY", "UIMAGE1DARRAY", "IMAGE2DARRAY", "IIMAGE2DARRAY", 1074 "UIMAGE2DARRAY", "IMAGECUBEARRAY", "IIMAGECUBEARRAY", "UIMAGECUBEARRAY", 1075 "IMAGE2DMS", "IIMAGE2DMS", "UIMAGE2DMS", "IMAGE2DMSARRAY", 1076 "IIMAGE2DMSARRAY", "UIMAGE2DMSARRAY", "F16IMAGE1D", "F16IMAGE2D", 1077 "F16IMAGE3D", "F16IMAGE2DRECT", "F16IMAGECUBE", "F16IMAGE1DARRAY", 1078 "F16IMAGE2DARRAY", "F16IMAGECUBEARRAY", "F16IMAGEBUFFER", "F16IMAGE2DMS", 1079 "F16IMAGE2DMSARRAY", "STRUCT", "VOID", "WHILE", "IDENTIFIER", 1080 "TYPE_NAME", "FLOATCONSTANT", "DOUBLECONSTANT", "INT16CONSTANT", 1081 "UINT16CONSTANT", "INT32CONSTANT", "UINT32CONSTANT", "INTCONSTANT", 1082 "UINTCONSTANT", "INT64CONSTANT", "UINT64CONSTANT", "BOOLCONSTANT", 1083 "FLOAT16CONSTANT", "LEFT_OP", "RIGHT_OP", "INC_OP", "DEC_OP", "LE_OP", 1084 "GE_OP", "EQ_OP", "NE_OP", "AND_OP", "OR_OP", "XOR_OP", "MUL_ASSIGN", 1085 "DIV_ASSIGN", "ADD_ASSIGN", "MOD_ASSIGN", "LEFT_ASSIGN", "RIGHT_ASSIGN", 1086 "AND_ASSIGN", "XOR_ASSIGN", "OR_ASSIGN", "SUB_ASSIGN", "LEFT_PAREN", 1087 "RIGHT_PAREN", "LEFT_BRACKET", "RIGHT_BRACKET", "LEFT_BRACE", 1088 "RIGHT_BRACE", "DOT", "COMMA", "COLON", "EQUAL", "SEMICOLON", "BANG", 1089 "DASH", "TILDE", "PLUS", "STAR", "SLASH", "PERCENT", "LEFT_ANGLE", 1090 "RIGHT_ANGLE", "VERTICAL_BAR", "CARET", "AMPERSAND", "QUESTION", 1091 "INVARIANT", "PRECISE", "HIGH_PRECISION", "MEDIUM_PRECISION", 1092 "LOW_PRECISION", "PRECISION", "PACKED", "RESOURCE", "SUPERP", "$accept", 1093 "variable_identifier", "primary_expression", "postfix_expression", 1094 "integer_expression", "function_call", "function_call_or_method", 1095 "function_call_generic", "function_call_header_no_parameters", 1096 "function_call_header_with_parameters", "function_call_header", 1097 "function_identifier", "unary_expression", "unary_operator", 1098 "multiplicative_expression", "additive_expression", "shift_expression", 1099 "relational_expression", "equality_expression", "and_expression", 1100 "exclusive_or_expression", "inclusive_or_expression", 1101 "logical_and_expression", "logical_xor_expression", 1102 "logical_or_expression", "conditional_expression", "$@1", 1103 "assignment_expression", "assignment_operator", "expression", 1104 "constant_expression", "declaration", "block_structure", "$@2", 1105 "identifier_list", "function_prototype", "function_declarator", 1106 "function_header_with_parameters", "function_header", 1107 "parameter_declarator", "parameter_declaration", 1108 "parameter_type_specifier", "init_declarator_list", "single_declaration", 1109 "fully_specified_type", "invariant_qualifier", "interpolation_qualifier", 1110 "layout_qualifier", "layout_qualifier_id_list", "layout_qualifier_id", 1111 "precise_qualifier", "type_qualifier", "single_type_qualifier", 1112 "storage_qualifier", "non_uniform_qualifier", "type_name_list", 1113 "type_specifier", "array_specifier", "type_specifier_nonarray", 1114 "precision_qualifier", "struct_specifier", "$@3", "$@4", 1115 "struct_declaration_list", "struct_declaration", 1116 "struct_declarator_list", "struct_declarator", "initializer", 1117 "initializer_list", "declaration_statement", "statement", 1118 "simple_statement", "compound_statement", "$@5", "$@6", 1119 "statement_no_new_scope", "statement_scoped", "$@7", "$@8", 1120 "compound_statement_no_new_scope", "statement_list", 1121 "expression_statement", "selection_statement", 1122 "selection_statement_nonattributed", "selection_rest_statement", 1123 "condition", "switch_statement", "switch_statement_nonattributed", "$@9", 1124 "switch_statement_list", "case_label", "iteration_statement", 1125 "iteration_statement_nonattributed", "$@10", "$@11", "$@12", 1126 "for_init_statement", "conditionopt", "for_rest_statement", 1127 "jump_statement", "translation_unit", "external_declaration", 1128 "function_definition", "$@13", "attribute", "attribute_list", 1129 "single_attribute", YY_NULLPTR 1130 }; 1131 #endif 1132 1133 # ifdef YYPRINT 1134 /* YYTOKNUM[NUM] -- (External) token number corresponding to the 1135 (internal) symbol number NUM (which must be that of a token). */ 1136 static const yytype_uint16 yytoknum[] = 1137 { 1138 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 1139 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 1140 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 1141 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 1142 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 1143 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 1144 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 1145 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 1146 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 1147 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 1148 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 1149 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 1150 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 1151 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 1152 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 1153 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 1154 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 1155 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 1156 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 1157 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 1158 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 1159 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 1160 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 1161 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 1162 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 1163 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 1164 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 1165 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 1166 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 1167 545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 1168 555, 556, 557, 558, 559, 560, 561, 562, 563, 564, 1169 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 1170 575, 576, 577, 578, 579, 580, 581, 582, 583, 584, 1171 585, 586, 587, 588, 589, 590, 591, 592, 593, 594, 1172 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, 1173 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 1174 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 1175 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 1176 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 1177 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 1178 655, 656, 657, 658, 659, 660 1179 }; 1180 # endif 1181 1182 #define YYPACT_NINF -649 1183 1184 #define yypact_value_is_default(Yystate) \ 1185 (!!((Yystate) == (-649))) 1186 1187 #define YYTABLE_NINF -517 1188 1189 #define yytable_value_is_error(Yytable_value) \ 1190 0 1191 1192 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 1193 STATE-NUM. */ 1194 static const yytype_int16 yypact[] = 1195 { 1196 3511, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1197 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1198 -326, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1199 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1200 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1201 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1202 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1203 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1204 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1205 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1206 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1207 -649, -649, -310, -649, -649, -649, -649, -649, -649, -649, 1208 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1209 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1210 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1211 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1212 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1213 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1214 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1215 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1216 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1217 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1218 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1219 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1220 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1221 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1222 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1223 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1224 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1225 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1226 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1227 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1228 -649, -649, -316, -649, -649, -649, -649, -649, -649, -649, 1229 -649, -256, -649, -317, -357, -305, -269, 5906, -315, -649, 1230 -225, -649, -649, -649, -649, 4310, -649, -649, -649, -649, 1231 -234, -649, -649, 711, -649, -649, -204, -69, -222, -649, 1232 8955, -335, -649, -649, -218, -649, 5906, -649, -649, -649, 1233 5906, -170, -169, -649, -339, -303, -649, -649, -649, 6657, 1234 -205, -649, -649, -649, -307, -649, -211, -302, -649, -649, 1235 5906, -210, -649, -321, 1111, -649, -649, -649, -649, -234, 1236 -340, -649, 7040, -325, -649, -166, -649, -292, -649, -649, 1237 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1238 -649, 8189, 8189, 8189, -649, -649, -649, -649, -649, -649, 1239 -649, -324, -649, -649, -649, -200, -298, 8572, -198, -649, 1240 8189, -242, -278, -314, -333, -209, -219, -217, -215, -180, 1241 -181, -336, -194, -649, -649, 7423, -649, -155, 8189, -649, 1242 -69, 5906, 5906, -154, 4709, -649, -649, -649, -197, -195, 1243 -649, -188, -184, -193, 7806, -179, 8189, -189, -178, -182, 1244 -177, -649, -649, -267, -649, -649, -252, -649, -357, -176, 1245 -173, -649, -649, -649, -649, 1511, -649, -649, -649, -649, 1246 -649, -649, -649, -649, -649, -19, -205, 7040, -311, 7040, 1247 -649, -649, 7040, 5906, -649, -142, -649, -649, -649, -293, 1248 -649, -649, 8189, -136, -649, -649, 8189, -171, -649, -649, 1249 -649, 8189, 8189, 8189, 8189, 8189, 8189, 8189, 8189, 8189, 1250 8189, 8189, 8189, 8189, 8189, 8189, 8189, 8189, 8189, 8189, 1251 -649, -649, -649, -172, -649, -649, -649, -649, 5108, -154, 1252 -234, -251, -649, -649, -649, -649, -649, 1911, -649, 8189, 1253 -649, -649, -245, 8189, -228, -649, -649, -133, -649, 1911, 1254 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1255 -649, 8189, 8189, -649, -649, -649, -649, -649, -649, -649, 1256 7040, -649, -285, -649, 5507, -649, -649, -168, -165, -649, 1257 -649, -649, -649, -649, -242, -242, -278, -278, -314, -314, 1258 -314, -314, -333, -333, -209, -219, -217, -215, -180, -181, 1259 8189, -649, -649, -241, -205, -154, -649, -128, 3111, -290, 1260 -649, -268, -649, 3911, -163, -297, -649, 1911, -649, -649, 1261 -649, -649, 6274, -649, -649, -223, -649, -649, -162, -649, 1262 -649, 3911, -161, -649, -165, -126, 5906, -160, 8189, -159, 1263 -133, -158, -649, -649, 8189, 8189, -649, -164, -156, 196, 1264 -151, 2711, -649, -131, -135, 2311, -152, -649, -649, -649, 1265 -649, -254, 8189, 2311, -161, -649, -649, 1911, 7040, -649, 1266 -649, -649, -649, -134, -165, -649, -649, 1911, -127, -649, 1267 -649, -649 1268 }; 1269 1270 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. 1271 Performed when YYTABLE does not specify something else to do. Zero 1272 means the default is an error. */ 1273 static const yytype_uint16 yydefact[] = 1274 { 1275 0, 157, 158, 197, 195, 198, 196, 199, 156, 210, 1276 200, 201, 208, 209, 206, 207, 204, 205, 202, 203, 1277 183, 226, 227, 228, 229, 230, 231, 244, 245, 246, 1278 241, 242, 243, 256, 257, 258, 238, 239, 240, 253, 1279 254, 255, 235, 236, 237, 250, 251, 252, 232, 233, 1280 234, 247, 248, 249, 211, 212, 213, 259, 260, 261, 1281 162, 160, 161, 159, 165, 163, 164, 166, 172, 185, 1282 168, 169, 167, 170, 171, 173, 179, 180, 181, 182, 1283 174, 175, 176, 177, 178, 214, 215, 216, 271, 272, 1284 273, 217, 218, 219, 283, 284, 285, 220, 221, 222, 1285 295, 296, 297, 223, 224, 225, 307, 308, 309, 134, 1286 133, 132, 0, 135, 136, 137, 138, 139, 262, 263, 1287 264, 265, 266, 267, 268, 269, 270, 274, 275, 276, 1288 277, 278, 279, 280, 281, 282, 286, 287, 288, 289, 1289 290, 291, 292, 293, 294, 298, 299, 300, 301, 302, 1290 303, 304, 305, 306, 310, 311, 312, 313, 314, 315, 1291 316, 317, 318, 320, 319, 321, 322, 323, 324, 325, 1292 326, 327, 328, 329, 330, 331, 347, 348, 349, 350, 1293 351, 352, 354, 355, 356, 357, 358, 359, 361, 362, 1294 365, 366, 367, 369, 370, 332, 333, 353, 360, 371, 1295 373, 374, 375, 377, 378, 469, 334, 335, 336, 363, 1296 337, 341, 342, 345, 368, 372, 376, 338, 339, 343, 1297 344, 364, 340, 346, 379, 380, 381, 383, 385, 387, 1298 389, 391, 395, 396, 397, 398, 399, 400, 402, 403, 1299 404, 405, 406, 407, 409, 411, 412, 413, 415, 416, 1300 393, 401, 408, 417, 419, 420, 421, 423, 424, 382, 1301 384, 386, 410, 388, 390, 392, 394, 414, 418, 422, 1302 470, 471, 474, 475, 476, 477, 472, 473, 425, 427, 1303 428, 429, 431, 432, 433, 435, 436, 437, 439, 440, 1304 441, 443, 444, 445, 447, 448, 449, 451, 452, 453, 1305 455, 456, 457, 459, 460, 461, 463, 464, 465, 467, 1306 468, 426, 430, 434, 438, 442, 450, 454, 458, 446, 1307 462, 466, 0, 194, 479, 564, 131, 146, 480, 481, 1308 482, 0, 563, 0, 565, 0, 108, 107, 0, 119, 1309 124, 153, 152, 150, 154, 0, 147, 149, 155, 129, 1310 188, 151, 478, 0, 560, 562, 0, 0, 0, 485, 1311 0, 0, 96, 93, 0, 106, 0, 115, 109, 117, 1312 0, 118, 0, 94, 125, 0, 99, 148, 130, 0, 1313 189, 1, 561, 186, 0, 145, 143, 0, 141, 483, 1314 0, 0, 97, 0, 0, 566, 110, 114, 116, 112, 1315 120, 111, 0, 126, 102, 0, 100, 0, 2, 12, 1316 13, 10, 11, 4, 5, 6, 7, 8, 9, 15, 1317 14, 0, 0, 0, 190, 42, 41, 43, 40, 3, 1318 17, 36, 19, 24, 25, 0, 0, 29, 0, 44, 1319 0, 48, 51, 54, 59, 62, 64, 66, 68, 70, 1320 72, 74, 0, 35, 33, 0, 184, 0, 0, 140, 1321 0, 0, 0, 0, 0, 487, 95, 98, 0, 0, 1322 545, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1323 511, 520, 524, 44, 77, 90, 0, 500, 0, 155, 1324 129, 503, 522, 502, 501, 0, 504, 505, 526, 506, 1325 533, 507, 508, 541, 509, 0, 113, 0, 121, 0, 1326 495, 128, 0, 0, 104, 0, 101, 37, 38, 0, 1327 21, 22, 0, 0, 27, 26, 0, 194, 30, 32, 1328 39, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1329 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1330 75, 191, 192, 0, 187, 92, 144, 142, 0, 0, 1331 493, 0, 491, 486, 488, 556, 555, 0, 547, 0, 1332 559, 557, 0, 0, 0, 540, 543, 0, 510, 0, 1333 80, 81, 83, 82, 85, 86, 87, 88, 89, 84, 1334 79, 0, 0, 525, 521, 523, 527, 534, 542, 123, 1335 0, 498, 0, 127, 0, 105, 16, 0, 23, 20, 1336 31, 45, 46, 47, 50, 49, 52, 53, 57, 58, 1337 55, 56, 60, 61, 63, 65, 67, 69, 71, 73, 1338 0, 193, 484, 0, 494, 0, 489, 0, 0, 0, 1339 558, 0, 539, 0, 570, 0, 568, 512, 78, 91, 1340 122, 496, 0, 103, 18, 0, 490, 492, 0, 550, 1341 549, 552, 518, 535, 531, 0, 0, 0, 0, 0, 1342 0, 0, 497, 499, 0, 0, 551, 0, 0, 530, 1343 0, 0, 528, 0, 0, 0, 0, 567, 569, 513, 1344 76, 0, 553, 0, 518, 517, 519, 537, 0, 515, 1345 544, 514, 571, 0, 554, 548, 529, 538, 0, 532, 1346 546, 536 1347 }; 1348 1349 /* YYPGOTO[NTERM-NUM]. */ 1350 static const yytype_int16 yypgoto[] = 1351 { 1352 -649, -649, -649, -649, -649, -649, -649, -649, -649, -649, 1353 -649, -649, -304, -649, -373, -370, -416, -379, -294, -322, 1354 -291, -295, -288, -296, -649, -369, -649, -393, -649, -382, 1355 -414, 1, -649, -649, -649, 2, -649, -649, -649, -114, 1356 -109, -112, -649, -649, -615, -649, -649, -649, -649, -196, 1357 -649, -334, -341, -649, 6, -649, 0, -347, -649, -68, 1358 -649, -649, -649, -443, -448, -287, -368, -492, -649, -376, 1359 -482, -648, -415, -649, -649, -427, -426, -649, -649, -93, 1360 -560, -365, -649, -231, -649, -386, -649, -229, -649, -649, 1361 -649, -649, -227, -649, -649, -649, -649, -649, -649, -649, 1362 -649, -76, -649, -649, -649, -649, -390 1363 }; 1364 1365 /* YYDEFGOTO[NTERM-NUM]. */ 1366 static const yytype_int16 yydefgoto[] = 1367 { 1368 -1, 429, 430, 431, 607, 432, 433, 434, 435, 436, 1369 437, 438, 483, 440, 441, 442, 443, 444, 445, 446, 1370 447, 448, 449, 450, 451, 484, 630, 485, 591, 486, 1371 556, 487, 333, 513, 407, 488, 335, 336, 337, 367, 1372 368, 369, 338, 339, 340, 341, 342, 343, 387, 388, 1373 344, 345, 346, 347, 453, 384, 454, 380, 350, 351, 1374 352, 461, 390, 464, 465, 561, 562, 511, 602, 491, 1375 492, 493, 494, 579, 671, 700, 679, 680, 681, 701, 1376 495, 496, 497, 498, 682, 667, 499, 500, 683, 708, 1377 501, 502, 503, 643, 567, 638, 661, 677, 678, 504, 1378 353, 354, 355, 364, 505, 645, 646 1379 }; 1380 1381 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If 1382 positive, shift that token. If negative, reduce the rule whose 1383 number is the opposite. If YYTABLE_NINF, syntax error. */ 1384 static const yytype_int16 yytable[] = 1385 {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}; 2317 2318 static const yytype_int16 yycheck[] = 2319 { 2320 0, 0, 0, 337, 345, 24, 0, 26, 27, 402, 2321 379, 30, 81, 495, 361, 507, 464, 509, 461, 579, 2322 512, 338, 338, 356, 357, 361, 383, 374, 643, 370, 2323 354, 355, 366, 681, 373, 375, 375, 685, 352, 353, 2324 375, 423, 382, 382, 437, 693, 661, 373, 383, 373, 2325 375, 375, 399, 400, 375, 379, 390, 382, 391, 392, 2326 396, 377, 383, 373, 375, 380, 383, 374, 383, 374, 2327 513, 382, 374, 380, 377, 379, 374, 380, 380, 376, 2328 383, 374, 380, 380, 374, 567, 455, 380, 380, 458, 2329 380, 383, 474, 378, 476, 380, 363, 364, 365, 366, 2330 367, 368, 369, 370, 371, 372, 374, 385, 600, 387, 2331 558, 380, 380, 338, 507, 382, 509, 421, 422, 512, 2332 374, 462, 538, 539, 540, 541, 380, 461, 380, 380, 2333 464, 383, 383, 526, 338, 380, 440, 697, 383, 380, 2334 522, 375, 383, 399, 400, 401, 388, 389, 390, 358, 2335 359, 455, 380, 381, 458, 377, 604, 380, 381, 377, 2336 652, 534, 535, 542, 543, 647, 536, 537, 338, 338, 2337 375, 382, 338, 383, 374, 373, 395, 394, 393, 513, 2338 360, 362, 376, 338, 338, 373, 383, 569, 383, 373, 2339 383, 573, 381, 375, 373, 373, 338, 373, 591, 592, 2340 373, 378, 338, 374, 376, 338, 698, 600, 376, 337, 2341 373, 373, 338, 560, 374, 380, 377, 376, 374, 383, 2342 378, 25, 374, 545, 558, 707, 377, 531, 532, 533, 2343 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 2344 544, 545, 546, 547, 548, 549, 377, 382, 630, 383, 2345 544, 378, 547, 549, 668, 546, 370, 366, 370, 652, 2346 548, 643, 638, 331, 460, 680, 693, 635, 694, 338, 2347 604, 364, 559, 638, 505, 661, 505, 353, 505, 661, 2348 670, 674, -1, -1, -1, -1, -1, -1, -1, -1, 2349 -1, -1, -1, 675, -1, -1, -1, -1, -1, 668, 2350 -1, -1, -1, -1, -1, 698, -1, -1, -1, 643, 2351 692, -1, -1, -1, -1, -1, -1, -1, 337, -1, 2352 -1, -1, -1, -1, -1, 666, -1, 661, -1, -1, 2353 -1, -1, -1, -1, -1, -1, -1, 337, -1, -1, 2354 -1, -1, -1, 337, -1, 345, -1, -1, -1, -1, 2355 -1, 345, -1, 353, 353, 353, -1, -1, -1, 353, 2356 360, -1, -1, -1, 668, -1, 366, -1, -1, -1, 2357 370, -1, 366, -1, -1, -1, 370, -1, -1, -1, 2358 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2359 390, -1, -1, -1, 394, -1, 390, -1, -1, -1, 2360 394, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2361 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2362 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2363 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2364 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2365 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2366 -1, 461, 462, -1, 464, -1, -1, 461, 462, -1, 2367 464, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2368 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2369 -1, -1, -1, -1, -1, 495, -1, -1, -1, -1, 2370 -1, 495, -1, -1, -1, -1, -1, -1, -1, -1, 2371 -1, -1, -1, 513, -1, -1, -1, -1, -1, 513, 2372 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2373 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2374 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2375 -1, -1, -1, -1, -1, -1, -1, -1, 558, -1, 2376 -1, -1, -1, -1, 558, -1, -1, 567, -1, -1, 2377 -1, -1, -1, 567, -1, -1, -1, -1, -1, 579, 2378 -1, -1, -1, -1, -1, 579, -1, -1, -1, -1, 2379 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2380 -1, -1, -1, -1, 604, -1, -1, -1, -1, -1, 2381 604, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2382 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2383 -1, -1, -1, -1, -1, -1, -1, -1, 638, -1, 2384 -1, -1, -1, 643, 638, -1, -1, 647, -1, 643, 2385 -1, -1, -1, 647, -1, -1, -1, -1, -1, -1, 2386 -1, 661, -1, -1, -1, -1, 666, 661, -1, -1, 2387 -1, -1, 666, -1, -1, -1, -1, -1, -1, -1, 2388 -1, 681, -1, -1, -1, 685, -1, 681, -1, -1, 2389 -1, 685, -1, 693, -1, -1, -1, 697, -1, 693, 2390 -1, -1, -1, 697, -1, -1, -1, 707, -1, -1, 2391 -1, 0, -1, 707, 3, 4, 5, 6, 7, 8, 2392 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 2393 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, 2394 -1, -1, -1, -1, 33, 34, 35, 36, 37, 38, 2395 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 2396 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 2397 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 2398 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 2399 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 2400 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 2401 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 2402 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 2403 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 2404 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 2405 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 2406 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 2407 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 2408 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 2409 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 2410 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 2411 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 2412 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 2413 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 2414 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 2415 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 2416 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 2417 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 2418 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 2419 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 2420 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 2421 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 2422 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 2423 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 2424 329, 330, 331, 332, 333, 334, 335, 336, -1, -1, 2425 339, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2426 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2427 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2428 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2429 -1, -1, -1, -1, 383, -1, -1, -1, -1, -1, 2430 -1, -1, -1, -1, -1, -1, -1, -1, 397, 398, 2431 399, 400, 401, 402, 3, 4, 5, 6, 7, 8, 2432 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 2433 19, 20, 21, 22, 23, 24, -1, 26, 27, 28, 2434 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 2435 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 2436 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 2437 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 2438 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 2439 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 2440 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 2441 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 2442 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 2443 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 2444 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 2445 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 2446 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 2447 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 2448 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 2449 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 2450 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 2451 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 2452 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 2453 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 2454 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 2455 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 2456 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 2457 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 2458 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 2459 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 2460 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 2461 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 2462 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 2463 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 2464 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 2465 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 2466 349, 350, 351, -1, -1, 354, 355, -1, -1, -1, 2467 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2468 -1, -1, -1, -1, 373, -1, 375, -1, 377, 378, 2469 -1, -1, -1, -1, 383, 384, 385, 386, 387, -1, 2470 -1, -1, -1, -1, -1, -1, -1, -1, 397, 398, 2471 399, 400, 401, 402, 3, 4, 5, 6, 7, 8, 2472 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 2473 19, 20, 21, 22, 23, 24, -1, 26, 27, 28, 2474 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 2475 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 2476 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 2477 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 2478 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 2479 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 2480 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 2481 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 2482 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 2483 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 2484 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 2485 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 2486 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 2487 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 2488 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 2489 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 2490 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 2491 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 2492 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 2493 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 2494 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 2495 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 2496 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 2497 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 2498 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 2499 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 2500 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 2501 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 2502 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 2503 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 2504 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 2505 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 2506 349, 350, 351, -1, -1, 354, 355, -1, -1, -1, 2507 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2508 -1, -1, -1, -1, 373, -1, 375, -1, 377, 378, 2509 -1, -1, -1, -1, 383, 384, 385, 386, 387, -1, 2510 -1, -1, -1, -1, -1, -1, -1, -1, 397, 398, 2511 399, 400, 401, 402, 3, 4, 5, 6, 7, 8, 2512 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 2513 19, 20, 21, 22, 23, 24, -1, 26, 27, 28, 2514 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 2515 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 2516 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 2517 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 2518 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 2519 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 2520 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 2521 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 2522 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 2523 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 2524 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 2525 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 2526 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 2527 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 2528 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 2529 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 2530 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 2531 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 2532 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 2533 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 2534 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 2535 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 2536 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 2537 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 2538 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 2539 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 2540 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 2541 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 2542 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 2543 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 2544 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 2545 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 2546 349, 350, 351, -1, -1, 354, 355, -1, -1, -1, 2547 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2548 -1, -1, -1, -1, 373, -1, 375, -1, 377, -1, 2549 -1, -1, -1, -1, 383, 384, 385, 386, 387, -1, 2550 -1, -1, -1, -1, -1, -1, -1, -1, 397, 398, 2551 399, 400, 401, 402, 3, 4, 5, 6, 7, 8, 2552 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 2553 19, 20, 21, 22, 23, 24, -1, 26, 27, 28, 2554 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 2555 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 2556 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 2557 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 2558 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 2559 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 2560 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 2561 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 2562 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 2563 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 2564 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 2565 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 2566 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 2567 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 2568 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 2569 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 2570 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 2571 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 2572 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 2573 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 2574 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 2575 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 2576 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 2577 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 2578 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 2579 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 2580 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 2581 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 2582 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 2583 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 2584 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 2585 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 2586 349, 350, 351, -1, -1, 354, 355, -1, -1, -1, 2587 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2588 -1, -1, -1, -1, 373, -1, 375, -1, 377, -1, 2589 -1, -1, -1, -1, 383, 384, 385, 386, 387, -1, 2590 -1, -1, -1, -1, -1, -1, -1, -1, 397, 398, 2591 399, 400, 401, 402, 3, 4, 5, 6, 7, 8, 2592 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 2593 19, 20, 21, 22, 23, 24, -1, 26, 27, 28, 2594 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 2595 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 2596 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 2597 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 2598 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 2599 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 2600 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 2601 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 2602 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 2603 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 2604 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 2605 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 2606 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 2607 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 2608 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 2609 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 2610 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 2611 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 2612 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 2613 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 2614 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 2615 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 2616 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 2617 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 2618 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 2619 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 2620 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 2621 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 2622 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 2623 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 2624 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 2625 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 2626 349, 350, 351, -1, -1, 354, 355, -1, -1, -1, 2627 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2628 -1, -1, -1, -1, 373, -1, 375, -1, -1, -1, 2629 -1, -1, -1, -1, 383, 384, 385, 386, 387, -1, 2630 -1, -1, -1, -1, -1, -1, -1, -1, 397, 398, 2631 399, 400, 401, 402, 3, 4, 5, 6, 7, 8, 2632 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 2633 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, 2634 -1, -1, -1, -1, 33, 34, 35, 36, 37, 38, 2635 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 2636 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 2637 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 2638 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 2639 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 2640 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 2641 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 2642 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 2643 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 2644 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 2645 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 2646 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 2647 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 2648 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 2649 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 2650 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 2651 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 2652 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 2653 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 2654 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 2655 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 2656 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 2657 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 2658 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 2659 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 2660 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 2661 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 2662 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 2663 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 2664 329, 330, 331, 332, 333, 334, 335, 336, -1, 338, 2665 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 2666 349, 350, 351, -1, -1, 354, 355, -1, -1, -1, 2667 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2668 -1, -1, -1, -1, 373, -1, -1, -1, -1, -1, 2669 -1, -1, -1, -1, 383, 384, 385, 386, 387, -1, 2670 -1, -1, -1, -1, -1, -1, -1, -1, 397, 398, 2671 399, 400, 401, 402, 3, 4, 5, 6, 7, 8, 2672 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 2673 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, 2674 -1, -1, -1, -1, 33, 34, 35, 36, 37, 38, 2675 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 2676 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 2677 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 2678 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 2679 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 2680 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 2681 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 2682 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 2683 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 2684 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 2685 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 2686 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 2687 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 2688 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 2689 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 2690 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 2691 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 2692 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 2693 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 2694 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 2695 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 2696 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 2697 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 2698 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 2699 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 2700 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 2701 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 2702 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 2703 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 2704 329, 330, 331, 332, 333, 334, 335, 336, -1, -1, 2705 339, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2706 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2707 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2708 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2709 -1, -1, -1, -1, 383, -1, -1, -1, -1, -1, 2710 -1, -1, -1, -1, -1, -1, -1, -1, 397, 398, 2711 399, 400, 401, 402, 3, 4, 5, 6, 7, 8, 2712 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 2713 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, 2714 -1, -1, -1, -1, 33, 34, 35, 36, 37, 38, 2715 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 2716 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 2717 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 2718 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 2719 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 2720 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 2721 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 2722 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 2723 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 2724 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 2725 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 2726 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 2727 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 2728 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 2729 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 2730 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 2731 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 2732 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 2733 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 2734 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 2735 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 2736 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 2737 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 2738 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 2739 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 2740 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 2741 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 2742 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 2743 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 2744 329, 330, 331, 332, 333, 334, 335, 336, -1, 338, 2745 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 2746 349, 350, 351, -1, -1, 354, 355, -1, -1, -1, 2747 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2748 -1, -1, -1, -1, 373, -1, -1, -1, -1, -1, 2749 -1, -1, -1, -1, -1, 384, 385, 386, 387, -1, 2750 -1, -1, -1, -1, -1, -1, -1, -1, 397, 398, 2751 399, 400, 401, 3, 4, 5, 6, 7, 8, 9, 2752 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 2753 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, 2754 -1, -1, -1, 33, 34, 35, 36, 37, 38, 39, 2755 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 2756 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 2757 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 2758 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 2759 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 2760 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2761 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 2762 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 2763 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 2764 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 2765 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 2766 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 2767 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 2768 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 2769 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 2770 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 2771 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 2772 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 2773 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 2774 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 2775 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 2776 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 2777 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 2778 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 2779 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 2780 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 2781 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 2782 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 2783 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 2784 330, 331, 332, 333, 334, 335, 336, -1, 338, 339, 2785 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2786 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2787 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2788 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2789 -1, -1, -1, 383, -1, -1, -1, -1, -1, -1, 2790 -1, -1, -1, -1, -1, -1, -1, 397, 398, 399, 2791 400, 401, 3, 4, 5, 6, 7, 8, 9, 10, 2792 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 2793 21, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2794 -1, -1, 33, 34, 35, 36, 37, 38, 39, 40, 2795 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 2796 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 2797 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 2798 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 2799 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 2800 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 2801 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 2802 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 2803 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 2804 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 2805 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 2806 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 2807 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 2808 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 2809 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 2810 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 2811 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 2812 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 2813 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 2814 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 2815 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 2816 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 2817 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 2818 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 2819 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 2820 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 2821 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 2822 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 2823 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 2824 331, 332, 333, 334, 335, 336, -1, -1, 339, -1, 2825 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2826 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2827 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2828 -1, -1, -1, -1, -1, -1, -1, 378, -1, -1, 2829 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2830 -1, -1, -1, -1, -1, -1, 397, 398, 399, 400, 2831 401, 3, 4, 5, 6, 7, 8, 9, 10, 11, 2832 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 2833 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2834 -1, 33, 34, 35, 36, 37, 38, 39, 40, 41, 2835 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 2836 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 2837 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 2838 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 2839 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 2840 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 2841 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 2842 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 2843 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 2844 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 2845 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 2846 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 2847 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 2848 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 2849 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 2850 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 2851 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 2852 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 2853 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 2854 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 2855 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 2856 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 2857 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 2858 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 2859 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 2860 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 2861 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 2862 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 2863 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 2864 332, 333, 334, 335, 336, -1, -1, 339, -1, -1, 2865 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2866 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2867 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2868 -1, -1, -1, -1, -1, -1, 378, -1, -1, -1, 2869 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2870 -1, -1, -1, -1, -1, 397, 398, 399, 400, 401, 2871 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 2872 13, 14, 15, 16, 17, 18, 19, 20, 21, -1, 2873 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2874 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 2875 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 2876 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 2877 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 2878 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 2879 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 2880 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 2881 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 2882 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 2883 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 2884 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 2885 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 2886 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 2887 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 2888 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 2889 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 2890 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 2891 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 2892 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 2893 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 2894 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 2895 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 2896 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 2897 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 2898 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 2899 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 2900 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 2901 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 2902 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 2903 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 2904 333, 334, 335, 336, -1, -1, 339, -1, -1, -1, 2905 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2906 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2907 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2908 -1, -1, -1, -1, -1, 378, -1, -1, -1, -1, 2909 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2910 -1, -1, -1, -1, 397, 398, 399, 400, 401, 3, 2911 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 2912 14, 15, 16, 17, 18, 19, 20, 21, -1, -1, 2913 -1, -1, -1, -1, -1, -1, -1, -1, -1, 33, 2914 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 2915 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 2916 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 2917 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 2918 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 2919 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 2920 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 2921 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 2922 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 2923 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 2924 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 2925 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 2926 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 2927 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 2928 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 2929 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 2930 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 2931 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 2932 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 2933 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 2934 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 2935 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 2936 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 2937 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 2938 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 2939 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 2940 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 2941 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 2942 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 2943 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 2944 334, 335, 336, -1, -1, 339, -1, -1, -1, -1, 2945 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2946 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2947 -1, -1, -1, -1, -1, -1, -1, -1, -1, 5, 2948 6, 7, 8, 9, -1, 11, 12, 13, 14, 15, 2949 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, 2950 -1, -1, -1, 397, 398, 399, 400, 401, 34, 35, 2951 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 2952 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 2953 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 2954 66, 67, 68, 69, 70, 71, 72, -1, -1, -1, 2955 -1, -1, -1, -1, -1, -1, 82, -1, -1, -1, 2956 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2957 -1, -1, 98, 99, 100, 101, 102, 103, 104, 105, 2958 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 2959 116, 117, 118, 119, 120, 121, -1, -1, -1, -1, 2960 -1, -1, -1, -1, -1, 131, 132, 133, 134, 135, 2961 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 2962 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 2963 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 2964 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 2965 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 2966 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 2967 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 2968 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 2969 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 2970 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 2971 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 2972 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 2973 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 2974 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 2975 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 2976 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 2977 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 2978 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 2979 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 2980 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 2981 336, -1, 338, 339, 340, 341, 342, 343, 344, 345, 2982 346, 347, 348, 349, 350, 351, -1, -1, 354, 355, 2983 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2984 -1, -1, -1, -1, -1, -1, -1, 373, -1, -1, 2985 -1, 377, 378, -1, -1, -1, -1, -1, 384, 385, 2986 386, 387, 5, 6, 7, 8, 9, -1, 11, 12, 2987 13, 14, 15, 16, 17, 18, 19, 20, 21, -1, 2988 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2989 -1, 34, 35, 36, 37, 38, 39, 40, 41, 42, 2990 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 2991 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 2992 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 2993 -1, -1, -1, -1, -1, -1, -1, -1, -1, 82, 2994 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2995 -1, -1, -1, -1, -1, 98, 99, 100, 101, 102, 2996 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 2997 113, 114, 115, 116, 117, 118, 119, 120, 121, -1, 2998 -1, -1, -1, -1, -1, -1, -1, -1, 131, 132, 2999 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 3000 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 3001 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 3002 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 3003 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 3004 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 3005 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 3006 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 3007 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 3008 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 3009 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 3010 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 3011 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 3012 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 3013 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 3014 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 3015 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 3016 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 3017 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 3018 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 3019 333, 334, 335, 336, -1, 338, 339, 340, 341, 342, 3020 343, 344, 345, 346, 347, 348, 349, 350, 351, -1, 3021 -1, 354, 355, -1, -1, -1, -1, -1, -1, -1, 3022 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3023 373, -1, -1, 376, -1, -1, -1, -1, -1, -1, 3024 -1, 384, 385, 386, 387, 5, 6, 7, 8, 9, 3025 -1, 11, 12, 13, 14, 15, 16, 17, 18, 19, 3026 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, 3027 -1, -1, -1, -1, 34, 35, 36, 37, 38, 39, 3028 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 3029 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 3030 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 3031 70, 71, 72, -1, -1, -1, -1, -1, -1, -1, 3032 -1, -1, 82, -1, -1, -1, -1, -1, -1, -1, 3033 -1, -1, -1, -1, -1, -1, -1, -1, 98, 99, 3034 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 3035 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 3036 120, 121, -1, -1, -1, -1, -1, -1, -1, -1, 3037 -1, 131, 132, 133, 134, 135, 136, 137, 138, 139, 3038 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 3039 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 3040 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 3041 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 3042 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 3043 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 3044 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 3045 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 3046 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 3047 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 3048 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 3049 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 3050 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 3051 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 3052 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 3053 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 3054 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 3055 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 3056 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 3057 330, 331, 332, 333, 334, 335, 336, -1, 338, 339, 3058 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 3059 350, 351, -1, -1, 354, 355, -1, -1, -1, -1, 3060 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3061 -1, -1, -1, 373, -1, -1, -1, 377, -1, -1, 3062 -1, -1, -1, -1, 384, 385, 386, 387, 5, 6, 3063 7, 8, 9, -1, 11, 12, 13, 14, 15, 16, 3064 17, 18, 19, 20, 21, -1, -1, -1, -1, -1, 3065 -1, -1, -1, -1, -1, -1, -1, 34, 35, 36, 3066 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 3067 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 3068 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 3069 67, 68, 69, 70, 71, 72, -1, -1, -1, -1, 3070 -1, -1, -1, -1, -1, 82, -1, -1, -1, -1, 3071 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3072 -1, 98, 99, 100, 101, 102, 103, 104, 105, 106, 3073 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 3074 117, 118, 119, 120, 121, -1, -1, -1, -1, -1, 3075 -1, -1, -1, -1, 131, 132, 133, 134, 135, 136, 3076 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 3077 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 3078 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 3079 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 3080 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 3081 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 3082 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 3083 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 3084 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 3085 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 3086 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 3087 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 3088 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 3089 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 3090 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 3091 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 3092 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 3093 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 3094 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 3095 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 3096 -1, 338, 339, 340, 341, 342, 343, 344, 345, 346, 3097 347, 348, 349, 350, 351, -1, -1, 354, 355, -1, 3098 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3099 -1, -1, -1, -1, -1, -1, 373, -1, -1, 376, 3100 -1, -1, -1, -1, -1, -1, -1, 384, 385, 386, 3101 387, 5, 6, 7, 8, 9, -1, 11, 12, 13, 3102 14, 15, 16, 17, 18, 19, 20, 21, -1, -1, 3103 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3104 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 3105 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 3106 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 3107 64, 65, 66, 67, 68, 69, 70, 71, 72, -1, 3108 -1, -1, -1, -1, -1, -1, -1, -1, 82, -1, 3109 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3110 -1, -1, -1, -1, 98, 99, 100, 101, 102, 103, 3111 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 3112 114, 115, 116, 117, 118, 119, 120, 121, -1, -1, 3113 -1, -1, -1, -1, -1, -1, -1, 131, 132, 133, 3114 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 3115 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 3116 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 3117 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 3118 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 3119 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 3120 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 3121 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 3122 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 3123 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 3124 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 3125 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 3126 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 3127 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 3128 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 3129 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 3130 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 3131 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 3132 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 3133 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 3134 334, 335, 336, -1, 338, 339, 340, 341, 342, 343, 3135 344, 345, 346, 347, 348, 349, 350, 351, -1, -1, 3136 354, 355, -1, -1, -1, -1, -1, -1, -1, -1, 3137 -1, -1, -1, -1, -1, -1, -1, -1, -1, 373, 3138 -1, -1, -1, -1, -1, -1, -1, -1, -1, 383, 3139 384, 385, 386, 387, 5, 6, 7, 8, 9, -1, 3140 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 3141 21, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3142 -1, -1, -1, 34, 35, 36, 37, 38, 39, 40, 3143 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 3144 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 3145 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 3146 71, 72, -1, -1, -1, -1, -1, -1, -1, -1, 3147 -1, 82, -1, -1, -1, -1, -1, -1, -1, -1, 3148 -1, -1, -1, -1, -1, -1, -1, 98, 99, 100, 3149 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 3150 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 3151 121, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3152 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 3153 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 3154 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 3155 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 3156 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 3157 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 3158 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 3159 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 3160 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 3161 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 3162 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 3163 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 3164 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 3165 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 3166 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 3167 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 3168 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 3169 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 3170 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 3171 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 3172 331, 332, 333, 334, 335, 336, -1, 338, 339, 340, 3173 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 3174 351, -1, -1, 354, 355, -1, -1, -1, -1, -1, 3175 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3176 -1, -1, 373, -1, -1, -1, -1, -1, -1, -1, 3177 -1, -1, -1, 384, 385, 386, 387, 5, 6, 7, 3178 8, 9, -1, 11, 12, 13, 14, 15, 16, 17, 3179 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, 3180 -1, -1, -1, -1, -1, -1, 34, 35, 36, 37, 3181 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 3182 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 3183 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 3184 68, 69, 70, 71, 72, -1, -1, -1, -1, -1, 3185 -1, -1, -1, -1, 82, -1, -1, -1, -1, -1, 3186 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3187 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 3188 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 3189 118, 119, 120, 121, -1, -1, -1, -1, -1, -1, 3190 -1, -1, -1, 131, 132, 133, 134, 135, 136, 137, 3191 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 3192 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 3193 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 3194 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 3195 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 3196 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 3197 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 3198 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 3199 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 3200 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 3201 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 3202 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 3203 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 3204 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 3205 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 3206 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 3207 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 3208 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 3209 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 3210 328, 329, 330, 331, 332, 333, 334, 335, 336, -1, 3211 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 3212 348, 349, 350, 351, -1, -1, 354, 355, -1, -1, 3213 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3214 -1, -1, -1, -1, -1, 373, -1, -1, -1, -1, 3215 -1, -1, -1, -1, -1, -1, 384, 385, 386, 387, 3216 5, 6, 7, 8, 9, -1, 11, 12, 13, 14, 3217 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, 3218 -1, -1, -1, -1, -1, -1, -1, -1, -1, 34, 3219 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 3220 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 3221 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 3222 65, 66, 67, 68, 69, 70, 71, 72, -1, -1, 3223 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3224 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3225 -1, -1, -1, 98, 99, 100, 101, 102, 103, 104, 3226 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 3227 115, 116, 117, 118, 119, 120, 121, -1, -1, -1, 3228 -1, -1, -1, -1, -1, -1, 131, 132, 133, 134, 3229 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 3230 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 3231 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 3232 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 3233 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 3234 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 3235 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 3236 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 3237 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 3238 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 3239 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 3240 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 3241 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 3242 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 3243 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 3244 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 3245 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 3246 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 3247 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 3248 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 3249 335, 336, -1, -1, 339 3250 }; 3251 3252 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 3253 symbol of state STATE-NUM. */ 3254 static const yytype_uint16 yystos[] = 3255 { 3256 0, 3, 4, 5, 6, 7, 8, 9, 10, 11, 3257 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 3258 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 3259 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 3260 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 3261 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 3262 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 3263 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 3264 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 3265 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 3266 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 3267 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 3268 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 3269 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 3270 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 3271 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 3272 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 3273 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 3274 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 3275 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 3276 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 3277 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 3278 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 3279 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 3280 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 3281 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 3282 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 3283 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 3284 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 3285 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 3286 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 3287 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 3288 333, 334, 335, 336, 339, 383, 397, 398, 399, 400, 3289 401, 402, 437, 438, 441, 442, 443, 444, 448, 449, 3290 450, 451, 452, 453, 456, 457, 458, 459, 460, 462, 3291 464, 465, 466, 506, 507, 508, 373, 373, 338, 377, 3292 465, 338, 383, 383, 509, 374, 380, 445, 446, 447, 3293 457, 462, 380, 383, 338, 338, 383, 458, 462, 375, 3294 463, 0, 507, 338, 461, 81, 338, 454, 455, 377, 3295 468, 462, 383, 463, 377, 485, 446, 445, 447, 338, 3296 338, 373, 382, 463, 377, 380, 383, 440, 338, 340, 3297 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 3298 351, 354, 355, 373, 376, 384, 385, 386, 387, 407, 3299 408, 409, 411, 412, 413, 414, 415, 416, 417, 418, 3300 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 3301 429, 430, 431, 460, 462, 375, 374, 380, 382, 374, 3302 380, 467, 457, 462, 469, 470, 383, 383, 22, 23, 3303 24, 26, 27, 28, 29, 30, 31, 32, 337, 375, 3304 377, 378, 383, 418, 431, 433, 435, 437, 441, 460, 3305 462, 475, 476, 477, 478, 486, 487, 488, 489, 492, 3306 493, 496, 497, 498, 505, 510, 463, 382, 463, 377, 3307 433, 473, 382, 439, 338, 380, 383, 418, 418, 435, 3308 354, 355, 375, 379, 374, 374, 380, 336, 433, 373, 3309 418, 388, 389, 390, 385, 387, 352, 353, 356, 357, 3310 391, 392, 358, 359, 395, 394, 393, 360, 362, 361, 3311 396, 376, 376, 431, 338, 431, 436, 455, 469, 462, 3312 338, 471, 472, 378, 470, 383, 383, 500, 373, 373, 3313 383, 383, 435, 373, 435, 381, 373, 375, 378, 479, 3314 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 3315 382, 434, 380, 383, 378, 476, 489, 493, 498, 473, 3316 382, 473, 474, 473, 469, 338, 374, 410, 435, 338, 3317 433, 418, 418, 418, 420, 420, 421, 421, 422, 422, 3318 422, 422, 423, 423, 424, 425, 426, 427, 428, 429, 3319 432, 376, 378, 471, 463, 380, 383, 476, 501, 435, 3320 383, 435, 381, 499, 338, 511, 512, 486, 433, 433, 3321 473, 378, 380, 378, 376, 435, 383, 472, 337, 475, 3322 487, 502, 374, 374, 435, 450, 457, 491, 373, 376, 3323 380, 480, 378, 473, 381, 373, 491, 503, 504, 482, 3324 483, 484, 490, 494, 338, 374, 436, 376, 512, 378, 3325 433, 435, 383, 374, 25, 478, 477, 377, 382, 477, 3326 481, 485, 374, 374, 435, 481, 482, 486, 495, 473, 3327 383, 378 3328 }; 3329 3330 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 3331 static const yytype_uint16 yyr1[] = 3332 { 3333 0, 406, 407, 408, 408, 408, 408, 408, 408, 408, 3334 408, 408, 408, 408, 408, 408, 408, 409, 409, 409, 3335 409, 409, 409, 410, 411, 412, 413, 413, 414, 414, 3336 415, 415, 416, 417, 417, 417, 418, 418, 418, 418, 3337 419, 419, 419, 419, 420, 420, 420, 420, 421, 421, 3338 421, 422, 422, 422, 423, 423, 423, 423, 423, 424, 3339 424, 424, 425, 425, 426, 426, 427, 427, 428, 428, 3340 429, 429, 430, 430, 431, 432, 431, 433, 433, 434, 3341 434, 434, 434, 434, 434, 434, 434, 434, 434, 434, 3342 435, 435, 436, 437, 437, 437, 437, 437, 437, 437, 3343 437, 437, 439, 438, 440, 440, 441, 442, 442, 443, 3344 443, 444, 445, 445, 446, 446, 446, 446, 447, 448, 3345 448, 448, 448, 448, 449, 449, 449, 449, 449, 450, 3346 450, 451, 452, 452, 452, 452, 452, 452, 452, 452, 3347 453, 454, 454, 455, 455, 455, 456, 457, 457, 458, 3348 458, 458, 458, 458, 458, 458, 459, 459, 459, 459, 3349 459, 459, 459, 459, 459, 459, 459, 459, 459, 459, 3350 459, 459, 459, 459, 459, 459, 459, 459, 459, 459, 3351 459, 459, 459, 459, 459, 460, 461, 461, 462, 462, 3352 463, 463, 463, 463, 464, 464, 464, 464, 464, 464, 3353 464, 464, 464, 464, 464, 464, 464, 464, 464, 464, 3354 464, 464, 464, 464, 464, 464, 464, 464, 464, 464, 3355 464, 464, 464, 464, 464, 464, 464, 464, 464, 464, 3356 464, 464, 464, 464, 464, 464, 464, 464, 464, 464, 3357 464, 464, 464, 464, 464, 464, 464, 464, 464, 464, 3358 464, 464, 464, 464, 464, 464, 464, 464, 464, 464, 3359 464, 464, 464, 464, 464, 464, 464, 464, 464, 464, 3360 464, 464, 464, 464, 464, 464, 464, 464, 464, 464, 3361 464, 464, 464, 464, 464, 464, 464, 464, 464, 464, 3362 464, 464, 464, 464, 464, 464, 464, 464, 464, 464, 3363 464, 464, 464, 464, 464, 464, 464, 464, 464, 464, 3364 464, 464, 464, 464, 464, 464, 464, 464, 464, 464, 3365 464, 464, 464, 464, 464, 464, 464, 464, 464, 464, 3366 464, 464, 464, 464, 464, 464, 464, 464, 464, 464, 3367 464, 464, 464, 464, 464, 464, 464, 464, 464, 464, 3368 464, 464, 464, 464, 464, 464, 464, 464, 464, 464, 3369 464, 464, 464, 464, 464, 464, 464, 464, 464, 464, 3370 464, 464, 464, 464, 464, 464, 464, 464, 464, 464, 3371 464, 464, 464, 464, 464, 464, 464, 464, 464, 464, 3372 464, 464, 464, 464, 464, 464, 464, 464, 464, 464, 3373 464, 464, 464, 464, 464, 464, 464, 464, 464, 464, 3374 464, 464, 464, 464, 464, 464, 464, 464, 464, 464, 3375 464, 464, 464, 464, 464, 464, 464, 464, 464, 464, 3376 464, 464, 464, 464, 464, 464, 464, 464, 464, 464, 3377 464, 464, 464, 464, 464, 464, 464, 464, 464, 464, 3378 464, 464, 464, 464, 464, 464, 464, 464, 464, 464, 3379 464, 464, 464, 464, 464, 464, 464, 464, 464, 464, 3380 464, 464, 464, 464, 464, 464, 464, 464, 464, 464, 3381 465, 465, 465, 467, 466, 468, 466, 469, 469, 470, 3382 470, 471, 471, 472, 472, 473, 473, 473, 474, 474, 3383 475, 476, 476, 477, 477, 477, 477, 477, 477, 477, 3384 478, 479, 480, 478, 481, 481, 483, 482, 484, 482, 3385 485, 485, 486, 486, 487, 487, 488, 488, 489, 490, 3386 490, 491, 491, 492, 492, 494, 493, 495, 495, 496, 3387 496, 497, 497, 499, 498, 500, 498, 501, 498, 502, 3388 502, 503, 503, 504, 504, 505, 505, 505, 505, 505, 3389 506, 506, 507, 507, 507, 509, 508, 510, 511, 511, 3390 512, 512 3391 }; 3392 3393 /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */ 3394 static const yytype_uint8 yyr2[] = 3395 { 3396 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 3397 1, 1, 1, 1, 1, 1, 3, 1, 4, 1, 3398 3, 2, 2, 1, 1, 1, 2, 2, 2, 1, 3399 2, 3, 2, 1, 1, 1, 1, 2, 2, 2, 3400 1, 1, 1, 1, 1, 3, 3, 3, 1, 3, 3401 3, 1, 3, 3, 1, 3, 3, 3, 3, 1, 3402 3, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3403 1, 3, 1, 3, 1, 0, 6, 1, 3, 1, 3404 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3405 1, 3, 1, 2, 2, 4, 2, 3, 4, 2, 3406 3, 4, 0, 6, 2, 3, 2, 1, 1, 2, 3407 3, 3, 2, 3, 2, 1, 2, 1, 1, 1, 3408 3, 4, 6, 5, 1, 2, 3, 5, 4, 1, 3409 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3410 4, 1, 3, 1, 3, 1, 1, 1, 2, 1, 3411 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3412 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3413 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3414 1, 1, 1, 1, 4, 1, 1, 3, 1, 2, 3415 2, 3, 3, 4, 1, 1, 1, 1, 1, 1, 3416 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3417 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3418 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3419 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3420 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3421 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3422 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3423 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3424 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3425 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3426 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3427 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3428 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3429 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3430 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3431 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3432 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3433 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3434 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3435 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3436 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3437 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3438 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3439 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3440 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3441 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3442 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3443 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3444 1, 1, 1, 0, 6, 0, 5, 1, 2, 3, 3445 4, 1, 3, 1, 2, 1, 3, 4, 1, 3, 3446 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3447 2, 0, 0, 5, 1, 1, 0, 2, 0, 2, 3448 2, 3, 1, 2, 1, 2, 1, 2, 5, 3, 3449 1, 1, 4, 1, 2, 0, 8, 0, 1, 3, 3450 2, 1, 2, 0, 6, 0, 8, 0, 7, 1, 3451 1, 1, 0, 2, 3, 2, 2, 2, 3, 2, 3452 1, 2, 1, 1, 1, 0, 3, 5, 1, 3, 3453 1, 4 3454 }; 3455 3456 3457 #define yyerrok (yyerrstatus = 0) 3458 #define yyclearin (yychar = YYEMPTY) 3459 #define YYEMPTY (-2) 3460 #define YYEOF 0 3461 3462 #define YYACCEPT goto yyacceptlab 3463 #define YYABORT goto yyabortlab 3464 #define YYERROR goto yyerrorlab 3465 3466 3467 #define YYRECOVERING() (!!yyerrstatus) 3468 3469 #define YYBACKUP(Token, Value) \ 3470 do \ 3471 if (yychar == YYEMPTY) \ 3472 { \ 3473 yychar = (Token); \ 3474 yylval = (Value); \ 3475 YYPOPSTACK (yylen); \ 3476 yystate = *yyssp; \ 3477 goto yybackup; \ 3478 } \ 3479 else \ 3480 { \ 3481 yyerror (pParseContext, YY_("syntax error: cannot back up")); \ 3482 YYERROR; \ 3483 } \ 3484 while (0) 3485 3486 /* Error token number */ 3487 #define YYTERROR 1 3488 #define YYERRCODE 256 3489 3490 3491 3492 /* Enable debugging if requested. */ 3493 #if YYDEBUG 3494 3495 # ifndef YYFPRINTF 3496 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 3497 # define YYFPRINTF fprintf 3498 # endif 3499 3500 # define YYDPRINTF(Args) \ 3501 do { \ 3502 if (yydebug) \ 3503 YYFPRINTF Args; \ 3504 } while (0) 3505 3506 /* This macro is provided for backward compatibility. */ 3507 #ifndef YY_LOCATION_PRINT 3508 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 3509 #endif 3510 3511 3512 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 3513 do { \ 3514 if (yydebug) \ 3515 { \ 3516 YYFPRINTF (stderr, "%s ", Title); \ 3517 yy_symbol_print (stderr, \ 3518 Type, Value, pParseContext); \ 3519 YYFPRINTF (stderr, "\n"); \ 3520 } \ 3521 } while (0) 3522 3523 3524 /*----------------------------------------. 3525 | Print this symbol's value on YYOUTPUT. | 3526 `----------------------------------------*/ 3527 3528 static void 3529 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, glslang::TParseContext* pParseContext) 3530 { 3531 FILE *yyo = yyoutput; 3532 YYUSE (yyo); 3533 YYUSE (pParseContext); 3534 if (!yyvaluep) 3535 return; 3536 # ifdef YYPRINT 3537 if (yytype < YYNTOKENS) 3538 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 3539 # endif 3540 YYUSE (yytype); 3541 } 3542 3543 3544 /*--------------------------------. 3545 | Print this symbol on YYOUTPUT. | 3546 `--------------------------------*/ 3547 3548 static void 3549 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, glslang::TParseContext* pParseContext) 3550 { 3551 YYFPRINTF (yyoutput, "%s %s (", 3552 yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]); 3553 3554 yy_symbol_value_print (yyoutput, yytype, yyvaluep, pParseContext); 3555 YYFPRINTF (yyoutput, ")"); 3556 } 3557 3558 /*------------------------------------------------------------------. 3559 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 3560 | TOP (included). | 3561 `------------------------------------------------------------------*/ 3562 3563 static void 3564 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 3565 { 3566 YYFPRINTF (stderr, "Stack now"); 3567 for (; yybottom <= yytop; yybottom++) 3568 { 3569 int yybot = *yybottom; 3570 YYFPRINTF (stderr, " %d", yybot); 3571 } 3572 YYFPRINTF (stderr, "\n"); 3573 } 3574 3575 # define YY_STACK_PRINT(Bottom, Top) \ 3576 do { \ 3577 if (yydebug) \ 3578 yy_stack_print ((Bottom), (Top)); \ 3579 } while (0) 3580 3581 3582 /*------------------------------------------------. 3583 | Report that the YYRULE is going to be reduced. | 3584 `------------------------------------------------*/ 3585 3586 static void 3587 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, glslang::TParseContext* pParseContext) 3588 { 3589 unsigned long int yylno = yyrline[yyrule]; 3590 int yynrhs = yyr2[yyrule]; 3591 int yyi; 3592 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 3593 yyrule - 1, yylno); 3594 /* The symbols being reduced. */ 3595 for (yyi = 0; yyi < yynrhs; yyi++) 3596 { 3597 YYFPRINTF (stderr, " $%d = ", yyi + 1); 3598 yy_symbol_print (stderr, 3599 yystos[yyssp[yyi + 1 - yynrhs]], 3600 &(yyvsp[(yyi + 1) - (yynrhs)]) 3601 , pParseContext); 3602 YYFPRINTF (stderr, "\n"); 3603 } 3604 } 3605 3606 # define YY_REDUCE_PRINT(Rule) \ 3607 do { \ 3608 if (yydebug) \ 3609 yy_reduce_print (yyssp, yyvsp, Rule, pParseContext); \ 3610 } while (0) 3611 3612 /* Nonzero means print parse trace. It is left uninitialized so that 3613 multiple parsers can coexist. */ 3614 int yydebug; 3615 #else /* !YYDEBUG */ 3616 # define YYDPRINTF(Args) 3617 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 3618 # define YY_STACK_PRINT(Bottom, Top) 3619 # define YY_REDUCE_PRINT(Rule) 3620 #endif /* !YYDEBUG */ 3621 3622 3623 /* YYINITDEPTH -- initial size of the parser's stacks. */ 3624 #ifndef YYINITDEPTH 3625 # define YYINITDEPTH 200 3626 #endif 3627 3628 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 3629 if the built-in stack extension method is used). 3630 3631 Do not make this value too large; the results are undefined if 3632 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 3633 evaluated with infinite-precision integer arithmetic. */ 3634 3635 #ifndef YYMAXDEPTH 3636 # define YYMAXDEPTH 10000 3637 #endif 3638 3639 3640 #if YYERROR_VERBOSE 3641 3642 # ifndef yystrlen 3643 # if defined __GLIBC__ && defined _STRING_H 3644 # define yystrlen strlen 3645 # else 3646 /* Return the length of YYSTR. */ 3647 static YYSIZE_T 3648 yystrlen (const char *yystr) 3649 { 3650 YYSIZE_T yylen; 3651 for (yylen = 0; yystr[yylen]; yylen++) 3652 continue; 3653 return yylen; 3654 } 3655 # endif 3656 # endif 3657 3658 # ifndef yystpcpy 3659 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 3660 # define yystpcpy stpcpy 3661 # else 3662 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 3663 YYDEST. */ 3664 static char * 3665 yystpcpy (char *yydest, const char *yysrc) 3666 { 3667 char *yyd = yydest; 3668 const char *yys = yysrc; 3669 3670 while ((*yyd++ = *yys++) != '\0') 3671 continue; 3672 3673 return yyd - 1; 3674 } 3675 # endif 3676 # endif 3677 3678 # ifndef yytnamerr 3679 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 3680 quotes and backslashes, so that it's suitable for yyerror. The 3681 heuristic is that double-quoting is unnecessary unless the string 3682 contains an apostrophe, a comma, or backslash (other than 3683 backslash-backslash). YYSTR is taken from yytname. If YYRES is 3684 null, do not copy; instead, return the length of what the result 3685 would have been. */ 3686 static YYSIZE_T 3687 yytnamerr (char *yyres, const char *yystr) 3688 { 3689 if (*yystr == '"') 3690 { 3691 YYSIZE_T yyn = 0; 3692 char const *yyp = yystr; 3693 3694 for (;;) 3695 switch (*++yyp) 3696 { 3697 case '\'': 3698 case ',': 3699 goto do_not_strip_quotes; 3700 3701 case '\\': 3702 if (*++yyp != '\\') 3703 goto do_not_strip_quotes; 3704 /* Fall through. */ 3705 default: 3706 if (yyres) 3707 yyres[yyn] = *yyp; 3708 yyn++; 3709 break; 3710 3711 case '"': 3712 if (yyres) 3713 yyres[yyn] = '\0'; 3714 return yyn; 3715 } 3716 do_not_strip_quotes: ; 3717 } 3718 3719 if (! yyres) 3720 return yystrlen (yystr); 3721 3722 return yystpcpy (yyres, yystr) - yyres; 3723 } 3724 # endif 3725 3726 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message 3727 about the unexpected token YYTOKEN for the state stack whose top is 3728 YYSSP. 3729 3730 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is 3731 not large enough to hold the message. In that case, also set 3732 *YYMSG_ALLOC to the required number of bytes. Return 2 if the 3733 required number of bytes is too large to store. */ 3734 static int 3735 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, 3736 yytype_int16 *yyssp, int yytoken) 3737 { 3738 YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); 3739 YYSIZE_T yysize = yysize0; 3740 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 3741 /* Internationalized format string. */ 3742 const char *yyformat = YY_NULLPTR; 3743 /* Arguments of yyformat. */ 3744 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 3745 /* Number of reported tokens (one for the "unexpected", one per 3746 "expected"). */ 3747 int yycount = 0; 3748 3749 /* There are many possibilities here to consider: 3750 - If this state is a consistent state with a default action, then 3751 the only way this function was invoked is if the default action 3752 is an error action. In that case, don't check for expected 3753 tokens because there are none. 3754 - The only way there can be no lookahead present (in yychar) is if 3755 this state is a consistent state with a default action. Thus, 3756 detecting the absence of a lookahead is sufficient to determine 3757 that there is no unexpected or expected token to report. In that 3758 case, just report a simple "syntax error". 3759 - Don't assume there isn't a lookahead just because this state is a 3760 consistent state with a default action. There might have been a 3761 previous inconsistent state, consistent state with a non-default 3762 action, or user semantic action that manipulated yychar. 3763 - Of course, the expected token list depends on states to have 3764 correct lookahead information, and it depends on the parser not 3765 to perform extra reductions after fetching a lookahead from the 3766 scanner and before detecting a syntax error. Thus, state merging 3767 (from LALR or IELR) and default reductions corrupt the expected 3768 token list. However, the list is correct for canonical LR with 3769 one exception: it will still contain any token that will not be 3770 accepted due to an error action in a later state. 3771 */ 3772 if (yytoken != YYEMPTY) 3773 { 3774 int yyn = yypact[*yyssp]; 3775 yyarg[yycount++] = yytname[yytoken]; 3776 if (!yypact_value_is_default (yyn)) 3777 { 3778 /* Start YYX at -YYN if negative to avoid negative indexes in 3779 YYCHECK. In other words, skip the first -YYN actions for 3780 this state because they are default actions. */ 3781 int yyxbegin = yyn < 0 ? -yyn : 0; 3782 /* Stay within bounds of both yycheck and yytname. */ 3783 int yychecklim = YYLAST - yyn + 1; 3784 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 3785 int yyx; 3786 3787 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 3788 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR 3789 && !yytable_value_is_error (yytable[yyx + yyn])) 3790 { 3791 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 3792 { 3793 yycount = 1; 3794 yysize = yysize0; 3795 break; 3796 } 3797 yyarg[yycount++] = yytname[yyx]; 3798 { 3799 YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); 3800 if (! (yysize <= yysize1 3801 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 3802 return 2; 3803 yysize = yysize1; 3804 } 3805 } 3806 } 3807 } 3808 3809 switch (yycount) 3810 { 3811 # define YYCASE_(N, S) \ 3812 case N: \ 3813 yyformat = S; \ 3814 break 3815 YYCASE_(0, YY_("syntax error")); 3816 YYCASE_(1, YY_("syntax error, unexpected %s")); 3817 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); 3818 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); 3819 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); 3820 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); 3821 # undef YYCASE_ 3822 } 3823 3824 { 3825 YYSIZE_T yysize1 = yysize + yystrlen (yyformat); 3826 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 3827 return 2; 3828 yysize = yysize1; 3829 } 3830 3831 if (*yymsg_alloc < yysize) 3832 { 3833 *yymsg_alloc = 2 * yysize; 3834 if (! (yysize <= *yymsg_alloc 3835 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) 3836 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; 3837 return 1; 3838 } 3839 3840 /* Avoid sprintf, as that infringes on the user's name space. 3841 Don't have undefined behavior even if the translation 3842 produced a string with the wrong number of "%s"s. */ 3843 { 3844 char *yyp = *yymsg; 3845 int yyi = 0; 3846 while ((*yyp = *yyformat) != '\0') 3847 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) 3848 { 3849 yyp += yytnamerr (yyp, yyarg[yyi++]); 3850 yyformat += 2; 3851 } 3852 else 3853 { 3854 yyp++; 3855 yyformat++; 3856 } 3857 } 3858 return 0; 3859 } 3860 #endif /* YYERROR_VERBOSE */ 3861 3862 /*-----------------------------------------------. 3863 | Release the memory associated to this symbol. | 3864 `-----------------------------------------------*/ 3865 3866 static void 3867 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, glslang::TParseContext* pParseContext) 3868 { 3869 YYUSE (yyvaluep); 3870 YYUSE (pParseContext); 3871 if (!yymsg) 3872 yymsg = "Deleting"; 3873 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 3874 3875 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 3876 YYUSE (yytype); 3877 YY_IGNORE_MAYBE_UNINITIALIZED_END 3878 } 3879 3880 3881 3882 3883 /*----------. 3884 | yyparse. | 3885 `----------*/ 3886 3887 int 3888 yyparse (glslang::TParseContext* pParseContext) 3889 { 3890 /* The lookahead symbol. */ 3891 int yychar; 3892 3893 3894 /* The semantic value of the lookahead symbol. */ 3895 /* Default value used for initialization, for pacifying older GCCs 3896 or non-GCC compilers. */ 3897 YY_INITIAL_VALUE (static YYSTYPE yyval_default;) 3898 YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); 3899 3900 /* Number of syntax errors so far. */ 3901 int yynerrs; 3902 3903 int yystate; 3904 /* Number of tokens to shift before error messages enabled. */ 3905 int yyerrstatus; 3906 3907 /* The stacks and their tools: 3908 'yyss': related to states. 3909 'yyvs': related to semantic values. 3910 3911 Refer to the stacks through separate pointers, to allow yyoverflow 3912 to reallocate them elsewhere. */ 3913 3914 /* The state stack. */ 3915 yytype_int16 yyssa[YYINITDEPTH]; 3916 yytype_int16 *yyss; 3917 yytype_int16 *yyssp; 3918 3919 /* The semantic value stack. */ 3920 YYSTYPE yyvsa[YYINITDEPTH]; 3921 YYSTYPE *yyvs; 3922 YYSTYPE *yyvsp; 3923 3924 YYSIZE_T yystacksize; 3925 3926 int yyn; 3927 int yyresult; 3928 /* Lookahead token as an internal (translated) token number. */ 3929 int yytoken = 0; 3930 /* The variables used to return semantic value and location from the 3931 action routines. */ 3932 YYSTYPE yyval; 3933 3934 #if YYERROR_VERBOSE 3935 /* Buffer for error messages, and its allocated size. */ 3936 char yymsgbuf[128]; 3937 char *yymsg = yymsgbuf; 3938 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 3939 #endif 3940 3941 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 3942 3943 /* The number of symbols on the RHS of the reduced rule. 3944 Keep to zero when no symbol should be popped. */ 3945 int yylen = 0; 3946 3947 yyssp = yyss = yyssa; 3948 yyvsp = yyvs = yyvsa; 3949 yystacksize = YYINITDEPTH; 3950 3951 YYDPRINTF ((stderr, "Starting parse\n")); 3952 3953 yystate = 0; 3954 yyerrstatus = 0; 3955 yynerrs = 0; 3956 yychar = YYEMPTY; /* Cause a token to be read. */ 3957 goto yysetstate; 3958 3959 /*------------------------------------------------------------. 3960 | yynewstate -- Push a new state, which is found in yystate. | 3961 `------------------------------------------------------------*/ 3962 yynewstate: 3963 /* In all cases, when you get here, the value and location stacks 3964 have just been pushed. So pushing a state here evens the stacks. */ 3965 yyssp++; 3966 3967 yysetstate: 3968 *yyssp = yystate; 3969 3970 if (yyss + yystacksize - 1 <= yyssp) 3971 { 3972 /* Get the current used size of the three stacks, in elements. */ 3973 YYSIZE_T yysize = yyssp - yyss + 1; 3974 3975 #ifdef yyoverflow 3976 { 3977 /* Give user a chance to reallocate the stack. Use copies of 3978 these so that the &'s don't force the real ones into 3979 memory. */ 3980 YYSTYPE *yyvs1 = yyvs; 3981 yytype_int16 *yyss1 = yyss; 3982 3983 /* Each stack pointer address is followed by the size of the 3984 data in use in that stack, in bytes. This used to be a 3985 conditional around just the two extra args, but that might 3986 be undefined if yyoverflow is a macro. */ 3987 yyoverflow (YY_("memory exhausted"), 3988 &yyss1, yysize * sizeof (*yyssp), 3989 &yyvs1, yysize * sizeof (*yyvsp), 3990 &yystacksize); 3991 3992 yyss = yyss1; 3993 yyvs = yyvs1; 3994 } 3995 #else /* no yyoverflow */ 3996 # ifndef YYSTACK_RELOCATE 3997 goto yyexhaustedlab; 3998 # else 3999 /* Extend the stack our own way. */ 4000 if (YYMAXDEPTH <= yystacksize) 4001 goto yyexhaustedlab; 4002 yystacksize *= 2; 4003 if (YYMAXDEPTH < yystacksize) 4004 yystacksize = YYMAXDEPTH; 4005 4006 { 4007 yytype_int16 *yyss1 = yyss; 4008 union yyalloc *yyptr = 4009 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 4010 if (! yyptr) 4011 goto yyexhaustedlab; 4012 YYSTACK_RELOCATE (yyss_alloc, yyss); 4013 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 4014 # undef YYSTACK_RELOCATE 4015 if (yyss1 != yyssa) 4016 YYSTACK_FREE (yyss1); 4017 } 4018 # endif 4019 #endif /* no yyoverflow */ 4020 4021 yyssp = yyss + yysize - 1; 4022 yyvsp = yyvs + yysize - 1; 4023 4024 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 4025 (unsigned long int) yystacksize)); 4026 4027 if (yyss + yystacksize - 1 <= yyssp) 4028 YYABORT; 4029 } 4030 4031 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 4032 4033 if (yystate == YYFINAL) 4034 YYACCEPT; 4035 4036 goto yybackup; 4037 4038 /*-----------. 4039 | yybackup. | 4040 `-----------*/ 4041 yybackup: 4042 4043 /* Do appropriate processing given the current state. Read a 4044 lookahead token if we need one and don't already have one. */ 4045 4046 /* First try to decide what to do without reference to lookahead token. */ 4047 yyn = yypact[yystate]; 4048 if (yypact_value_is_default (yyn)) 4049 goto yydefault; 4050 4051 /* Not known => get a lookahead token if don't already have one. */ 4052 4053 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 4054 if (yychar == YYEMPTY) 4055 { 4056 YYDPRINTF ((stderr, "Reading a token: ")); 4057 yychar = yylex (&yylval, parseContext); 4058 } 4059 4060 if (yychar <= YYEOF) 4061 { 4062 yychar = yytoken = YYEOF; 4063 YYDPRINTF ((stderr, "Now at end of input.\n")); 4064 } 4065 else 4066 { 4067 yytoken = YYTRANSLATE (yychar); 4068 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 4069 } 4070 4071 /* If the proper action on seeing token YYTOKEN is to reduce or to 4072 detect an error, take that action. */ 4073 yyn += yytoken; 4074 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 4075 goto yydefault; 4076 yyn = yytable[yyn]; 4077 if (yyn <= 0) 4078 { 4079 if (yytable_value_is_error (yyn)) 4080 goto yyerrlab; 4081 yyn = -yyn; 4082 goto yyreduce; 4083 } 4084 4085 /* Count tokens shifted since error; after three, turn off error 4086 status. */ 4087 if (yyerrstatus) 4088 yyerrstatus--; 4089 4090 /* Shift the lookahead token. */ 4091 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 4092 4093 /* Discard the shifted token. */ 4094 yychar = YYEMPTY; 4095 4096 yystate = yyn; 4097 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 4098 *++yyvsp = yylval; 4099 YY_IGNORE_MAYBE_UNINITIALIZED_END 4100 4101 goto yynewstate; 4102 4103 4104 /*-----------------------------------------------------------. 4105 | yydefault -- do the default action for the current state. | 4106 `-----------------------------------------------------------*/ 4107 yydefault: 4108 yyn = yydefact[yystate]; 4109 if (yyn == 0) 4110 goto yyerrlab; 4111 goto yyreduce; 4112 4113 4114 /*-----------------------------. 4115 | yyreduce -- Do a reduction. | 4116 `-----------------------------*/ 4117 yyreduce: 4118 /* yyn is the number of a rule to reduce with. */ 4119 yylen = yyr2[yyn]; 4120 4121 /* If YYLEN is nonzero, implement the default value of the action: 4122 '$$ = $1'. 4123 4124 Otherwise, the following line sets YYVAL to garbage. 4125 This behavior is undocumented and Bison 4126 users should not rely upon it. Assigning to YYVAL 4127 unconditionally makes the parser a bit smaller, and it avoids a 4128 GCC warning that YYVAL may be used uninitialized. */ 4129 yyval = yyvsp[1-yylen]; 4130 4131 4132 YY_REDUCE_PRINT (yyn); 4133 switch (yyn) 4134 { 4135 case 2: 4136 #line 294 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4137 { 4138 (yyval.interm.intermTypedNode) = parseContext.handleVariable((yyvsp[0].lex).loc, (yyvsp[0].lex).symbol, (yyvsp[0].lex).string); 4139 } 4140 #line 4141 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4141 break; 4142 4143 case 3: 4144 #line 300 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4145 { 4146 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); 4147 } 4148 #line 4149 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4149 break; 4150 4151 case 4: 4152 #line 303 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4153 { 4154 parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed literal"); 4155 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); 4156 } 4157 #line 4158 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4158 break; 4159 4160 case 5: 4161 #line 307 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4162 { 4163 parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed literal"); 4164 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); 4165 } 4166 #line 4167 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4167 break; 4168 4169 case 6: 4170 #line 311 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4171 { 4172 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); 4173 } 4174 #line 4175 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4175 break; 4176 4177 case 7: 4178 #line 314 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4179 { 4180 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned literal"); 4181 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); 4182 } 4183 #line 4184 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4184 break; 4185 4186 case 8: 4187 #line 318 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4188 { 4189 parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer literal"); 4190 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i64, (yyvsp[0].lex).loc, true); 4191 } 4192 #line 4193 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4193 break; 4194 4195 case 9: 4196 #line 322 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4197 { 4198 parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer literal"); 4199 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u64, (yyvsp[0].lex).loc, true); 4200 } 4201 #line 4202 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4202 break; 4203 4204 case 10: 4205 #line 326 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4206 { 4207 parseContext.explicitInt16Check((yyvsp[0].lex).loc, "16-bit integer literal"); 4208 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((short)(yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); 4209 } 4210 #line 4211 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4211 break; 4212 4213 case 11: 4214 #line 330 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4215 { 4216 parseContext.explicitInt16Check((yyvsp[0].lex).loc, "16-bit unsigned integer literal"); 4217 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((unsigned short)(yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); 4218 } 4219 #line 4220 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4220 break; 4221 4222 case 12: 4223 #line 334 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4224 { 4225 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true); 4226 } 4227 #line 4228 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4228 break; 4229 4230 case 13: 4231 #line 337 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4232 { 4233 parseContext.doubleCheck((yyvsp[0].lex).loc, "double literal"); 4234 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtDouble, (yyvsp[0].lex).loc, true); 4235 } 4236 #line 4237 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4237 break; 4238 4239 case 14: 4240 #line 341 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4241 { 4242 parseContext.float16Check((yyvsp[0].lex).loc, "half float literal"); 4243 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat16, (yyvsp[0].lex).loc, true); 4244 } 4245 #line 4246 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4246 break; 4247 4248 case 15: 4249 #line 345 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4250 { 4251 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true); 4252 } 4253 #line 4254 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4254 break; 4255 4256 case 16: 4257 #line 348 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4258 { 4259 (yyval.interm.intermTypedNode) = (yyvsp[-1].interm.intermTypedNode); 4260 if ((yyval.interm.intermTypedNode)->getAsConstantUnion()) 4261 (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression(); 4262 } 4263 #line 4264 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4264 break; 4265 4266 case 17: 4267 #line 356 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4268 { 4269 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); 4270 } 4271 #line 4272 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4272 break; 4273 4274 case 18: 4275 #line 359 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4276 { 4277 (yyval.interm.intermTypedNode) = parseContext.handleBracketDereference((yyvsp[-2].lex).loc, (yyvsp[-3].interm.intermTypedNode), (yyvsp[-1].interm.intermTypedNode)); 4278 } 4279 #line 4280 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4280 break; 4281 4282 case 19: 4283 #line 362 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4284 { 4285 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); 4286 } 4287 #line 4288 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4288 break; 4289 4290 case 20: 4291 #line 365 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4292 { 4293 (yyval.interm.intermTypedNode) = parseContext.handleDotDereference((yyvsp[0].lex).loc, (yyvsp[-2].interm.intermTypedNode), *(yyvsp[0].lex).string); 4294 } 4295 #line 4296 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4296 break; 4297 4298 case 21: 4299 #line 368 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4300 { 4301 parseContext.variableCheck((yyvsp[-1].interm.intermTypedNode)); 4302 parseContext.lValueErrorCheck((yyvsp[0].lex).loc, "++", (yyvsp[-1].interm.intermTypedNode)); 4303 (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[0].lex).loc, "++", EOpPostIncrement, (yyvsp[-1].interm.intermTypedNode)); 4304 } 4305 #line 4306 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4306 break; 4307 4308 case 22: 4309 #line 373 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4310 { 4311 parseContext.variableCheck((yyvsp[-1].interm.intermTypedNode)); 4312 parseContext.lValueErrorCheck((yyvsp[0].lex).loc, "--", (yyvsp[-1].interm.intermTypedNode)); 4313 (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[0].lex).loc, "--", EOpPostDecrement, (yyvsp[-1].interm.intermTypedNode)); 4314 } 4315 #line 4316 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4316 break; 4317 4318 case 23: 4319 #line 381 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4320 { 4321 parseContext.integerCheck((yyvsp[0].interm.intermTypedNode), "[]"); 4322 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); 4323 } 4324 #line 4325 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4325 break; 4326 4327 case 24: 4328 #line 388 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4329 { 4330 (yyval.interm.intermTypedNode) = parseContext.handleFunctionCall((yyvsp[0].interm).loc, (yyvsp[0].interm).function, (yyvsp[0].interm).intermNode); 4331 delete (yyvsp[0].interm).function; 4332 } 4333 #line 4334 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4334 break; 4335 4336 case 25: 4337 #line 395 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4338 { 4339 (yyval.interm) = (yyvsp[0].interm); 4340 } 4341 #line 4342 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4342 break; 4343 4344 case 26: 4345 #line 401 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4346 { 4347 (yyval.interm) = (yyvsp[-1].interm); 4348 (yyval.interm).loc = (yyvsp[0].lex).loc; 4349 } 4350 #line 4351 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4351 break; 4352 4353 case 27: 4354 #line 405 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4355 { 4356 (yyval.interm) = (yyvsp[-1].interm); 4357 (yyval.interm).loc = (yyvsp[0].lex).loc; 4358 } 4359 #line 4360 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4360 break; 4361 4362 case 28: 4363 #line 412 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4364 { 4365 (yyval.interm) = (yyvsp[-1].interm); 4366 } 4367 #line 4368 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4368 break; 4369 4370 case 29: 4371 #line 415 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4372 { 4373 (yyval.interm) = (yyvsp[0].interm); 4374 } 4375 #line 4376 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4376 break; 4377 4378 case 30: 4379 #line 421 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4380 { 4381 TParameter param = { 0, new TType }; 4382 param.type->shallowCopy((yyvsp[0].interm.intermTypedNode)->getType()); 4383 (yyvsp[-1].interm).function->addParameter(param); 4384 (yyval.interm).function = (yyvsp[-1].interm).function; 4385 (yyval.interm).intermNode = (yyvsp[0].interm.intermTypedNode); 4386 } 4387 #line 4388 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4388 break; 4389 4390 case 31: 4391 #line 428 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4392 { 4393 TParameter param = { 0, new TType }; 4394 param.type->shallowCopy((yyvsp[0].interm.intermTypedNode)->getType()); 4395 (yyvsp[-2].interm).function->addParameter(param); 4396 (yyval.interm).function = (yyvsp[-2].interm).function; 4397 (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-2].interm).intermNode, (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].lex).loc); 4398 } 4399 #line 4400 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4400 break; 4401 4402 case 32: 4403 #line 438 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4404 { 4405 (yyval.interm) = (yyvsp[-1].interm); 4406 } 4407 #line 4408 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4408 break; 4409 4410 case 33: 4411 #line 446 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4412 { 4413 // Constructor 4414 (yyval.interm).intermNode = 0; 4415 (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type)); 4416 } 4417 #line 4418 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4418 break; 4419 4420 case 34: 4421 #line 451 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4422 { 4423 // 4424 // Should be a method or subroutine call, but we haven't recognized the arguments yet. 4425 // 4426 (yyval.interm).function = 0; 4427 (yyval.interm).intermNode = 0; 4428 4429 TIntermMethod* method = (yyvsp[0].interm.intermTypedNode)->getAsMethodNode(); 4430 if (method) { 4431 (yyval.interm).function = new TFunction(&method->getMethodName(), TType(EbtInt), EOpArrayLength); 4432 (yyval.interm).intermNode = method->getObject(); 4433 } else { 4434 TIntermSymbol* symbol = (yyvsp[0].interm.intermTypedNode)->getAsSymbolNode(); 4435 if (symbol) { 4436 parseContext.reservedErrorCheck(symbol->getLoc(), symbol->getName()); 4437 TFunction *function = new TFunction(&symbol->getName(), TType(EbtVoid)); 4438 (yyval.interm).function = function; 4439 } else 4440 parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "function call, method, or subroutine call expected", "", ""); 4441 } 4442 4443 if ((yyval.interm).function == 0) { 4444 // error recover 4445 TString empty(""); 4446 (yyval.interm).function = new TFunction(&empty, TType(EbtVoid), EOpNull); 4447 } 4448 } 4449 #line 4450 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4450 break; 4451 4452 case 35: 4453 #line 478 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4454 { 4455 // Constructor 4456 (yyval.interm).intermNode = 0; 4457 (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type)); 4458 } 4459 #line 4460 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4460 break; 4461 4462 case 36: 4463 #line 486 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4464 { 4465 parseContext.variableCheck((yyvsp[0].interm.intermTypedNode)); 4466 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); 4467 if (TIntermMethod* method = (yyvsp[0].interm.intermTypedNode)->getAsMethodNode()) 4468 parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "incomplete method syntax", method->getMethodName().c_str(), ""); 4469 } 4470 #line 4471 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4471 break; 4472 4473 case 37: 4474 #line 492 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4475 { 4476 parseContext.lValueErrorCheck((yyvsp[-1].lex).loc, "++", (yyvsp[0].interm.intermTypedNode)); 4477 (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].lex).loc, "++", EOpPreIncrement, (yyvsp[0].interm.intermTypedNode)); 4478 } 4479 #line 4480 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4480 break; 4481 4482 case 38: 4483 #line 496 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4484 { 4485 parseContext.lValueErrorCheck((yyvsp[-1].lex).loc, "--", (yyvsp[0].interm.intermTypedNode)); 4486 (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].lex).loc, "--", EOpPreDecrement, (yyvsp[0].interm.intermTypedNode)); 4487 } 4488 #line 4489 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4489 break; 4490 4491 case 39: 4492 #line 500 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4493 { 4494 if ((yyvsp[-1].interm).op != EOpNull) { 4495 char errorOp[2] = {0, 0}; 4496 switch((yyvsp[-1].interm).op) { 4497 case EOpNegative: errorOp[0] = '-'; break; 4498 case EOpLogicalNot: errorOp[0] = '!'; break; 4499 case EOpBitwiseNot: errorOp[0] = '~'; break; 4500 default: break; // some compilers want this 4501 } 4502 (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].interm).loc, errorOp, (yyvsp[-1].interm).op, (yyvsp[0].interm.intermTypedNode)); 4503 } else { 4504 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); 4505 if ((yyval.interm.intermTypedNode)->getAsConstantUnion()) 4506 (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression(); 4507 } 4508 } 4509 #line 4510 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4510 break; 4511 4512 case 40: 4513 #line 520 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4514 { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNull; } 4515 #line 4516 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4516 break; 4517 4518 case 41: 4519 #line 521 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4520 { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNegative; } 4521 #line 4522 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4522 break; 4523 4524 case 42: 4525 #line 522 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4526 { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLogicalNot; } 4527 #line 4528 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4528 break; 4529 4530 case 43: 4531 #line 523 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4532 { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpBitwiseNot; 4533 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise not"); } 4534 #line 4535 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4535 break; 4536 4537 case 44: 4538 #line 529 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4539 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } 4540 #line 4541 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4541 break; 4542 4543 case 45: 4544 #line 530 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4545 { 4546 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "*", EOpMul, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 4547 if ((yyval.interm.intermTypedNode) == 0) 4548 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); 4549 } 4550 #line 4551 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4551 break; 4552 4553 case 46: 4554 #line 535 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4555 { 4556 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "/", EOpDiv, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 4557 if ((yyval.interm.intermTypedNode) == 0) 4558 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); 4559 } 4560 #line 4561 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4561 break; 4562 4563 case 47: 4564 #line 540 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4565 { 4566 parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "%"); 4567 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "%", EOpMod, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 4568 if ((yyval.interm.intermTypedNode) == 0) 4569 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); 4570 } 4571 #line 4572 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4572 break; 4573 4574 case 48: 4575 #line 549 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4576 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } 4577 #line 4578 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4578 break; 4579 4580 case 49: 4581 #line 550 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4582 { 4583 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "+", EOpAdd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 4584 if ((yyval.interm.intermTypedNode) == 0) 4585 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); 4586 } 4587 #line 4588 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4588 break; 4589 4590 case 50: 4591 #line 555 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4592 { 4593 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "-", EOpSub, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 4594 if ((yyval.interm.intermTypedNode) == 0) 4595 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); 4596 } 4597 #line 4598 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4598 break; 4599 4600 case 51: 4601 #line 563 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4602 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } 4603 #line 4604 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4604 break; 4605 4606 case 52: 4607 #line 564 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4608 { 4609 parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bit shift left"); 4610 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<<", EOpLeftShift, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 4611 if ((yyval.interm.intermTypedNode) == 0) 4612 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); 4613 } 4614 #line 4615 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4615 break; 4616 4617 case 53: 4618 #line 570 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4619 { 4620 parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bit shift right"); 4621 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">>", EOpRightShift, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 4622 if ((yyval.interm.intermTypedNode) == 0) 4623 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); 4624 } 4625 #line 4626 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4626 break; 4627 4628 case 54: 4629 #line 579 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4630 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } 4631 #line 4632 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4632 break; 4633 4634 case 55: 4635 #line 580 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4636 { 4637 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<", EOpLessThan, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 4638 if ((yyval.interm.intermTypedNode) == 0) 4639 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); 4640 } 4641 #line 4642 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4642 break; 4643 4644 case 56: 4645 #line 585 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4646 { 4647 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">", EOpGreaterThan, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 4648 if ((yyval.interm.intermTypedNode) == 0) 4649 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); 4650 } 4651 #line 4652 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4652 break; 4653 4654 case 57: 4655 #line 590 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4656 { 4657 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<=", EOpLessThanEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 4658 if ((yyval.interm.intermTypedNode) == 0) 4659 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); 4660 } 4661 #line 4662 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4662 break; 4663 4664 case 58: 4665 #line 595 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4666 { 4667 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">=", EOpGreaterThanEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 4668 if ((yyval.interm.intermTypedNode) == 0) 4669 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); 4670 } 4671 #line 4672 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4672 break; 4673 4674 case 59: 4675 #line 603 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4676 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } 4677 #line 4678 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4678 break; 4679 4680 case 60: 4681 #line 604 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4682 { 4683 parseContext.arrayObjectCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array comparison"); 4684 parseContext.opaqueCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "=="); 4685 parseContext.specializationCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "=="); 4686 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "==", EOpEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 4687 if ((yyval.interm.intermTypedNode) == 0) 4688 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); 4689 } 4690 #line 4691 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4691 break; 4692 4693 case 61: 4694 #line 612 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4695 { 4696 parseContext.arrayObjectCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array comparison"); 4697 parseContext.opaqueCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "!="); 4698 parseContext.specializationCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "!="); 4699 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "!=", EOpNotEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 4700 if ((yyval.interm.intermTypedNode) == 0) 4701 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); 4702 } 4703 #line 4704 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4704 break; 4705 4706 case 62: 4707 #line 623 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4708 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } 4709 #line 4710 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4710 break; 4711 4712 case 63: 4713 #line 624 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4714 { 4715 parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise and"); 4716 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "&", EOpAnd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 4717 if ((yyval.interm.intermTypedNode) == 0) 4718 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); 4719 } 4720 #line 4721 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4721 break; 4722 4723 case 64: 4724 #line 633 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4725 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } 4726 #line 4727 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4727 break; 4728 4729 case 65: 4730 #line 634 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4731 { 4732 parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise exclusive or"); 4733 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "^", EOpExclusiveOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 4734 if ((yyval.interm.intermTypedNode) == 0) 4735 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); 4736 } 4737 #line 4738 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4738 break; 4739 4740 case 66: 4741 #line 643 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4742 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } 4743 #line 4744 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4744 break; 4745 4746 case 67: 4747 #line 644 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4748 { 4749 parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise inclusive or"); 4750 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "|", EOpInclusiveOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 4751 if ((yyval.interm.intermTypedNode) == 0) 4752 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); 4753 } 4754 #line 4755 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4755 break; 4756 4757 case 68: 4758 #line 653 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4759 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } 4760 #line 4761 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4761 break; 4762 4763 case 69: 4764 #line 654 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4765 { 4766 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "&&", EOpLogicalAnd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 4767 if ((yyval.interm.intermTypedNode) == 0) 4768 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); 4769 } 4770 #line 4771 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4771 break; 4772 4773 case 70: 4774 #line 662 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4775 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } 4776 #line 4777 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4777 break; 4778 4779 case 71: 4780 #line 663 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4781 { 4782 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "^^", EOpLogicalXor, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 4783 if ((yyval.interm.intermTypedNode) == 0) 4784 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); 4785 } 4786 #line 4787 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4787 break; 4788 4789 case 72: 4790 #line 671 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4791 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } 4792 #line 4793 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4793 break; 4794 4795 case 73: 4796 #line 672 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4797 { 4798 (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "||", EOpLogicalOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 4799 if ((yyval.interm.intermTypedNode) == 0) 4800 (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); 4801 } 4802 #line 4803 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4803 break; 4804 4805 case 74: 4806 #line 680 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4807 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } 4808 #line 4809 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4809 break; 4810 4811 case 75: 4812 #line 681 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4813 { 4814 ++parseContext.controlFlowNestingLevel; 4815 } 4816 #line 4817 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4817 break; 4818 4819 case 76: 4820 #line 684 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4821 { 4822 --parseContext.controlFlowNestingLevel; 4823 parseContext.boolCheck((yyvsp[-4].lex).loc, (yyvsp[-5].interm.intermTypedNode)); 4824 parseContext.rValueErrorCheck((yyvsp[-4].lex).loc, "?", (yyvsp[-5].interm.intermTypedNode)); 4825 parseContext.rValueErrorCheck((yyvsp[-1].lex).loc, ":", (yyvsp[-2].interm.intermTypedNode)); 4826 parseContext.rValueErrorCheck((yyvsp[-1].lex).loc, ":", (yyvsp[0].interm.intermTypedNode)); 4827 (yyval.interm.intermTypedNode) = parseContext.intermediate.addSelection((yyvsp[-5].interm.intermTypedNode), (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yyvsp[-4].lex).loc); 4828 if ((yyval.interm.intermTypedNode) == 0) { 4829 parseContext.binaryOpError((yyvsp[-4].lex).loc, ":", (yyvsp[-2].interm.intermTypedNode)->getCompleteString(), (yyvsp[0].interm.intermTypedNode)->getCompleteString()); 4830 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); 4831 } 4832 } 4833 #line 4834 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4834 break; 4835 4836 case 77: 4837 #line 699 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4838 { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } 4839 #line 4840 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4840 break; 4841 4842 case 78: 4843 #line 700 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4844 { 4845 parseContext.arrayObjectCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array assignment"); 4846 parseContext.opaqueCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "="); 4847 parseContext.storage16BitAssignmentCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "="); 4848 parseContext.specializationCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "="); 4849 parseContext.lValueErrorCheck((yyvsp[-1].interm).loc, "assign", (yyvsp[-2].interm.intermTypedNode)); 4850 parseContext.rValueErrorCheck((yyvsp[-1].interm).loc, "assign", (yyvsp[0].interm.intermTypedNode)); 4851 (yyval.interm.intermTypedNode) = parseContext.intermediate.addAssign((yyvsp[-1].interm).op, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].interm).loc); 4852 if ((yyval.interm.intermTypedNode) == 0) { 4853 parseContext.assignError((yyvsp[-1].interm).loc, "assign", (yyvsp[-2].interm.intermTypedNode)->getCompleteString(), (yyvsp[0].interm.intermTypedNode)->getCompleteString()); 4854 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); 4855 } 4856 } 4857 #line 4858 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4858 break; 4859 4860 case 79: 4861 #line 716 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4862 { 4863 (yyval.interm).loc = (yyvsp[0].lex).loc; 4864 (yyval.interm).op = EOpAssign; 4865 } 4866 #line 4867 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4867 break; 4868 4869 case 80: 4870 #line 720 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4871 { 4872 (yyval.interm).loc = (yyvsp[0].lex).loc; 4873 (yyval.interm).op = EOpMulAssign; 4874 } 4875 #line 4876 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4876 break; 4877 4878 case 81: 4879 #line 724 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4880 { 4881 (yyval.interm).loc = (yyvsp[0].lex).loc; 4882 (yyval.interm).op = EOpDivAssign; 4883 } 4884 #line 4885 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4885 break; 4886 4887 case 82: 4888 #line 728 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4889 { 4890 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "%="); 4891 (yyval.interm).loc = (yyvsp[0].lex).loc; 4892 (yyval.interm).op = EOpModAssign; 4893 } 4894 #line 4895 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4895 break; 4896 4897 case 83: 4898 #line 733 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4899 { 4900 (yyval.interm).loc = (yyvsp[0].lex).loc; 4901 (yyval.interm).op = EOpAddAssign; 4902 } 4903 #line 4904 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4904 break; 4905 4906 case 84: 4907 #line 737 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4908 { 4909 (yyval.interm).loc = (yyvsp[0].lex).loc; 4910 (yyval.interm).op = EOpSubAssign; 4911 } 4912 #line 4913 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4913 break; 4914 4915 case 85: 4916 #line 741 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4917 { 4918 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift left assign"); 4919 (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLeftShiftAssign; 4920 } 4921 #line 4922 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4922 break; 4923 4924 case 86: 4925 #line 745 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4926 { 4927 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift right assign"); 4928 (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpRightShiftAssign; 4929 } 4930 #line 4931 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4931 break; 4932 4933 case 87: 4934 #line 749 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4935 { 4936 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-and assign"); 4937 (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAndAssign; 4938 } 4939 #line 4940 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4940 break; 4941 4942 case 88: 4943 #line 753 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4944 { 4945 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-xor assign"); 4946 (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpExclusiveOrAssign; 4947 } 4948 #line 4949 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4949 break; 4950 4951 case 89: 4952 #line 757 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4953 { 4954 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-or assign"); 4955 (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpInclusiveOrAssign; 4956 } 4957 #line 4958 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4958 break; 4959 4960 case 90: 4961 #line 764 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4962 { 4963 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); 4964 } 4965 #line 4966 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4966 break; 4967 4968 case 91: 4969 #line 767 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4970 { 4971 parseContext.samplerConstructorLocationCheck((yyvsp[-1].lex).loc, ",", (yyvsp[0].interm.intermTypedNode)); 4972 (yyval.interm.intermTypedNode) = parseContext.intermediate.addComma((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].lex).loc); 4973 if ((yyval.interm.intermTypedNode) == 0) { 4974 parseContext.binaryOpError((yyvsp[-1].lex).loc, ",", (yyvsp[-2].interm.intermTypedNode)->getCompleteString(), (yyvsp[0].interm.intermTypedNode)->getCompleteString()); 4975 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); 4976 } 4977 } 4978 #line 4979 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4979 break; 4980 4981 case 92: 4982 #line 778 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4983 { 4984 parseContext.constantValueCheck((yyvsp[0].interm.intermTypedNode), ""); 4985 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); 4986 } 4987 #line 4988 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4988 break; 4989 4990 case 93: 4991 #line 785 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 4992 { 4993 parseContext.handleFunctionDeclarator((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).function, true /* prototype */); 4994 (yyval.interm.intermNode) = 0; 4995 // TODO: 4.0 functionality: subroutines: make the identifier a user type for this signature 4996 } 4997 #line 4998 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 4998 break; 4999 5000 case 94: 5001 #line 790 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5002 { 5003 if ((yyvsp[-1].interm).intermNode && (yyvsp[-1].interm).intermNode->getAsAggregate()) 5004 (yyvsp[-1].interm).intermNode->getAsAggregate()->setOperator(EOpSequence); 5005 (yyval.interm.intermNode) = (yyvsp[-1].interm).intermNode; 5006 } 5007 #line 5008 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5008 break; 5009 5010 case 95: 5011 #line 795 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5012 { 5013 parseContext.profileRequires((yyvsp[-3].lex).loc, ENoProfile, 130, 0, "precision statement"); 5014 5015 // lazy setting of the previous scope's defaults, has effect only the first time it is called in a particular scope 5016 parseContext.symbolTable.setPreviousDefaultPrecisions(&parseContext.defaultPrecision[0]); 5017 parseContext.setDefaultPrecision((yyvsp[-3].lex).loc, (yyvsp[-1].interm.type), (yyvsp[-2].interm.type).qualifier.precision); 5018 (yyval.interm.intermNode) = 0; 5019 } 5020 #line 5021 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5021 break; 5022 5023 case 96: 5024 #line 803 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5025 { 5026 parseContext.declareBlock((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).typeList); 5027 (yyval.interm.intermNode) = 0; 5028 } 5029 #line 5030 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5030 break; 5031 5032 case 97: 5033 #line 807 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5034 { 5035 parseContext.declareBlock((yyvsp[-2].interm).loc, *(yyvsp[-2].interm).typeList, (yyvsp[-1].lex).string); 5036 (yyval.interm.intermNode) = 0; 5037 } 5038 #line 5039 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5039 break; 5040 5041 case 98: 5042 #line 811 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5043 { 5044 parseContext.declareBlock((yyvsp[-3].interm).loc, *(yyvsp[-3].interm).typeList, (yyvsp[-2].lex).string, (yyvsp[-1].interm).arraySizes); 5045 (yyval.interm.intermNode) = 0; 5046 } 5047 #line 5048 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5048 break; 5049 5050 case 99: 5051 #line 815 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5052 { 5053 parseContext.globalQualifierFixCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier); 5054 parseContext.updateStandaloneQualifierDefaults((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type)); 5055 (yyval.interm.intermNode) = 0; 5056 } 5057 #line 5058 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5058 break; 5059 5060 case 100: 5061 #line 820 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5062 { 5063 parseContext.checkNoShaderLayouts((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).shaderQualifiers); 5064 parseContext.addQualifierToExisting((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).qualifier, *(yyvsp[-1].lex).string); 5065 (yyval.interm.intermNode) = 0; 5066 } 5067 #line 5068 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5068 break; 5069 5070 case 101: 5071 #line 825 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5072 { 5073 parseContext.checkNoShaderLayouts((yyvsp[-3].interm.type).loc, (yyvsp[-3].interm.type).shaderQualifiers); 5074 (yyvsp[-1].interm.identifierList)->push_back((yyvsp[-2].lex).string); 5075 parseContext.addQualifierToExisting((yyvsp[-3].interm.type).loc, (yyvsp[-3].interm.type).qualifier, *(yyvsp[-1].interm.identifierList)); 5076 (yyval.interm.intermNode) = 0; 5077 } 5078 #line 5079 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5079 break; 5080 5081 case 102: 5082 #line 834 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5083 { parseContext.nestedBlockCheck((yyvsp[-2].interm.type).loc); } 5084 #line 5085 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5085 break; 5086 5087 case 103: 5088 #line 834 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5089 { 5090 --parseContext.structNestingLevel; 5091 parseContext.blockName = (yyvsp[-4].lex).string; 5092 parseContext.globalQualifierFixCheck((yyvsp[-5].interm.type).loc, (yyvsp[-5].interm.type).qualifier); 5093 parseContext.checkNoShaderLayouts((yyvsp[-5].interm.type).loc, (yyvsp[-5].interm.type).shaderQualifiers); 5094 parseContext.currentBlockQualifier = (yyvsp[-5].interm.type).qualifier; 5095 (yyval.interm).loc = (yyvsp[-5].interm.type).loc; 5096 (yyval.interm).typeList = (yyvsp[-1].interm.typeList); 5097 } 5098 #line 5099 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5099 break; 5100 5101 case 104: 5102 #line 845 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5103 { 5104 (yyval.interm.identifierList) = new TIdentifierList; 5105 (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string); 5106 } 5107 #line 5108 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5108 break; 5109 5110 case 105: 5111 #line 849 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5112 { 5113 (yyval.interm.identifierList) = (yyvsp[-2].interm.identifierList); 5114 (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string); 5115 } 5116 #line 5117 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5117 break; 5118 5119 case 106: 5120 #line 856 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5121 { 5122 (yyval.interm).function = (yyvsp[-1].interm.function); 5123 (yyval.interm).loc = (yyvsp[0].lex).loc; 5124 } 5125 #line 5126 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5126 break; 5127 5128 case 107: 5129 #line 863 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5130 { 5131 (yyval.interm.function) = (yyvsp[0].interm.function); 5132 } 5133 #line 5134 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5134 break; 5135 5136 case 108: 5137 #line 866 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5138 { 5139 (yyval.interm.function) = (yyvsp[0].interm.function); 5140 } 5141 #line 5142 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5142 break; 5143 5144 case 109: 5145 #line 873 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5146 { 5147 // Add the parameter 5148 (yyval.interm.function) = (yyvsp[-1].interm.function); 5149 if ((yyvsp[0].interm).param.type->getBasicType() != EbtVoid) 5150 (yyvsp[-1].interm.function)->addParameter((yyvsp[0].interm).param); 5151 else 5152 delete (yyvsp[0].interm).param.type; 5153 } 5154 #line 5155 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5155 break; 5156 5157 case 110: 5158 #line 881 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5159 { 5160 // 5161 // Only first parameter of one-parameter functions can be void 5162 // The check for named parameters not being void is done in parameter_declarator 5163 // 5164 if ((yyvsp[0].interm).param.type->getBasicType() == EbtVoid) { 5165 // 5166 // This parameter > first is void 5167 // 5168 parseContext.error((yyvsp[-1].lex).loc, "cannot be an argument type except for '(void)'", "void", ""); 5169 delete (yyvsp[0].interm).param.type; 5170 } else { 5171 // Add the parameter 5172 (yyval.interm.function) = (yyvsp[-2].interm.function); 5173 (yyvsp[-2].interm.function)->addParameter((yyvsp[0].interm).param); 5174 } 5175 } 5176 #line 5177 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5177 break; 5178 5179 case 111: 5180 #line 901 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5181 { 5182 if ((yyvsp[-2].interm.type).qualifier.storage != EvqGlobal && (yyvsp[-2].interm.type).qualifier.storage != EvqTemporary) { 5183 parseContext.error((yyvsp[-1].lex).loc, "no qualifiers allowed for function return", 5184 GetStorageQualifierString((yyvsp[-2].interm.type).qualifier.storage), ""); 5185 } 5186 if ((yyvsp[-2].interm.type).arraySizes) 5187 parseContext.arraySizeRequiredCheck((yyvsp[-2].interm.type).loc, *(yyvsp[-2].interm.type).arraySizes); 5188 5189 // Add the function as a prototype after parsing it (we do not support recursion) 5190 TFunction *function; 5191 TType type((yyvsp[-2].interm.type)); 5192 5193 // Potentially rename shader entry point function. No-op most of the time. 5194 parseContext.renameShaderFunction((yyvsp[-1].lex).string); 5195 5196 // Make the function 5197 function = new TFunction((yyvsp[-1].lex).string, type); 5198 (yyval.interm.function) = function; 5199 } 5200 #line 5201 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5201 break; 5202 5203 case 112: 5204 #line 924 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5205 { 5206 if ((yyvsp[-1].interm.type).arraySizes) { 5207 parseContext.profileRequires((yyvsp[-1].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); 5208 parseContext.profileRequires((yyvsp[-1].interm.type).loc, EEsProfile, 300, 0, "arrayed type"); 5209 parseContext.arraySizeRequiredCheck((yyvsp[-1].interm.type).loc, *(yyvsp[-1].interm.type).arraySizes); 5210 } 5211 if ((yyvsp[-1].interm.type).basicType == EbtVoid) { 5212 parseContext.error((yyvsp[0].lex).loc, "illegal use of type 'void'", (yyvsp[0].lex).string->c_str(), ""); 5213 } 5214 parseContext.reservedErrorCheck((yyvsp[0].lex).loc, *(yyvsp[0].lex).string); 5215 5216 TParameter param = {(yyvsp[0].lex).string, new TType((yyvsp[-1].interm.type))}; 5217 (yyval.interm).loc = (yyvsp[0].lex).loc; 5218 (yyval.interm).param = param; 5219 } 5220 #line 5221 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5221 break; 5222 5223 case 113: 5224 #line 939 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5225 { 5226 if ((yyvsp[-2].interm.type).arraySizes) { 5227 parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); 5228 parseContext.profileRequires((yyvsp[-2].interm.type).loc, EEsProfile, 300, 0, "arrayed type"); 5229 parseContext.arraySizeRequiredCheck((yyvsp[-2].interm.type).loc, *(yyvsp[-2].interm.type).arraySizes); 5230 } 5231 TType* type = new TType((yyvsp[-2].interm.type)); 5232 type->transferArraySizes((yyvsp[0].interm).arraySizes); 5233 type->copyArrayInnerSizes((yyvsp[-2].interm.type).arraySizes); 5234 5235 parseContext.arrayOfArrayVersionCheck((yyvsp[-1].lex).loc, type->getArraySizes()); 5236 parseContext.arraySizeRequiredCheck((yyvsp[0].interm).loc, *(yyvsp[0].interm).arraySizes); 5237 parseContext.reservedErrorCheck((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string); 5238 5239 TParameter param = { (yyvsp[-1].lex).string, type }; 5240 5241 (yyval.interm).loc = (yyvsp[-1].lex).loc; 5242 (yyval.interm).param = param; 5243 } 5244 #line 5245 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5245 break; 5246 5247 case 114: 5248 #line 964 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5249 { 5250 (yyval.interm) = (yyvsp[0].interm); 5251 if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone) 5252 (yyval.interm).param.type->getQualifier().precision = (yyvsp[-1].interm.type).qualifier.precision; 5253 parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier()); 5254 5255 parseContext.checkNoShaderLayouts((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).shaderQualifiers); 5256 parseContext.parameterTypeCheck((yyvsp[0].interm).loc, (yyvsp[-1].interm.type).qualifier.storage, *(yyval.interm).param.type); 5257 parseContext.paramCheckFix((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, *(yyval.interm).param.type); 5258 5259 } 5260 #line 5261 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5261 break; 5262 5263 case 115: 5264 #line 975 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5265 { 5266 (yyval.interm) = (yyvsp[0].interm); 5267 5268 parseContext.parameterTypeCheck((yyvsp[0].interm).loc, EvqIn, *(yyvsp[0].interm).param.type); 5269 parseContext.paramCheckFixStorage((yyvsp[0].interm).loc, EvqTemporary, *(yyval.interm).param.type); 5270 parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier()); 5271 } 5272 #line 5273 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5273 break; 5274 5275 case 116: 5276 #line 985 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5277 { 5278 (yyval.interm) = (yyvsp[0].interm); 5279 if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone) 5280 (yyval.interm).param.type->getQualifier().precision = (yyvsp[-1].interm.type).qualifier.precision; 5281 parseContext.precisionQualifierCheck((yyvsp[-1].interm.type).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier()); 5282 5283 parseContext.checkNoShaderLayouts((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).shaderQualifiers); 5284 parseContext.parameterTypeCheck((yyvsp[0].interm).loc, (yyvsp[-1].interm.type).qualifier.storage, *(yyval.interm).param.type); 5285 parseContext.paramCheckFix((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, *(yyval.interm).param.type); 5286 } 5287 #line 5288 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5288 break; 5289 5290 case 117: 5291 #line 995 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5292 { 5293 (yyval.interm) = (yyvsp[0].interm); 5294 5295 parseContext.parameterTypeCheck((yyvsp[0].interm).loc, EvqIn, *(yyvsp[0].interm).param.type); 5296 parseContext.paramCheckFixStorage((yyvsp[0].interm).loc, EvqTemporary, *(yyval.interm).param.type); 5297 parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier()); 5298 } 5299 #line 5300 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5300 break; 5301 5302 case 118: 5303 #line 1005 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5304 { 5305 TParameter param = { 0, new TType((yyvsp[0].interm.type)) }; 5306 (yyval.interm).param = param; 5307 if ((yyvsp[0].interm.type).arraySizes) 5308 parseContext.arraySizeRequiredCheck((yyvsp[0].interm.type).loc, *(yyvsp[0].interm.type).arraySizes); 5309 } 5310 #line 5311 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5311 break; 5312 5313 case 119: 5314 #line 1014 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5315 { 5316 (yyval.interm) = (yyvsp[0].interm); 5317 } 5318 #line 5319 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5319 break; 5320 5321 case 120: 5322 #line 1017 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5323 { 5324 (yyval.interm) = (yyvsp[-2].interm); 5325 parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-2].interm).type); 5326 } 5327 #line 5328 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5328 break; 5329 5330 case 121: 5331 #line 1021 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5332 { 5333 (yyval.interm) = (yyvsp[-3].interm); 5334 parseContext.declareVariable((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string, (yyvsp[-3].interm).type, (yyvsp[0].interm).arraySizes); 5335 } 5336 #line 5337 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5337 break; 5338 5339 case 122: 5340 #line 1025 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5341 { 5342 (yyval.interm).type = (yyvsp[-5].interm).type; 5343 TIntermNode* initNode = parseContext.declareVariable((yyvsp[-3].lex).loc, *(yyvsp[-3].lex).string, (yyvsp[-5].interm).type, (yyvsp[-2].interm).arraySizes, (yyvsp[0].interm.intermTypedNode)); 5344 (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-5].interm).intermNode, initNode, (yyvsp[-1].lex).loc); 5345 } 5346 #line 5347 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5347 break; 5348 5349 case 123: 5350 #line 1030 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5351 { 5352 (yyval.interm).type = (yyvsp[-4].interm).type; 5353 TIntermNode* initNode = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-4].interm).type, 0, (yyvsp[0].interm.intermTypedNode)); 5354 (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-4].interm).intermNode, initNode, (yyvsp[-1].lex).loc); 5355 } 5356 #line 5357 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5357 break; 5358 5359 case 124: 5360 #line 1038 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5361 { 5362 (yyval.interm).type = (yyvsp[0].interm.type); 5363 (yyval.interm).intermNode = 0; 5364 parseContext.declareTypeDefaults((yyval.interm).loc, (yyval.interm).type); 5365 } 5366 #line 5367 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5367 break; 5368 5369 case 125: 5370 #line 1043 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5371 { 5372 (yyval.interm).type = (yyvsp[-1].interm.type); 5373 (yyval.interm).intermNode = 0; 5374 parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-1].interm.type)); 5375 } 5376 #line 5377 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5377 break; 5378 5379 case 126: 5380 #line 1048 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5381 { 5382 (yyval.interm).type = (yyvsp[-2].interm.type); 5383 (yyval.interm).intermNode = 0; 5384 parseContext.declareVariable((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string, (yyvsp[-2].interm.type), (yyvsp[0].interm).arraySizes); 5385 } 5386 #line 5387 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5387 break; 5388 5389 case 127: 5390 #line 1053 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5391 { 5392 (yyval.interm).type = (yyvsp[-4].interm.type); 5393 TIntermNode* initNode = parseContext.declareVariable((yyvsp[-3].lex).loc, *(yyvsp[-3].lex).string, (yyvsp[-4].interm.type), (yyvsp[-2].interm).arraySizes, (yyvsp[0].interm.intermTypedNode)); 5394 (yyval.interm).intermNode = parseContext.intermediate.growAggregate(0, initNode, (yyvsp[-1].lex).loc); 5395 } 5396 #line 5397 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5397 break; 5398 5399 case 128: 5400 #line 1058 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5401 { 5402 (yyval.interm).type = (yyvsp[-3].interm.type); 5403 TIntermNode* initNode = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-3].interm.type), 0, (yyvsp[0].interm.intermTypedNode)); 5404 (yyval.interm).intermNode = parseContext.intermediate.growAggregate(0, initNode, (yyvsp[-1].lex).loc); 5405 } 5406 #line 5407 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5407 break; 5408 5409 case 129: 5410 #line 1067 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5411 { 5412 (yyval.interm.type) = (yyvsp[0].interm.type); 5413 5414 parseContext.globalQualifierTypeCheck((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).qualifier, (yyval.interm.type)); 5415 if ((yyvsp[0].interm.type).arraySizes) { 5416 parseContext.profileRequires((yyvsp[0].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); 5417 parseContext.profileRequires((yyvsp[0].interm.type).loc, EEsProfile, 300, 0, "arrayed type"); 5418 } 5419 5420 parseContext.precisionQualifierCheck((yyval.interm.type).loc, (yyval.interm.type).basicType, (yyval.interm.type).qualifier); 5421 } 5422 #line 5423 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5423 break; 5424 5425 case 130: 5426 #line 1078 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5427 { 5428 parseContext.globalQualifierFixCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier); 5429 parseContext.globalQualifierTypeCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, (yyvsp[0].interm.type)); 5430 5431 if ((yyvsp[0].interm.type).arraySizes) { 5432 parseContext.profileRequires((yyvsp[0].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); 5433 parseContext.profileRequires((yyvsp[0].interm.type).loc, EEsProfile, 300, 0, "arrayed type"); 5434 } 5435 5436 if ((yyvsp[0].interm.type).arraySizes && parseContext.arrayQualifierError((yyvsp[0].interm.type).loc, (yyvsp[-1].interm.type).qualifier)) 5437 (yyvsp[0].interm.type).arraySizes = nullptr; 5438 5439 parseContext.checkNoShaderLayouts((yyvsp[0].interm.type).loc, (yyvsp[-1].interm.type).shaderQualifiers); 5440 (yyvsp[0].interm.type).shaderQualifiers.merge((yyvsp[-1].interm.type).shaderQualifiers); 5441 parseContext.mergeQualifiers((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).qualifier, (yyvsp[-1].interm.type).qualifier, true); 5442 parseContext.precisionQualifierCheck((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).basicType, (yyvsp[0].interm.type).qualifier); 5443 5444 (yyval.interm.type) = (yyvsp[0].interm.type); 5445 5446 if (! (yyval.interm.type).qualifier.isInterpolation() && 5447 ((parseContext.language == EShLangVertex && (yyval.interm.type).qualifier.storage == EvqVaryingOut) || 5448 (parseContext.language == EShLangFragment && (yyval.interm.type).qualifier.storage == EvqVaryingIn))) 5449 (yyval.interm.type).qualifier.smooth = true; 5450 } 5451 #line 5452 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5452 break; 5453 5454 case 131: 5455 #line 1105 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5456 { 5457 parseContext.globalCheck((yyvsp[0].lex).loc, "invariant"); 5458 parseContext.profileRequires((yyval.interm.type).loc, ENoProfile, 120, 0, "invariant"); 5459 (yyval.interm.type).init((yyvsp[0].lex).loc); 5460 (yyval.interm.type).qualifier.invariant = true; 5461 } 5462 #line 5463 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5463 break; 5464 5465 case 132: 5466 #line 1114 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5467 { 5468 parseContext.globalCheck((yyvsp[0].lex).loc, "smooth"); 5469 parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "smooth"); 5470 parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 300, 0, "smooth"); 5471 (yyval.interm.type).init((yyvsp[0].lex).loc); 5472 (yyval.interm.type).qualifier.smooth = true; 5473 } 5474 #line 5475 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5475 break; 5476 5477 case 133: 5478 #line 1121 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5479 { 5480 parseContext.globalCheck((yyvsp[0].lex).loc, "flat"); 5481 parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "flat"); 5482 parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 300, 0, "flat"); 5483 (yyval.interm.type).init((yyvsp[0].lex).loc); 5484 (yyval.interm.type).qualifier.flat = true; 5485 } 5486 #line 5487 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5487 break; 5488 5489 case 134: 5490 #line 1128 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5491 { 5492 parseContext.globalCheck((yyvsp[0].lex).loc, "noperspective"); 5493 #ifdef NV_EXTENSIONS 5494 parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 0, E_GL_NV_shader_noperspective_interpolation, "noperspective"); 5495 #else 5496 parseContext.requireProfile((yyvsp[0].lex).loc, ~EEsProfile, "noperspective"); 5497 #endif 5498 parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "noperspective"); 5499 (yyval.interm.type).init((yyvsp[0].lex).loc); 5500 (yyval.interm.type).qualifier.nopersp = true; 5501 } 5502 #line 5503 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5503 break; 5504 5505 case 135: 5506 #line 1139 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5507 { 5508 #ifdef AMD_EXTENSIONS 5509 parseContext.globalCheck((yyvsp[0].lex).loc, "__explicitInterpAMD"); 5510 parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 450, E_GL_AMD_shader_explicit_vertex_parameter, "explicit interpolation"); 5511 parseContext.profileRequires((yyvsp[0].lex).loc, ECompatibilityProfile, 450, E_GL_AMD_shader_explicit_vertex_parameter, "explicit interpolation"); 5512 (yyval.interm.type).init((yyvsp[0].lex).loc); 5513 (yyval.interm.type).qualifier.explicitInterp = true; 5514 #endif 5515 } 5516 #line 5517 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5517 break; 5518 5519 case 136: 5520 #line 1148 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5521 { 5522 #ifdef NV_EXTENSIONS 5523 parseContext.globalCheck((yyvsp[0].lex).loc, "pervertexNV"); 5524 parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 0, E_GL_NV_fragment_shader_barycentric, "fragment shader barycentric"); 5525 parseContext.profileRequires((yyvsp[0].lex).loc, ECompatibilityProfile, 0, E_GL_NV_fragment_shader_barycentric, "fragment shader barycentric"); 5526 parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 0, E_GL_NV_fragment_shader_barycentric, "fragment shader barycentric"); 5527 (yyval.interm.type).init((yyvsp[0].lex).loc); 5528 (yyval.interm.type).qualifier.pervertexNV = true; 5529 #endif 5530 } 5531 #line 5532 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5532 break; 5533 5534 case 137: 5535 #line 1158 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5536 { 5537 #ifdef NV_EXTENSIONS 5538 // No need for profile version or extension check. Shader stage already checks both. 5539 parseContext.globalCheck((yyvsp[0].lex).loc, "perprimitiveNV"); 5540 parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangFragmentMask | EShLangMeshNVMask), "perprimitiveNV"); 5541 // Fragment shader stage doesn't check for extension. So we explicitly add below extension check. 5542 if (parseContext.language == EShLangFragment) 5543 parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_NV_mesh_shader, "perprimitiveNV"); 5544 (yyval.interm.type).init((yyvsp[0].lex).loc); 5545 (yyval.interm.type).qualifier.perPrimitiveNV = true; 5546 #endif 5547 } 5548 #line 5549 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5549 break; 5550 5551 case 138: 5552 #line 1170 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5553 { 5554 #ifdef NV_EXTENSIONS 5555 // No need for profile version or extension check. Shader stage already checks both. 5556 parseContext.globalCheck((yyvsp[0].lex).loc, "perviewNV"); 5557 parseContext.requireStage((yyvsp[0].lex).loc, EShLangMeshNV, "perviewNV"); 5558 (yyval.interm.type).init((yyvsp[0].lex).loc); 5559 (yyval.interm.type).qualifier.perViewNV = true; 5560 #endif 5561 } 5562 #line 5563 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5563 break; 5564 5565 case 139: 5566 #line 1179 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5567 { 5568 #ifdef NV_EXTENSIONS 5569 // No need for profile version or extension check. Shader stage already checks both. 5570 parseContext.globalCheck((yyvsp[0].lex).loc, "taskNV"); 5571 parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangTaskNVMask | EShLangMeshNVMask), "taskNV"); 5572 (yyval.interm.type).init((yyvsp[0].lex).loc); 5573 (yyval.interm.type).qualifier.perTaskNV = true; 5574 #endif 5575 } 5576 #line 5577 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5577 break; 5578 5579 case 140: 5580 #line 1191 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5581 { 5582 (yyval.interm.type) = (yyvsp[-1].interm.type); 5583 } 5584 #line 5585 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5585 break; 5586 5587 case 141: 5588 #line 1197 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5589 { 5590 (yyval.interm.type) = (yyvsp[0].interm.type); 5591 } 5592 #line 5593 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5593 break; 5594 5595 case 142: 5596 #line 1200 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5597 { 5598 (yyval.interm.type) = (yyvsp[-2].interm.type); 5599 (yyval.interm.type).shaderQualifiers.merge((yyvsp[0].interm.type).shaderQualifiers); 5600 parseContext.mergeObjectLayoutQualifiers((yyval.interm.type).qualifier, (yyvsp[0].interm.type).qualifier, false); 5601 } 5602 #line 5603 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5603 break; 5604 5605 case 143: 5606 #line 1207 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5607 { 5608 (yyval.interm.type).init((yyvsp[0].lex).loc); 5609 parseContext.setLayoutQualifier((yyvsp[0].lex).loc, (yyval.interm.type), *(yyvsp[0].lex).string); 5610 } 5611 #line 5612 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5612 break; 5613 5614 case 144: 5615 #line 1211 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5616 { 5617 (yyval.interm.type).init((yyvsp[-2].lex).loc); 5618 parseContext.setLayoutQualifier((yyvsp[-2].lex).loc, (yyval.interm.type), *(yyvsp[-2].lex).string, (yyvsp[0].interm.intermTypedNode)); 5619 } 5620 #line 5621 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5621 break; 5622 5623 case 145: 5624 #line 1215 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5625 { // because "shared" is both an identifier and a keyword 5626 (yyval.interm.type).init((yyvsp[0].lex).loc); 5627 TString strShared("shared"); 5628 parseContext.setLayoutQualifier((yyvsp[0].lex).loc, (yyval.interm.type), strShared); 5629 } 5630 #line 5631 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5631 break; 5632 5633 case 146: 5634 #line 1223 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5635 { 5636 parseContext.profileRequires((yyval.interm.type).loc, ECoreProfile | ECompatibilityProfile, 400, E_GL_ARB_gpu_shader5, "precise"); 5637 parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 320, Num_AEP_gpu_shader5, AEP_gpu_shader5, "precise"); 5638 (yyval.interm.type).init((yyvsp[0].lex).loc); 5639 (yyval.interm.type).qualifier.noContraction = true; 5640 } 5641 #line 5642 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5642 break; 5643 5644 case 147: 5645 #line 1232 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5646 { 5647 (yyval.interm.type) = (yyvsp[0].interm.type); 5648 } 5649 #line 5650 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5650 break; 5651 5652 case 148: 5653 #line 1235 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5654 { 5655 (yyval.interm.type) = (yyvsp[-1].interm.type); 5656 if ((yyval.interm.type).basicType == EbtVoid) 5657 (yyval.interm.type).basicType = (yyvsp[0].interm.type).basicType; 5658 5659 (yyval.interm.type).shaderQualifiers.merge((yyvsp[0].interm.type).shaderQualifiers); 5660 parseContext.mergeQualifiers((yyval.interm.type).loc, (yyval.interm.type).qualifier, (yyvsp[0].interm.type).qualifier, false); 5661 } 5662 #line 5663 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5663 break; 5664 5665 case 149: 5666 #line 1246 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5667 { 5668 (yyval.interm.type) = (yyvsp[0].interm.type); 5669 } 5670 #line 5671 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5671 break; 5672 5673 case 150: 5674 #line 1249 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5675 { 5676 (yyval.interm.type) = (yyvsp[0].interm.type); 5677 } 5678 #line 5679 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5679 break; 5680 5681 case 151: 5682 #line 1252 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5683 { 5684 parseContext.checkPrecisionQualifier((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).qualifier.precision); 5685 (yyval.interm.type) = (yyvsp[0].interm.type); 5686 } 5687 #line 5688 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5688 break; 5689 5690 case 152: 5691 #line 1256 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5692 { 5693 // allow inheritance of storage qualifier from block declaration 5694 (yyval.interm.type) = (yyvsp[0].interm.type); 5695 } 5696 #line 5697 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5697 break; 5698 5699 case 153: 5700 #line 1260 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5701 { 5702 // allow inheritance of storage qualifier from block declaration 5703 (yyval.interm.type) = (yyvsp[0].interm.type); 5704 } 5705 #line 5706 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5706 break; 5707 5708 case 154: 5709 #line 1264 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5710 { 5711 // allow inheritance of storage qualifier from block declaration 5712 (yyval.interm.type) = (yyvsp[0].interm.type); 5713 } 5714 #line 5715 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5715 break; 5716 5717 case 155: 5718 #line 1268 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5719 { 5720 (yyval.interm.type) = (yyvsp[0].interm.type); 5721 } 5722 #line 5723 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5723 break; 5724 5725 case 156: 5726 #line 1274 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5727 { 5728 (yyval.interm.type).init((yyvsp[0].lex).loc); 5729 (yyval.interm.type).qualifier.storage = EvqConst; // will later turn into EvqConstReadOnly, if the initializer is not constant 5730 } 5731 #line 5732 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5732 break; 5733 5734 case 157: 5735 #line 1278 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5736 { 5737 parseContext.requireStage((yyvsp[0].lex).loc, EShLangVertex, "attribute"); 5738 parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "attribute"); 5739 parseContext.checkDeprecated((yyvsp[0].lex).loc, ENoProfile, 130, "attribute"); 5740 parseContext.requireNotRemoved((yyvsp[0].lex).loc, ECoreProfile, 420, "attribute"); 5741 parseContext.requireNotRemoved((yyvsp[0].lex).loc, EEsProfile, 300, "attribute"); 5742 5743 parseContext.globalCheck((yyvsp[0].lex).loc, "attribute"); 5744 5745 (yyval.interm.type).init((yyvsp[0].lex).loc); 5746 (yyval.interm.type).qualifier.storage = EvqVaryingIn; 5747 } 5748 #line 5749 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5749 break; 5750 5751 case 158: 5752 #line 1290 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5753 { 5754 parseContext.checkDeprecated((yyvsp[0].lex).loc, ENoProfile, 130, "varying"); 5755 parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "varying"); 5756 parseContext.requireNotRemoved((yyvsp[0].lex).loc, ECoreProfile, 420, "varying"); 5757 parseContext.requireNotRemoved((yyvsp[0].lex).loc, EEsProfile, 300, "varying"); 5758 5759 parseContext.globalCheck((yyvsp[0].lex).loc, "varying"); 5760 5761 (yyval.interm.type).init((yyvsp[0].lex).loc); 5762 if (parseContext.language == EShLangVertex) 5763 (yyval.interm.type).qualifier.storage = EvqVaryingOut; 5764 else 5765 (yyval.interm.type).qualifier.storage = EvqVaryingIn; 5766 } 5767 #line 5768 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5768 break; 5769 5770 case 159: 5771 #line 1304 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5772 { 5773 parseContext.globalCheck((yyvsp[0].lex).loc, "inout"); 5774 (yyval.interm.type).init((yyvsp[0].lex).loc); 5775 (yyval.interm.type).qualifier.storage = EvqInOut; 5776 } 5777 #line 5778 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5778 break; 5779 5780 case 160: 5781 #line 1309 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5782 { 5783 parseContext.globalCheck((yyvsp[0].lex).loc, "in"); 5784 (yyval.interm.type).init((yyvsp[0].lex).loc); 5785 // whether this is a parameter "in" or a pipeline "in" will get sorted out a bit later 5786 (yyval.interm.type).qualifier.storage = EvqIn; 5787 } 5788 #line 5789 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5789 break; 5790 5791 case 161: 5792 #line 1315 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5793 { 5794 parseContext.globalCheck((yyvsp[0].lex).loc, "out"); 5795 (yyval.interm.type).init((yyvsp[0].lex).loc); 5796 // whether this is a parameter "out" or a pipeline "out" will get sorted out a bit later 5797 (yyval.interm.type).qualifier.storage = EvqOut; 5798 } 5799 #line 5800 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5800 break; 5801 5802 case 162: 5803 #line 1321 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5804 { 5805 parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 120, 0, "centroid"); 5806 parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 300, 0, "centroid"); 5807 parseContext.globalCheck((yyvsp[0].lex).loc, "centroid"); 5808 (yyval.interm.type).init((yyvsp[0].lex).loc); 5809 (yyval.interm.type).qualifier.centroid = true; 5810 } 5811 #line 5812 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5812 break; 5813 5814 case 163: 5815 #line 1328 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5816 { 5817 parseContext.globalCheck((yyvsp[0].lex).loc, "patch"); 5818 parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangTessControlMask | EShLangTessEvaluationMask), "patch"); 5819 (yyval.interm.type).init((yyvsp[0].lex).loc); 5820 (yyval.interm.type).qualifier.patch = true; 5821 } 5822 #line 5823 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5823 break; 5824 5825 case 164: 5826 #line 1334 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5827 { 5828 parseContext.globalCheck((yyvsp[0].lex).loc, "sample"); 5829 (yyval.interm.type).init((yyvsp[0].lex).loc); 5830 (yyval.interm.type).qualifier.sample = true; 5831 } 5832 #line 5833 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5833 break; 5834 5835 case 165: 5836 #line 1339 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5837 { 5838 parseContext.globalCheck((yyvsp[0].lex).loc, "uniform"); 5839 (yyval.interm.type).init((yyvsp[0].lex).loc); 5840 (yyval.interm.type).qualifier.storage = EvqUniform; 5841 } 5842 #line 5843 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5843 break; 5844 5845 case 166: 5846 #line 1344 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5847 { 5848 parseContext.globalCheck((yyvsp[0].lex).loc, "buffer"); 5849 (yyval.interm.type).init((yyvsp[0].lex).loc); 5850 (yyval.interm.type).qualifier.storage = EvqBuffer; 5851 } 5852 #line 5853 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5853 break; 5854 5855 case 167: 5856 #line 1349 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5857 { 5858 #ifdef NV_EXTENSIONS 5859 parseContext.globalCheck((yyvsp[0].lex).loc, "hitAttributeNV"); 5860 parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangIntersectNVMask | EShLangClosestHitNVMask 5861 | EShLangAnyHitNVMask), "hitAttributeNV"); 5862 parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 460, E_GL_NV_ray_tracing, "hitAttributeNV"); 5863 (yyval.interm.type).init((yyvsp[0].lex).loc); 5864 (yyval.interm.type).qualifier.storage = EvqHitAttrNV; 5865 #endif 5866 } 5867 #line 5868 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5868 break; 5869 5870 case 168: 5871 #line 1359 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5872 { 5873 #ifdef NV_EXTENSIONS 5874 parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadNV"); 5875 parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenNVMask | EShLangClosestHitNVMask | 5876 EShLangAnyHitNVMask | EShLangMissNVMask), "rayPayloadNV"); 5877 parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 460, E_GL_NV_ray_tracing, "rayPayloadNV"); 5878 (yyval.interm.type).init((yyvsp[0].lex).loc); 5879 (yyval.interm.type).qualifier.storage = EvqPayloadNV; 5880 #endif 5881 } 5882 #line 5883 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5883 break; 5884 5885 case 169: 5886 #line 1369 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5887 { 5888 #ifdef NV_EXTENSIONS 5889 parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadInNV"); 5890 parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangClosestHitNVMask | 5891 EShLangAnyHitNVMask | EShLangMissNVMask), "rayPayloadInNV"); 5892 parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 460, E_GL_NV_ray_tracing, "rayPayloadInNV"); 5893 (yyval.interm.type).init((yyvsp[0].lex).loc); 5894 (yyval.interm.type).qualifier.storage = EvqPayloadInNV; 5895 #endif 5896 } 5897 #line 5898 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5898 break; 5899 5900 case 170: 5901 #line 1379 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5902 { 5903 #ifdef NV_EXTENSIONS 5904 parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataNV"); 5905 parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenNVMask | 5906 EShLangClosestHitNVMask | EShLangMissNVMask | EShLangCallableNVMask), "callableDataNV"); 5907 parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 460, E_GL_NV_ray_tracing, "callableDataNV"); 5908 (yyval.interm.type).init((yyvsp[0].lex).loc); 5909 (yyval.interm.type).qualifier.storage = EvqCallableDataNV; 5910 #endif 5911 } 5912 #line 5913 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5913 break; 5914 5915 case 171: 5916 #line 1389 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5917 { 5918 #ifdef NV_EXTENSIONS 5919 parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataInNV"); 5920 parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangCallableNVMask), "callableDataInNV"); 5921 parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 460, E_GL_NV_ray_tracing, "callableDataInNV"); 5922 (yyval.interm.type).init((yyvsp[0].lex).loc); 5923 (yyval.interm.type).qualifier.storage = EvqCallableDataInNV; 5924 #endif 5925 } 5926 #line 5927 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5927 break; 5928 5929 case 172: 5930 #line 1398 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5931 { 5932 parseContext.globalCheck((yyvsp[0].lex).loc, "shared"); 5933 parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, 430, E_GL_ARB_compute_shader, "shared"); 5934 parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 310, 0, "shared"); 5935 #ifdef NV_EXTENSIONS 5936 parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangComputeMask | EShLangMeshNVMask | EShLangTaskNVMask), "shared"); 5937 #else 5938 parseContext.requireStage((yyvsp[0].lex).loc, EShLangCompute, "shared"); 5939 #endif 5940 (yyval.interm.type).init((yyvsp[0].lex).loc); 5941 (yyval.interm.type).qualifier.storage = EvqShared; 5942 } 5943 #line 5944 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5944 break; 5945 5946 case 173: 5947 #line 1410 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5948 { 5949 (yyval.interm.type).init((yyvsp[0].lex).loc); 5950 (yyval.interm.type).qualifier.coherent = true; 5951 } 5952 #line 5953 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5953 break; 5954 5955 case 174: 5956 #line 1414 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5957 { 5958 (yyval.interm.type).init((yyvsp[0].lex).loc); 5959 parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "devicecoherent"); 5960 (yyval.interm.type).qualifier.devicecoherent = true; 5961 } 5962 #line 5963 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5963 break; 5964 5965 case 175: 5966 #line 1419 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5967 { 5968 (yyval.interm.type).init((yyvsp[0].lex).loc); 5969 parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "queuefamilycoherent"); 5970 (yyval.interm.type).qualifier.queuefamilycoherent = true; 5971 } 5972 #line 5973 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5973 break; 5974 5975 case 176: 5976 #line 1424 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5977 { 5978 (yyval.interm.type).init((yyvsp[0].lex).loc); 5979 parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "workgroupcoherent"); 5980 (yyval.interm.type).qualifier.workgroupcoherent = true; 5981 } 5982 #line 5983 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5983 break; 5984 5985 case 177: 5986 #line 1429 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5987 { 5988 (yyval.interm.type).init((yyvsp[0].lex).loc); 5989 parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "subgroupcoherent"); 5990 (yyval.interm.type).qualifier.subgroupcoherent = true; 5991 } 5992 #line 5993 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 5993 break; 5994 5995 case 178: 5996 #line 1434 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 5997 { 5998 (yyval.interm.type).init((yyvsp[0].lex).loc); 5999 parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "nonprivate"); 6000 (yyval.interm.type).qualifier.nonprivate = true; 6001 } 6002 #line 6003 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6003 break; 6004 6005 case 179: 6006 #line 1439 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6007 { 6008 (yyval.interm.type).init((yyvsp[0].lex).loc); 6009 (yyval.interm.type).qualifier.volatil = true; 6010 } 6011 #line 6012 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6012 break; 6013 6014 case 180: 6015 #line 1443 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6016 { 6017 (yyval.interm.type).init((yyvsp[0].lex).loc); 6018 (yyval.interm.type).qualifier.restrict = true; 6019 } 6020 #line 6021 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6021 break; 6022 6023 case 181: 6024 #line 1447 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6025 { 6026 (yyval.interm.type).init((yyvsp[0].lex).loc); 6027 (yyval.interm.type).qualifier.readonly = true; 6028 } 6029 #line 6030 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6030 break; 6031 6032 case 182: 6033 #line 1451 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6034 { 6035 (yyval.interm.type).init((yyvsp[0].lex).loc); 6036 (yyval.interm.type).qualifier.writeonly = true; 6037 } 6038 #line 6039 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6039 break; 6040 6041 case 183: 6042 #line 1455 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6043 { 6044 parseContext.spvRemoved((yyvsp[0].lex).loc, "subroutine"); 6045 parseContext.globalCheck((yyvsp[0].lex).loc, "subroutine"); 6046 parseContext.unimplemented((yyvsp[0].lex).loc, "subroutine"); 6047 (yyval.interm.type).init((yyvsp[0].lex).loc); 6048 } 6049 #line 6050 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6050 break; 6051 6052 case 184: 6053 #line 1461 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6054 { 6055 parseContext.spvRemoved((yyvsp[-3].lex).loc, "subroutine"); 6056 parseContext.globalCheck((yyvsp[-3].lex).loc, "subroutine"); 6057 parseContext.unimplemented((yyvsp[-3].lex).loc, "subroutine"); 6058 (yyval.interm.type).init((yyvsp[-3].lex).loc); 6059 } 6060 #line 6061 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6061 break; 6062 6063 case 185: 6064 #line 1470 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6065 { 6066 (yyval.interm.type).init((yyvsp[0].lex).loc); 6067 (yyval.interm.type).qualifier.nonUniform = true; 6068 } 6069 #line 6070 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6070 break; 6071 6072 case 186: 6073 #line 1477 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6074 { 6075 // TODO 6076 } 6077 #line 6078 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6078 break; 6079 6080 case 187: 6081 #line 1480 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6082 { 6083 // TODO: 4.0 semantics: subroutines 6084 // 1) make sure each identifier is a type declared earlier with SUBROUTINE 6085 // 2) save all of the identifiers for future comparison with the declared function 6086 } 6087 #line 6088 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6088 break; 6089 6090 case 188: 6091 #line 1488 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6092 { 6093 (yyval.interm.type) = (yyvsp[0].interm.type); 6094 (yyval.interm.type).qualifier.precision = parseContext.getDefaultPrecision((yyval.interm.type)); 6095 } 6096 #line 6097 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6097 break; 6098 6099 case 189: 6100 #line 1492 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6101 { 6102 parseContext.arrayOfArrayVersionCheck((yyvsp[0].interm).loc, (yyvsp[0].interm).arraySizes); 6103 (yyval.interm.type) = (yyvsp[-1].interm.type); 6104 (yyval.interm.type).qualifier.precision = parseContext.getDefaultPrecision((yyval.interm.type)); 6105 (yyval.interm.type).arraySizes = (yyvsp[0].interm).arraySizes; 6106 } 6107 #line 6108 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6108 break; 6109 6110 case 190: 6111 #line 1501 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6112 { 6113 (yyval.interm).loc = (yyvsp[-1].lex).loc; 6114 (yyval.interm).arraySizes = new TArraySizes; 6115 (yyval.interm).arraySizes->addInnerSize(); 6116 } 6117 #line 6118 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6118 break; 6119 6120 case 191: 6121 #line 1506 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6122 { 6123 (yyval.interm).loc = (yyvsp[-2].lex).loc; 6124 (yyval.interm).arraySizes = new TArraySizes; 6125 6126 TArraySize size; 6127 parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size); 6128 (yyval.interm).arraySizes->addInnerSize(size); 6129 } 6130 #line 6131 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6131 break; 6132 6133 case 192: 6134 #line 1514 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6135 { 6136 (yyval.interm) = (yyvsp[-2].interm); 6137 (yyval.interm).arraySizes->addInnerSize(); 6138 } 6139 #line 6140 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6140 break; 6141 6142 case 193: 6143 #line 1518 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6144 { 6145 (yyval.interm) = (yyvsp[-3].interm); 6146 6147 TArraySize size; 6148 parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size); 6149 (yyval.interm).arraySizes->addInnerSize(size); 6150 } 6151 #line 6152 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6152 break; 6153 6154 case 194: 6155 #line 1528 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6156 { 6157 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6158 (yyval.interm.type).basicType = EbtVoid; 6159 } 6160 #line 6161 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6161 break; 6162 6163 case 195: 6164 #line 1532 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6165 { 6166 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6167 (yyval.interm.type).basicType = EbtFloat; 6168 } 6169 #line 6170 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6170 break; 6171 6172 case 196: 6173 #line 1536 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6174 { 6175 parseContext.doubleCheck((yyvsp[0].lex).loc, "double"); 6176 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6177 (yyval.interm.type).basicType = EbtDouble; 6178 } 6179 #line 6180 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6180 break; 6181 6182 case 197: 6183 #line 1541 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6184 { 6185 parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "float16_t", parseContext.symbolTable.atBuiltInLevel()); 6186 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6187 (yyval.interm.type).basicType = EbtFloat16; 6188 } 6189 #line 6190 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6190 break; 6191 6192 case 198: 6193 #line 1546 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6194 { 6195 parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t", parseContext.symbolTable.atBuiltInLevel()); 6196 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6197 (yyval.interm.type).basicType = EbtFloat; 6198 } 6199 #line 6200 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6200 break; 6201 6202 case 199: 6203 #line 1551 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6204 { 6205 parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t", parseContext.symbolTable.atBuiltInLevel()); 6206 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6207 (yyval.interm.type).basicType = EbtDouble; 6208 } 6209 #line 6210 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6210 break; 6211 6212 case 200: 6213 #line 1556 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6214 { 6215 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6216 (yyval.interm.type).basicType = EbtInt; 6217 } 6218 #line 6219 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6219 break; 6220 6221 case 201: 6222 #line 1560 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6223 { 6224 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer"); 6225 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6226 (yyval.interm.type).basicType = EbtUint; 6227 } 6228 #line 6229 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6229 break; 6230 6231 case 202: 6232 #line 1565 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6233 { 6234 parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer", parseContext.symbolTable.atBuiltInLevel()); 6235 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6236 (yyval.interm.type).basicType = EbtInt8; 6237 } 6238 #line 6239 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6239 break; 6240 6241 case 203: 6242 #line 1570 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6243 { 6244 parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel()); 6245 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6246 (yyval.interm.type).basicType = EbtUint8; 6247 } 6248 #line 6249 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6249 break; 6250 6251 case 204: 6252 #line 1575 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6253 { 6254 parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer", parseContext.symbolTable.atBuiltInLevel()); 6255 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6256 (yyval.interm.type).basicType = EbtInt16; 6257 } 6258 #line 6259 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6259 break; 6260 6261 case 205: 6262 #line 1580 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6263 { 6264 parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel()); 6265 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6266 (yyval.interm.type).basicType = EbtUint16; 6267 } 6268 #line 6269 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6269 break; 6270 6271 case 206: 6272 #line 1585 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6273 { 6274 parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer", parseContext.symbolTable.atBuiltInLevel()); 6275 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6276 (yyval.interm.type).basicType = EbtInt; 6277 } 6278 #line 6279 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6279 break; 6280 6281 case 207: 6282 #line 1590 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6283 { 6284 parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel()); 6285 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6286 (yyval.interm.type).basicType = EbtUint; 6287 } 6288 #line 6289 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6289 break; 6290 6291 case 208: 6292 #line 1595 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6293 { 6294 parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer", parseContext.symbolTable.atBuiltInLevel()); 6295 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6296 (yyval.interm.type).basicType = EbtInt64; 6297 } 6298 #line 6299 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6299 break; 6300 6301 case 209: 6302 #line 1600 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6303 { 6304 parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel()); 6305 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6306 (yyval.interm.type).basicType = EbtUint64; 6307 } 6308 #line 6309 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6309 break; 6310 6311 case 210: 6312 #line 1605 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6313 { 6314 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6315 (yyval.interm.type).basicType = EbtBool; 6316 } 6317 #line 6318 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6318 break; 6319 6320 case 211: 6321 #line 1609 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6322 { 6323 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6324 (yyval.interm.type).basicType = EbtFloat; 6325 (yyval.interm.type).setVector(2); 6326 } 6327 #line 6328 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6328 break; 6329 6330 case 212: 6331 #line 1614 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6332 { 6333 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6334 (yyval.interm.type).basicType = EbtFloat; 6335 (yyval.interm.type).setVector(3); 6336 } 6337 #line 6338 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6338 break; 6339 6340 case 213: 6341 #line 1619 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6342 { 6343 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6344 (yyval.interm.type).basicType = EbtFloat; 6345 (yyval.interm.type).setVector(4); 6346 } 6347 #line 6348 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6348 break; 6349 6350 case 214: 6351 #line 1624 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6352 { 6353 parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector"); 6354 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6355 (yyval.interm.type).basicType = EbtDouble; 6356 (yyval.interm.type).setVector(2); 6357 } 6358 #line 6359 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6359 break; 6360 6361 case 215: 6362 #line 1630 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6363 { 6364 parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector"); 6365 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6366 (yyval.interm.type).basicType = EbtDouble; 6367 (yyval.interm.type).setVector(3); 6368 } 6369 #line 6370 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6370 break; 6371 6372 case 216: 6373 #line 1636 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6374 { 6375 parseContext.doubleCheck((yyvsp[0].lex).loc, "double vector"); 6376 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6377 (yyval.interm.type).basicType = EbtDouble; 6378 (yyval.interm.type).setVector(4); 6379 } 6380 #line 6381 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6381 break; 6382 6383 case 217: 6384 #line 1642 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6385 { 6386 parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); 6387 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6388 (yyval.interm.type).basicType = EbtFloat16; 6389 (yyval.interm.type).setVector(2); 6390 } 6391 #line 6392 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6392 break; 6393 6394 case 218: 6395 #line 1648 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6396 { 6397 parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); 6398 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6399 (yyval.interm.type).basicType = EbtFloat16; 6400 (yyval.interm.type).setVector(3); 6401 } 6402 #line 6403 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6403 break; 6404 6405 case 219: 6406 #line 1654 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6407 { 6408 parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); 6409 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6410 (yyval.interm.type).basicType = EbtFloat16; 6411 (yyval.interm.type).setVector(4); 6412 } 6413 #line 6414 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6414 break; 6415 6416 case 220: 6417 #line 1660 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6418 { 6419 parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel()); 6420 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6421 (yyval.interm.type).basicType = EbtFloat; 6422 (yyval.interm.type).setVector(2); 6423 } 6424 #line 6425 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6425 break; 6426 6427 case 221: 6428 #line 1666 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6429 { 6430 parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel()); 6431 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6432 (yyval.interm.type).basicType = EbtFloat; 6433 (yyval.interm.type).setVector(3); 6434 } 6435 #line 6436 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6436 break; 6437 6438 case 222: 6439 #line 1672 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6440 { 6441 parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel()); 6442 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6443 (yyval.interm.type).basicType = EbtFloat; 6444 (yyval.interm.type).setVector(4); 6445 } 6446 #line 6447 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6447 break; 6448 6449 case 223: 6450 #line 1678 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6451 { 6452 parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel()); 6453 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6454 (yyval.interm.type).basicType = EbtDouble; 6455 (yyval.interm.type).setVector(2); 6456 } 6457 #line 6458 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6458 break; 6459 6460 case 224: 6461 #line 1684 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6462 { 6463 parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel()); 6464 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6465 (yyval.interm.type).basicType = EbtDouble; 6466 (yyval.interm.type).setVector(3); 6467 } 6468 #line 6469 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6469 break; 6470 6471 case 225: 6472 #line 1690 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6473 { 6474 parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel()); 6475 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6476 (yyval.interm.type).basicType = EbtDouble; 6477 (yyval.interm.type).setVector(4); 6478 } 6479 #line 6480 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6480 break; 6481 6482 case 226: 6483 #line 1696 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6484 { 6485 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6486 (yyval.interm.type).basicType = EbtBool; 6487 (yyval.interm.type).setVector(2); 6488 } 6489 #line 6490 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6490 break; 6491 6492 case 227: 6493 #line 1701 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6494 { 6495 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6496 (yyval.interm.type).basicType = EbtBool; 6497 (yyval.interm.type).setVector(3); 6498 } 6499 #line 6500 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6500 break; 6501 6502 case 228: 6503 #line 1706 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6504 { 6505 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6506 (yyval.interm.type).basicType = EbtBool; 6507 (yyval.interm.type).setVector(4); 6508 } 6509 #line 6510 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6510 break; 6511 6512 case 229: 6513 #line 1711 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6514 { 6515 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6516 (yyval.interm.type).basicType = EbtInt; 6517 (yyval.interm.type).setVector(2); 6518 } 6519 #line 6520 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6520 break; 6521 6522 case 230: 6523 #line 1716 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6524 { 6525 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6526 (yyval.interm.type).basicType = EbtInt; 6527 (yyval.interm.type).setVector(3); 6528 } 6529 #line 6530 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6530 break; 6531 6532 case 231: 6533 #line 1721 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6534 { 6535 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6536 (yyval.interm.type).basicType = EbtInt; 6537 (yyval.interm.type).setVector(4); 6538 } 6539 #line 6540 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6540 break; 6541 6542 case 232: 6543 #line 1726 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6544 { 6545 parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); 6546 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6547 (yyval.interm.type).basicType = EbtInt8; 6548 (yyval.interm.type).setVector(2); 6549 } 6550 #line 6551 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6551 break; 6552 6553 case 233: 6554 #line 1732 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6555 { 6556 parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); 6557 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6558 (yyval.interm.type).basicType = EbtInt8; 6559 (yyval.interm.type).setVector(3); 6560 } 6561 #line 6562 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6562 break; 6563 6564 case 234: 6565 #line 1738 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6566 { 6567 parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); 6568 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6569 (yyval.interm.type).basicType = EbtInt8; 6570 (yyval.interm.type).setVector(4); 6571 } 6572 #line 6573 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6573 break; 6574 6575 case 235: 6576 #line 1744 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6577 { 6578 parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); 6579 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6580 (yyval.interm.type).basicType = EbtInt16; 6581 (yyval.interm.type).setVector(2); 6582 } 6583 #line 6584 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6584 break; 6585 6586 case 236: 6587 #line 1750 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6588 { 6589 parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); 6590 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6591 (yyval.interm.type).basicType = EbtInt16; 6592 (yyval.interm.type).setVector(3); 6593 } 6594 #line 6595 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6595 break; 6596 6597 case 237: 6598 #line 1756 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6599 { 6600 parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); 6601 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6602 (yyval.interm.type).basicType = EbtInt16; 6603 (yyval.interm.type).setVector(4); 6604 } 6605 #line 6606 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6606 break; 6607 6608 case 238: 6609 #line 1762 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6610 { 6611 parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); 6612 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6613 (yyval.interm.type).basicType = EbtInt; 6614 (yyval.interm.type).setVector(2); 6615 } 6616 #line 6617 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6617 break; 6618 6619 case 239: 6620 #line 1768 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6621 { 6622 parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); 6623 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6624 (yyval.interm.type).basicType = EbtInt; 6625 (yyval.interm.type).setVector(3); 6626 } 6627 #line 6628 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6628 break; 6629 6630 case 240: 6631 #line 1774 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6632 { 6633 parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); 6634 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6635 (yyval.interm.type).basicType = EbtInt; 6636 (yyval.interm.type).setVector(4); 6637 } 6638 #line 6639 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6639 break; 6640 6641 case 241: 6642 #line 1780 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6643 { 6644 parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); 6645 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6646 (yyval.interm.type).basicType = EbtInt64; 6647 (yyval.interm.type).setVector(2); 6648 } 6649 #line 6650 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6650 break; 6651 6652 case 242: 6653 #line 1786 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6654 { 6655 parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); 6656 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6657 (yyval.interm.type).basicType = EbtInt64; 6658 (yyval.interm.type).setVector(3); 6659 } 6660 #line 6661 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6661 break; 6662 6663 case 243: 6664 #line 1792 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6665 { 6666 parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); 6667 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6668 (yyval.interm.type).basicType = EbtInt64; 6669 (yyval.interm.type).setVector(4); 6670 } 6671 #line 6672 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6672 break; 6673 6674 case 244: 6675 #line 1798 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6676 { 6677 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector"); 6678 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6679 (yyval.interm.type).basicType = EbtUint; 6680 (yyval.interm.type).setVector(2); 6681 } 6682 #line 6683 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6683 break; 6684 6685 case 245: 6686 #line 1804 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6687 { 6688 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector"); 6689 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6690 (yyval.interm.type).basicType = EbtUint; 6691 (yyval.interm.type).setVector(3); 6692 } 6693 #line 6694 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6694 break; 6695 6696 case 246: 6697 #line 1810 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6698 { 6699 parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector"); 6700 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6701 (yyval.interm.type).basicType = EbtUint; 6702 (yyval.interm.type).setVector(4); 6703 } 6704 #line 6705 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6705 break; 6706 6707 case 247: 6708 #line 1816 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6709 { 6710 parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); 6711 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6712 (yyval.interm.type).basicType = EbtUint8; 6713 (yyval.interm.type).setVector(2); 6714 } 6715 #line 6716 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6716 break; 6717 6718 case 248: 6719 #line 1822 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6720 { 6721 parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); 6722 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6723 (yyval.interm.type).basicType = EbtUint8; 6724 (yyval.interm.type).setVector(3); 6725 } 6726 #line 6727 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6727 break; 6728 6729 case 249: 6730 #line 1828 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6731 { 6732 parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); 6733 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6734 (yyval.interm.type).basicType = EbtUint8; 6735 (yyval.interm.type).setVector(4); 6736 } 6737 #line 6738 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6738 break; 6739 6740 case 250: 6741 #line 1834 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6742 { 6743 parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); 6744 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6745 (yyval.interm.type).basicType = EbtUint16; 6746 (yyval.interm.type).setVector(2); 6747 } 6748 #line 6749 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6749 break; 6750 6751 case 251: 6752 #line 1840 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6753 { 6754 parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); 6755 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6756 (yyval.interm.type).basicType = EbtUint16; 6757 (yyval.interm.type).setVector(3); 6758 } 6759 #line 6760 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6760 break; 6761 6762 case 252: 6763 #line 1846 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6764 { 6765 parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); 6766 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6767 (yyval.interm.type).basicType = EbtUint16; 6768 (yyval.interm.type).setVector(4); 6769 } 6770 #line 6771 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6771 break; 6772 6773 case 253: 6774 #line 1852 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6775 { 6776 parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); 6777 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6778 (yyval.interm.type).basicType = EbtUint; 6779 (yyval.interm.type).setVector(2); 6780 } 6781 #line 6782 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6782 break; 6783 6784 case 254: 6785 #line 1858 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6786 { 6787 parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); 6788 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6789 (yyval.interm.type).basicType = EbtUint; 6790 (yyval.interm.type).setVector(3); 6791 } 6792 #line 6793 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6793 break; 6794 6795 case 255: 6796 #line 1864 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6797 { 6798 parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); 6799 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6800 (yyval.interm.type).basicType = EbtUint; 6801 (yyval.interm.type).setVector(4); 6802 } 6803 #line 6804 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6804 break; 6805 6806 case 256: 6807 #line 1870 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6808 { 6809 parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); 6810 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6811 (yyval.interm.type).basicType = EbtUint64; 6812 (yyval.interm.type).setVector(2); 6813 } 6814 #line 6815 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6815 break; 6816 6817 case 257: 6818 #line 1876 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6819 { 6820 parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); 6821 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6822 (yyval.interm.type).basicType = EbtUint64; 6823 (yyval.interm.type).setVector(3); 6824 } 6825 #line 6826 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6826 break; 6827 6828 case 258: 6829 #line 1882 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6830 { 6831 parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); 6832 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6833 (yyval.interm.type).basicType = EbtUint64; 6834 (yyval.interm.type).setVector(4); 6835 } 6836 #line 6837 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6837 break; 6838 6839 case 259: 6840 #line 1888 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6841 { 6842 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6843 (yyval.interm.type).basicType = EbtFloat; 6844 (yyval.interm.type).setMatrix(2, 2); 6845 } 6846 #line 6847 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6847 break; 6848 6849 case 260: 6850 #line 1893 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6851 { 6852 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6853 (yyval.interm.type).basicType = EbtFloat; 6854 (yyval.interm.type).setMatrix(3, 3); 6855 } 6856 #line 6857 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6857 break; 6858 6859 case 261: 6860 #line 1898 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6861 { 6862 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6863 (yyval.interm.type).basicType = EbtFloat; 6864 (yyval.interm.type).setMatrix(4, 4); 6865 } 6866 #line 6867 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6867 break; 6868 6869 case 262: 6870 #line 1903 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6871 { 6872 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6873 (yyval.interm.type).basicType = EbtFloat; 6874 (yyval.interm.type).setMatrix(2, 2); 6875 } 6876 #line 6877 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6877 break; 6878 6879 case 263: 6880 #line 1908 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6881 { 6882 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6883 (yyval.interm.type).basicType = EbtFloat; 6884 (yyval.interm.type).setMatrix(2, 3); 6885 } 6886 #line 6887 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6887 break; 6888 6889 case 264: 6890 #line 1913 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6891 { 6892 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6893 (yyval.interm.type).basicType = EbtFloat; 6894 (yyval.interm.type).setMatrix(2, 4); 6895 } 6896 #line 6897 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6897 break; 6898 6899 case 265: 6900 #line 1918 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6901 { 6902 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6903 (yyval.interm.type).basicType = EbtFloat; 6904 (yyval.interm.type).setMatrix(3, 2); 6905 } 6906 #line 6907 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6907 break; 6908 6909 case 266: 6910 #line 1923 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6911 { 6912 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6913 (yyval.interm.type).basicType = EbtFloat; 6914 (yyval.interm.type).setMatrix(3, 3); 6915 } 6916 #line 6917 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6917 break; 6918 6919 case 267: 6920 #line 1928 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6921 { 6922 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6923 (yyval.interm.type).basicType = EbtFloat; 6924 (yyval.interm.type).setMatrix(3, 4); 6925 } 6926 #line 6927 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6927 break; 6928 6929 case 268: 6930 #line 1933 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6931 { 6932 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6933 (yyval.interm.type).basicType = EbtFloat; 6934 (yyval.interm.type).setMatrix(4, 2); 6935 } 6936 #line 6937 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6937 break; 6938 6939 case 269: 6940 #line 1938 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6941 { 6942 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6943 (yyval.interm.type).basicType = EbtFloat; 6944 (yyval.interm.type).setMatrix(4, 3); 6945 } 6946 #line 6947 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6947 break; 6948 6949 case 270: 6950 #line 1943 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6951 { 6952 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6953 (yyval.interm.type).basicType = EbtFloat; 6954 (yyval.interm.type).setMatrix(4, 4); 6955 } 6956 #line 6957 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6957 break; 6958 6959 case 271: 6960 #line 1948 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6961 { 6962 parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); 6963 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6964 (yyval.interm.type).basicType = EbtDouble; 6965 (yyval.interm.type).setMatrix(2, 2); 6966 } 6967 #line 6968 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6968 break; 6969 6970 case 272: 6971 #line 1954 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6972 { 6973 parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); 6974 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6975 (yyval.interm.type).basicType = EbtDouble; 6976 (yyval.interm.type).setMatrix(3, 3); 6977 } 6978 #line 6979 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6979 break; 6980 6981 case 273: 6982 #line 1960 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6983 { 6984 parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); 6985 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6986 (yyval.interm.type).basicType = EbtDouble; 6987 (yyval.interm.type).setMatrix(4, 4); 6988 } 6989 #line 6990 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 6990 break; 6991 6992 case 274: 6993 #line 1966 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 6994 { 6995 parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); 6996 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 6997 (yyval.interm.type).basicType = EbtDouble; 6998 (yyval.interm.type).setMatrix(2, 2); 6999 } 7000 #line 7001 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7001 break; 7002 7003 case 275: 7004 #line 1972 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7005 { 7006 parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); 7007 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7008 (yyval.interm.type).basicType = EbtDouble; 7009 (yyval.interm.type).setMatrix(2, 3); 7010 } 7011 #line 7012 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7012 break; 7013 7014 case 276: 7015 #line 1978 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7016 { 7017 parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); 7018 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7019 (yyval.interm.type).basicType = EbtDouble; 7020 (yyval.interm.type).setMatrix(2, 4); 7021 } 7022 #line 7023 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7023 break; 7024 7025 case 277: 7026 #line 1984 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7027 { 7028 parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); 7029 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7030 (yyval.interm.type).basicType = EbtDouble; 7031 (yyval.interm.type).setMatrix(3, 2); 7032 } 7033 #line 7034 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7034 break; 7035 7036 case 278: 7037 #line 1990 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7038 { 7039 parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); 7040 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7041 (yyval.interm.type).basicType = EbtDouble; 7042 (yyval.interm.type).setMatrix(3, 3); 7043 } 7044 #line 7045 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7045 break; 7046 7047 case 279: 7048 #line 1996 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7049 { 7050 parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); 7051 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7052 (yyval.interm.type).basicType = EbtDouble; 7053 (yyval.interm.type).setMatrix(3, 4); 7054 } 7055 #line 7056 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7056 break; 7057 7058 case 280: 7059 #line 2002 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7060 { 7061 parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); 7062 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7063 (yyval.interm.type).basicType = EbtDouble; 7064 (yyval.interm.type).setMatrix(4, 2); 7065 } 7066 #line 7067 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7067 break; 7068 7069 case 281: 7070 #line 2008 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7071 { 7072 parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); 7073 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7074 (yyval.interm.type).basicType = EbtDouble; 7075 (yyval.interm.type).setMatrix(4, 3); 7076 } 7077 #line 7078 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7078 break; 7079 7080 case 282: 7081 #line 2014 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7082 { 7083 parseContext.doubleCheck((yyvsp[0].lex).loc, "double matrix"); 7084 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7085 (yyval.interm.type).basicType = EbtDouble; 7086 (yyval.interm.type).setMatrix(4, 4); 7087 } 7088 #line 7089 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7089 break; 7090 7091 case 283: 7092 #line 2020 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7093 { 7094 parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); 7095 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7096 (yyval.interm.type).basicType = EbtFloat16; 7097 (yyval.interm.type).setMatrix(2, 2); 7098 } 7099 #line 7100 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7100 break; 7101 7102 case 284: 7103 #line 2026 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7104 { 7105 parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); 7106 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7107 (yyval.interm.type).basicType = EbtFloat16; 7108 (yyval.interm.type).setMatrix(3, 3); 7109 } 7110 #line 7111 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7111 break; 7112 7113 case 285: 7114 #line 2032 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7115 { 7116 parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); 7117 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7118 (yyval.interm.type).basicType = EbtFloat16; 7119 (yyval.interm.type).setMatrix(4, 4); 7120 } 7121 #line 7122 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7122 break; 7123 7124 case 286: 7125 #line 2038 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7126 { 7127 parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); 7128 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7129 (yyval.interm.type).basicType = EbtFloat16; 7130 (yyval.interm.type).setMatrix(2, 2); 7131 } 7132 #line 7133 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7133 break; 7134 7135 case 287: 7136 #line 2044 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7137 { 7138 parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); 7139 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7140 (yyval.interm.type).basicType = EbtFloat16; 7141 (yyval.interm.type).setMatrix(2, 3); 7142 } 7143 #line 7144 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7144 break; 7145 7146 case 288: 7147 #line 2050 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7148 { 7149 parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); 7150 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7151 (yyval.interm.type).basicType = EbtFloat16; 7152 (yyval.interm.type).setMatrix(2, 4); 7153 } 7154 #line 7155 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7155 break; 7156 7157 case 289: 7158 #line 2056 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7159 { 7160 parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); 7161 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7162 (yyval.interm.type).basicType = EbtFloat16; 7163 (yyval.interm.type).setMatrix(3, 2); 7164 } 7165 #line 7166 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7166 break; 7167 7168 case 290: 7169 #line 2062 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7170 { 7171 parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); 7172 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7173 (yyval.interm.type).basicType = EbtFloat16; 7174 (yyval.interm.type).setMatrix(3, 3); 7175 } 7176 #line 7177 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7177 break; 7178 7179 case 291: 7180 #line 2068 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7181 { 7182 parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); 7183 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7184 (yyval.interm.type).basicType = EbtFloat16; 7185 (yyval.interm.type).setMatrix(3, 4); 7186 } 7187 #line 7188 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7188 break; 7189 7190 case 292: 7191 #line 2074 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7192 { 7193 parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); 7194 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7195 (yyval.interm.type).basicType = EbtFloat16; 7196 (yyval.interm.type).setMatrix(4, 2); 7197 } 7198 #line 7199 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7199 break; 7200 7201 case 293: 7202 #line 2080 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7203 { 7204 parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); 7205 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7206 (yyval.interm.type).basicType = EbtFloat16; 7207 (yyval.interm.type).setMatrix(4, 3); 7208 } 7209 #line 7210 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7210 break; 7211 7212 case 294: 7213 #line 2086 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7214 { 7215 parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); 7216 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7217 (yyval.interm.type).basicType = EbtFloat16; 7218 (yyval.interm.type).setMatrix(4, 4); 7219 } 7220 #line 7221 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7221 break; 7222 7223 case 295: 7224 #line 2092 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7225 { 7226 parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); 7227 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7228 (yyval.interm.type).basicType = EbtFloat; 7229 (yyval.interm.type).setMatrix(2, 2); 7230 } 7231 #line 7232 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7232 break; 7233 7234 case 296: 7235 #line 2098 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7236 { 7237 parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); 7238 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7239 (yyval.interm.type).basicType = EbtFloat; 7240 (yyval.interm.type).setMatrix(3, 3); 7241 } 7242 #line 7243 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7243 break; 7244 7245 case 297: 7246 #line 2104 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7247 { 7248 parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); 7249 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7250 (yyval.interm.type).basicType = EbtFloat; 7251 (yyval.interm.type).setMatrix(4, 4); 7252 } 7253 #line 7254 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7254 break; 7255 7256 case 298: 7257 #line 2110 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7258 { 7259 parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); 7260 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7261 (yyval.interm.type).basicType = EbtFloat; 7262 (yyval.interm.type).setMatrix(2, 2); 7263 } 7264 #line 7265 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7265 break; 7266 7267 case 299: 7268 #line 2116 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7269 { 7270 parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); 7271 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7272 (yyval.interm.type).basicType = EbtFloat; 7273 (yyval.interm.type).setMatrix(2, 3); 7274 } 7275 #line 7276 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7276 break; 7277 7278 case 300: 7279 #line 2122 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7280 { 7281 parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); 7282 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7283 (yyval.interm.type).basicType = EbtFloat; 7284 (yyval.interm.type).setMatrix(2, 4); 7285 } 7286 #line 7287 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7287 break; 7288 7289 case 301: 7290 #line 2128 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7291 { 7292 parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); 7293 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7294 (yyval.interm.type).basicType = EbtFloat; 7295 (yyval.interm.type).setMatrix(3, 2); 7296 } 7297 #line 7298 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7298 break; 7299 7300 case 302: 7301 #line 2134 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7302 { 7303 parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); 7304 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7305 (yyval.interm.type).basicType = EbtFloat; 7306 (yyval.interm.type).setMatrix(3, 3); 7307 } 7308 #line 7309 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7309 break; 7310 7311 case 303: 7312 #line 2140 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7313 { 7314 parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); 7315 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7316 (yyval.interm.type).basicType = EbtFloat; 7317 (yyval.interm.type).setMatrix(3, 4); 7318 } 7319 #line 7320 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7320 break; 7321 7322 case 304: 7323 #line 2146 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7324 { 7325 parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); 7326 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7327 (yyval.interm.type).basicType = EbtFloat; 7328 (yyval.interm.type).setMatrix(4, 2); 7329 } 7330 #line 7331 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7331 break; 7332 7333 case 305: 7334 #line 2152 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7335 { 7336 parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); 7337 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7338 (yyval.interm.type).basicType = EbtFloat; 7339 (yyval.interm.type).setMatrix(4, 3); 7340 } 7341 #line 7342 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7342 break; 7343 7344 case 306: 7345 #line 2158 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7346 { 7347 parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); 7348 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7349 (yyval.interm.type).basicType = EbtFloat; 7350 (yyval.interm.type).setMatrix(4, 4); 7351 } 7352 #line 7353 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7353 break; 7354 7355 case 307: 7356 #line 2164 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7357 { 7358 parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); 7359 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7360 (yyval.interm.type).basicType = EbtDouble; 7361 (yyval.interm.type).setMatrix(2, 2); 7362 } 7363 #line 7364 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7364 break; 7365 7366 case 308: 7367 #line 2170 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7368 { 7369 parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); 7370 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7371 (yyval.interm.type).basicType = EbtDouble; 7372 (yyval.interm.type).setMatrix(3, 3); 7373 } 7374 #line 7375 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7375 break; 7376 7377 case 309: 7378 #line 2176 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7379 { 7380 parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); 7381 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7382 (yyval.interm.type).basicType = EbtDouble; 7383 (yyval.interm.type).setMatrix(4, 4); 7384 } 7385 #line 7386 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7386 break; 7387 7388 case 310: 7389 #line 2182 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7390 { 7391 parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); 7392 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7393 (yyval.interm.type).basicType = EbtDouble; 7394 (yyval.interm.type).setMatrix(2, 2); 7395 } 7396 #line 7397 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7397 break; 7398 7399 case 311: 7400 #line 2188 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7401 { 7402 parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); 7403 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7404 (yyval.interm.type).basicType = EbtDouble; 7405 (yyval.interm.type).setMatrix(2, 3); 7406 } 7407 #line 7408 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7408 break; 7409 7410 case 312: 7411 #line 2194 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7412 { 7413 parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); 7414 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7415 (yyval.interm.type).basicType = EbtDouble; 7416 (yyval.interm.type).setMatrix(2, 4); 7417 } 7418 #line 7419 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7419 break; 7420 7421 case 313: 7422 #line 2200 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7423 { 7424 parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); 7425 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7426 (yyval.interm.type).basicType = EbtDouble; 7427 (yyval.interm.type).setMatrix(3, 2); 7428 } 7429 #line 7430 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7430 break; 7431 7432 case 314: 7433 #line 2206 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7434 { 7435 parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); 7436 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7437 (yyval.interm.type).basicType = EbtDouble; 7438 (yyval.interm.type).setMatrix(3, 3); 7439 } 7440 #line 7441 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7441 break; 7442 7443 case 315: 7444 #line 2212 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7445 { 7446 parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); 7447 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7448 (yyval.interm.type).basicType = EbtDouble; 7449 (yyval.interm.type).setMatrix(3, 4); 7450 } 7451 #line 7452 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7452 break; 7453 7454 case 316: 7455 #line 2218 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7456 { 7457 parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); 7458 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7459 (yyval.interm.type).basicType = EbtDouble; 7460 (yyval.interm.type).setMatrix(4, 2); 7461 } 7462 #line 7463 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7463 break; 7464 7465 case 317: 7466 #line 2224 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7467 { 7468 parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); 7469 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7470 (yyval.interm.type).basicType = EbtDouble; 7471 (yyval.interm.type).setMatrix(4, 3); 7472 } 7473 #line 7474 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7474 break; 7475 7476 case 318: 7477 #line 2230 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7478 { 7479 parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); 7480 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7481 (yyval.interm.type).basicType = EbtDouble; 7482 (yyval.interm.type).setMatrix(4, 4); 7483 } 7484 #line 7485 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7485 break; 7486 7487 case 319: 7488 #line 2236 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7489 { 7490 #ifdef NV_EXTENSIONS 7491 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7492 (yyval.interm.type).basicType = EbtAccStructNV; 7493 #endif 7494 } 7495 #line 7496 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7496 break; 7497 7498 case 320: 7499 #line 2242 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7500 { 7501 parseContext.vulkanRemoved((yyvsp[0].lex).loc, "atomic counter types"); 7502 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7503 (yyval.interm.type).basicType = EbtAtomicUint; 7504 } 7505 #line 7506 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7506 break; 7507 7508 case 321: 7509 #line 2247 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7510 { 7511 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7512 (yyval.interm.type).basicType = EbtSampler; 7513 (yyval.interm.type).sampler.set(EbtFloat, Esd1D); 7514 } 7515 #line 7516 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7516 break; 7517 7518 case 322: 7519 #line 2252 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7520 { 7521 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7522 (yyval.interm.type).basicType = EbtSampler; 7523 (yyval.interm.type).sampler.set(EbtFloat, Esd2D); 7524 } 7525 #line 7526 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7526 break; 7527 7528 case 323: 7529 #line 2257 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7530 { 7531 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7532 (yyval.interm.type).basicType = EbtSampler; 7533 (yyval.interm.type).sampler.set(EbtFloat, Esd3D); 7534 } 7535 #line 7536 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7536 break; 7537 7538 case 324: 7539 #line 2262 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7540 { 7541 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7542 (yyval.interm.type).basicType = EbtSampler; 7543 (yyval.interm.type).sampler.set(EbtFloat, EsdCube); 7544 } 7545 #line 7546 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7546 break; 7547 7548 case 325: 7549 #line 2267 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7550 { 7551 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7552 (yyval.interm.type).basicType = EbtSampler; 7553 (yyval.interm.type).sampler.set(EbtFloat, Esd1D, false, true); 7554 } 7555 #line 7556 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7556 break; 7557 7558 case 326: 7559 #line 2272 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7560 { 7561 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7562 (yyval.interm.type).basicType = EbtSampler; 7563 (yyval.interm.type).sampler.set(EbtFloat, Esd2D, false, true); 7564 } 7565 #line 7566 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7566 break; 7567 7568 case 327: 7569 #line 2277 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7570 { 7571 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7572 (yyval.interm.type).basicType = EbtSampler; 7573 (yyval.interm.type).sampler.set(EbtFloat, EsdCube, false, true); 7574 } 7575 #line 7576 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7576 break; 7577 7578 case 328: 7579 #line 2282 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7580 { 7581 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7582 (yyval.interm.type).basicType = EbtSampler; 7583 (yyval.interm.type).sampler.set(EbtFloat, Esd1D, true); 7584 } 7585 #line 7586 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7586 break; 7587 7588 case 329: 7589 #line 2287 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7590 { 7591 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7592 (yyval.interm.type).basicType = EbtSampler; 7593 (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true); 7594 } 7595 #line 7596 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7596 break; 7597 7598 case 330: 7599 #line 2292 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7600 { 7601 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7602 (yyval.interm.type).basicType = EbtSampler; 7603 (yyval.interm.type).sampler.set(EbtFloat, Esd1D, true, true); 7604 } 7605 #line 7606 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7606 break; 7607 7608 case 331: 7609 #line 2297 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7610 { 7611 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7612 (yyval.interm.type).basicType = EbtSampler; 7613 (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true, true); 7614 } 7615 #line 7616 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7616 break; 7617 7618 case 332: 7619 #line 2302 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7620 { 7621 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7622 (yyval.interm.type).basicType = EbtSampler; 7623 (yyval.interm.type).sampler.set(EbtFloat, EsdCube, true); 7624 } 7625 #line 7626 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7626 break; 7627 7628 case 333: 7629 #line 2307 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7630 { 7631 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7632 (yyval.interm.type).basicType = EbtSampler; 7633 (yyval.interm.type).sampler.set(EbtFloat, EsdCube, true, true); 7634 } 7635 #line 7636 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7636 break; 7637 7638 case 334: 7639 #line 2312 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7640 { 7641 #ifdef AMD_EXTENSIONS 7642 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); 7643 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7644 (yyval.interm.type).basicType = EbtSampler; 7645 (yyval.interm.type).sampler.set(EbtFloat16, Esd1D); 7646 #endif 7647 } 7648 #line 7649 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7649 break; 7650 7651 case 335: 7652 #line 2320 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7653 { 7654 #ifdef AMD_EXTENSIONS 7655 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); 7656 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7657 (yyval.interm.type).basicType = EbtSampler; 7658 (yyval.interm.type).sampler.set(EbtFloat16, Esd2D); 7659 #endif 7660 } 7661 #line 7662 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7662 break; 7663 7664 case 336: 7665 #line 2328 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7666 { 7667 #ifdef AMD_EXTENSIONS 7668 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); 7669 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7670 (yyval.interm.type).basicType = EbtSampler; 7671 (yyval.interm.type).sampler.set(EbtFloat16, Esd3D); 7672 #endif 7673 } 7674 #line 7675 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7675 break; 7676 7677 case 337: 7678 #line 2336 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7679 { 7680 #ifdef AMD_EXTENSIONS 7681 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); 7682 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7683 (yyval.interm.type).basicType = EbtSampler; 7684 (yyval.interm.type).sampler.set(EbtFloat16, EsdCube); 7685 #endif 7686 } 7687 #line 7688 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7688 break; 7689 7690 case 338: 7691 #line 2344 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7692 { 7693 #ifdef AMD_EXTENSIONS 7694 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); 7695 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7696 (yyval.interm.type).basicType = EbtSampler; 7697 (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, false, true); 7698 #endif 7699 } 7700 #line 7701 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7701 break; 7702 7703 case 339: 7704 #line 2352 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7705 { 7706 #ifdef AMD_EXTENSIONS 7707 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); 7708 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7709 (yyval.interm.type).basicType = EbtSampler; 7710 (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, false, true); 7711 #endif 7712 } 7713 #line 7714 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7714 break; 7715 7716 case 340: 7717 #line 2360 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7718 { 7719 #ifdef AMD_EXTENSIONS 7720 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); 7721 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7722 (yyval.interm.type).basicType = EbtSampler; 7723 (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, false, true); 7724 #endif 7725 } 7726 #line 7727 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7727 break; 7728 7729 case 341: 7730 #line 2368 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7731 { 7732 #ifdef AMD_EXTENSIONS 7733 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); 7734 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7735 (yyval.interm.type).basicType = EbtSampler; 7736 (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, true); 7737 #endif 7738 } 7739 #line 7740 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7740 break; 7741 7742 case 342: 7743 #line 2376 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7744 { 7745 #ifdef AMD_EXTENSIONS 7746 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); 7747 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7748 (yyval.interm.type).basicType = EbtSampler; 7749 (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true); 7750 #endif 7751 } 7752 #line 7753 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7753 break; 7754 7755 case 343: 7756 #line 2384 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7757 { 7758 #ifdef AMD_EXTENSIONS 7759 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); 7760 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7761 (yyval.interm.type).basicType = EbtSampler; 7762 (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, true, true); 7763 #endif 7764 } 7765 #line 7766 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7766 break; 7767 7768 case 344: 7769 #line 2392 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7770 { 7771 #ifdef AMD_EXTENSIONS 7772 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); 7773 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7774 (yyval.interm.type).basicType = EbtSampler; 7775 (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true, true); 7776 #endif 7777 } 7778 #line 7779 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7779 break; 7780 7781 case 345: 7782 #line 2400 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7783 { 7784 #ifdef AMD_EXTENSIONS 7785 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); 7786 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7787 (yyval.interm.type).basicType = EbtSampler; 7788 (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, true); 7789 #endif 7790 } 7791 #line 7792 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7792 break; 7793 7794 case 346: 7795 #line 2408 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7796 { 7797 #ifdef AMD_EXTENSIONS 7798 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); 7799 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7800 (yyval.interm.type).basicType = EbtSampler; 7801 (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, true, true); 7802 #endif 7803 } 7804 #line 7805 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7805 break; 7806 7807 case 347: 7808 #line 2416 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7809 { 7810 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7811 (yyval.interm.type).basicType = EbtSampler; 7812 (yyval.interm.type).sampler.set(EbtInt, Esd1D); 7813 } 7814 #line 7815 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7815 break; 7816 7817 case 348: 7818 #line 2421 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7819 { 7820 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7821 (yyval.interm.type).basicType = EbtSampler; 7822 (yyval.interm.type).sampler.set(EbtInt, Esd2D); 7823 } 7824 #line 7825 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7825 break; 7826 7827 case 349: 7828 #line 2426 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7829 { 7830 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7831 (yyval.interm.type).basicType = EbtSampler; 7832 (yyval.interm.type).sampler.set(EbtInt, Esd3D); 7833 } 7834 #line 7835 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7835 break; 7836 7837 case 350: 7838 #line 2431 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7839 { 7840 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7841 (yyval.interm.type).basicType = EbtSampler; 7842 (yyval.interm.type).sampler.set(EbtInt, EsdCube); 7843 } 7844 #line 7845 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7845 break; 7846 7847 case 351: 7848 #line 2436 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7849 { 7850 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7851 (yyval.interm.type).basicType = EbtSampler; 7852 (yyval.interm.type).sampler.set(EbtInt, Esd1D, true); 7853 } 7854 #line 7855 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7855 break; 7856 7857 case 352: 7858 #line 2441 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7859 { 7860 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7861 (yyval.interm.type).basicType = EbtSampler; 7862 (yyval.interm.type).sampler.set(EbtInt, Esd2D, true); 7863 } 7864 #line 7865 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7865 break; 7866 7867 case 353: 7868 #line 2446 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7869 { 7870 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7871 (yyval.interm.type).basicType = EbtSampler; 7872 (yyval.interm.type).sampler.set(EbtInt, EsdCube, true); 7873 } 7874 #line 7875 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7875 break; 7876 7877 case 354: 7878 #line 2451 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7879 { 7880 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7881 (yyval.interm.type).basicType = EbtSampler; 7882 (yyval.interm.type).sampler.set(EbtUint, Esd1D); 7883 } 7884 #line 7885 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7885 break; 7886 7887 case 355: 7888 #line 2456 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7889 { 7890 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7891 (yyval.interm.type).basicType = EbtSampler; 7892 (yyval.interm.type).sampler.set(EbtUint, Esd2D); 7893 } 7894 #line 7895 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7895 break; 7896 7897 case 356: 7898 #line 2461 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7899 { 7900 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7901 (yyval.interm.type).basicType = EbtSampler; 7902 (yyval.interm.type).sampler.set(EbtUint, Esd3D); 7903 } 7904 #line 7905 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7905 break; 7906 7907 case 357: 7908 #line 2466 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7909 { 7910 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7911 (yyval.interm.type).basicType = EbtSampler; 7912 (yyval.interm.type).sampler.set(EbtUint, EsdCube); 7913 } 7914 #line 7915 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7915 break; 7916 7917 case 358: 7918 #line 2471 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7919 { 7920 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7921 (yyval.interm.type).basicType = EbtSampler; 7922 (yyval.interm.type).sampler.set(EbtUint, Esd1D, true); 7923 } 7924 #line 7925 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7925 break; 7926 7927 case 359: 7928 #line 2476 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7929 { 7930 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7931 (yyval.interm.type).basicType = EbtSampler; 7932 (yyval.interm.type).sampler.set(EbtUint, Esd2D, true); 7933 } 7934 #line 7935 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7935 break; 7936 7937 case 360: 7938 #line 2481 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7939 { 7940 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7941 (yyval.interm.type).basicType = EbtSampler; 7942 (yyval.interm.type).sampler.set(EbtUint, EsdCube, true); 7943 } 7944 #line 7945 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7945 break; 7946 7947 case 361: 7948 #line 2486 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7949 { 7950 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7951 (yyval.interm.type).basicType = EbtSampler; 7952 (yyval.interm.type).sampler.set(EbtFloat, EsdRect); 7953 } 7954 #line 7955 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7955 break; 7956 7957 case 362: 7958 #line 2491 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7959 { 7960 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7961 (yyval.interm.type).basicType = EbtSampler; 7962 (yyval.interm.type).sampler.set(EbtFloat, EsdRect, false, true); 7963 } 7964 #line 7965 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7965 break; 7966 7967 case 363: 7968 #line 2496 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7969 { 7970 #ifdef AMD_EXTENSIONS 7971 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); 7972 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7973 (yyval.interm.type).basicType = EbtSampler; 7974 (yyval.interm.type).sampler.set(EbtFloat16, EsdRect); 7975 #endif 7976 } 7977 #line 7978 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7978 break; 7979 7980 case 364: 7981 #line 2504 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7982 { 7983 #ifdef AMD_EXTENSIONS 7984 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); 7985 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7986 (yyval.interm.type).basicType = EbtSampler; 7987 (yyval.interm.type).sampler.set(EbtFloat16, EsdRect, false, true); 7988 #endif 7989 } 7990 #line 7991 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 7991 break; 7992 7993 case 365: 7994 #line 2512 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 7995 { 7996 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 7997 (yyval.interm.type).basicType = EbtSampler; 7998 (yyval.interm.type).sampler.set(EbtInt, EsdRect); 7999 } 8000 #line 8001 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8001 break; 8002 8003 case 366: 8004 #line 2517 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8005 { 8006 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8007 (yyval.interm.type).basicType = EbtSampler; 8008 (yyval.interm.type).sampler.set(EbtUint, EsdRect); 8009 } 8010 #line 8011 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8011 break; 8012 8013 case 367: 8014 #line 2522 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8015 { 8016 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8017 (yyval.interm.type).basicType = EbtSampler; 8018 (yyval.interm.type).sampler.set(EbtFloat, EsdBuffer); 8019 } 8020 #line 8021 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8021 break; 8022 8023 case 368: 8024 #line 2527 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8025 { 8026 #ifdef AMD_EXTENSIONS 8027 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); 8028 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8029 (yyval.interm.type).basicType = EbtSampler; 8030 (yyval.interm.type).sampler.set(EbtFloat16, EsdBuffer); 8031 #endif 8032 } 8033 #line 8034 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8034 break; 8035 8036 case 369: 8037 #line 2535 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8038 { 8039 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8040 (yyval.interm.type).basicType = EbtSampler; 8041 (yyval.interm.type).sampler.set(EbtInt, EsdBuffer); 8042 } 8043 #line 8044 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8044 break; 8045 8046 case 370: 8047 #line 2540 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8048 { 8049 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8050 (yyval.interm.type).basicType = EbtSampler; 8051 (yyval.interm.type).sampler.set(EbtUint, EsdBuffer); 8052 } 8053 #line 8054 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8054 break; 8055 8056 case 371: 8057 #line 2545 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8058 { 8059 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8060 (yyval.interm.type).basicType = EbtSampler; 8061 (yyval.interm.type).sampler.set(EbtFloat, Esd2D, false, false, true); 8062 } 8063 #line 8064 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8064 break; 8065 8066 case 372: 8067 #line 2550 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8068 { 8069 #ifdef AMD_EXTENSIONS 8070 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); 8071 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8072 (yyval.interm.type).basicType = EbtSampler; 8073 (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, false, false, true); 8074 #endif 8075 } 8076 #line 8077 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8077 break; 8078 8079 case 373: 8080 #line 2558 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8081 { 8082 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8083 (yyval.interm.type).basicType = EbtSampler; 8084 (yyval.interm.type).sampler.set(EbtInt, Esd2D, false, false, true); 8085 } 8086 #line 8087 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8087 break; 8088 8089 case 374: 8090 #line 2563 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8091 { 8092 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8093 (yyval.interm.type).basicType = EbtSampler; 8094 (yyval.interm.type).sampler.set(EbtUint, Esd2D, false, false, true); 8095 } 8096 #line 8097 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8097 break; 8098 8099 case 375: 8100 #line 2568 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8101 { 8102 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8103 (yyval.interm.type).basicType = EbtSampler; 8104 (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true, false, true); 8105 } 8106 #line 8107 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8107 break; 8108 8109 case 376: 8110 #line 2573 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8111 { 8112 #ifdef AMD_EXTENSIONS 8113 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); 8114 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8115 (yyval.interm.type).basicType = EbtSampler; 8116 (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true, false, true); 8117 #endif 8118 } 8119 #line 8120 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8120 break; 8121 8122 case 377: 8123 #line 2581 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8124 { 8125 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8126 (yyval.interm.type).basicType = EbtSampler; 8127 (yyval.interm.type).sampler.set(EbtInt, Esd2D, true, false, true); 8128 } 8129 #line 8130 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8130 break; 8131 8132 case 378: 8133 #line 2586 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8134 { 8135 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8136 (yyval.interm.type).basicType = EbtSampler; 8137 (yyval.interm.type).sampler.set(EbtUint, Esd2D, true, false, true); 8138 } 8139 #line 8140 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8140 break; 8141 8142 case 379: 8143 #line 2591 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8144 { 8145 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8146 (yyval.interm.type).basicType = EbtSampler; 8147 (yyval.interm.type).sampler.setPureSampler(false); 8148 } 8149 #line 8150 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8150 break; 8151 8152 case 380: 8153 #line 2596 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8154 { 8155 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8156 (yyval.interm.type).basicType = EbtSampler; 8157 (yyval.interm.type).sampler.setPureSampler(true); 8158 } 8159 #line 8160 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8160 break; 8161 8162 case 381: 8163 #line 2601 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8164 { 8165 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8166 (yyval.interm.type).basicType = EbtSampler; 8167 (yyval.interm.type).sampler.setTexture(EbtFloat, Esd1D); 8168 } 8169 #line 8170 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8170 break; 8171 8172 case 382: 8173 #line 2606 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8174 { 8175 #ifdef AMD_EXTENSIONS 8176 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); 8177 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8178 (yyval.interm.type).basicType = EbtSampler; 8179 (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd1D); 8180 #endif 8181 } 8182 #line 8183 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8183 break; 8184 8185 case 383: 8186 #line 2614 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8187 { 8188 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8189 (yyval.interm.type).basicType = EbtSampler; 8190 (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D); 8191 } 8192 #line 8193 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8193 break; 8194 8195 case 384: 8196 #line 2619 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8197 { 8198 #ifdef AMD_EXTENSIONS 8199 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); 8200 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8201 (yyval.interm.type).basicType = EbtSampler; 8202 (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D); 8203 #endif 8204 } 8205 #line 8206 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8206 break; 8207 8208 case 385: 8209 #line 2627 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8210 { 8211 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8212 (yyval.interm.type).basicType = EbtSampler; 8213 (yyval.interm.type).sampler.setTexture(EbtFloat, Esd3D); 8214 } 8215 #line 8216 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8216 break; 8217 8218 case 386: 8219 #line 2632 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8220 { 8221 #ifdef AMD_EXTENSIONS 8222 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); 8223 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8224 (yyval.interm.type).basicType = EbtSampler; 8225 (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd3D); 8226 #endif 8227 } 8228 #line 8229 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8229 break; 8230 8231 case 387: 8232 #line 2640 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8233 { 8234 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8235 (yyval.interm.type).basicType = EbtSampler; 8236 (yyval.interm.type).sampler.setTexture(EbtFloat, EsdCube); 8237 } 8238 #line 8239 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8239 break; 8240 8241 case 388: 8242 #line 2645 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8243 { 8244 #ifdef AMD_EXTENSIONS 8245 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); 8246 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8247 (yyval.interm.type).basicType = EbtSampler; 8248 (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdCube); 8249 #endif 8250 } 8251 #line 8252 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8252 break; 8253 8254 case 389: 8255 #line 2653 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8256 { 8257 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8258 (yyval.interm.type).basicType = EbtSampler; 8259 (yyval.interm.type).sampler.setTexture(EbtFloat, Esd1D, true); 8260 } 8261 #line 8262 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8262 break; 8263 8264 case 390: 8265 #line 2658 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8266 { 8267 #ifdef AMD_EXTENSIONS 8268 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); 8269 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8270 (yyval.interm.type).basicType = EbtSampler; 8271 (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd1D, true); 8272 #endif 8273 } 8274 #line 8275 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8275 break; 8276 8277 case 391: 8278 #line 2666 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8279 { 8280 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8281 (yyval.interm.type).basicType = EbtSampler; 8282 (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, true); 8283 } 8284 #line 8285 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8285 break; 8286 8287 case 392: 8288 #line 2671 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8289 { 8290 #ifdef AMD_EXTENSIONS 8291 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); 8292 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8293 (yyval.interm.type).basicType = EbtSampler; 8294 (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, true); 8295 #endif 8296 } 8297 #line 8298 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8298 break; 8299 8300 case 393: 8301 #line 2679 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8302 { 8303 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8304 (yyval.interm.type).basicType = EbtSampler; 8305 (yyval.interm.type).sampler.setTexture(EbtFloat, EsdCube, true); 8306 } 8307 #line 8308 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8308 break; 8309 8310 case 394: 8311 #line 2684 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8312 { 8313 #ifdef AMD_EXTENSIONS 8314 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); 8315 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8316 (yyval.interm.type).basicType = EbtSampler; 8317 (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdCube, true); 8318 #endif 8319 } 8320 #line 8321 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8321 break; 8322 8323 case 395: 8324 #line 2692 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8325 { 8326 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8327 (yyval.interm.type).basicType = EbtSampler; 8328 (yyval.interm.type).sampler.setTexture(EbtInt, Esd1D); 8329 } 8330 #line 8331 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8331 break; 8332 8333 case 396: 8334 #line 2697 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8335 { 8336 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8337 (yyval.interm.type).basicType = EbtSampler; 8338 (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D); 8339 } 8340 #line 8341 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8341 break; 8342 8343 case 397: 8344 #line 2702 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8345 { 8346 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8347 (yyval.interm.type).basicType = EbtSampler; 8348 (yyval.interm.type).sampler.setTexture(EbtInt, Esd3D); 8349 } 8350 #line 8351 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8351 break; 8352 8353 case 398: 8354 #line 2707 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8355 { 8356 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8357 (yyval.interm.type).basicType = EbtSampler; 8358 (yyval.interm.type).sampler.setTexture(EbtInt, EsdCube); 8359 } 8360 #line 8361 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8361 break; 8362 8363 case 399: 8364 #line 2712 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8365 { 8366 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8367 (yyval.interm.type).basicType = EbtSampler; 8368 (yyval.interm.type).sampler.setTexture(EbtInt, Esd1D, true); 8369 } 8370 #line 8371 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8371 break; 8372 8373 case 400: 8374 #line 2717 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8375 { 8376 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8377 (yyval.interm.type).basicType = EbtSampler; 8378 (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, true); 8379 } 8380 #line 8381 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8381 break; 8382 8383 case 401: 8384 #line 2722 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8385 { 8386 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8387 (yyval.interm.type).basicType = EbtSampler; 8388 (yyval.interm.type).sampler.setTexture(EbtInt, EsdCube, true); 8389 } 8390 #line 8391 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8391 break; 8392 8393 case 402: 8394 #line 2727 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8395 { 8396 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8397 (yyval.interm.type).basicType = EbtSampler; 8398 (yyval.interm.type).sampler.setTexture(EbtUint, Esd1D); 8399 } 8400 #line 8401 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8401 break; 8402 8403 case 403: 8404 #line 2732 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8405 { 8406 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8407 (yyval.interm.type).basicType = EbtSampler; 8408 (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D); 8409 } 8410 #line 8411 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8411 break; 8412 8413 case 404: 8414 #line 2737 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8415 { 8416 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8417 (yyval.interm.type).basicType = EbtSampler; 8418 (yyval.interm.type).sampler.setTexture(EbtUint, Esd3D); 8419 } 8420 #line 8421 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8421 break; 8422 8423 case 405: 8424 #line 2742 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8425 { 8426 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8427 (yyval.interm.type).basicType = EbtSampler; 8428 (yyval.interm.type).sampler.setTexture(EbtUint, EsdCube); 8429 } 8430 #line 8431 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8431 break; 8432 8433 case 406: 8434 #line 2747 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8435 { 8436 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8437 (yyval.interm.type).basicType = EbtSampler; 8438 (yyval.interm.type).sampler.setTexture(EbtUint, Esd1D, true); 8439 } 8440 #line 8441 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8441 break; 8442 8443 case 407: 8444 #line 2752 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8445 { 8446 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8447 (yyval.interm.type).basicType = EbtSampler; 8448 (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, true); 8449 } 8450 #line 8451 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8451 break; 8452 8453 case 408: 8454 #line 2757 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8455 { 8456 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8457 (yyval.interm.type).basicType = EbtSampler; 8458 (yyval.interm.type).sampler.setTexture(EbtUint, EsdCube, true); 8459 } 8460 #line 8461 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8461 break; 8462 8463 case 409: 8464 #line 2762 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8465 { 8466 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8467 (yyval.interm.type).basicType = EbtSampler; 8468 (yyval.interm.type).sampler.setTexture(EbtFloat, EsdRect); 8469 } 8470 #line 8471 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8471 break; 8472 8473 case 410: 8474 #line 2767 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8475 { 8476 #ifdef AMD_EXTENSIONS 8477 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); 8478 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8479 (yyval.interm.type).basicType = EbtSampler; 8480 (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdRect); 8481 #endif 8482 } 8483 #line 8484 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8484 break; 8485 8486 case 411: 8487 #line 2775 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8488 { 8489 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8490 (yyval.interm.type).basicType = EbtSampler; 8491 (yyval.interm.type).sampler.setTexture(EbtInt, EsdRect); 8492 } 8493 #line 8494 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8494 break; 8495 8496 case 412: 8497 #line 2780 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8498 { 8499 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8500 (yyval.interm.type).basicType = EbtSampler; 8501 (yyval.interm.type).sampler.setTexture(EbtUint, EsdRect); 8502 } 8503 #line 8504 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8504 break; 8505 8506 case 413: 8507 #line 2785 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8508 { 8509 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8510 (yyval.interm.type).basicType = EbtSampler; 8511 (yyval.interm.type).sampler.setTexture(EbtFloat, EsdBuffer); 8512 } 8513 #line 8514 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8514 break; 8515 8516 case 414: 8517 #line 2790 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8518 { 8519 #ifdef AMD_EXTENSIONS 8520 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); 8521 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8522 (yyval.interm.type).basicType = EbtSampler; 8523 (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdBuffer); 8524 #endif 8525 } 8526 #line 8527 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8527 break; 8528 8529 case 415: 8530 #line 2798 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8531 { 8532 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8533 (yyval.interm.type).basicType = EbtSampler; 8534 (yyval.interm.type).sampler.setTexture(EbtInt, EsdBuffer); 8535 } 8536 #line 8537 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8537 break; 8538 8539 case 416: 8540 #line 2803 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8541 { 8542 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8543 (yyval.interm.type).basicType = EbtSampler; 8544 (yyval.interm.type).sampler.setTexture(EbtUint, EsdBuffer); 8545 } 8546 #line 8547 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8547 break; 8548 8549 case 417: 8550 #line 2808 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8551 { 8552 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8553 (yyval.interm.type).basicType = EbtSampler; 8554 (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, false, false, true); 8555 } 8556 #line 8557 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8557 break; 8558 8559 case 418: 8560 #line 2813 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8561 { 8562 #ifdef AMD_EXTENSIONS 8563 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); 8564 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8565 (yyval.interm.type).basicType = EbtSampler; 8566 (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, false, false, true); 8567 #endif 8568 } 8569 #line 8570 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8570 break; 8571 8572 case 419: 8573 #line 2821 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8574 { 8575 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8576 (yyval.interm.type).basicType = EbtSampler; 8577 (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, false, false, true); 8578 } 8579 #line 8580 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8580 break; 8581 8582 case 420: 8583 #line 2826 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8584 { 8585 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8586 (yyval.interm.type).basicType = EbtSampler; 8587 (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, false, false, true); 8588 } 8589 #line 8590 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8590 break; 8591 8592 case 421: 8593 #line 2831 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8594 { 8595 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8596 (yyval.interm.type).basicType = EbtSampler; 8597 (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, true, false, true); 8598 } 8599 #line 8600 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8600 break; 8601 8602 case 422: 8603 #line 2836 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8604 { 8605 #ifdef AMD_EXTENSIONS 8606 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); 8607 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8608 (yyval.interm.type).basicType = EbtSampler; 8609 (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, true, false, true); 8610 #endif 8611 } 8612 #line 8613 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8613 break; 8614 8615 case 423: 8616 #line 2844 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8617 { 8618 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8619 (yyval.interm.type).basicType = EbtSampler; 8620 (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, true, false, true); 8621 } 8622 #line 8623 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8623 break; 8624 8625 case 424: 8626 #line 2849 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8627 { 8628 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8629 (yyval.interm.type).basicType = EbtSampler; 8630 (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, true, false, true); 8631 } 8632 #line 8633 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8633 break; 8634 8635 case 425: 8636 #line 2854 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8637 { 8638 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8639 (yyval.interm.type).basicType = EbtSampler; 8640 (yyval.interm.type).sampler.setImage(EbtFloat, Esd1D); 8641 } 8642 #line 8643 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8643 break; 8644 8645 case 426: 8646 #line 2859 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8647 { 8648 #ifdef AMD_EXTENSIONS 8649 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); 8650 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8651 (yyval.interm.type).basicType = EbtSampler; 8652 (yyval.interm.type).sampler.setImage(EbtFloat16, Esd1D); 8653 #endif 8654 } 8655 #line 8656 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8656 break; 8657 8658 case 427: 8659 #line 2867 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8660 { 8661 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8662 (yyval.interm.type).basicType = EbtSampler; 8663 (yyval.interm.type).sampler.setImage(EbtInt, Esd1D); 8664 } 8665 #line 8666 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8666 break; 8667 8668 case 428: 8669 #line 2872 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8670 { 8671 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8672 (yyval.interm.type).basicType = EbtSampler; 8673 (yyval.interm.type).sampler.setImage(EbtUint, Esd1D); 8674 } 8675 #line 8676 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8676 break; 8677 8678 case 429: 8679 #line 2877 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8680 { 8681 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8682 (yyval.interm.type).basicType = EbtSampler; 8683 (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D); 8684 } 8685 #line 8686 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8686 break; 8687 8688 case 430: 8689 #line 2882 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8690 { 8691 #ifdef AMD_EXTENSIONS 8692 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); 8693 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8694 (yyval.interm.type).basicType = EbtSampler; 8695 (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D); 8696 #endif 8697 } 8698 #line 8699 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8699 break; 8700 8701 case 431: 8702 #line 2890 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8703 { 8704 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8705 (yyval.interm.type).basicType = EbtSampler; 8706 (yyval.interm.type).sampler.setImage(EbtInt, Esd2D); 8707 } 8708 #line 8709 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8709 break; 8710 8711 case 432: 8712 #line 2895 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8713 { 8714 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8715 (yyval.interm.type).basicType = EbtSampler; 8716 (yyval.interm.type).sampler.setImage(EbtUint, Esd2D); 8717 } 8718 #line 8719 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8719 break; 8720 8721 case 433: 8722 #line 2900 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8723 { 8724 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8725 (yyval.interm.type).basicType = EbtSampler; 8726 (yyval.interm.type).sampler.setImage(EbtFloat, Esd3D); 8727 } 8728 #line 8729 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8729 break; 8730 8731 case 434: 8732 #line 2905 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8733 { 8734 #ifdef AMD_EXTENSIONS 8735 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); 8736 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8737 (yyval.interm.type).basicType = EbtSampler; 8738 (yyval.interm.type).sampler.setImage(EbtFloat16, Esd3D); 8739 #endif 8740 } 8741 #line 8742 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8742 break; 8743 8744 case 435: 8745 #line 2913 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8746 { 8747 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8748 (yyval.interm.type).basicType = EbtSampler; 8749 (yyval.interm.type).sampler.setImage(EbtInt, Esd3D); 8750 } 8751 #line 8752 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8752 break; 8753 8754 case 436: 8755 #line 2918 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8756 { 8757 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8758 (yyval.interm.type).basicType = EbtSampler; 8759 (yyval.interm.type).sampler.setImage(EbtUint, Esd3D); 8760 } 8761 #line 8762 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8762 break; 8763 8764 case 437: 8765 #line 2923 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8766 { 8767 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8768 (yyval.interm.type).basicType = EbtSampler; 8769 (yyval.interm.type).sampler.setImage(EbtFloat, EsdRect); 8770 } 8771 #line 8772 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8772 break; 8773 8774 case 438: 8775 #line 2928 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8776 { 8777 #ifdef AMD_EXTENSIONS 8778 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); 8779 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8780 (yyval.interm.type).basicType = EbtSampler; 8781 (yyval.interm.type).sampler.setImage(EbtFloat16, EsdRect); 8782 #endif 8783 } 8784 #line 8785 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8785 break; 8786 8787 case 439: 8788 #line 2936 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8789 { 8790 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8791 (yyval.interm.type).basicType = EbtSampler; 8792 (yyval.interm.type).sampler.setImage(EbtInt, EsdRect); 8793 } 8794 #line 8795 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8795 break; 8796 8797 case 440: 8798 #line 2941 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8799 { 8800 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8801 (yyval.interm.type).basicType = EbtSampler; 8802 (yyval.interm.type).sampler.setImage(EbtUint, EsdRect); 8803 } 8804 #line 8805 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8805 break; 8806 8807 case 441: 8808 #line 2946 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8809 { 8810 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8811 (yyval.interm.type).basicType = EbtSampler; 8812 (yyval.interm.type).sampler.setImage(EbtFloat, EsdCube); 8813 } 8814 #line 8815 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8815 break; 8816 8817 case 442: 8818 #line 2951 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8819 { 8820 #ifdef AMD_EXTENSIONS 8821 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); 8822 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8823 (yyval.interm.type).basicType = EbtSampler; 8824 (yyval.interm.type).sampler.setImage(EbtFloat16, EsdCube); 8825 #endif 8826 } 8827 #line 8828 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8828 break; 8829 8830 case 443: 8831 #line 2959 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8832 { 8833 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8834 (yyval.interm.type).basicType = EbtSampler; 8835 (yyval.interm.type).sampler.setImage(EbtInt, EsdCube); 8836 } 8837 #line 8838 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8838 break; 8839 8840 case 444: 8841 #line 2964 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8842 { 8843 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8844 (yyval.interm.type).basicType = EbtSampler; 8845 (yyval.interm.type).sampler.setImage(EbtUint, EsdCube); 8846 } 8847 #line 8848 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8848 break; 8849 8850 case 445: 8851 #line 2969 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8852 { 8853 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8854 (yyval.interm.type).basicType = EbtSampler; 8855 (yyval.interm.type).sampler.setImage(EbtFloat, EsdBuffer); 8856 } 8857 #line 8858 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8858 break; 8859 8860 case 446: 8861 #line 2974 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8862 { 8863 #ifdef AMD_EXTENSIONS 8864 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); 8865 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8866 (yyval.interm.type).basicType = EbtSampler; 8867 (yyval.interm.type).sampler.setImage(EbtFloat16, EsdBuffer); 8868 #endif 8869 } 8870 #line 8871 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8871 break; 8872 8873 case 447: 8874 #line 2982 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8875 { 8876 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8877 (yyval.interm.type).basicType = EbtSampler; 8878 (yyval.interm.type).sampler.setImage(EbtInt, EsdBuffer); 8879 } 8880 #line 8881 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8881 break; 8882 8883 case 448: 8884 #line 2987 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8885 { 8886 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8887 (yyval.interm.type).basicType = EbtSampler; 8888 (yyval.interm.type).sampler.setImage(EbtUint, EsdBuffer); 8889 } 8890 #line 8891 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8891 break; 8892 8893 case 449: 8894 #line 2992 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8895 { 8896 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8897 (yyval.interm.type).basicType = EbtSampler; 8898 (yyval.interm.type).sampler.setImage(EbtFloat, Esd1D, true); 8899 } 8900 #line 8901 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8901 break; 8902 8903 case 450: 8904 #line 2997 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8905 { 8906 #ifdef AMD_EXTENSIONS 8907 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); 8908 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8909 (yyval.interm.type).basicType = EbtSampler; 8910 (yyval.interm.type).sampler.setImage(EbtFloat16, Esd1D, true); 8911 #endif 8912 } 8913 #line 8914 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8914 break; 8915 8916 case 451: 8917 #line 3005 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8918 { 8919 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8920 (yyval.interm.type).basicType = EbtSampler; 8921 (yyval.interm.type).sampler.setImage(EbtInt, Esd1D, true); 8922 } 8923 #line 8924 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8924 break; 8925 8926 case 452: 8927 #line 3010 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8928 { 8929 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8930 (yyval.interm.type).basicType = EbtSampler; 8931 (yyval.interm.type).sampler.setImage(EbtUint, Esd1D, true); 8932 } 8933 #line 8934 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8934 break; 8935 8936 case 453: 8937 #line 3015 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8938 { 8939 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8940 (yyval.interm.type).basicType = EbtSampler; 8941 (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, true); 8942 } 8943 #line 8944 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8944 break; 8945 8946 case 454: 8947 #line 3020 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8948 { 8949 #ifdef AMD_EXTENSIONS 8950 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); 8951 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8952 (yyval.interm.type).basicType = EbtSampler; 8953 (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, true); 8954 #endif 8955 } 8956 #line 8957 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8957 break; 8958 8959 case 455: 8960 #line 3028 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8961 { 8962 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8963 (yyval.interm.type).basicType = EbtSampler; 8964 (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, true); 8965 } 8966 #line 8967 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8967 break; 8968 8969 case 456: 8970 #line 3033 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8971 { 8972 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8973 (yyval.interm.type).basicType = EbtSampler; 8974 (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, true); 8975 } 8976 #line 8977 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8977 break; 8978 8979 case 457: 8980 #line 3038 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8981 { 8982 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8983 (yyval.interm.type).basicType = EbtSampler; 8984 (yyval.interm.type).sampler.setImage(EbtFloat, EsdCube, true); 8985 } 8986 #line 8987 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 8987 break; 8988 8989 case 458: 8990 #line 3043 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 8991 { 8992 #ifdef AMD_EXTENSIONS 8993 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); 8994 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 8995 (yyval.interm.type).basicType = EbtSampler; 8996 (yyval.interm.type).sampler.setImage(EbtFloat16, EsdCube, true); 8997 #endif 8998 } 8999 #line 9000 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9000 break; 9001 9002 case 459: 9003 #line 3051 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9004 { 9005 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 9006 (yyval.interm.type).basicType = EbtSampler; 9007 (yyval.interm.type).sampler.setImage(EbtInt, EsdCube, true); 9008 } 9009 #line 9010 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9010 break; 9011 9012 case 460: 9013 #line 3056 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9014 { 9015 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 9016 (yyval.interm.type).basicType = EbtSampler; 9017 (yyval.interm.type).sampler.setImage(EbtUint, EsdCube, true); 9018 } 9019 #line 9020 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9020 break; 9021 9022 case 461: 9023 #line 3061 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9024 { 9025 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 9026 (yyval.interm.type).basicType = EbtSampler; 9027 (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, false, false, true); 9028 } 9029 #line 9030 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9030 break; 9031 9032 case 462: 9033 #line 3066 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9034 { 9035 #ifdef AMD_EXTENSIONS 9036 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); 9037 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 9038 (yyval.interm.type).basicType = EbtSampler; 9039 (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, false, false, true); 9040 #endif 9041 } 9042 #line 9043 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9043 break; 9044 9045 case 463: 9046 #line 3074 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9047 { 9048 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 9049 (yyval.interm.type).basicType = EbtSampler; 9050 (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, false, false, true); 9051 } 9052 #line 9053 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9053 break; 9054 9055 case 464: 9056 #line 3079 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9057 { 9058 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 9059 (yyval.interm.type).basicType = EbtSampler; 9060 (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, false, false, true); 9061 } 9062 #line 9063 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9063 break; 9064 9065 case 465: 9066 #line 3084 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9067 { 9068 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 9069 (yyval.interm.type).basicType = EbtSampler; 9070 (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, true, false, true); 9071 } 9072 #line 9073 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9073 break; 9074 9075 case 466: 9076 #line 3089 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9077 { 9078 #ifdef AMD_EXTENSIONS 9079 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); 9080 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 9081 (yyval.interm.type).basicType = EbtSampler; 9082 (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, true, false, true); 9083 #endif 9084 } 9085 #line 9086 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9086 break; 9087 9088 case 467: 9089 #line 3097 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9090 { 9091 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 9092 (yyval.interm.type).basicType = EbtSampler; 9093 (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, true, false, true); 9094 } 9095 #line 9096 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9096 break; 9097 9098 case 468: 9099 #line 3102 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9100 { 9101 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 9102 (yyval.interm.type).basicType = EbtSampler; 9103 (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, true, false, true); 9104 } 9105 #line 9106 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9106 break; 9107 9108 case 469: 9109 #line 3107 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9110 { // GL_OES_EGL_image_external 9111 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 9112 (yyval.interm.type).basicType = EbtSampler; 9113 (yyval.interm.type).sampler.set(EbtFloat, Esd2D); 9114 (yyval.interm.type).sampler.external = true; 9115 } 9116 #line 9117 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9117 break; 9118 9119 case 470: 9120 #line 3113 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9121 { 9122 parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); 9123 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 9124 (yyval.interm.type).basicType = EbtSampler; 9125 (yyval.interm.type).sampler.setSubpass(EbtFloat); 9126 } 9127 #line 9128 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9128 break; 9129 9130 case 471: 9131 #line 3119 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9132 { 9133 parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); 9134 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 9135 (yyval.interm.type).basicType = EbtSampler; 9136 (yyval.interm.type).sampler.setSubpass(EbtFloat, true); 9137 } 9138 #line 9139 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9139 break; 9140 9141 case 472: 9142 #line 3125 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9143 { 9144 #ifdef AMD_EXTENSIONS 9145 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel()); 9146 parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); 9147 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 9148 (yyval.interm.type).basicType = EbtSampler; 9149 (yyval.interm.type).sampler.setSubpass(EbtFloat16); 9150 #endif 9151 } 9152 #line 9153 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9153 break; 9154 9155 case 473: 9156 #line 3134 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9157 { 9158 #ifdef AMD_EXTENSIONS 9159 parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel()); 9160 parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); 9161 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 9162 (yyval.interm.type).basicType = EbtSampler; 9163 (yyval.interm.type).sampler.setSubpass(EbtFloat16, true); 9164 #endif 9165 } 9166 #line 9167 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9167 break; 9168 9169 case 474: 9170 #line 3143 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9171 { 9172 parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); 9173 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 9174 (yyval.interm.type).basicType = EbtSampler; 9175 (yyval.interm.type).sampler.setSubpass(EbtInt); 9176 } 9177 #line 9178 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9178 break; 9179 9180 case 475: 9181 #line 3149 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9182 { 9183 parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); 9184 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 9185 (yyval.interm.type).basicType = EbtSampler; 9186 (yyval.interm.type).sampler.setSubpass(EbtInt, true); 9187 } 9188 #line 9189 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9189 break; 9190 9191 case 476: 9192 #line 3155 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9193 { 9194 parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); 9195 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 9196 (yyval.interm.type).basicType = EbtSampler; 9197 (yyval.interm.type).sampler.setSubpass(EbtUint); 9198 } 9199 #line 9200 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9200 break; 9201 9202 case 477: 9203 #line 3161 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9204 { 9205 parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); 9206 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 9207 (yyval.interm.type).basicType = EbtSampler; 9208 (yyval.interm.type).sampler.setSubpass(EbtUint, true); 9209 } 9210 #line 9211 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9211 break; 9212 9213 case 478: 9214 #line 3167 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9215 { 9216 (yyval.interm.type) = (yyvsp[0].interm.type); 9217 (yyval.interm.type).qualifier.storage = parseContext.symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary; 9218 parseContext.structTypeCheck((yyval.interm.type).loc, (yyval.interm.type)); 9219 } 9220 #line 9221 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9221 break; 9222 9223 case 479: 9224 #line 3172 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9225 { 9226 // 9227 // This is for user defined type names. The lexical phase looked up the 9228 // type. 9229 // 9230 if (const TVariable* variable = ((yyvsp[0].lex).symbol)->getAsVariable()) { 9231 const TType& structure = variable->getType(); 9232 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 9233 (yyval.interm.type).basicType = EbtStruct; 9234 (yyval.interm.type).userDef = &structure; 9235 } else 9236 parseContext.error((yyvsp[0].lex).loc, "expected type name", (yyvsp[0].lex).string->c_str(), ""); 9237 } 9238 #line 9239 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9239 break; 9240 9241 case 480: 9242 #line 3188 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9243 { 9244 parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "highp precision qualifier"); 9245 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 9246 parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqHigh); 9247 } 9248 #line 9249 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9249 break; 9250 9251 case 481: 9252 #line 3193 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9253 { 9254 parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "mediump precision qualifier"); 9255 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 9256 parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqMedium); 9257 } 9258 #line 9259 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9259 break; 9260 9261 case 482: 9262 #line 3198 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9263 { 9264 parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "lowp precision qualifier"); 9265 (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); 9266 parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqLow); 9267 } 9268 #line 9269 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9269 break; 9270 9271 case 483: 9272 #line 3206 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9273 { parseContext.nestedStructCheck((yyvsp[-2].lex).loc); } 9274 #line 9275 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9275 break; 9276 9277 case 484: 9278 #line 3206 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9279 { 9280 TType* structure = new TType((yyvsp[-1].interm.typeList), *(yyvsp[-4].lex).string); 9281 parseContext.structArrayCheck((yyvsp[-4].lex).loc, *structure); 9282 TVariable* userTypeDef = new TVariable((yyvsp[-4].lex).string, *structure, true); 9283 if (! parseContext.symbolTable.insert(*userTypeDef)) 9284 parseContext.error((yyvsp[-4].lex).loc, "redefinition", (yyvsp[-4].lex).string->c_str(), "struct"); 9285 (yyval.interm.type).init((yyvsp[-5].lex).loc); 9286 (yyval.interm.type).basicType = EbtStruct; 9287 (yyval.interm.type).userDef = structure; 9288 --parseContext.structNestingLevel; 9289 } 9290 #line 9291 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9291 break; 9292 9293 case 485: 9294 #line 3217 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9295 { parseContext.nestedStructCheck((yyvsp[-1].lex).loc); } 9296 #line 9297 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9297 break; 9298 9299 case 486: 9300 #line 3217 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9301 { 9302 TType* structure = new TType((yyvsp[-1].interm.typeList), TString("")); 9303 (yyval.interm.type).init((yyvsp[-4].lex).loc); 9304 (yyval.interm.type).basicType = EbtStruct; 9305 (yyval.interm.type).userDef = structure; 9306 --parseContext.structNestingLevel; 9307 } 9308 #line 9309 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9309 break; 9310 9311 case 487: 9312 #line 3227 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9313 { 9314 (yyval.interm.typeList) = (yyvsp[0].interm.typeList); 9315 } 9316 #line 9317 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9317 break; 9318 9319 case 488: 9320 #line 3230 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9321 { 9322 (yyval.interm.typeList) = (yyvsp[-1].interm.typeList); 9323 for (unsigned int i = 0; i < (yyvsp[0].interm.typeList)->size(); ++i) { 9324 for (unsigned int j = 0; j < (yyval.interm.typeList)->size(); ++j) { 9325 if ((*(yyval.interm.typeList))[j].type->getFieldName() == (*(yyvsp[0].interm.typeList))[i].type->getFieldName()) 9326 parseContext.error((*(yyvsp[0].interm.typeList))[i].loc, "duplicate member name:", "", (*(yyvsp[0].interm.typeList))[i].type->getFieldName().c_str()); 9327 } 9328 (yyval.interm.typeList)->push_back((*(yyvsp[0].interm.typeList))[i]); 9329 } 9330 } 9331 #line 9332 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9332 break; 9333 9334 case 489: 9335 #line 3243 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9336 { 9337 if ((yyvsp[-2].interm.type).arraySizes) { 9338 parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); 9339 parseContext.profileRequires((yyvsp[-2].interm.type).loc, EEsProfile, 300, 0, "arrayed type"); 9340 if (parseContext.profile == EEsProfile) 9341 parseContext.arraySizeRequiredCheck((yyvsp[-2].interm.type).loc, *(yyvsp[-2].interm.type).arraySizes); 9342 } 9343 9344 (yyval.interm.typeList) = (yyvsp[-1].interm.typeList); 9345 9346 parseContext.voidErrorCheck((yyvsp[-2].interm.type).loc, (*(yyvsp[-1].interm.typeList))[0].type->getFieldName(), (yyvsp[-2].interm.type).basicType); 9347 parseContext.precisionQualifierCheck((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).basicType, (yyvsp[-2].interm.type).qualifier); 9348 9349 for (unsigned int i = 0; i < (yyval.interm.typeList)->size(); ++i) { 9350 TType type((yyvsp[-2].interm.type)); 9351 type.setFieldName((*(yyval.interm.typeList))[i].type->getFieldName()); 9352 type.transferArraySizes((*(yyval.interm.typeList))[i].type->getArraySizes()); 9353 type.copyArrayInnerSizes((yyvsp[-2].interm.type).arraySizes); 9354 parseContext.arrayOfArrayVersionCheck((*(yyval.interm.typeList))[i].loc, type.getArraySizes()); 9355 (*(yyval.interm.typeList))[i].type->shallowCopy(type); 9356 } 9357 } 9358 #line 9359 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9359 break; 9360 9361 case 490: 9362 #line 3265 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9363 { 9364 if ((yyvsp[-2].interm.type).arraySizes) { 9365 parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); 9366 parseContext.profileRequires((yyvsp[-2].interm.type).loc, EEsProfile, 300, 0, "arrayed type"); 9367 if (parseContext.profile == EEsProfile) 9368 parseContext.arraySizeRequiredCheck((yyvsp[-2].interm.type).loc, *(yyvsp[-2].interm.type).arraySizes); 9369 } 9370 9371 (yyval.interm.typeList) = (yyvsp[-1].interm.typeList); 9372 9373 parseContext.memberQualifierCheck((yyvsp[-3].interm.type)); 9374 parseContext.voidErrorCheck((yyvsp[-2].interm.type).loc, (*(yyvsp[-1].interm.typeList))[0].type->getFieldName(), (yyvsp[-2].interm.type).basicType); 9375 parseContext.mergeQualifiers((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).qualifier, (yyvsp[-3].interm.type).qualifier, true); 9376 parseContext.precisionQualifierCheck((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).basicType, (yyvsp[-2].interm.type).qualifier); 9377 9378 for (unsigned int i = 0; i < (yyval.interm.typeList)->size(); ++i) { 9379 TType type((yyvsp[-2].interm.type)); 9380 type.setFieldName((*(yyval.interm.typeList))[i].type->getFieldName()); 9381 type.transferArraySizes((*(yyval.interm.typeList))[i].type->getArraySizes()); 9382 type.copyArrayInnerSizes((yyvsp[-2].interm.type).arraySizes); 9383 parseContext.arrayOfArrayVersionCheck((*(yyval.interm.typeList))[i].loc, type.getArraySizes()); 9384 (*(yyval.interm.typeList))[i].type->shallowCopy(type); 9385 } 9386 } 9387 #line 9388 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9388 break; 9389 9390 case 491: 9391 #line 3292 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9392 { 9393 (yyval.interm.typeList) = new TTypeList; 9394 (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine)); 9395 } 9396 #line 9397 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9397 break; 9398 9399 case 492: 9400 #line 3296 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9401 { 9402 (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine)); 9403 } 9404 #line 9405 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9405 break; 9406 9407 case 493: 9408 #line 3302 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9409 { 9410 (yyval.interm.typeLine).type = new TType(EbtVoid); 9411 (yyval.interm.typeLine).loc = (yyvsp[0].lex).loc; 9412 (yyval.interm.typeLine).type->setFieldName(*(yyvsp[0].lex).string); 9413 } 9414 #line 9415 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9415 break; 9416 9417 case 494: 9418 #line 3307 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9419 { 9420 parseContext.arrayOfArrayVersionCheck((yyvsp[-1].lex).loc, (yyvsp[0].interm).arraySizes); 9421 9422 (yyval.interm.typeLine).type = new TType(EbtVoid); 9423 (yyval.interm.typeLine).loc = (yyvsp[-1].lex).loc; 9424 (yyval.interm.typeLine).type->setFieldName(*(yyvsp[-1].lex).string); 9425 (yyval.interm.typeLine).type->transferArraySizes((yyvsp[0].interm).arraySizes); 9426 } 9427 #line 9428 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9428 break; 9429 9430 case 495: 9431 #line 3318 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9432 { 9433 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); 9434 } 9435 #line 9436 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9436 break; 9437 9438 case 496: 9439 #line 3321 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9440 { 9441 const char* initFeature = "{ } style initializers"; 9442 parseContext.requireProfile((yyvsp[-2].lex).loc, ~EEsProfile, initFeature); 9443 parseContext.profileRequires((yyvsp[-2].lex).loc, ~EEsProfile, 420, E_GL_ARB_shading_language_420pack, initFeature); 9444 (yyval.interm.intermTypedNode) = (yyvsp[-1].interm.intermTypedNode); 9445 } 9446 #line 9447 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9447 break; 9448 9449 case 497: 9450 #line 3327 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9451 { 9452 const char* initFeature = "{ } style initializers"; 9453 parseContext.requireProfile((yyvsp[-3].lex).loc, ~EEsProfile, initFeature); 9454 parseContext.profileRequires((yyvsp[-3].lex).loc, ~EEsProfile, 420, E_GL_ARB_shading_language_420pack, initFeature); 9455 (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); 9456 } 9457 #line 9458 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9458 break; 9459 9460 case 498: 9461 #line 3336 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9462 { 9463 (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate(0, (yyvsp[0].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)->getLoc()); 9464 } 9465 #line 9466 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9466 break; 9467 9468 case 499: 9469 #line 3339 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9470 { 9471 (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); 9472 } 9473 #line 9474 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9474 break; 9475 9476 case 500: 9477 #line 3345 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9478 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } 9479 #line 9480 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9480 break; 9481 9482 case 501: 9483 #line 3349 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9484 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } 9485 #line 9486 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9486 break; 9487 9488 case 502: 9489 #line 3350 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9490 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } 9491 #line 9492 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9492 break; 9493 9494 case 503: 9495 #line 3356 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9496 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } 9497 #line 9498 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9498 break; 9499 9500 case 504: 9501 #line 3357 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9502 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } 9503 #line 9504 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9504 break; 9505 9506 case 505: 9507 #line 3358 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9508 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } 9509 #line 9510 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9510 break; 9511 9512 case 506: 9513 #line 3359 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9514 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } 9515 #line 9516 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9516 break; 9517 9518 case 507: 9519 #line 3360 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9520 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } 9521 #line 9522 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9522 break; 9523 9524 case 508: 9525 #line 3361 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9526 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } 9527 #line 9528 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9528 break; 9529 9530 case 509: 9531 #line 3362 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9532 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } 9533 #line 9534 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9534 break; 9535 9536 case 510: 9537 #line 3366 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9538 { (yyval.interm.intermNode) = 0; } 9539 #line 9540 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9540 break; 9541 9542 case 511: 9543 #line 3367 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9544 { 9545 parseContext.symbolTable.push(); 9546 ++parseContext.statementNestingLevel; 9547 } 9548 #line 9549 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9549 break; 9550 9551 case 512: 9552 #line 3371 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9553 { 9554 parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); 9555 --parseContext.statementNestingLevel; 9556 } 9557 #line 9558 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9558 break; 9559 9560 case 513: 9561 #line 3375 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9562 { 9563 if ((yyvsp[-2].interm.intermNode) && (yyvsp[-2].interm.intermNode)->getAsAggregate()) 9564 (yyvsp[-2].interm.intermNode)->getAsAggregate()->setOperator(EOpSequence); 9565 (yyval.interm.intermNode) = (yyvsp[-2].interm.intermNode); 9566 } 9567 #line 9568 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9568 break; 9569 9570 case 514: 9571 #line 3383 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9572 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } 9573 #line 9574 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9574 break; 9575 9576 case 515: 9577 #line 3384 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9578 { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } 9579 #line 9580 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9580 break; 9581 9582 case 516: 9583 #line 3388 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9584 { 9585 ++parseContext.controlFlowNestingLevel; 9586 } 9587 #line 9588 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9588 break; 9589 9590 case 517: 9591 #line 3391 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9592 { 9593 --parseContext.controlFlowNestingLevel; 9594 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); 9595 } 9596 #line 9597 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9597 break; 9598 9599 case 518: 9600 #line 3395 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9601 { 9602 parseContext.symbolTable.push(); 9603 ++parseContext.statementNestingLevel; 9604 ++parseContext.controlFlowNestingLevel; 9605 } 9606 #line 9607 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9607 break; 9608 9609 case 519: 9610 #line 3400 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9611 { 9612 parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); 9613 --parseContext.statementNestingLevel; 9614 --parseContext.controlFlowNestingLevel; 9615 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); 9616 } 9617 #line 9618 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9618 break; 9619 9620 case 520: 9621 #line 3409 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9622 { 9623 (yyval.interm.intermNode) = 0; 9624 } 9625 #line 9626 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9626 break; 9627 9628 case 521: 9629 #line 3412 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9630 { 9631 if ((yyvsp[-1].interm.intermNode) && (yyvsp[-1].interm.intermNode)->getAsAggregate()) 9632 (yyvsp[-1].interm.intermNode)->getAsAggregate()->setOperator(EOpSequence); 9633 (yyval.interm.intermNode) = (yyvsp[-1].interm.intermNode); 9634 } 9635 #line 9636 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9636 break; 9637 9638 case 522: 9639 #line 3420 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9640 { 9641 (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermNode)); 9642 if ((yyvsp[0].interm.intermNode) && (yyvsp[0].interm.intermNode)->getAsBranchNode() && ((yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpCase || 9643 (yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpDefault)) { 9644 parseContext.wrapupSwitchSubsequence(0, (yyvsp[0].interm.intermNode)); 9645 (yyval.interm.intermNode) = 0; // start a fresh subsequence for what's after this case 9646 } 9647 } 9648 #line 9649 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9649 break; 9650 9651 case 523: 9652 #line 3428 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9653 { 9654 if ((yyvsp[0].interm.intermNode) && (yyvsp[0].interm.intermNode)->getAsBranchNode() && ((yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpCase || 9655 (yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpDefault)) { 9656 parseContext.wrapupSwitchSubsequence((yyvsp[-1].interm.intermNode) ? (yyvsp[-1].interm.intermNode)->getAsAggregate() : 0, (yyvsp[0].interm.intermNode)); 9657 (yyval.interm.intermNode) = 0; // start a fresh subsequence for what's after this case 9658 } else 9659 (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode)); 9660 } 9661 #line 9662 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9662 break; 9663 9664 case 524: 9665 #line 3439 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9666 { (yyval.interm.intermNode) = 0; } 9667 #line 9668 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9668 break; 9669 9670 case 525: 9671 #line 3440 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9672 { (yyval.interm.intermNode) = static_cast<TIntermNode*>((yyvsp[-1].interm.intermTypedNode)); } 9673 #line 9674 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9674 break; 9675 9676 case 526: 9677 #line 3444 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9678 { 9679 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); 9680 } 9681 #line 9682 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9682 break; 9683 9684 case 527: 9685 #line 3447 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9686 { 9687 parseContext.handleSelectionAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode)); 9688 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); 9689 } 9690 #line 9691 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9691 break; 9692 9693 case 528: 9694 #line 3453 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9695 { 9696 parseContext.boolCheck((yyvsp[-4].lex).loc, (yyvsp[-2].interm.intermTypedNode)); 9697 (yyval.interm.intermNode) = parseContext.intermediate.addSelection((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.nodePair), (yyvsp[-4].lex).loc); 9698 } 9699 #line 9700 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9700 break; 9701 9702 case 529: 9703 #line 3460 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9704 { 9705 (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermNode); 9706 (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermNode); 9707 } 9708 #line 9709 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9709 break; 9710 9711 case 530: 9712 #line 3464 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9713 { 9714 (yyval.interm.nodePair).node1 = (yyvsp[0].interm.intermNode); 9715 (yyval.interm.nodePair).node2 = 0; 9716 } 9717 #line 9718 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9718 break; 9719 9720 case 531: 9721 #line 3472 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9722 { 9723 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); 9724 parseContext.boolCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode)); 9725 } 9726 #line 9727 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9727 break; 9728 9729 case 532: 9730 #line 3476 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9731 { 9732 parseContext.boolCheck((yyvsp[-2].lex).loc, (yyvsp[-3].interm.type)); 9733 9734 TType type((yyvsp[-3].interm.type)); 9735 TIntermNode* initNode = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-3].interm.type), 0, (yyvsp[0].interm.intermTypedNode)); 9736 if (initNode) 9737 (yyval.interm.intermTypedNode) = initNode->getAsTyped(); 9738 else 9739 (yyval.interm.intermTypedNode) = 0; 9740 } 9741 #line 9742 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9742 break; 9743 9744 case 533: 9745 #line 3489 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9746 { 9747 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); 9748 } 9749 #line 9750 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9750 break; 9751 9752 case 534: 9753 #line 3492 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9754 { 9755 parseContext.handleSwitchAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode)); 9756 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); 9757 } 9758 #line 9759 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9759 break; 9760 9761 case 535: 9762 #line 3498 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9763 { 9764 // start new switch sequence on the switch stack 9765 ++parseContext.controlFlowNestingLevel; 9766 ++parseContext.statementNestingLevel; 9767 parseContext.switchSequenceStack.push_back(new TIntermSequence); 9768 parseContext.switchLevel.push_back(parseContext.statementNestingLevel); 9769 parseContext.symbolTable.push(); 9770 } 9771 #line 9772 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9772 break; 9773 9774 case 536: 9775 #line 3506 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9776 { 9777 (yyval.interm.intermNode) = parseContext.addSwitch((yyvsp[-7].lex).loc, (yyvsp[-5].interm.intermTypedNode), (yyvsp[-1].interm.intermNode) ? (yyvsp[-1].interm.intermNode)->getAsAggregate() : 0); 9778 delete parseContext.switchSequenceStack.back(); 9779 parseContext.switchSequenceStack.pop_back(); 9780 parseContext.switchLevel.pop_back(); 9781 parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); 9782 --parseContext.statementNestingLevel; 9783 --parseContext.controlFlowNestingLevel; 9784 } 9785 #line 9786 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9786 break; 9787 9788 case 537: 9789 #line 3518 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9790 { 9791 (yyval.interm.intermNode) = 0; 9792 } 9793 #line 9794 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9794 break; 9795 9796 case 538: 9797 #line 3521 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9798 { 9799 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); 9800 } 9801 #line 9802 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9802 break; 9803 9804 case 539: 9805 #line 3527 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9806 { 9807 (yyval.interm.intermNode) = 0; 9808 if (parseContext.switchLevel.size() == 0) 9809 parseContext.error((yyvsp[-2].lex).loc, "cannot appear outside switch statement", "case", ""); 9810 else if (parseContext.switchLevel.back() != parseContext.statementNestingLevel) 9811 parseContext.error((yyvsp[-2].lex).loc, "cannot be nested inside control flow", "case", ""); 9812 else { 9813 parseContext.constantValueCheck((yyvsp[-1].interm.intermTypedNode), "case"); 9814 parseContext.integerCheck((yyvsp[-1].interm.intermTypedNode), "case"); 9815 (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpCase, (yyvsp[-1].interm.intermTypedNode), (yyvsp[-2].lex).loc); 9816 } 9817 } 9818 #line 9819 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9819 break; 9820 9821 case 540: 9822 #line 3539 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9823 { 9824 (yyval.interm.intermNode) = 0; 9825 if (parseContext.switchLevel.size() == 0) 9826 parseContext.error((yyvsp[-1].lex).loc, "cannot appear outside switch statement", "default", ""); 9827 else if (parseContext.switchLevel.back() != parseContext.statementNestingLevel) 9828 parseContext.error((yyvsp[-1].lex).loc, "cannot be nested inside control flow", "default", ""); 9829 else 9830 (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpDefault, (yyvsp[-1].lex).loc); 9831 } 9832 #line 9833 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9833 break; 9834 9835 case 541: 9836 #line 3551 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9837 { 9838 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); 9839 } 9840 #line 9841 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9841 break; 9842 9843 case 542: 9844 #line 3554 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9845 { 9846 parseContext.handleLoopAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode)); 9847 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); 9848 } 9849 #line 9850 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9850 break; 9851 9852 case 543: 9853 #line 3560 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9854 { 9855 if (! parseContext.limits.whileLoops) 9856 parseContext.error((yyvsp[-1].lex).loc, "while loops not available", "limitation", ""); 9857 parseContext.symbolTable.push(); 9858 ++parseContext.loopNestingLevel; 9859 ++parseContext.statementNestingLevel; 9860 ++parseContext.controlFlowNestingLevel; 9861 } 9862 #line 9863 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9863 break; 9864 9865 case 544: 9866 #line 3568 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9867 { 9868 parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); 9869 (yyval.interm.intermNode) = parseContext.intermediate.addLoop((yyvsp[0].interm.intermNode), (yyvsp[-2].interm.intermTypedNode), 0, true, (yyvsp[-5].lex).loc); 9870 --parseContext.loopNestingLevel; 9871 --parseContext.statementNestingLevel; 9872 --parseContext.controlFlowNestingLevel; 9873 } 9874 #line 9875 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9875 break; 9876 9877 case 545: 9878 #line 3575 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9879 { 9880 ++parseContext.loopNestingLevel; 9881 ++parseContext.statementNestingLevel; 9882 ++parseContext.controlFlowNestingLevel; 9883 } 9884 #line 9885 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9885 break; 9886 9887 case 546: 9888 #line 3580 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9889 { 9890 if (! parseContext.limits.whileLoops) 9891 parseContext.error((yyvsp[-7].lex).loc, "do-while loops not available", "limitation", ""); 9892 9893 parseContext.boolCheck((yyvsp[0].lex).loc, (yyvsp[-2].interm.intermTypedNode)); 9894 9895 (yyval.interm.intermNode) = parseContext.intermediate.addLoop((yyvsp[-5].interm.intermNode), (yyvsp[-2].interm.intermTypedNode), 0, false, (yyvsp[-4].lex).loc); 9896 --parseContext.loopNestingLevel; 9897 --parseContext.statementNestingLevel; 9898 --parseContext.controlFlowNestingLevel; 9899 } 9900 #line 9901 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9901 break; 9902 9903 case 547: 9904 #line 3591 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9905 { 9906 parseContext.symbolTable.push(); 9907 ++parseContext.loopNestingLevel; 9908 ++parseContext.statementNestingLevel; 9909 ++parseContext.controlFlowNestingLevel; 9910 } 9911 #line 9912 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9912 break; 9913 9914 case 548: 9915 #line 3597 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9916 { 9917 parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); 9918 (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[-3].interm.intermNode), (yyvsp[-5].lex).loc); 9919 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); 9920 if (! parseContext.limits.nonInductiveForLoops) 9921 parseContext.inductiveLoopCheck((yyvsp[-6].lex).loc, (yyvsp[-3].interm.intermNode), forLoop); 9922 (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyval.interm.intermNode), forLoop, (yyvsp[-6].lex).loc); 9923 (yyval.interm.intermNode)->getAsAggregate()->setOperator(EOpSequence); 9924 --parseContext.loopNestingLevel; 9925 --parseContext.statementNestingLevel; 9926 --parseContext.controlFlowNestingLevel; 9927 } 9928 #line 9929 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9929 break; 9930 9931 case 549: 9932 #line 3612 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9933 { 9934 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); 9935 } 9936 #line 9937 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9937 break; 9938 9939 case 550: 9940 #line 3615 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9941 { 9942 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); 9943 } 9944 #line 9945 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9945 break; 9946 9947 case 551: 9948 #line 3621 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9949 { 9950 (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); 9951 } 9952 #line 9953 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9953 break; 9954 9955 case 552: 9956 #line 3624 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9957 { 9958 (yyval.interm.intermTypedNode) = 0; 9959 } 9960 #line 9961 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9961 break; 9962 9963 case 553: 9964 #line 3630 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9965 { 9966 (yyval.interm.nodePair).node1 = (yyvsp[-1].interm.intermTypedNode); 9967 (yyval.interm.nodePair).node2 = 0; 9968 } 9969 #line 9970 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9970 break; 9971 9972 case 554: 9973 #line 3634 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9974 { 9975 (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermTypedNode); 9976 (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermTypedNode); 9977 } 9978 #line 9979 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9979 break; 9980 9981 case 555: 9982 #line 3641 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9983 { 9984 if (parseContext.loopNestingLevel <= 0) 9985 parseContext.error((yyvsp[-1].lex).loc, "continue statement only allowed in loops", "", ""); 9986 (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpContinue, (yyvsp[-1].lex).loc); 9987 } 9988 #line 9989 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9989 break; 9990 9991 case 556: 9992 #line 3646 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 9993 { 9994 if (parseContext.loopNestingLevel + parseContext.switchSequenceStack.size() <= 0) 9995 parseContext.error((yyvsp[-1].lex).loc, "break statement only allowed in switch and loops", "", ""); 9996 (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpBreak, (yyvsp[-1].lex).loc); 9997 } 9998 #line 9999 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 9999 break; 10000 10001 case 557: 10002 #line 3651 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 10003 { 10004 (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpReturn, (yyvsp[-1].lex).loc); 10005 if (parseContext.currentFunctionType->getBasicType() != EbtVoid) 10006 parseContext.error((yyvsp[-1].lex).loc, "non-void function must return a value", "return", ""); 10007 if (parseContext.inMain) 10008 parseContext.postEntryPointReturn = true; 10009 } 10010 #line 10011 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 10011 break; 10012 10013 case 558: 10014 #line 3658 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 10015 { 10016 (yyval.interm.intermNode) = parseContext.handleReturnValue((yyvsp[-2].lex).loc, (yyvsp[-1].interm.intermTypedNode)); 10017 } 10018 #line 10019 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 10019 break; 10020 10021 case 559: 10022 #line 3661 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 10023 { 10024 parseContext.requireStage((yyvsp[-1].lex).loc, EShLangFragment, "discard"); 10025 (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpKill, (yyvsp[-1].lex).loc); 10026 } 10027 #line 10028 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 10028 break; 10029 10030 case 560: 10031 #line 3670 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 10032 { 10033 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); 10034 parseContext.intermediate.setTreeRoot((yyval.interm.intermNode)); 10035 } 10036 #line 10037 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 10037 break; 10038 10039 case 561: 10040 #line 3674 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 10041 { 10042 if ((yyvsp[0].interm.intermNode) != nullptr) { 10043 (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode)); 10044 parseContext.intermediate.setTreeRoot((yyval.interm.intermNode)); 10045 } 10046 } 10047 #line 10048 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 10048 break; 10049 10050 case 562: 10051 #line 3683 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 10052 { 10053 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); 10054 } 10055 #line 10056 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 10056 break; 10057 10058 case 563: 10059 #line 3686 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 10060 { 10061 (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); 10062 } 10063 #line 10064 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 10064 break; 10065 10066 case 564: 10067 #line 3689 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 10068 { 10069 parseContext.requireProfile((yyvsp[0].lex).loc, ~EEsProfile, "extraneous semicolon"); 10070 parseContext.profileRequires((yyvsp[0].lex).loc, ~EEsProfile, 460, nullptr, "extraneous semicolon"); 10071 (yyval.interm.intermNode) = nullptr; 10072 } 10073 #line 10074 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 10074 break; 10075 10076 case 565: 10077 #line 3697 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 10078 { 10079 (yyvsp[0].interm).function = parseContext.handleFunctionDeclarator((yyvsp[0].interm).loc, *(yyvsp[0].interm).function, false /* not prototype */); 10080 (yyvsp[0].interm).intermNode = parseContext.handleFunctionDefinition((yyvsp[0].interm).loc, *(yyvsp[0].interm).function); 10081 } 10082 #line 10083 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 10083 break; 10084 10085 case 566: 10086 #line 3701 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 10087 { 10088 // May be best done as post process phase on intermediate code 10089 if (parseContext.currentFunctionType->getBasicType() != EbtVoid && ! parseContext.functionReturnsValue) 10090 parseContext.error((yyvsp[-2].interm).loc, "function does not return a value:", "", (yyvsp[-2].interm).function->getName().c_str()); 10091 parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); 10092 (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm).intermNode, (yyvsp[0].interm.intermNode)); 10093 parseContext.intermediate.setAggregateOperator((yyval.interm.intermNode), EOpFunction, (yyvsp[-2].interm).function->getType(), (yyvsp[-2].interm).loc); 10094 (yyval.interm.intermNode)->getAsAggregate()->setName((yyvsp[-2].interm).function->getMangledName().c_str()); 10095 10096 // store the pragma information for debug and optimize and other vendor specific 10097 // information. This information can be queried from the parse tree 10098 (yyval.interm.intermNode)->getAsAggregate()->setOptimize(parseContext.contextPragma.optimize); 10099 (yyval.interm.intermNode)->getAsAggregate()->setDebug(parseContext.contextPragma.debug); 10100 (yyval.interm.intermNode)->getAsAggregate()->setPragmaTable(parseContext.contextPragma.pragmaTable); 10101 } 10102 #line 10103 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 10103 break; 10104 10105 case 567: 10106 #line 3719 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 10107 { 10108 (yyval.interm.attributes) = (yyvsp[-2].interm.attributes); 10109 parseContext.requireExtensions((yyvsp[-4].lex).loc, 1, &E_GL_EXT_control_flow_attributes, "attribute"); 10110 } 10111 #line 10112 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 10112 break; 10113 10114 case 568: 10115 #line 3725 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 10116 { 10117 (yyval.interm.attributes) = (yyvsp[0].interm.attributes); 10118 } 10119 #line 10120 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 10120 break; 10121 10122 case 569: 10123 #line 3728 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 10124 { 10125 (yyval.interm.attributes) = parseContext.mergeAttributes((yyvsp[-2].interm.attributes), (yyvsp[0].interm.attributes)); 10126 } 10127 #line 10128 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 10128 break; 10129 10130 case 570: 10131 #line 3733 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 10132 { 10133 (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[0].lex).string); 10134 } 10135 #line 10136 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 10136 break; 10137 10138 case 571: 10139 #line 3736 "MachineIndependent/glslang.y" /* yacc.c:1646 */ 10140 { 10141 (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[-3].lex).string, (yyvsp[-1].interm.intermTypedNode)); 10142 } 10143 #line 10144 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 10144 break; 10145 10146 10147 #line 10148 "MachineIndependent/glslang_tab.cpp" /* yacc.c:1646 */ 10148 default: break; 10149 } 10150 /* User semantic actions sometimes alter yychar, and that requires 10151 that yytoken be updated with the new translation. We take the 10152 approach of translating immediately before every use of yytoken. 10153 One alternative is translating here after every semantic action, 10154 but that translation would be missed if the semantic action invokes 10155 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 10156 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 10157 incorrect destructor might then be invoked immediately. In the 10158 case of YYERROR or YYBACKUP, subsequent parser actions might lead 10159 to an incorrect destructor call or verbose syntax error message 10160 before the lookahead is translated. */ 10161 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 10162 10163 YYPOPSTACK (yylen); 10164 yylen = 0; 10165 YY_STACK_PRINT (yyss, yyssp); 10166 10167 *++yyvsp = yyval; 10168 10169 /* Now 'shift' the result of the reduction. Determine what state 10170 that goes to, based on the state we popped back to and the rule 10171 number reduced by. */ 10172 10173 yyn = yyr1[yyn]; 10174 10175 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 10176 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 10177 yystate = yytable[yystate]; 10178 else 10179 yystate = yydefgoto[yyn - YYNTOKENS]; 10180 10181 goto yynewstate; 10182 10183 10184 /*--------------------------------------. 10185 | yyerrlab -- here on detecting error. | 10186 `--------------------------------------*/ 10187 yyerrlab: 10188 /* Make sure we have latest lookahead translation. See comments at 10189 user semantic actions for why this is necessary. */ 10190 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); 10191 10192 /* If not already recovering from an error, report this error. */ 10193 if (!yyerrstatus) 10194 { 10195 ++yynerrs; 10196 #if ! YYERROR_VERBOSE 10197 yyerror (pParseContext, YY_("syntax error")); 10198 #else 10199 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 10200 yyssp, yytoken) 10201 { 10202 char const *yymsgp = YY_("syntax error"); 10203 int yysyntax_error_status; 10204 yysyntax_error_status = YYSYNTAX_ERROR; 10205 if (yysyntax_error_status == 0) 10206 yymsgp = yymsg; 10207 else if (yysyntax_error_status == 1) 10208 { 10209 if (yymsg != yymsgbuf) 10210 YYSTACK_FREE (yymsg); 10211 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); 10212 if (!yymsg) 10213 { 10214 yymsg = yymsgbuf; 10215 yymsg_alloc = sizeof yymsgbuf; 10216 yysyntax_error_status = 2; 10217 } 10218 else 10219 { 10220 yysyntax_error_status = YYSYNTAX_ERROR; 10221 yymsgp = yymsg; 10222 } 10223 } 10224 yyerror (pParseContext, yymsgp); 10225 if (yysyntax_error_status == 2) 10226 goto yyexhaustedlab; 10227 } 10228 # undef YYSYNTAX_ERROR 10229 #endif 10230 } 10231 10232 10233 10234 if (yyerrstatus == 3) 10235 { 10236 /* If just tried and failed to reuse lookahead token after an 10237 error, discard it. */ 10238 10239 if (yychar <= YYEOF) 10240 { 10241 /* Return failure if at end of input. */ 10242 if (yychar == YYEOF) 10243 YYABORT; 10244 } 10245 else 10246 { 10247 yydestruct ("Error: discarding", 10248 yytoken, &yylval, pParseContext); 10249 yychar = YYEMPTY; 10250 } 10251 } 10252 10253 /* Else will try to reuse lookahead token after shifting the error 10254 token. */ 10255 goto yyerrlab1; 10256 10257 10258 /*---------------------------------------------------. 10259 | yyerrorlab -- error raised explicitly by YYERROR. | 10260 `---------------------------------------------------*/ 10261 yyerrorlab: 10262 10263 /* Pacify compilers like GCC when the user code never invokes 10264 YYERROR and the label yyerrorlab therefore never appears in user 10265 code. */ 10266 if (/*CONSTCOND*/ 0) 10267 goto yyerrorlab; 10268 10269 /* Do not reclaim the symbols of the rule whose action triggered 10270 this YYERROR. */ 10271 YYPOPSTACK (yylen); 10272 yylen = 0; 10273 YY_STACK_PRINT (yyss, yyssp); 10274 yystate = *yyssp; 10275 goto yyerrlab1; 10276 10277 10278 /*-------------------------------------------------------------. 10279 | yyerrlab1 -- common code for both syntax error and YYERROR. | 10280 `-------------------------------------------------------------*/ 10281 yyerrlab1: 10282 yyerrstatus = 3; /* Each real token shifted decrements this. */ 10283 10284 for (;;) 10285 { 10286 yyn = yypact[yystate]; 10287 if (!yypact_value_is_default (yyn)) 10288 { 10289 yyn += YYTERROR; 10290 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 10291 { 10292 yyn = yytable[yyn]; 10293 if (0 < yyn) 10294 break; 10295 } 10296 } 10297 10298 /* Pop the current state because it cannot handle the error token. */ 10299 if (yyssp == yyss) 10300 YYABORT; 10301 10302 10303 yydestruct ("Error: popping", 10304 yystos[yystate], yyvsp, pParseContext); 10305 YYPOPSTACK (1); 10306 yystate = *yyssp; 10307 YY_STACK_PRINT (yyss, yyssp); 10308 } 10309 10310 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 10311 *++yyvsp = yylval; 10312 YY_IGNORE_MAYBE_UNINITIALIZED_END 10313 10314 10315 /* Shift the error token. */ 10316 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 10317 10318 yystate = yyn; 10319 goto yynewstate; 10320 10321 10322 /*-------------------------------------. 10323 | yyacceptlab -- YYACCEPT comes here. | 10324 `-------------------------------------*/ 10325 yyacceptlab: 10326 yyresult = 0; 10327 goto yyreturn; 10328 10329 /*-----------------------------------. 10330 | yyabortlab -- YYABORT comes here. | 10331 `-----------------------------------*/ 10332 yyabortlab: 10333 yyresult = 1; 10334 goto yyreturn; 10335 10336 #if !defined yyoverflow || YYERROR_VERBOSE 10337 /*-------------------------------------------------. 10338 | yyexhaustedlab -- memory exhaustion comes here. | 10339 `-------------------------------------------------*/ 10340 yyexhaustedlab: 10341 yyerror (pParseContext, YY_("memory exhausted")); 10342 yyresult = 2; 10343 /* Fall through. */ 10344 #endif 10345 10346 yyreturn: 10347 if (yychar != YYEMPTY) 10348 { 10349 /* Make sure we have latest lookahead translation. See comments at 10350 user semantic actions for why this is necessary. */ 10351 yytoken = YYTRANSLATE (yychar); 10352 yydestruct ("Cleanup: discarding lookahead", 10353 yytoken, &yylval, pParseContext); 10354 } 10355 /* Do not reclaim the symbols of the rule whose action triggered 10356 this YYABORT or YYACCEPT. */ 10357 YYPOPSTACK (yylen); 10358 YY_STACK_PRINT (yyss, yyssp); 10359 while (yyssp != yyss) 10360 { 10361 yydestruct ("Cleanup: popping", 10362 yystos[*yyssp], yyvsp, pParseContext); 10363 YYPOPSTACK (1); 10364 } 10365 #ifndef yyoverflow 10366 if (yyss != yyssa) 10367 YYSTACK_FREE (yyss); 10368 #endif 10369 #if YYERROR_VERBOSE 10370 if (yymsg != yymsgbuf) 10371 YYSTACK_FREE (yymsg); 10372 #endif 10373 return yyresult; 10374 } 10375 #line 3740 "MachineIndependent/glslang.y" /* yacc.c:1906 */ 10376 10377
