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