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