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