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 339 typedef 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 384 typedef 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 408 typedef YYTYPE_UINT8 yytype_uint8; 409 #else 410 typedef unsigned char yytype_uint8; 411 #endif 412 413 #ifdef YYTYPE_INT8 414 typedef YYTYPE_INT8 yytype_int8; 415 #elif (defined __STDC__ || defined __C99__FUNC__ \ 416 || defined __cplusplus || defined _MSC_VER) 417 typedef signed char yytype_int8; 418 #else 419 typedef short int yytype_int8; 420 #endif 421 422 #ifdef YYTYPE_UINT16 423 typedef YYTYPE_UINT16 yytype_uint16; 424 #else 425 typedef unsigned short int yytype_uint16; 426 #endif 427 428 #ifdef YYTYPE_INT16 429 typedef YYTYPE_INT16 yytype_int16; 430 #else 431 typedef 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) 475 static int 476 YYID (int yyi) 477 #else 478 static int 479 YYID (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) 543 void *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) 550 void 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. */ 563 union 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. */ 637 static 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. */ 689 static 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. */ 722 static 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. */ 807 static 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. */ 843 static 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. */ 922 static 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. */ 950 static 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. */ 983 static 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. */ 1018 static 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]. */ 1065 static 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 1081 static 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]. */ 1128 static 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 1146 static 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 1522 static 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. */ 1900 static 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) \ 1974 do \ 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 } \ 1988 while (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) \ 2054 do { \ 2055 if (yydebug) \ 2056 YYFPRINTF Args; \ 2057 } while (YYID (0)) 2058 2059 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 2060 do { \ 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) 2078 static void 2079 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, struct _mesa_glsl_parse_state *state) 2080 #else 2081 static void 2082 yy_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) 2114 static void 2115 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, struct _mesa_glsl_parse_state *state) 2116 #else 2117 static void 2118 yy_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) 2144 static void 2145 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 2146 #else 2147 static void 2148 yy_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) \ 2163 do { \ 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) 2175 static void 2176 yy_reduce_print (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, struct _mesa_glsl_parse_state *state) 2177 #else 2178 static void 2179 yy_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) \ 2203 do { \ 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. */ 2210 int 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 2238 #if YYERROR_VERBOSE 2239 2240 # ifndef yystrlen 2241 # if defined __GLIBC__ && defined _STRING_H 2242 # define yystrlen strlen 2243 # else 2244 /* Return the length of YYSTR. */ 2245 #if (defined __STDC__ || defined __C99__FUNC__ \ 2246 || defined __cplusplus || defined _MSC_VER) 2247 static YYSIZE_T 2248 yystrlen (const char *yystr) 2249 #else 2250 static YYSIZE_T 2251 yystrlen (yystr) 2252 const char *yystr; 2253 #endif 2254 { 2255 YYSIZE_T yylen; 2256 for (yylen = 0; yystr[yylen]; yylen++) 2257 continue; 2258 return yylen; 2259 } 2260 # endif 2261 # endif 2262 2263 # ifndef yystpcpy 2264 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 2265 # define yystpcpy stpcpy 2266 # else 2267 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 2268 YYDEST. */ 2269 #if (defined __STDC__ || defined __C99__FUNC__ \ 2270 || defined __cplusplus || defined _MSC_VER) 2271 static char * 2272 yystpcpy (char *yydest, const char *yysrc) 2273 #else 2274 static char * 2275 yystpcpy (yydest, yysrc) 2276 char *yydest; 2277 const char *yysrc; 2278 #endif 2279 { 2280 char *yyd = yydest; 2281 const char *yys = yysrc; 2282 2283 while ((*yyd++ = *yys++) != '\0') 2284 continue; 2285 2286 return yyd - 1; 2287 } 2288 # endif 2289 # endif 2290 2291 # ifndef yytnamerr 2292 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 2293 quotes and backslashes, so that it's suitable for yyerror. The 2294 heuristic is that double-quoting is unnecessary unless the string 2295 contains an apostrophe, a comma, or backslash (other than 2296 backslash-backslash). YYSTR is taken from yytname. If YYRES is 2297 null, do not copy; instead, return the length of what the result 2298 would have been. */ 2299 static YYSIZE_T 2300 yytnamerr (char *yyres, const char *yystr) 2301 { 2302 if (*yystr == '"') 2303 { 2304 YYSIZE_T yyn = 0; 2305 char const *yyp = yystr; 2306 2307 for (;;) 2308 switch (*++yyp) 2309 { 2310 case '\'': 2311 case ',': 2312 goto do_not_strip_quotes; 2313 2314 case '\\': 2315 if (*++yyp != '\\') 2316 goto do_not_strip_quotes; 2317 /* Fall through. */ 2318 default: 2319 if (yyres) 2320 yyres[yyn] = *yyp; 2321 yyn++; 2322 break; 2323 2324 case '"': 2325 if (yyres) 2326 yyres[yyn] = '\0'; 2327 return yyn; 2328 } 2329 do_not_strip_quotes: ; 2330 } 2331 2332 if (! yyres) 2333 return yystrlen (yystr); 2334 2335 return yystpcpy (yyres, yystr) - yyres; 2336 } 2337 # endif 2338 2339 /* Copy into YYRESULT an error message about the unexpected token 2340 YYCHAR while in state YYSTATE. Return the number of bytes copied, 2341 including the terminating null byte. If YYRESULT is null, do not 2342 copy anything; just return the number of bytes that would be 2343 copied. As a special case, return 0 if an ordinary "syntax error" 2344 message will do. Return YYSIZE_MAXIMUM if overflow occurs during 2345 size calculation. */ 2346 static YYSIZE_T 2347 yysyntax_error (char *yyresult, int yystate, int yychar) 2348 { 2349 int yyn = yypact[yystate]; 2350 2351 if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) 2352 return 0; 2353 else 2354 { 2355 int yytype = YYTRANSLATE (yychar); 2356 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); 2357 YYSIZE_T yysize = yysize0; 2358 YYSIZE_T yysize1; 2359 int yysize_overflow = 0; 2360 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 2361 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 2362 int yyx; 2363 2364 # if 0 2365 /* This is so xgettext sees the translatable formats that are 2366 constructed on the fly. */ 2367 YY_("syntax error, unexpected %s"); 2368 YY_("syntax error, unexpected %s, expecting %s"); 2369 YY_("syntax error, unexpected %s, expecting %s or %s"); 2370 YY_("syntax error, unexpected %s, expecting %s or %s or %s"); 2371 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); 2372 # endif 2373 char *yyfmt; 2374 char const *yyf; 2375 static char const yyunexpected[] = "syntax error, unexpected %s"; 2376 static char const yyexpecting[] = ", expecting %s"; 2377 static char const yyor[] = " or %s"; 2378 char yyformat[sizeof yyunexpected 2379 + sizeof yyexpecting - 1 2380 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) 2381 * (sizeof yyor - 1))]; 2382 char const *yyprefix = yyexpecting; 2383 2384 /* Start YYX at -YYN if negative to avoid negative indexes in 2385 YYCHECK. */ 2386 int yyxbegin = yyn < 0 ? -yyn : 0; 2387 2388 /* Stay within bounds of both yycheck and yytname. */ 2389 int yychecklim = YYLAST - yyn + 1; 2390 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 2391 int yycount = 1; 2392 2393 yyarg[0] = yytname[yytype]; 2394 yyfmt = yystpcpy (yyformat, yyunexpected); 2395 2396 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 2397 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 2398 { 2399 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 2400 { 2401 yycount = 1; 2402 yysize = yysize0; 2403 yyformat[sizeof yyunexpected - 1] = '\0'; 2404 break; 2405 } 2406 yyarg[yycount++] = yytname[yyx]; 2407 yysize1 = yysize + yytnamerr (0, yytname[yyx]); 2408 yysize_overflow |= (yysize1 < yysize); 2409 yysize = yysize1; 2410 yyfmt = yystpcpy (yyfmt, yyprefix); 2411 yyprefix = yyor; 2412 } 2413 2414 yyf = YY_(yyformat); 2415 yysize1 = yysize + yystrlen (yyf); 2416 yysize_overflow |= (yysize1 < yysize); 2417 yysize = yysize1; 2418 2419 if (yysize_overflow) 2420 return YYSIZE_MAXIMUM; 2421 2422 if (yyresult) 2423 { 2424 /* Avoid sprintf, as that infringes on the user's name space. 2425 Don't have undefined behavior even if the translation 2426 produced a string with the wrong number of "%s"s. */ 2427 char *yyp = yyresult; 2428 int yyi = 0; 2429 while ((*yyp = *yyf) != '\0') 2430 { 2431 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) 2432 { 2433 yyp += yytnamerr (yyp, yyarg[yyi++]); 2434 yyf += 2; 2435 } 2436 else 2437 { 2438 yyp++; 2439 yyf++; 2440 } 2441 } 2442 } 2443 return yysize; 2444 } 2445 } 2446 #endif /* YYERROR_VERBOSE */ 2447 2448 2450 /*-----------------------------------------------. 2451 | Release the memory associated to this symbol. | 2452 `-----------------------------------------------*/ 2453 2454 /*ARGSUSED*/ 2455 #if (defined __STDC__ || defined __C99__FUNC__ \ 2456 || defined __cplusplus || defined _MSC_VER) 2457 static void 2458 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, struct _mesa_glsl_parse_state *state) 2459 #else 2460 static void 2461 yydestruct (yymsg, yytype, yyvaluep, yylocationp, state) 2462 const char *yymsg; 2463 int yytype; 2464 YYSTYPE *yyvaluep; 2465 YYLTYPE *yylocationp; 2466 struct _mesa_glsl_parse_state *state; 2467 #endif 2468 { 2469 YYUSE (yyvaluep); 2470 YYUSE (yylocationp); 2471 YYUSE (state); 2472 2473 if (!yymsg) 2474 yymsg = "Deleting"; 2475 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 2476 2477 switch (yytype) 2478 { 2479 2480 default: 2481 break; 2482 } 2483 } 2484 2485 /* Prevent warnings from -Wmissing-prototypes. */ 2486 #ifdef YYPARSE_PARAM 2487 #if defined __STDC__ || defined __cplusplus 2488 int yyparse (void *YYPARSE_PARAM); 2489 #else 2490 int yyparse (); 2491 #endif 2492 #else /* ! YYPARSE_PARAM */ 2493 #if defined __STDC__ || defined __cplusplus 2494 int yyparse (struct _mesa_glsl_parse_state *state); 2495 #else 2496 int yyparse (); 2497 #endif 2498 #endif /* ! YYPARSE_PARAM */ 2499 2500 2501 2502 2503 2504 /*-------------------------. 2505 | yyparse or yypush_parse. | 2506 `-------------------------*/ 2507 2508 #ifdef YYPARSE_PARAM 2509 #if (defined __STDC__ || defined __C99__FUNC__ \ 2510 || defined __cplusplus || defined _MSC_VER) 2511 int 2512 yyparse (void *YYPARSE_PARAM) 2513 #else 2514 int 2515 yyparse (YYPARSE_PARAM) 2516 void *YYPARSE_PARAM; 2517 #endif 2518 #else /* ! YYPARSE_PARAM */ 2519 #if (defined __STDC__ || defined __C99__FUNC__ \ 2520 || defined __cplusplus || defined _MSC_VER) 2521 int 2522 yyparse (struct _mesa_glsl_parse_state *state) 2523 #else 2524 int 2525 yyparse (state) 2526 struct _mesa_glsl_parse_state *state; 2527 #endif 2528 #endif 2529 { 2530 /* The lookahead symbol. */ 2531 int yychar; 2532 2533 /* The semantic value of the lookahead symbol. */ 2534 YYSTYPE yylval; 2535 2536 /* Location data for the lookahead symbol. */ 2537 YYLTYPE yylloc; 2538 2539 /* Number of syntax errors so far. */ 2540 int yynerrs; 2541 2542 int yystate; 2543 /* Number of tokens to shift before error messages enabled. */ 2544 int yyerrstatus; 2545 2546 /* The stacks and their tools: 2547 `yyss': related to states. 2548 `yyvs': related to semantic values. 2549 `yyls': related to locations. 2550 2551 Refer to the stacks thru separate pointers, to allow yyoverflow 2552 to reallocate them elsewhere. */ 2553 2554 /* The state stack. */ 2555 yytype_int16 yyssa[YYINITDEPTH]; 2556 yytype_int16 *yyss; 2557 yytype_int16 *yyssp; 2558 2559 /* The semantic value stack. */ 2560 YYSTYPE yyvsa[YYINITDEPTH]; 2561 YYSTYPE *yyvs; 2562 YYSTYPE *yyvsp; 2563 2564 /* The location stack. */ 2565 YYLTYPE yylsa[YYINITDEPTH]; 2566 YYLTYPE *yyls; 2567 YYLTYPE *yylsp; 2568 2569 /* The locations where the error started and ended. */ 2570 YYLTYPE yyerror_range[3]; 2571 2572 YYSIZE_T yystacksize; 2573 2574 int yyn; 2575 int yyresult; 2576 /* Lookahead token as an internal (translated) token number. */ 2577 int yytoken; 2578 /* The variables used to return semantic value and location from the 2579 action routines. */ 2580 YYSTYPE yyval; 2581 YYLTYPE yyloc; 2582 2583 #if YYERROR_VERBOSE 2584 /* Buffer for error messages, and its allocated size. */ 2585 char yymsgbuf[128]; 2586 char *yymsg = yymsgbuf; 2587 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 2588 #endif 2589 2590 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) 2591 2592 /* The number of symbols on the RHS of the reduced rule. 2593 Keep to zero when no symbol should be popped. */ 2594 int yylen = 0; 2595 2596 yytoken = 0; 2597 yyss = yyssa; 2598 yyvs = yyvsa; 2599 yyls = yylsa; 2600 yystacksize = YYINITDEPTH; 2601 2602 YYDPRINTF ((stderr, "Starting parse\n")); 2603 2604 yystate = 0; 2605 yyerrstatus = 0; 2606 yynerrs = 0; 2607 yychar = YYEMPTY; /* Cause a token to be read. */ 2608 2609 /* Initialize stack pointers. 2610 Waste one element of value and location stack 2611 so that they stay on the same level as the state stack. 2612 The wasted elements are never initialized. */ 2613 yyssp = yyss; 2614 yyvsp = yyvs; 2615 yylsp = yyls; 2616 2617 #if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL 2618 /* Initialize the default location before parsing starts. */ 2619 yylloc.first_line = yylloc.last_line = 1; 2620 yylloc.first_column = yylloc.last_column = 1; 2621 #endif 2622 2623 /* User initialization code. */ 2624 2625 /* Line 1251 of yacc.c */ 2626 #line 41 "glsl_parser.ypp" 2627 { 2628 yylloc.first_line = 1; 2629 yylloc.first_column = 1; 2630 yylloc.last_line = 1; 2631 yylloc.last_column = 1; 2632 yylloc.source = 0; 2633 } 2634 2635 /* Line 1251 of yacc.c */ 2636 #line 2635 "glsl_parser.cpp" 2637 yylsp[0] = yylloc; 2638 2639 goto yysetstate; 2640 2641 /*------------------------------------------------------------. 2642 | yynewstate -- Push a new state, which is found in yystate. | 2643 `------------------------------------------------------------*/ 2644 yynewstate: 2645 /* In all cases, when you get here, the value and location stacks 2646 have just been pushed. So pushing a state here evens the stacks. */ 2647 yyssp++; 2648 2649 yysetstate: 2650 *yyssp = yystate; 2651 2652 if (yyss + yystacksize - 1 <= yyssp) 2653 { 2654 /* Get the current used size of the three stacks, in elements. */ 2655 YYSIZE_T yysize = yyssp - yyss + 1; 2656 2657 #ifdef yyoverflow 2658 { 2659 /* Give user a chance to reallocate the stack. Use copies of 2660 these so that the &'s don't force the real ones into 2661 memory. */ 2662 YYSTYPE *yyvs1 = yyvs; 2663 yytype_int16 *yyss1 = yyss; 2664 YYLTYPE *yyls1 = yyls; 2665 2666 /* Each stack pointer address is followed by the size of the 2667 data in use in that stack, in bytes. This used to be a 2668 conditional around just the two extra args, but that might 2669 be undefined if yyoverflow is a macro. */ 2670 yyoverflow (YY_("memory exhausted"), 2671 &yyss1, yysize * sizeof (*yyssp), 2672 &yyvs1, yysize * sizeof (*yyvsp), 2673 &yyls1, yysize * sizeof (*yylsp), 2674 &yystacksize); 2675 2676 yyls = yyls1; 2677 yyss = yyss1; 2678 yyvs = yyvs1; 2679 } 2680 #else /* no yyoverflow */ 2681 # ifndef YYSTACK_RELOCATE 2682 goto yyexhaustedlab; 2683 # else 2684 /* Extend the stack our own way. */ 2685 if (YYMAXDEPTH <= yystacksize) 2686 goto yyexhaustedlab; 2687 yystacksize *= 2; 2688 if (YYMAXDEPTH < yystacksize) 2689 yystacksize = YYMAXDEPTH; 2690 2691 { 2692 yytype_int16 *yyss1 = yyss; 2693 union yyalloc *yyptr = 2694 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 2695 if (! yyptr) 2696 goto yyexhaustedlab; 2697 YYSTACK_RELOCATE (yyss_alloc, yyss); 2698 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 2699 YYSTACK_RELOCATE (yyls_alloc, yyls); 2700 # undef YYSTACK_RELOCATE 2701 if (yyss1 != yyssa) 2702 YYSTACK_FREE (yyss1); 2703 } 2704 # endif 2705 #endif /* no yyoverflow */ 2706 2707 yyssp = yyss + yysize - 1; 2708 yyvsp = yyvs + yysize - 1; 2709 yylsp = yyls + yysize - 1; 2710 2711 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 2712 (unsigned long int) yystacksize)); 2713 2714 if (yyss + yystacksize - 1 <= yyssp) 2715 YYABORT; 2716 } 2717 2718 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 2719 2720 if (yystate == YYFINAL) 2721 YYACCEPT; 2722 2723 goto yybackup; 2724 2725 /*-----------. 2726 | yybackup. | 2727 `-----------*/ 2728 yybackup: 2729 2730 /* Do appropriate processing given the current state. Read a 2731 lookahead token if we need one and don't already have one. */ 2732 2733 /* First try to decide what to do without reference to lookahead token. */ 2734 yyn = yypact[yystate]; 2735 if (yyn == YYPACT_NINF) 2736 goto yydefault; 2737 2738 /* Not known => get a lookahead token if don't already have one. */ 2739 2740 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 2741 if (yychar == YYEMPTY) 2742 { 2743 YYDPRINTF ((stderr, "Reading a token: ")); 2744 yychar = YYLEX; 2745 } 2746 2747 if (yychar <= YYEOF) 2748 { 2749 yychar = yytoken = YYEOF; 2750 YYDPRINTF ((stderr, "Now at end of input.\n")); 2751 } 2752 else 2753 { 2754 yytoken = YYTRANSLATE (yychar); 2755 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 2756 } 2757 2758 /* If the proper action on seeing token YYTOKEN is to reduce or to 2759 detect an error, take that action. */ 2760 yyn += yytoken; 2761 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 2762 goto yydefault; 2763 yyn = yytable[yyn]; 2764 if (yyn <= 0) 2765 { 2766 if (yyn == 0 || yyn == YYTABLE_NINF) 2767 goto yyerrlab; 2768 yyn = -yyn; 2769 goto yyreduce; 2770 } 2771 2772 /* Count tokens shifted since error; after three, turn off error 2773 status. */ 2774 if (yyerrstatus) 2775 yyerrstatus--; 2776 2777 /* Shift the lookahead token. */ 2778 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 2779 2780 /* Discard the shifted token. */ 2781 yychar = YYEMPTY; 2782 2783 yystate = yyn; 2784 *++yyvsp = yylval; 2785 *++yylsp = yylloc; 2786 goto yynewstate; 2787 2788 2789 /*-----------------------------------------------------------. 2790 | yydefault -- do the default action for the current state. | 2791 `-----------------------------------------------------------*/ 2792 yydefault: 2793 yyn = yydefact[yystate]; 2794 if (yyn == 0) 2795 goto yyerrlab; 2796 goto yyreduce; 2797 2798 2799 /*-----------------------------. 2800 | yyreduce -- Do a reduction. | 2801 `-----------------------------*/ 2802 yyreduce: 2803 /* yyn is the number of a rule to reduce with. */ 2804 yylen = yyr2[yyn]; 2805 2806 /* If YYLEN is nonzero, implement the default value of the action: 2807 `$$ = $1'. 2808 2809 Otherwise, the following line sets YYVAL to garbage. 2810 This behavior is undocumented and Bison 2811 users should not rely upon it. Assigning to YYVAL 2812 unconditionally makes the parser a bit smaller, and it avoids a 2813 GCC warning that YYVAL may be used uninitialized. */ 2814 yyval = yyvsp[1-yylen]; 2815 2816 /* Default location. */ 2817 YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); 2818 YY_REDUCE_PRINT (yyn); 2819 switch (yyn) 2820 { 2821 case 2: 2822 2823 /* Line 1464 of yacc.c */ 2824 #line 212 "glsl_parser.ypp" 2825 { 2826 _mesa_glsl_initialize_types(state); 2827 ;} 2828 break; 2829 2830 case 5: 2831 2832 /* Line 1464 of yacc.c */ 2833 #line 221 "glsl_parser.ypp" 2834 { 2835 switch ((yyvsp[(2) - (3)].n)) { 2836 case 100: 2837 state->es_shader = true; 2838 case 110: 2839 case 120: 2840 case 130: 2841 /* FINISHME: Check against implementation support versions. */ 2842 state->language_version = (yyvsp[(2) - (3)].n); 2843 break; 2844 default: 2845 _mesa_glsl_error(& (yylsp[(2) - (3)]), state, "Shading language version" 2846 "%u is not supported\n", (yyvsp[(2) - (3)].n)); 2847 break; 2848 } 2849 ;} 2850 break; 2851 2852 case 12: 2853 2854 /* Line 1464 of yacc.c */ 2855 #line 253 "glsl_parser.ypp" 2856 { 2857 if (!_mesa_glsl_process_extension((yyvsp[(2) - (5)].identifier), & (yylsp[(2) - (5)]), (yyvsp[(4) - (5)].identifier), & (yylsp[(4) - (5)]), state)) { 2858 YYERROR; 2859 } 2860 ;} 2861 break; 2862 2863 case 13: 2864 2865 /* Line 1464 of yacc.c */ 2866 #line 262 "glsl_parser.ypp" 2867 { 2868 /* FINISHME: The NULL test is only required because 'precision' 2869 * FINISHME: statements are not yet supported. 2870 */ 2871 if ((yyvsp[(1) - (1)].node) != NULL) 2872 state->translation_unit.push_tail(& (yyvsp[(1) - (1)].node)->link); 2873 ;} 2874 break; 2875 2876 case 14: 2877 2878 /* Line 1464 of yacc.c */ 2879 #line 270 "glsl_parser.ypp" 2880 { 2881 /* FINISHME: The NULL test is only required because 'precision' 2882 * FINISHME: statements are not yet supported. 2883 */ 2884 if ((yyvsp[(2) - (2)].node) != NULL) 2885 state->translation_unit.push_tail(& (yyvsp[(2) - (2)].node)->link); 2886 ;} 2887 break; 2888 2889 case 16: 2890 2891 /* Line 1464 of yacc.c */ 2892 #line 285 "glsl_parser.ypp" 2893 { 2894 void *ctx = state; 2895 (yyval.expression) = new(ctx) ast_expression(ast_identifier, NULL, NULL, NULL); 2896 (yyval.expression)->set_location(yylloc); 2897 (yyval.expression)->primary_expression.identifier = (yyvsp[(1) - (1)].identifier); 2898 ;} 2899 break; 2900 2901 case 17: 2902 2903 /* Line 1464 of yacc.c */ 2904 #line 292 "glsl_parser.ypp" 2905 { 2906 void *ctx = state; 2907 (yyval.expression) = new(ctx) ast_expression(ast_int_constant, NULL, NULL, NULL); 2908 (yyval.expression)->set_location(yylloc); 2909 (yyval.expression)->primary_expression.int_constant = (yyvsp[(1) - (1)].n); 2910 ;} 2911 break; 2912 2913 case 18: 2914 2915 /* Line 1464 of yacc.c */ 2916 #line 299 "glsl_parser.ypp" 2917 { 2918 void *ctx = state; 2919 (yyval.expression) = new(ctx) ast_expression(ast_uint_constant, NULL, NULL, NULL); 2920 (yyval.expression)->set_location(yylloc); 2921 (yyval.expression)->primary_expression.uint_constant = (yyvsp[(1) - (1)].n); 2922 ;} 2923 break; 2924 2925 case 19: 2926 2927 /* Line 1464 of yacc.c */ 2928 #line 306 "glsl_parser.ypp" 2929 { 2930 void *ctx = state; 2931 (yyval.expression) = new(ctx) ast_expression(ast_float_constant, NULL, NULL, NULL); 2932 (yyval.expression)->set_location(yylloc); 2933 (yyval.expression)->primary_expression.float_constant = (yyvsp[(1) - (1)].real); 2934 ;} 2935 break; 2936 2937 case 20: 2938 2939 /* Line 1464 of yacc.c */ 2940 #line 313 "glsl_parser.ypp" 2941 { 2942 void *ctx = state; 2943 (yyval.expression) = new(ctx) ast_expression(ast_bool_constant, NULL, NULL, NULL); 2944 (yyval.expression)->set_location(yylloc); 2945 (yyval.expression)->primary_expression.bool_constant = (yyvsp[(1) - (1)].n); 2946 ;} 2947 break; 2948 2949 case 21: 2950 2951 /* Line 1464 of yacc.c */ 2952 #line 320 "glsl_parser.ypp" 2953 { 2954 (yyval.expression) = (yyvsp[(2) - (3)].expression); 2955 ;} 2956 break; 2957 2958 case 23: 2959 2960 /* Line 1464 of yacc.c */ 2961 #line 328 "glsl_parser.ypp" 2962 { 2963 void *ctx = state; 2964 (yyval.expression) = new(ctx) ast_expression(ast_array_index, (yyvsp[(1) - (4)].expression), (yyvsp[(3) - (4)].expression), NULL); 2965 (yyval.expression)->set_location(yylloc); 2966 ;} 2967 break; 2968 2969 case 24: 2970 2971 /* Line 1464 of yacc.c */ 2972 #line 334 "glsl_parser.ypp" 2973 { 2974 (yyval.expression) = (yyvsp[(1) - (1)].expression); 2975 ;} 2976 break; 2977 2978 case 25: 2979 2980 /* Line 1464 of yacc.c */ 2981 #line 338 "glsl_parser.ypp" 2982 { 2983 void *ctx = state; 2984 (yyval.expression) = new(ctx) ast_expression(ast_field_selection, (yyvsp[(1) - (3)].expression), NULL, NULL); 2985 (yyval.expression)->set_location(yylloc); 2986 (yyval.expression)->primary_expression.identifier = (yyvsp[(3) - (3)].identifier); 2987 ;} 2988 break; 2989 2990 case 26: 2991 2992 /* Line 1464 of yacc.c */ 2993 #line 345 "glsl_parser.ypp" 2994 { 2995 void *ctx = state; 2996 (yyval.expression) = new(ctx) ast_expression(ast_post_inc, (yyvsp[(1) - (2)].expression), NULL, NULL); 2997 (yyval.expression)->set_location(yylloc); 2998 ;} 2999 break; 3000 3001 case 27: 3002 3003 /* Line 1464 of yacc.c */ 3004 #line 351 "glsl_parser.ypp" 3005 { 3006 void *ctx = state; 3007 (yyval.expression) = new(ctx) ast_expression(ast_post_dec, (yyvsp[(1) - (2)].expression), NULL, NULL); 3008 (yyval.expression)->set_location(yylloc); 3009 ;} 3010 break; 3011 3012 case 31: 3013 3014 /* Line 1464 of yacc.c */ 3015 #line 369 "glsl_parser.ypp" 3016 { 3017 void *ctx = state; 3018 (yyval.expression) = new(ctx) ast_expression(ast_field_selection, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression), NULL); 3019 (yyval.expression)->set_location(yylloc); 3020 ;} 3021 break; 3022 3023 case 36: 3024 3025 /* Line 1464 of yacc.c */ 3026 #line 388 "glsl_parser.ypp" 3027 { 3028 (yyval.expression) = (yyvsp[(1) - (2)].expression); 3029 (yyval.expression)->set_location(yylloc); 3030 (yyval.expression)->expressions.push_tail(& (yyvsp[(2) - (2)].expression)->link); 3031 ;} 3032 break; 3033 3034 case 37: 3035 3036 /* Line 1464 of yacc.c */ 3037 #line 394 "glsl_parser.ypp" 3038 { 3039 (yyval.expression) = (yyvsp[(1) - (3)].expression); 3040 (yyval.expression)->set_location(yylloc); 3041 (yyval.expression)->expressions.push_tail(& (yyvsp[(3) - (3)].expression)->link); 3042 ;} 3043 break; 3044 3045 case 39: 3046 3047 /* Line 1464 of yacc.c */ 3048 #line 410 "glsl_parser.ypp" 3049 { 3050 void *ctx = state; 3051 (yyval.expression) = new(ctx) ast_function_expression((yyvsp[(1) - (1)].type_specifier)); 3052 (yyval.expression)->set_location(yylloc); 3053 ;} 3054 break; 3055 3056 case 40: 3057 3058 /* Line 1464 of yacc.c */ 3059 #line 416 "glsl_parser.ypp" 3060 { 3061 void *ctx = state; 3062 ast_expression *callee = new(ctx) ast_expression((yyvsp[(1) - (1)].identifier)); 3063 (yyval.expression) = new(ctx) ast_function_expression(callee); 3064 (yyval.expression)->set_location(yylloc); 3065 ;} 3066 break; 3067 3068 case 41: 3069 3070 /* Line 1464 of yacc.c */ 3071 #line 423 "glsl_parser.ypp" 3072 { 3073 void *ctx = state; 3074 ast_expression *callee = new(ctx) ast_expression((yyvsp[(1) - (1)].identifier)); 3075 (yyval.expression) = new(ctx) ast_function_expression(callee); 3076 (yyval.expression)->set_location(yylloc); 3077 ;} 3078 break; 3079 3080 case 43: 3081 3082 /* Line 1464 of yacc.c */ 3083 #line 435 "glsl_parser.ypp" 3084 { 3085 void *ctx = state; 3086 (yyval.expression) = new(ctx) ast_expression(ast_pre_inc, (yyvsp[(2) - (2)].expression), NULL, NULL); 3087 (yyval.expression)->set_location(yylloc); 3088 ;} 3089 break; 3090 3091 case 44: 3092 3093 /* Line 1464 of yacc.c */ 3094 #line 441 "glsl_parser.ypp" 3095 { 3096 void *ctx = state; 3097 (yyval.expression) = new(ctx) ast_expression(ast_pre_dec, (yyvsp[(2) - (2)].expression), NULL, NULL); 3098 (yyval.expression)->set_location(yylloc); 3099 ;} 3100 break; 3101 3102 case 45: 3103 3104 /* Line 1464 of yacc.c */ 3105 #line 447 "glsl_parser.ypp" 3106 { 3107 void *ctx = state; 3108 (yyval.expression) = new(ctx) ast_expression((yyvsp[(1) - (2)].n), (yyvsp[(2) - (2)].expression), NULL, NULL); 3109 (yyval.expression)->set_location(yylloc); 3110 ;} 3111 break; 3112 3113 case 46: 3114 3115 /* Line 1464 of yacc.c */ 3116 #line 456 "glsl_parser.ypp" 3117 { (yyval.n) = ast_plus; ;} 3118 break; 3119 3120 case 47: 3121 3122 /* Line 1464 of yacc.c */ 3123 #line 457 "glsl_parser.ypp" 3124 { (yyval.n) = ast_neg; ;} 3125 break; 3126 3127 case 48: 3128 3129 /* Line 1464 of yacc.c */ 3130 #line 458 "glsl_parser.ypp" 3131 { (yyval.n) = ast_logic_not; ;} 3132 break; 3133 3134 case 49: 3135 3136 /* Line 1464 of yacc.c */ 3137 #line 459 "glsl_parser.ypp" 3138 { (yyval.n) = ast_bit_not; ;} 3139 break; 3140 3141 case 51: 3142 3143 /* Line 1464 of yacc.c */ 3144 #line 465 "glsl_parser.ypp" 3145 { 3146 void *ctx = state; 3147 (yyval.expression) = new(ctx) ast_expression_bin(ast_mul, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); 3148 (yyval.expression)->set_location(yylloc); 3149 ;} 3150 break; 3151 3152 case 52: 3153 3154 /* Line 1464 of yacc.c */ 3155 #line 471 "glsl_parser.ypp" 3156 { 3157 void *ctx = state; 3158 (yyval.expression) = new(ctx) ast_expression_bin(ast_div, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); 3159 (yyval.expression)->set_location(yylloc); 3160 ;} 3161 break; 3162 3163 case 53: 3164 3165 /* Line 1464 of yacc.c */ 3166 #line 477 "glsl_parser.ypp" 3167 { 3168 void *ctx = state; 3169 (yyval.expression) = new(ctx) ast_expression_bin(ast_mod, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); 3170 (yyval.expression)->set_location(yylloc); 3171 ;} 3172 break; 3173 3174 case 55: 3175 3176 /* Line 1464 of yacc.c */ 3177 #line 487 "glsl_parser.ypp" 3178 { 3179 void *ctx = state; 3180 (yyval.expression) = new(ctx) ast_expression_bin(ast_add, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); 3181 (yyval.expression)->set_location(yylloc); 3182 ;} 3183 break; 3184 3185 case 56: 3186 3187 /* Line 1464 of yacc.c */ 3188 #line 493 "glsl_parser.ypp" 3189 { 3190 void *ctx = state; 3191 (yyval.expression) = new(ctx) ast_expression_bin(ast_sub, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); 3192 (yyval.expression)->set_location(yylloc); 3193 ;} 3194 break; 3195 3196 case 58: 3197 3198 /* Line 1464 of yacc.c */ 3199 #line 503 "glsl_parser.ypp" 3200 { 3201 void *ctx = state; 3202 (yyval.expression) = new(ctx) ast_expression_bin(ast_lshift, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); 3203 (yyval.expression)->set_location(yylloc); 3204 ;} 3205 break; 3206 3207 case 59: 3208 3209 /* Line 1464 of yacc.c */ 3210 #line 509 "glsl_parser.ypp" 3211 { 3212 void *ctx = state; 3213 (yyval.expression) = new(ctx) ast_expression_bin(ast_rshift, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); 3214 (yyval.expression)->set_location(yylloc); 3215 ;} 3216 break; 3217 3218 case 61: 3219 3220 /* Line 1464 of yacc.c */ 3221 #line 519 "glsl_parser.ypp" 3222 { 3223 void *ctx = state; 3224 (yyval.expression) = new(ctx) ast_expression_bin(ast_less, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); 3225 (yyval.expression)->set_location(yylloc); 3226 ;} 3227 break; 3228 3229 case 62: 3230 3231 /* Line 1464 of yacc.c */ 3232 #line 525 "glsl_parser.ypp" 3233 { 3234 void *ctx = state; 3235 (yyval.expression) = new(ctx) ast_expression_bin(ast_greater, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); 3236 (yyval.expression)->set_location(yylloc); 3237 ;} 3238 break; 3239 3240 case 63: 3241 3242 /* Line 1464 of yacc.c */ 3243 #line 531 "glsl_parser.ypp" 3244 { 3245 void *ctx = state; 3246 (yyval.expression) = new(ctx) ast_expression_bin(ast_lequal, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); 3247 (yyval.expression)->set_location(yylloc); 3248 ;} 3249 break; 3250 3251 case 64: 3252 3253 /* Line 1464 of yacc.c */ 3254 #line 537 "glsl_parser.ypp" 3255 { 3256 void *ctx = state; 3257 (yyval.expression) = new(ctx) ast_expression_bin(ast_gequal, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); 3258 (yyval.expression)->set_location(yylloc); 3259 ;} 3260 break; 3261 3262 case 66: 3263 3264 /* Line 1464 of yacc.c */ 3265 #line 547 "glsl_parser.ypp" 3266 { 3267 void *ctx = state; 3268 (yyval.expression) = new(ctx) ast_expression_bin(ast_equal, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); 3269 (yyval.expression)->set_location(yylloc); 3270 ;} 3271 break; 3272 3273 case 67: 3274 3275 /* Line 1464 of yacc.c */ 3276 #line 553 "glsl_parser.ypp" 3277 { 3278 void *ctx = state; 3279 (yyval.expression) = new(ctx) ast_expression_bin(ast_nequal, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); 3280 (yyval.expression)->set_location(yylloc); 3281 ;} 3282 break; 3283 3284 case 69: 3285 3286 /* Line 1464 of yacc.c */ 3287 #line 563 "glsl_parser.ypp" 3288 { 3289 void *ctx = state; 3290 (yyval.expression) = new(ctx) ast_expression_bin(ast_bit_and, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); 3291 (yyval.expression)->set_location(yylloc); 3292 ;} 3293 break; 3294 3295 case 71: 3296 3297 /* Line 1464 of yacc.c */ 3298 #line 573 "glsl_parser.ypp" 3299 { 3300 void *ctx = state; 3301 (yyval.expression) = new(ctx) ast_expression_bin(ast_bit_xor, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); 3302 (yyval.expression)->set_location(yylloc); 3303 ;} 3304 break; 3305 3306 case 73: 3307 3308 /* Line 1464 of yacc.c */ 3309 #line 583 "glsl_parser.ypp" 3310 { 3311 void *ctx = state; 3312 (yyval.expression) = new(ctx) ast_expression_bin(ast_bit_or, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); 3313 (yyval.expression)->set_location(yylloc); 3314 ;} 3315 break; 3316 3317 case 75: 3318 3319 /* Line 1464 of yacc.c */ 3320 #line 593 "glsl_parser.ypp" 3321 { 3322 void *ctx = state; 3323 (yyval.expression) = new(ctx) ast_expression_bin(ast_logic_and, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); 3324 (yyval.expression)->set_location(yylloc); 3325 ;} 3326 break; 3327 3328 case 77: 3329 3330 /* Line 1464 of yacc.c */ 3331 #line 603 "glsl_parser.ypp" 3332 { 3333 void *ctx = state; 3334 (yyval.expression) = new(ctx) ast_expression_bin(ast_logic_xor, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); 3335 (yyval.expression)->set_location(yylloc); 3336 ;} 3337 break; 3338 3339 case 79: 3340 3341 /* Line 1464 of yacc.c */ 3342 #line 613 "glsl_parser.ypp" 3343 { 3344 void *ctx = state; 3345 (yyval.expression) = new(ctx) ast_expression_bin(ast_logic_or, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); 3346 (yyval.expression)->set_location(yylloc); 3347 ;} 3348 break; 3349 3350 case 81: 3351 3352 /* Line 1464 of yacc.c */ 3353 #line 623 "glsl_parser.ypp" 3354 { 3355 void *ctx = state; 3356 (yyval.expression) = new(ctx) ast_expression(ast_conditional, (yyvsp[(1) - (5)].expression), (yyvsp[(3) - (5)].expression), (yyvsp[(5) - (5)].expression)); 3357 (yyval.expression)->set_location(yylloc); 3358 ;} 3359 break; 3360 3361 case 83: 3362 3363 /* Line 1464 of yacc.c */ 3364 #line 633 "glsl_parser.ypp" 3365 { 3366 void *ctx = state; 3367 (yyval.expression) = new(ctx) ast_expression((yyvsp[(2) - (3)].n), (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression), NULL); 3368 (yyval.expression)->set_location(yylloc); 3369 ;} 3370 break; 3371 3372 case 84: 3373 3374 /* Line 1464 of yacc.c */ 3375 #line 641 "glsl_parser.ypp" 3376 { (yyval.n) = ast_assign; ;} 3377 break; 3378 3379 case 85: 3380 3381 /* Line 1464 of yacc.c */ 3382 #line 642 "glsl_parser.ypp" 3383 { (yyval.n) = ast_mul_assign; ;} 3384 break; 3385 3386 case 86: 3387 3388 /* Line 1464 of yacc.c */ 3389 #line 643 "glsl_parser.ypp" 3390 { (yyval.n) = ast_div_assign; ;} 3391 break; 3392 3393 case 87: 3394 3395 /* Line 1464 of yacc.c */ 3396 #line 644 "glsl_parser.ypp" 3397 { (yyval.n) = ast_mod_assign; ;} 3398 break; 3399 3400 case 88: 3401 3402 /* Line 1464 of yacc.c */ 3403 #line 645 "glsl_parser.ypp" 3404 { (yyval.n) = ast_add_assign; ;} 3405 break; 3406 3407 case 89: 3408 3409 /* Line 1464 of yacc.c */ 3410 #line 646 "glsl_parser.ypp" 3411 { (yyval.n) = ast_sub_assign; ;} 3412 break; 3413 3414 case 90: 3415 3416 /* Line 1464 of yacc.c */ 3417 #line 647 "glsl_parser.ypp" 3418 { (yyval.n) = ast_ls_assign; ;} 3419 break; 3420 3421 case 91: 3422 3423 /* Line 1464 of yacc.c */ 3424 #line 648 "glsl_parser.ypp" 3425 { (yyval.n) = ast_rs_assign; ;} 3426 break; 3427 3428 case 92: 3429 3430 /* Line 1464 of yacc.c */ 3431 #line 649 "glsl_parser.ypp" 3432 { (yyval.n) = ast_and_assign; ;} 3433 break; 3434 3435 case 93: 3436 3437 /* Line 1464 of yacc.c */ 3438 #line 650 "glsl_parser.ypp" 3439 { (yyval.n) = ast_xor_assign; ;} 3440 break; 3441 3442 case 94: 3443 3444 /* Line 1464 of yacc.c */ 3445 #line 651 "glsl_parser.ypp" 3446 { (yyval.n) = ast_or_assign; ;} 3447 break; 3448 3449 case 95: 3450 3451 /* Line 1464 of yacc.c */ 3452 #line 656 "glsl_parser.ypp" 3453 { 3454 (yyval.expression) = (yyvsp[(1) - (1)].expression); 3455 ;} 3456 break; 3457 3458 case 96: 3459 3460 /* Line 1464 of yacc.c */ 3461 #line 660 "glsl_parser.ypp" 3462 { 3463 void *ctx = state; 3464 if ((yyvsp[(1) - (3)].expression)->oper != ast_sequence) { 3465 (yyval.expression) = new(ctx) ast_expression(ast_sequence, NULL, NULL, NULL); 3466 (yyval.expression)->set_location(yylloc); 3467 (yyval.expression)->expressions.push_tail(& (yyvsp[(1) - (3)].expression)->link); 3468 } else { 3469 (yyval.expression) = (yyvsp[(1) - (3)].expression); 3470 } 3471 3472 (yyval.expression)->expressions.push_tail(& (yyvsp[(3) - (3)].expression)->link); 3473 ;} 3474 break; 3475 3476 case 98: 3477 3478 /* Line 1464 of yacc.c */ 3479 #line 680 "glsl_parser.ypp" 3480 { 3481 (yyval.node) = (yyvsp[(1) - (2)].function); 3482 ;} 3483 break; 3484 3485 case 99: 3486 3487 /* Line 1464 of yacc.c */ 3488 #line 684 "glsl_parser.ypp" 3489 { 3490 (yyval.node) = (yyvsp[(1) - (2)].declarator_list); 3491 ;} 3492 break; 3493 3494 case 100: 3495 3496 /* Line 1464 of yacc.c */ 3497 #line 688 "glsl_parser.ypp" 3498 { 3499 if (((yyvsp[(3) - (4)].type_specifier)->type_specifier != ast_float) 3500 && ((yyvsp[(3) - (4)].type_specifier)->type_specifier != ast_int)) { 3501 _mesa_glsl_error(& (yylsp[(3) - (4)]), state, "global precision qualifier can " 3502 "only be applied to `int' or `float'\n"); 3503 YYERROR; 3504 } 3505 3506 (yyval.node) = NULL; /* FINISHME */ 3507 ;} 3508 break; 3509 3510 case 104: 3511 3512 /* Line 1464 of yacc.c */ 3513 #line 711 "glsl_parser.ypp" 3514 { 3515 (yyval.function) = (yyvsp[(1) - (2)].function); 3516 (yyval.function)->parameters.push_tail(& (yyvsp[(2) - (2)].parameter_declarator)->link); 3517 ;} 3518 break; 3519 3520 case 105: 3521 3522 /* Line 1464 of yacc.c */ 3523 #line 716 "glsl_parser.ypp" 3524 { 3525 (yyval.function) = (yyvsp[(1) - (3)].function); 3526 (yyval.function)->parameters.push_tail(& (yyvsp[(3) - (3)].parameter_declarator)->link); 3527 ;} 3528 break; 3529 3530 case 106: 3531 3532 /* Line 1464 of yacc.c */ 3533 #line 724 "glsl_parser.ypp" 3534 { 3535 void *ctx = state; 3536 (yyval.function) = new(ctx) ast_function(); 3537 (yyval.function)->set_location(yylloc); 3538 (yyval.function)->return_type = (yyvsp[(1) - (3)].fully_specified_type); 3539 (yyval.function)->identifier = (yyvsp[(2) - (3)].identifier); 3540 ;} 3541 break; 3542 3543 case 107: 3544 3545 /* Line 1464 of yacc.c */ 3546 #line 735 "glsl_parser.ypp" 3547 { 3548 void *ctx = state; 3549 (yyval.parameter_declarator) = new(ctx) ast_parameter_declarator(); 3550 (yyval.parameter_declarator)->set_location(yylloc); 3551 (yyval.parameter_declarator)->type = new(ctx) ast_fully_specified_type(); 3552 (yyval.parameter_declarator)->type->set_location(yylloc); 3553 (yyval.parameter_declarator)->type->specifier = (yyvsp[(1) - (2)].type_specifier); 3554 (yyval.parameter_declarator)->identifier = (yyvsp[(2) - (2)].identifier); 3555 ;} 3556 break; 3557 3558 case 108: 3559 3560 /* Line 1464 of yacc.c */ 3561 #line 745 "glsl_parser.ypp" 3562 { 3563 void *ctx = state; 3564 (yyval.parameter_declarator) = new(ctx) ast_parameter_declarator(); 3565 (yyval.parameter_declarator)->set_location(yylloc); 3566 (yyval.parameter_declarator)->type = new(ctx) ast_fully_specified_type(); 3567 (yyval.parameter_declarator)->type->set_location(yylloc); 3568 (yyval.parameter_declarator)->type->specifier = (yyvsp[(1) - (5)].type_specifier); 3569 (yyval.parameter_declarator)->identifier = (yyvsp[(2) - (5)].identifier); 3570 (yyval.parameter_declarator)->is_array = true; 3571 (yyval.parameter_declarator)->array_size = (yyvsp[(4) - (5)].expression); 3572 ;} 3573 break; 3574 3575 case 109: 3576 3577 /* Line 1464 of yacc.c */ 3578 #line 760 "glsl_parser.ypp" 3579 { 3580 (yyvsp[(1) - (3)].type_qualifier).flags.i |= (yyvsp[(2) - (3)].type_qualifier).flags.i; 3581 3582 (yyval.parameter_declarator) = (yyvsp[(3) - (3)].parameter_declarator); 3583 (yyval.parameter_declarator)->type->qualifier = (yyvsp[(1) - (3)].type_qualifier); 3584 ;} 3585 break; 3586 3587 case 110: 3588 3589 /* Line 1464 of yacc.c */ 3590 #line 767 "glsl_parser.ypp" 3591 { 3592 (yyval.parameter_declarator) = (yyvsp[(2) - (2)].parameter_declarator); 3593 (yyval.parameter_declarator)->type->qualifier = (yyvsp[(1) - (2)].type_qualifier); 3594 ;} 3595 break; 3596 3597 case 111: 3598 3599 /* Line 1464 of yacc.c */ 3600 #line 772 "glsl_parser.ypp" 3601 { 3602 void *ctx = state; 3603 (yyvsp[(1) - (3)].type_qualifier).flags.i |= (yyvsp[(2) - (3)].type_qualifier).flags.i; 3604 3605 (yyval.parameter_declarator) = new(ctx) ast_parameter_declarator(); 3606 (yyval.parameter_declarator)->set_location(yylloc); 3607 (yyval.parameter_declarator)->type = new(ctx) ast_fully_specified_type(); 3608 (yyval.parameter_declarator)->type->qualifier = (yyvsp[(1) - (3)].type_qualifier); 3609 (yyval.parameter_declarator)->type->specifier = (yyvsp[(3) - (3)].type_specifier); 3610 ;} 3611 break; 3612 3613 case 112: 3614 3615 /* Line 1464 of yacc.c */ 3616 #line 783 "glsl_parser.ypp" 3617 { 3618 void *ctx = state; 3619 (yyval.parameter_declarator) = new(ctx) ast_parameter_declarator(); 3620 (yyval.parameter_declarator)->set_location(yylloc); 3621 (yyval.parameter_declarator)->type = new(ctx) ast_fully_specified_type(); 3622 (yyval.parameter_declarator)->type->qualifier = (yyvsp[(1) - (2)].type_qualifier); 3623 (yyval.parameter_declarator)->type->specifier = (yyvsp[(2) - (2)].type_specifier); 3624 ;} 3625 break; 3626 3627 case 113: 3628 3629 /* Line 1464 of yacc.c */ 3630 #line 795 "glsl_parser.ypp" 3631 { 3632 memset(& (yyval.type_qualifier), 0, sizeof((yyval.type_qualifier))); 3633 ;} 3634 break; 3635 3636 case 114: 3637 3638 /* Line 1464 of yacc.c */ 3639 #line 799 "glsl_parser.ypp" 3640 { 3641 memset(& (yyval.type_qualifier), 0, sizeof((yyval.type_qualifier))); 3642 (yyval.type_qualifier).flags.q.in = 1; 3643 ;} 3644 break; 3645 3646 case 115: 3647 3648 /* Line 1464 of yacc.c */ 3649 #line 804 "glsl_parser.ypp" 3650 { 3651 memset(& (yyval.type_qualifier), 0, sizeof((yyval.type_qualifier))); 3652 (yyval.type_qualifier).flags.q.out = 1; 3653 ;} 3654 break; 3655 3656 case 116: 3657 3658 /* Line 1464 of yacc.c */ 3659 #line 809 "glsl_parser.ypp" 3660 { 3661 memset(& (yyval.type_qualifier), 0, sizeof((yyval.type_qualifier))); 3662 (yyval.type_qualifier).flags.q.in = 1; 3663 (yyval.type_qualifier).flags.q.out = 1; 3664 ;} 3665 break; 3666 3667 case 119: 3668 3669 /* Line 1464 of yacc.c */ 3670 #line 823 "glsl_parser.ypp" 3671 { 3672 void *ctx = state; 3673 ast_declaration *decl = new(ctx) ast_declaration((yyvsp[(3) - (3)].identifier), false, NULL, NULL); 3674 decl->set_location(yylloc); 3675 3676 (yyval.declarator_list) = (yyvsp[(1) - (3)].declarator_list); 3677 (yyval.declarator_list)->declarations.push_tail(&decl->link); 3678 ;} 3679 break; 3680 3681 case 120: 3682 3683 /* Line 1464 of yacc.c */ 3684 #line 832 "glsl_parser.ypp" 3685 { 3686 void *ctx = state; 3687 ast_declaration *decl = new(ctx) ast_declaration((yyvsp[(3) - (5)].identifier), true, NULL, NULL); 3688 decl->set_location(yylloc); 3689 3690 (yyval.declarator_list) = (yyvsp[(1) - (5)].declarator_list); 3691 (yyval.declarator_list)->declarations.push_tail(&decl->link); 3692 ;} 3693 break; 3694 3695 case 121: 3696 3697 /* Line 1464 of yacc.c */ 3698 #line 841 "glsl_parser.ypp" 3699 { 3700 void *ctx = state; 3701 ast_declaration *decl = new(ctx) ast_declaration((yyvsp[(3) - (6)].identifier), true, (yyvsp[(5) - (6)].expression), NULL); 3702 decl->set_location(yylloc); 3703 3704 (yyval.declarator_list) = (yyvsp[(1) - (6)].declarator_list); 3705 (yyval.declarator_list)->declarations.push_tail(&decl->link); 3706 ;} 3707 break; 3708 3709 case 122: 3710 3711 /* Line 1464 of yacc.c */ 3712 #line 850 "glsl_parser.ypp" 3713 { 3714 void *ctx = state; 3715 ast_declaration *decl = new(ctx) ast_declaration((yyvsp[(3) - (7)].identifier), true, NULL, (yyvsp[(7) - (7)].expression)); 3716 decl->set_location(yylloc); 3717 3718 (yyval.declarator_list) = (yyvsp[(1) - (7)].declarator_list); 3719 (yyval.declarator_list)->declarations.push_tail(&decl->link); 3720 ;} 3721 break; 3722 3723 case 123: 3724 3725 /* Line 1464 of yacc.c */ 3726 #line 859 "glsl_parser.ypp" 3727 { 3728 void *ctx = state; 3729 ast_declaration *decl = new(ctx) ast_declaration((yyvsp[(3) - (8)].identifier), true, (yyvsp[(5) - (8)].expression), (yyvsp[(8) - (8)].expression)); 3730 decl->set_location(yylloc); 3731 3732 (yyval.declarator_list) = (yyvsp[(1) - (8)].declarator_list); 3733 (yyval.declarator_list)->declarations.push_tail(&decl->link); 3734 ;} 3735 break; 3736 3737 case 124: 3738 3739 /* Line 1464 of yacc.c */ 3740 #line 868 "glsl_parser.ypp" 3741 { 3742 void *ctx = state; 3743 ast_declaration *decl = new(ctx) ast_declaration((yyvsp[(3) - (5)].identifier), false, NULL, (yyvsp[(5) - (5)].expression)); 3744 decl->set_location(yylloc); 3745 3746 (yyval.declarator_list) = (yyvsp[(1) - (5)].declarator_list); 3747 (yyval.declarator_list)->declarations.push_tail(&decl->link); 3748 ;} 3749 break; 3750 3751 case 125: 3752 3753 /* Line 1464 of yacc.c */ 3754 #line 881 "glsl_parser.ypp" 3755 { 3756 void *ctx = state; 3757 if ((yyvsp[(1) - (1)].fully_specified_type)->specifier->type_specifier != ast_struct) { 3758 _mesa_glsl_error(& (yylsp[(1) - (1)]), state, "empty declaration list\n"); 3759 YYERROR; 3760 } else { 3761 (yyval.declarator_list) = new(ctx) ast_declarator_list((yyvsp[(1) - (1)].fully_specified_type)); 3762 (yyval.declarator_list)->set_location(yylloc); 3763 } 3764 ;} 3765 break; 3766 3767 case 126: 3768 3769 /* Line 1464 of yacc.c */ 3770 #line 892 "glsl_parser.ypp" 3771 { 3772 void *ctx = state; 3773 ast_declaration *decl = new(ctx) ast_declaration((yyvsp[(2) - (2)].identifier), false, NULL, NULL); 3774 3775 (yyval.declarator_list) = new(ctx) ast_declarator_list((yyvsp[(1) - (2)].fully_specified_type)); 3776 (yyval.declarator_list)->set_location(yylloc); 3777 (yyval.declarator_list)->declarations.push_tail(&decl->link); 3778 ;} 3779 break; 3780 3781 case 127: 3782 3783 /* Line 1464 of yacc.c */ 3784 #line 901 "glsl_parser.ypp" 3785 { 3786 void *ctx = state; 3787 ast_declaration *decl = new(ctx) ast_declaration((yyvsp[(2) - (4)].identifier), true, NULL, NULL); 3788 3789 (yyval.declarator_list) = new(ctx) ast_declarator_list((yyvsp[(1) - (4)].fully_specified_type)); 3790 (yyval.declarator_list)->set_location(yylloc); 3791 (yyval.declarator_list)->declarations.push_tail(&decl->link); 3792 ;} 3793 break; 3794 3795 case 128: 3796 3797 /* Line 1464 of yacc.c */ 3798 #line 910 "glsl_parser.ypp" 3799 { 3800 void *ctx = state; 3801 ast_declaration *decl = new(ctx) ast_declaration((yyvsp[(2) - (5)].identifier), true, (yyvsp[(4) - (5)].expression), NULL); 3802 3803 (yyval.declarator_list) = new(ctx) ast_declarator_list((yyvsp[(1) - (5)].fully_specified_type)); 3804 (yyval.declarator_list)->set_location(yylloc); 3805 (yyval.declarator_list)->declarations.push_tail(&decl->link); 3806 ;} 3807 break; 3808 3809 case 129: 3810 3811 /* Line 1464 of yacc.c */ 3812 #line 919 "glsl_parser.ypp" 3813 { 3814 void *ctx = state; 3815 ast_declaration *decl = new(ctx) ast_declaration((yyvsp[(2) - (6)].identifier), true, NULL, (yyvsp[(6) - (6)].expression)); 3816 3817 (yyval.declarator_list) = new(ctx) ast_declarator_list((yyvsp[(1) - (6)].fully_specified_type)); 3818 (yyval.declarator_list)->set_location(yylloc); 3819 (yyval.declarator_list)->declarations.push_tail(&decl->link); 3820 ;} 3821 break; 3822 3823 case 130: 3824 3825 /* Line 1464 of yacc.c */ 3826 #line 928 "glsl_parser.ypp" 3827 { 3828 void *ctx = state; 3829 ast_declaration *decl = new(ctx) ast_declaration((yyvsp[(2) - (7)].identifier), true, (yyvsp[(4) - (7)].expression), (yyvsp[(7) - (7)].expression)); 3830 3831 (yyval.declarator_list) = new(ctx) ast_declarator_list((yyvsp[(1) - (7)].fully_specified_type)); 3832 (yyval.declarator_list)->set_location(yylloc); 3833 (yyval.declarator_list)->declarations.push_tail(&decl->link); 3834 ;} 3835 break; 3836 3837 case 131: 3838 3839 /* Line 1464 of yacc.c */ 3840 #line 937 "glsl_parser.ypp" 3841 { 3842 void *ctx = state; 3843 ast_declaration *decl = new(ctx) ast_declaration((yyvsp[(2) - (4)].identifier), false, NULL, (yyvsp[(4) - (4)].expression)); 3844 3845 (yyval.declarator_list) = new(ctx) ast_declarator_list((yyvsp[(1) - (4)].fully_specified_type)); 3846 (yyval.declarator_list)->set_location(yylloc); 3847 (yyval.declarator_list)->declarations.push_tail(&decl->link); 3848 ;} 3849 break; 3850 3851 case 132: 3852 3853 /* Line 1464 of yacc.c */ 3854 #line 946 "glsl_parser.ypp" 3855 { 3856 void *ctx = state; 3857 ast_declaration *decl = new(ctx) ast_declaration((yyvsp[(2) - (2)].identifier), false, NULL, NULL); 3858 3859 (yyval.declarator_list) = new(ctx) ast_declarator_list(NULL); 3860 (yyval.declarator_list)->set_location(yylloc); 3861 (yyval.declarator_list)->invariant = true; 3862 3863 (yyval.declarator_list)->declarations.push_tail(&decl->link); 3864 ;} 3865 break; 3866 3867 case 133: 3868 3869 /* Line 1464 of yacc.c */ 3870 #line 960 "glsl_parser.ypp" 3871 { 3872 void *ctx = state; 3873 (yyval.fully_specified_type) = new(ctx) ast_fully_specified_type(); 3874 (yyval.fully_specified_type)->set_location(yylloc); 3875 (yyval.fully_specified_type)->specifier = (yyvsp[(1) - (1)].type_specifier); 3876 ;} 3877 break; 3878 3879 case 134: 3880 3881 /* Line 1464 of yacc.c */ 3882 #line 967 "glsl_parser.ypp" 3883 { 3884 void *ctx = state; 3885 (yyval.fully_specified_type) = new(ctx) ast_fully_specified_type(); 3886 (yyval.fully_specified_type)->set_location(yylloc); 3887 (yyval.fully_specified_type)->qualifier = (yyvsp[(1) - (2)].type_qualifier); 3888 (yyval.fully_specified_type)->specifier = (yyvsp[(2) - (2)].type_specifier); 3889 ;} 3890 break; 3891 3892 case 135: 3893 3894 /* Line 1464 of yacc.c */ 3895 #line 978 "glsl_parser.ypp" 3896 { 3897 (yyval.type_qualifier) = (yyvsp[(3) - (4)].type_qualifier); 3898 ;} 3899 break; 3900 3901 case 137: 3902 3903 /* Line 1464 of yacc.c */ 3904 #line 986 "glsl_parser.ypp" 3905 { 3906 if (((yyvsp[(1) - (3)].type_qualifier).flags.i & (yyvsp[(3) - (3)].type_qualifier).flags.i) != 0) { 3907 _mesa_glsl_error(& (yylsp[(3) - (3)]), state, 3908 "duplicate layout qualifiers used\n"); 3909 YYERROR; 3910 } 3911 3912 (yyval.type_qualifier).flags.i = (yyvsp[(1) - (3)].type_qualifier).flags.i | (yyvsp[(3) - (3)].type_qualifier).flags.i; 3913 3914 if ((yyvsp[(1) - (3)].type_qualifier).flags.q.explicit_location) 3915 (yyval.type_qualifier).location = (yyvsp[(1) - (3)].type_qualifier).location; 3916 3917 if ((yyvsp[(3) - (3)].type_qualifier).flags.q.explicit_location) 3918 (yyval.type_qualifier).location = (yyvsp[(3) - (3)].type_qualifier).location; 3919 ;} 3920 break; 3921 3922 case 138: 3923 3924 /* Line 1464 of yacc.c */ 3925 #line 1005 "glsl_parser.ypp" 3926 { 3927 bool got_one = false; 3928 3929 memset(& (yyval.type_qualifier), 0, sizeof((yyval.type_qualifier))); 3930 3931 if (state->ARB_fragment_coord_conventions_enable) { 3932 if (strcmp((yyvsp[(1) - (1)].identifier), "origin_upper_left") == 0) { 3933 got_one = true; 3934 (yyval.type_qualifier).flags.q.origin_upper_left = 1; 3935 } else if (strcmp((yyvsp[(1) - (1)].identifier), "pixel_center_integer") == 0) { 3936 got_one = true; 3937 (yyval.type_qualifier).flags.q.pixel_center_integer = 1; 3938 } 3939 } 3940 3941 /* If the identifier didn't match any known layout identifiers, 3942 * emit an error. 3943 */ 3944 if (!got_one) { 3945 _mesa_glsl_error(& (yylsp[(1) - (1)]), state, "unrecognized layout identifier " 3946 "`%s'\n", (yyvsp[(1) - (1)].identifier)); 3947 YYERROR; 3948 } else if (state->ARB_fragment_coord_conventions_warn) { 3949 _mesa_glsl_warning(& (yylsp[(1) - (1)]), state, 3950 "GL_ARB_fragment_coord_conventions layout " 3951 "identifier `%s' used\n", (yyvsp[(1) - (1)].identifier)); 3952 } 3953 ;} 3954 break; 3955 3956 case 139: 3957 3958 /* Line 1464 of yacc.c */ 3959 #line 1034 "glsl_parser.ypp" 3960 { 3961 bool got_one = false; 3962 3963 memset(& (yyval.type_qualifier), 0, sizeof((yyval.type_qualifier))); 3964 3965 if (state->ARB_explicit_attrib_location_enable) { 3966 /* FINISHME: Handle 'index' once GL_ARB_blend_func_exteneded and 3967 * FINISHME: GLSL 1.30 (or later) are supported. 3968 */ 3969 if (strcmp("location", (yyvsp[(1) - (3)].identifier)) == 0) { 3970 got_one = true; 3971 3972 (yyval.type_qualifier).flags.q.explicit_location = 1; 3973 3974 if ((yyvsp[(3) - (3)].n) >= 0) { 3975 (yyval.type_qualifier).location = (yyvsp[(3) - (3)].n); 3976 } else { 3977 _mesa_glsl_error(& (yylsp[(3) - (3)]), state, 3978 "invalid location %d specified\n", (yyvsp[(3) - (3)].n)); 3979 YYERROR; 3980 } 3981 } 3982 } 3983 3984 /* If the identifier didn't match any known layout identifiers, 3985 * emit an error. 3986 */ 3987 if (!got_one) { 3988 _mesa_glsl_error(& (yylsp[(1) - (3)]), state, "unrecognized layout identifier " 3989 "`%s'\n", (yyvsp[(1) - (3)].identifier)); 3990 YYERROR; 3991 } else if (state->ARB_explicit_attrib_location_warn) { 3992 _mesa_glsl_warning(& (yylsp[(1) - (3)]), state, 3993 "GL_ARB_explicit_attrib_location layout " 3994 "identifier `%s' used\n", (yyvsp[(1) - (3)].identifier)); 3995 } 3996 ;} 3997 break; 3998 3999 case 140: 4000 4001 /* Line 1464 of yacc.c */ 4002 #line 1075 "glsl_parser.ypp" 4003 { 4004 memset(& (yyval.type_qualifier), 0, sizeof((yyval.type_qualifier))); 4005 (yyval.type_qualifier).flags.q.smooth = 1; 4006 ;} 4007 break; 4008 4009 case 141: 4010 4011 /* Line 1464 of yacc.c */ 4012 #line 1080 "glsl_parser.ypp" 4013 { 4014 memset(& (yyval.type_qualifier), 0, sizeof((yyval.type_qualifier))); 4015 (yyval.type_qualifier).flags.q.flat = 1; 4016 ;} 4017 break; 4018 4019 case 142: 4020 4021 /* Line 1464 of yacc.c */ 4022 #line 1085 "glsl_parser.ypp" 4023 { 4024 memset(& (yyval.type_qualifier), 0, sizeof((yyval.type_qualifier))); 4025 (yyval.type_qualifier).flags.q.noperspective = 1; 4026 ;} 4027 break; 4028 4029 case 143: 4030 4031 /* Line 1464 of yacc.c */ 4032 #line 1093 "glsl_parser.ypp" 4033 { 4034 memset(& (yyval.type_qualifier), 0, sizeof((yyval.type_qualifier))); 4035 (yyval.type_qualifier).flags.q.constant = 1; 4036 ;} 4037 break; 4038 4039 case 146: 4040 4041 /* Line 1464 of yacc.c */ 4042 #line 1103 "glsl_parser.ypp" 4043 { 4044 (yyval.type_qualifier) = (yyvsp[(1) - (2)].type_qualifier); 4045 (yyval.type_qualifier).flags.i |= (yyvsp[(2) - (2)].type_qualifier).flags.i; 4046 ;} 4047 break; 4048 4049 case 148: 4050 4051 /* Line 1464 of yacc.c */ 4052 #line 1109 "glsl_parser.ypp" 4053 { 4054 (yyval.type_qualifier) = (yyvsp[(1) - (2)].type_qualifier); 4055 (yyval.type_qualifier).flags.i |= (yyvsp[(2) - (2)].type_qualifier).flags.i; 4056 ;} 4057 break; 4058 4059 case 149: 4060 4061 /* Line 1464 of yacc.c */ 4062 #line 1114 "glsl_parser.ypp" 4063 { 4064 (yyval.type_qualifier) = (yyvsp[(2) - (2)].type_qualifier); 4065 (yyval.type_qualifier).flags.q.invariant = 1; 4066 ;} 4067 break; 4068 4069 case 150: 4070 4071 /* Line 1464 of yacc.c */ 4072 #line 1119 "glsl_parser.ypp" 4073 { 4074 (yyval.type_qualifier) = (yyvsp[(2) - (3)].type_qualifier); 4075 (yyval.type_qualifier).flags.i |= (yyvsp[(3) - (3)].type_qualifier).flags.i; 4076 (yyval.type_qualifier).flags.q.invariant = 1; 4077 ;} 4078 break; 4079 4080 case 151: 4081 4082 /* Line 1464 of yacc.c */ 4083 #line 1125 "glsl_parser.ypp" 4084 { 4085 memset(& (yyval.type_qualifier), 0, sizeof((yyval.type_qualifier))); 4086 (yyval.type_qualifier).flags.q.invariant = 1; 4087 ;} 4088 break; 4089 4090 case 152: 4091 4092 /* Line 1464 of yacc.c */ 4093 #line 1133 "glsl_parser.ypp" 4094 { 4095 memset(& (yyval.type_qualifier), 0, sizeof((yyval.type_qualifier))); 4096 (yyval.type_qualifier).flags.q.constant = 1; 4097 ;} 4098 break; 4099 4100 case 153: 4101 4102 /* Line 1464 of yacc.c */ 4103 #line 1138 "glsl_parser.ypp" 4104 { 4105 memset(& (yyval.type_qualifier), 0, sizeof((yyval.type_qualifier))); 4106 (yyval.type_qualifier).flags.q.attribute = 1; 4107 ;} 4108 break; 4109 4110 case 154: 4111 4112 /* Line 1464 of yacc.c */ 4113 #line 1143 "glsl_parser.ypp" 4114 { 4115 memset(& (yyval.type_qualifier), 0, sizeof((yyval.type_qualifier))); 4116 (yyval.type_qualifier).flags.q.varying = 1; 4117 ;} 4118 break; 4119 4120 case 155: 4121 4122 /* Line 1464 of yacc.c */ 4123 #line 1148 "glsl_parser.ypp" 4124 { 4125 memset(& (yyval.type_qualifier), 0, sizeof((yyval.type_qualifier))); 4126 (yyval.type_qualifier).flags.q.centroid = 1; 4127 (yyval.type_qualifier).flags.q.varying = 1; 4128 ;} 4129 break; 4130 4131 case 156: 4132 4133 /* Line 1464 of yacc.c */ 4134 #line 1154 "glsl_parser.ypp" 4135 { 4136 memset(& (yyval.type_qualifier), 0, sizeof((yyval.type_qualifier))); 4137 (yyval.type_qualifier).flags.q.in = 1; 4138 ;} 4139 break; 4140 4141 case 157: 4142 4143 /* Line 1464 of yacc.c */ 4144 #line 1159 "glsl_parser.ypp" 4145 { 4146 memset(& (yyval.type_qualifier), 0, sizeof((yyval.type_qualifier))); 4147 (yyval.type_qualifier).flags.q.out = 1; 4148 ;} 4149 break; 4150 4151 case 158: 4152 4153 /* Line 1464 of yacc.c */ 4154 #line 1164 "glsl_parser.ypp" 4155 { 4156 memset(& (yyval.type_qualifier), 0, sizeof((yyval.type_qualifier))); 4157 (yyval.type_qualifier).flags.q.centroid = 1; (yyval.type_qualifier).flags.q.in = 1; 4158 ;} 4159 break; 4160 4161 case 159: 4162 4163 /* Line 1464 of yacc.c */ 4164 #line 1169 "glsl_parser.ypp" 4165 { 4166 memset(& (yyval.type_qualifier), 0, sizeof((yyval.type_qualifier))); 4167 (yyval.type_qualifier).flags.q.centroid = 1; (yyval.type_qualifier).flags.q.out = 1; 4168 ;} 4169 break; 4170 4171 case 160: 4172 4173 /* Line 1464 of yacc.c */ 4174 #line 1174 "glsl_parser.ypp" 4175 { 4176 memset(& (yyval.type_qualifier), 0, sizeof((yyval.type_qualifier))); 4177 (yyval.type_qualifier).flags.q.uniform = 1; 4178 ;} 4179 break; 4180 4181 case 162: 4182 4183 /* Line 1464 of yacc.c */ 4184 #line 1183 "glsl_parser.ypp" 4185 { 4186 (yyval.type_specifier) = (yyvsp[(2) - (2)].type_specifier); 4187 (yyval.type_specifier)->precision = (yyvsp[(1) - (2)].n); 4188 ;} 4189 break; 4190 4191 case 164: 4192 4193 /* Line 1464 of yacc.c */ 4194 #line 1192 "glsl_parser.ypp" 4195 { 4196 (yyval.type_specifier) = (yyvsp[(1) - (3)].type_specifier); 4197 (yyval.type_specifier)->is_array = true; 4198 (yyval.type_specifier)->array_size = NULL; 4199 ;} 4200 break; 4201 4202 case 165: 4203 4204 /* Line 1464 of yacc.c */ 4205 #line 1198 "glsl_parser.ypp" 4206 { 4207 (yyval.type_specifier) = (yyvsp[(1) - (4)].type_specifier); 4208 (yyval.type_specifier)->is_array = true; 4209 (yyval.type_specifier)->array_size = (yyvsp[(3) - (4)].expression); 4210 ;} 4211 break; 4212 4213 case 166: 4214 4215 /* Line 1464 of yacc.c */ 4216 #line 1207 "glsl_parser.ypp" 4217 { 4218 void *ctx = state; 4219 (yyval.type_specifier) = new(ctx) ast_type_specifier((yyvsp[(1) - (1)].n)); 4220 (yyval.type_specifier)->set_location(yylloc); 4221 ;} 4222 break; 4223 4224 case 167: 4225 4226 /* Line 1464 of yacc.c */ 4227 #line 1213 "glsl_parser.ypp" 4228 { 4229 void *ctx = state; 4230 (yyval.type_specifier) = new(ctx) ast_type_specifier((yyvsp[(1) - (1)].struct_specifier)); 4231 (yyval.type_specifier)->set_location(yylloc); 4232 ;} 4233 break; 4234 4235 case 168: 4236 4237 /* Line 1464 of yacc.c */ 4238 #line 1219 "glsl_parser.ypp" 4239 { 4240 void *ctx = state; 4241 (yyval.type_specifier) = new(ctx) ast_type_specifier((yyvsp[(1) - (1)].identifier)); 4242 (yyval.type_specifier)->set_location(yylloc); 4243 ;} 4244 break; 4245 4246 case 169: 4247 4248 /* Line 1464 of yacc.c */ 4249 #line 1227 "glsl_parser.ypp" 4250 { (yyval.n) = ast_void; ;} 4251 break; 4252 4253 case 170: 4254 4255 /* Line 1464 of yacc.c */ 4256 #line 1228 "glsl_parser.ypp" 4257 { (yyval.n) = ast_float; ;} 4258 break; 4259 4260 case 171: 4261 4262 /* Line 1464 of yacc.c */ 4263 #line 1229 "glsl_parser.ypp" 4264 { (yyval.n) = ast_int; ;} 4265 break; 4266 4267 case 172: 4268 4269 /* Line 1464 of yacc.c */ 4270 #line 1230 "glsl_parser.ypp" 4271 { (yyval.n) = ast_uint; ;} 4272 break; 4273 4274 case 173: 4275 4276 /* Line 1464 of yacc.c */ 4277 #line 1231 "glsl_parser.ypp" 4278 { (yyval.n) = ast_bool; ;} 4279 break; 4280 4281 case 174: 4282 4283 /* Line 1464 of yacc.c */ 4284 #line 1232 "glsl_parser.ypp" 4285 { (yyval.n) = ast_vec2; ;} 4286 break; 4287 4288 case 175: 4289 4290 /* Line 1464 of yacc.c */ 4291 #line 1233 "glsl_parser.ypp" 4292 { (yyval.n) = ast_vec3; ;} 4293 break; 4294 4295 case 176: 4296 4297 /* Line 1464 of yacc.c */ 4298 #line 1234 "glsl_parser.ypp" 4299 { (yyval.n) = ast_vec4; ;} 4300 break; 4301 4302 case 177: 4303 4304 /* Line 1464 of yacc.c */ 4305 #line 1235 "glsl_parser.ypp" 4306 { (yyval.n) = ast_bvec2; ;} 4307 break; 4308 4309 case 178: 4310 4311 /* Line 1464 of yacc.c */ 4312 #line 1236 "glsl_parser.ypp" 4313 { (yyval.n) = ast_bvec3; ;} 4314 break; 4315 4316 case 179: 4317 4318 /* Line 1464 of yacc.c */ 4319 #line 1237 "glsl_parser.ypp" 4320 { (yyval.n) = ast_bvec4; ;} 4321 break; 4322 4323 case 180: 4324 4325 /* Line 1464 of yacc.c */ 4326 #line 1238 "glsl_parser.ypp" 4327 { (yyval.n) = ast_ivec2; ;} 4328 break; 4329 4330 case 181: 4331 4332 /* Line 1464 of yacc.c */ 4333 #line 1239 "glsl_parser.ypp" 4334 { (yyval.n) = ast_ivec3; ;} 4335 break; 4336 4337 case 182: 4338 4339 /* Line 1464 of yacc.c */ 4340 #line 1240 "glsl_parser.ypp" 4341 { (yyval.n) = ast_ivec4; ;} 4342 break; 4343 4344 case 183: 4345 4346 /* Line 1464 of yacc.c */ 4347 #line 1241 "glsl_parser.ypp" 4348 { (yyval.n) = ast_uvec2; ;} 4349 break; 4350 4351 case 184: 4352 4353 /* Line 1464 of yacc.c */ 4354 #line 1242 "glsl_parser.ypp" 4355 { (yyval.n) = ast_uvec3; ;} 4356 break; 4357 4358 case 185: 4359 4360 /* Line 1464 of yacc.c */ 4361 #line 1243 "glsl_parser.ypp" 4362 { (yyval.n) = ast_uvec4; ;} 4363 break; 4364 4365 case 186: 4366 4367 /* Line 1464 of yacc.c */ 4368 #line 1244 "glsl_parser.ypp" 4369 { (yyval.n) = ast_mat2; ;} 4370 break; 4371 4372 case 187: 4373 4374 /* Line 1464 of yacc.c */ 4375 #line 1245 "glsl_parser.ypp" 4376 { (yyval.n) = ast_mat2x3; ;} 4377 break; 4378 4379 case 188: 4380 4381 /* Line 1464 of yacc.c */ 4382 #line 1246 "glsl_parser.ypp" 4383 { (yyval.n) = ast_mat2x4; ;} 4384 break; 4385 4386 case 189: 4387 4388 /* Line 1464 of yacc.c */ 4389 #line 1247 "glsl_parser.ypp" 4390 { (yyval.n) = ast_mat3x2; ;} 4391 break; 4392 4393 case 190: 4394 4395 /* Line 1464 of yacc.c */ 4396 #line 1248 "glsl_parser.ypp" 4397 { (yyval.n) = ast_mat3; ;} 4398 break; 4399 4400 case 191: 4401 4402 /* Line 1464 of yacc.c */ 4403 #line 1249 "glsl_parser.ypp" 4404 { (yyval.n) = ast_mat3x4; ;} 4405 break; 4406 4407 case 192: 4408 4409 /* Line 1464 of yacc.c */ 4410 #line 1250 "glsl_parser.ypp" 4411 { (yyval.n) = ast_mat4x2; ;} 4412 break; 4413 4414 case 193: 4415 4416 /* Line 1464 of yacc.c */ 4417 #line 1251 "glsl_parser.ypp" 4418 { (yyval.n) = ast_mat4x3; ;} 4419 break; 4420 4421 case 194: 4422 4423 /* Line 1464 of yacc.c */ 4424 #line 1252 "glsl_parser.ypp" 4425 { (yyval.n) = ast_mat4; ;} 4426 break; 4427 4428 case 195: 4429 4430 /* Line 1464 of yacc.c */ 4431 #line 1253 "glsl_parser.ypp" 4432 { (yyval.n) = ast_sampler1d; ;} 4433 break; 4434 4435 case 196: 4436 4437 /* Line 1464 of yacc.c */ 4438 #line 1254 "glsl_parser.ypp" 4439 { (yyval.n) = ast_sampler2d; ;} 4440 break; 4441 4442 case 197: 4443 4444 /* Line 1464 of yacc.c */ 4445 #line 1255 "glsl_parser.ypp" 4446 { (yyval.n) = ast_sampler2drect; ;} 4447 break; 4448 4449 case 198: 4450 4451 /* Line 1464 of yacc.c */ 4452 #line 1256 "glsl_parser.ypp" 4453 { (yyval.n) = ast_sampler3d; ;} 4454 break; 4455 4456 case 199: 4457 4458 /* Line 1464 of yacc.c */ 4459 #line 1257 "glsl_parser.ypp" 4460 { (yyval.n) = ast_samplercube; ;} 4461 break; 4462 4463 case 200: 4464 4465 /* Line 1464 of yacc.c */ 4466 #line 1258 "glsl_parser.ypp" 4467 { (yyval.n) = ast_sampler1dshadow; ;} 4468 break; 4469 4470 case 201: 4471 4472 /* Line 1464 of yacc.c */ 4473 #line 1259 "glsl_parser.ypp" 4474 { (yyval.n) = ast_sampler2dshadow; ;} 4475 break; 4476 4477 case 202: 4478 4479 /* Line 1464 of yacc.c */ 4480 #line 1260 "glsl_parser.ypp" 4481 { (yyval.n) = ast_sampler2drectshadow; ;} 4482 break; 4483 4484 case 203: 4485 4486 /* Line 1464 of yacc.c */ 4487 #line 1261 "glsl_parser.ypp" 4488 { (yyval.n) = ast_samplercubeshadow; ;} 4489 break; 4490 4491 case 204: 4492 4493 /* Line 1464 of yacc.c */ 4494 #line 1262 "glsl_parser.ypp" 4495 { (yyval.n) = ast_sampler1darray; ;} 4496 break; 4497 4498 case 205: 4499 4500 /* Line 1464 of yacc.c */ 4501 #line 1263 "glsl_parser.ypp" 4502 { (yyval.n) = ast_sampler2darray; ;} 4503 break; 4504 4505 case 206: 4506 4507 /* Line 1464 of yacc.c */ 4508 #line 1264 "glsl_parser.ypp" 4509 { (yyval.n) = ast_sampler1darrayshadow; ;} 4510 break; 4511 4512 case 207: 4513 4514 /* Line 1464 of yacc.c */ 4515 #line 1265 "glsl_parser.ypp" 4516 { (yyval.n) = ast_sampler2darrayshadow; ;} 4517 break; 4518 4519 case 208: 4520 4521 /* Line 1464 of yacc.c */ 4522 #line 1266 "glsl_parser.ypp" 4523 { (yyval.n) = ast_isampler1d; ;} 4524 break; 4525 4526 case 209: 4527 4528 /* Line 1464 of yacc.c */ 4529 #line 1267 "glsl_parser.ypp" 4530 { (yyval.n) = ast_isampler2d; ;} 4531 break; 4532 4533 case 210: 4534 4535 /* Line 1464 of yacc.c */ 4536 #line 1268 "glsl_parser.ypp" 4537 { (yyval.n) = ast_isampler3d; ;} 4538 break; 4539 4540 case 211: 4541 4542 /* Line 1464 of yacc.c */ 4543 #line 1269 "glsl_parser.ypp" 4544 { (yyval.n) = ast_isamplercube; ;} 4545 break; 4546 4547 case 212: 4548 4549 /* Line 1464 of yacc.c */ 4550 #line 1270 "glsl_parser.ypp" 4551 { (yyval.n) = ast_isampler1darray; ;} 4552 break; 4553 4554 case 213: 4555 4556 /* Line 1464 of yacc.c */ 4557 #line 1271 "glsl_parser.ypp" 4558 { (yyval.n) = ast_isampler2darray; ;} 4559 break; 4560 4561 case 214: 4562 4563 /* Line 1464 of yacc.c */ 4564 #line 1272 "glsl_parser.ypp" 4565 { (yyval.n) = ast_usampler1d; ;} 4566 break; 4567 4568 case 215: 4569 4570 /* Line 1464 of yacc.c */ 4571 #line 1273 "glsl_parser.ypp" 4572 { (yyval.n) = ast_usampler2d; ;} 4573 break; 4574 4575 case 216: 4576 4577 /* Line 1464 of yacc.c */ 4578 #line 1274 "glsl_parser.ypp" 4579 { (yyval.n) = ast_usampler3d; ;} 4580 break; 4581 4582 case 217: 4583 4584 /* Line 1464 of yacc.c */ 4585 #line 1275 "glsl_parser.ypp" 4586 { (yyval.n) = ast_usamplercube; ;} 4587 break; 4588 4589 case 218: 4590 4591 /* Line 1464 of yacc.c */ 4592 #line 1276 "glsl_parser.ypp" 4593 { (yyval.n) = ast_usampler1darray; ;} 4594 break; 4595 4596 case 219: 4597 4598 /* Line 1464 of yacc.c */ 4599 #line 1277 "glsl_parser.ypp" 4600 { (yyval.n) = ast_usampler2darray; ;} 4601 break; 4602 4603 case 220: 4604 4605 /* Line 1464 of yacc.c */ 4606 #line 1281 "glsl_parser.ypp" 4607 { 4608 if (!state->es_shader && state->language_version < 130) 4609 _mesa_glsl_error(& (yylsp[(1) - (1)]), state, 4610 "precision qualifier forbidden " 4611 "in GLSL %d.%d (1.30 or later " 4612 "required)\n", 4613 state->language_version / 100, 4614 state->language_version % 100); 4615 4616 (yyval.n) = ast_precision_high; 4617 ;} 4618 break; 4619 4620 case 221: 4621 4622 /* Line 1464 of yacc.c */ 4623 #line 1292 "glsl_parser.ypp" 4624 { 4625 if (!state->es_shader && state->language_version < 130) 4626 _mesa_glsl_error(& (yylsp[(1) - (1)]), state, 4627 "precision qualifier forbidden " 4628 "in GLSL %d.%d (1.30 or later " 4629 "required)\n", 4630 state->language_version / 100, 4631 state->language_version % 100); 4632 4633 (yyval.n) = ast_precision_medium; 4634 ;} 4635 break; 4636 4637 case 222: 4638 4639 /* Line 1464 of yacc.c */ 4640 #line 1303 "glsl_parser.ypp" 4641 { 4642 if (!state->es_shader && state->language_version < 130) 4643 _mesa_glsl_error(& (yylsp[(1) - (1)]), state, 4644 "precision qualifier forbidden " 4645 "in GLSL %d.%d (1.30 or later " 4646 "required)\n", 4647 state->language_version / 100, 4648 state->language_version % 100); 4649 4650 (yyval.n) = ast_precision_low; 4651 ;} 4652 break; 4653 4654 case 223: 4655 4656 /* Line 1464 of yacc.c */ 4657 #line 1318 "glsl_parser.ypp" 4658 { 4659 void *ctx = state; 4660 (yyval.struct_specifier) = new(ctx) ast_struct_specifier((yyvsp[(2) - (5)].identifier), (yyvsp[(4) - (5)].node)); 4661 (yyval.struct_specifier)->set_location(yylloc); 4662 ;} 4663 break; 4664 4665 case 224: 4666 4667 /* Line 1464 of yacc.c */ 4668 #line 1324 "glsl_parser.ypp" 4669 { 4670 void *ctx = state; 4671 (yyval.struct_specifier) = new(ctx) ast_struct_specifier(NULL, (yyvsp[(3) - (4)].node)); 4672 (yyval.struct_specifier)->set_location(yylloc); 4673 ;} 4674 break; 4675 4676 case 225: 4677 4678 /* Line 1464 of yacc.c */ 4679 #line 1333 "glsl_parser.ypp" 4680 { 4681 (yyval.node) = (ast_node *) (yyvsp[(1) - (1)].declarator_list); 4682 (yyvsp[(1) - (1)].declarator_list)->link.self_link(); 4683 ;} 4684 break; 4685 4686 case 226: 4687 4688 /* Line 1464 of yacc.c */ 4689 #line 1338 "glsl_parser.ypp" 4690 { 4691 (yyval.node) = (ast_node *) (yyvsp[(1) - (2)].node); 4692 (yyval.node)->link.insert_before(& (yyvsp[(2) - (2)].declarator_list)->link); 4693 ;} 4694 break; 4695 4696 case 227: 4697 4698 /* Line 1464 of yacc.c */ 4699 #line 1346 "glsl_parser.ypp" 4700 { 4701 void *ctx = state; 4702 ast_fully_specified_type *type = new(ctx) ast_fully_specified_type(); 4703 type->set_location(yylloc); 4704 4705 type->specifier = (yyvsp[(1) - (3)].type_specifier); 4706 (yyval.declarator_list) = new(ctx) ast_declarator_list(type); 4707 (yyval.declarator_list)->set_location(yylloc); 4708 4709 (yyval.declarator_list)->declarations.push_degenerate_list_at_head(& (yyvsp[(2) - (3)].declaration)->link); 4710 ;} 4711 break; 4712 4713 case 228: 4714 4715 /* Line 1464 of yacc.c */ 4716 #line 1361 "glsl_parser.ypp" 4717 { 4718 (yyval.declaration) = (yyvsp[(1) - (1)].declaration); 4719 (yyvsp[(1) - (1)].declaration)->link.self_link(); 4720 ;} 4721 break; 4722 4723 case 229: 4724 4725 /* Line 1464 of yacc.c */ 4726 #line 1366 "glsl_parser.ypp" 4727 { 4728 (yyval.declaration) = (yyvsp[(1) - (3)].declaration); 4729 (yyval.declaration)->link.insert_before(& (yyvsp[(3) - (3)].declaration)->link); 4730 ;} 4731 break; 4732 4733 case 230: 4734 4735 /* Line 1464 of yacc.c */ 4736 #line 1374 "glsl_parser.ypp" 4737 { 4738 void *ctx = state; 4739 (yyval.declaration) = new(ctx) ast_declaration((yyvsp[(1) - (1)].identifier), false, NULL, NULL); 4740 (yyval.declaration)->set_location(yylloc); 4741 ;} 4742 break; 4743 4744 case 231: 4745 4746 /* Line 1464 of yacc.c */ 4747 #line 1380 "glsl_parser.ypp" 4748 { 4749 void *ctx = state; 4750 (yyval.declaration) = new(ctx) ast_declaration((yyvsp[(1) - (4)].identifier), true, (yyvsp[(3) - (4)].expression), NULL); 4751 (yyval.declaration)->set_location(yylloc); 4752 ;} 4753 break; 4754 4755 case 234: 4756 4757 /* Line 1464 of yacc.c */ 4758 #line 1398 "glsl_parser.ypp" 4759 { (yyval.node) = (ast_node *) (yyvsp[(1) - (1)].compound_statement); ;} 4760 break; 4761 4762 case 239: 4763 4764 /* Line 1464 of yacc.c */ 4765 #line 1406 "glsl_parser.ypp" 4766 { (yyval.node) = NULL; ;} 4767 break; 4768 4769 case 240: 4770 4771 /* Line 1464 of yacc.c */ 4772 #line 1407 "glsl_parser.ypp" 4773 { (yyval.node) = NULL; ;} 4774 break; 4775 4776 case 243: 4777 4778 /* Line 1464 of yacc.c */ 4779 #line 1414 "glsl_parser.ypp" 4780 { 4781 void *ctx = state; 4782 (yyval.compound_statement) = new(ctx) ast_compound_statement(true, NULL); 4783 (yyval.compound_statement)->set_location(yylloc); 4784 ;} 4785 break; 4786 4787 case 244: 4788 4789 /* Line 1464 of yacc.c */ 4790 #line 1420 "glsl_parser.ypp" 4791 { 4792 void *ctx = state; 4793 (yyval.compound_statement) = new(ctx) ast_compound_statement(true, (yyvsp[(2) - (3)].node)); 4794 (yyval.compound_statement)->set_location(yylloc); 4795 ;} 4796 break; 4797 4798 case 245: 4799 4800 /* Line 1464 of yacc.c */ 4801 #line 1428 "glsl_parser.ypp" 4802 { (yyval.node) = (ast_node *) (yyvsp[(1) - (1)].compound_statement); ;} 4803 break; 4804 4805 case 247: 4806 4807 /* Line 1464 of yacc.c */ 4808 #line 1434 "glsl_parser.ypp" 4809 { 4810 void *ctx = state; 4811 (yyval.compound_statement) = new(ctx) ast_compound_statement(false, NULL); 4812 (yyval.compound_statement)->set_location(yylloc); 4813 ;} 4814 break; 4815 4816 case 248: 4817 4818 /* Line 1464 of yacc.c */ 4819 #line 1440 "glsl_parser.ypp" 4820 { 4821 void *ctx = state; 4822 (yyval.compound_statement) = new(ctx) ast_compound_statement(false, (yyvsp[(2) - (3)].node)); 4823 (yyval.compound_statement)->set_location(yylloc); 4824 ;} 4825 break; 4826 4827 case 249: 4828 4829 /* Line 1464 of yacc.c */ 4830 #line 1449 "glsl_parser.ypp" 4831 { 4832 if ((yyvsp[(1) - (1)].node) == NULL) { 4833 _mesa_glsl_error(& (yylsp[(1) - (1)]), state, "<nil> statement\n"); 4834 assert((yyvsp[(1) - (1)].node) != NULL); 4835 } 4836 4837 (yyval.node) = (yyvsp[(1) - (1)].node); 4838 (yyval.node)->link.self_link(); 4839 ;} 4840 break; 4841 4842 case 250: 4843 4844 /* Line 1464 of yacc.c */ 4845 #line 1459 "glsl_parser.ypp" 4846 { 4847 if ((yyvsp[(2) - (2)].node) == NULL) { 4848 _mesa_glsl_error(& (yylsp[(2) - (2)]), state, "<nil> statement\n"); 4849 assert((yyvsp[(2) - (2)].node) != NULL); 4850 } 4851 (yyval.node) = (yyvsp[(1) - (2)].node); 4852 (yyval.node)->link.insert_before(& (yyvsp[(2) - (2)].node)->link); 4853 ;} 4854 break; 4855 4856 case 251: 4857 4858 /* Line 1464 of yacc.c */ 4859 #line 1471 "glsl_parser.ypp" 4860 { 4861 void *ctx = state; 4862 (yyval.node) = new(ctx) ast_expression_statement(NULL); 4863 (yyval.node)->set_location(yylloc); 4864 ;} 4865 break; 4866 4867 case 252: 4868 4869 /* Line 1464 of yacc.c */ 4870 #line 1477 "glsl_parser.ypp" 4871 { 4872 void *ctx = state; 4873 (yyval.node) = new(ctx) ast_expression_statement((yyvsp[(1) - (2)].expression)); 4874 (yyval.node)->set_location(yylloc); 4875 ;} 4876 break; 4877 4878 case 253: 4879 4880 /* Line 1464 of yacc.c */ 4881 #line 1486 "glsl_parser.ypp" 4882 { 4883 (yyval.node) = new(state) ast_selection_statement((yyvsp[(3) - (5)].expression), (yyvsp[(5) - (5)].selection_rest_statement).then_statement, 4884 (yyvsp[(5) - (5)].selection_rest_statement).else_statement); 4885 (yyval.node)->set_location(yylloc); 4886 ;} 4887 break; 4888 4889 case 254: 4890 4891 /* Line 1464 of yacc.c */ 4892 #line 1495 "glsl_parser.ypp" 4893 { 4894 (yyval.selection_rest_statement).then_statement = (yyvsp[(1) - (3)].node); 4895 (yyval.selection_rest_statement).else_statement = (yyvsp[(3) - (3)].node); 4896 ;} 4897 break; 4898 4899 case 255: 4900 4901 /* Line 1464 of yacc.c */ 4902 #line 1500 "glsl_parser.ypp" 4903 { 4904 (yyval.selection_rest_statement).then_statement = (yyvsp[(1) - (1)].node); 4905 (yyval.selection_rest_statement).else_statement = NULL; 4906 ;} 4907 break; 4908 4909 case 256: 4910 4911 /* Line 1464 of yacc.c */ 4912 #line 1508 "glsl_parser.ypp" 4913 { 4914 (yyval.node) = (ast_node *) (yyvsp[(1) - (1)].expression); 4915 ;} 4916 break; 4917 4918 case 257: 4919 4920 /* Line 1464 of yacc.c */ 4921 #line 1512 "glsl_parser.ypp" 4922 { 4923 void *ctx = state; 4924 ast_declaration *decl = new(ctx) ast_declaration((yyvsp[(2) - (4)].identifier), false, NULL, (yyvsp[(4) - (4)].expression)); 4925 ast_declarator_list *declarator = new(ctx) ast_declarator_list((yyvsp[(1) - (4)].fully_specified_type)); 4926 decl->set_location(yylloc); 4927 declarator->set_location(yylloc); 4928 4929 declarator->declarations.push_tail(&decl->link); 4930 (yyval.node) = declarator; 4931 ;} 4932 break; 4933 4934 case 261: 4935 4936 /* Line 1464 of yacc.c */ 4937 #line 1535 "glsl_parser.ypp" 4938 { 4939 void *ctx = state; 4940 (yyval.node) = new(ctx) ast_iteration_statement(ast_iteration_statement::ast_while, 4941 NULL, (yyvsp[(3) - (5)].node), NULL, (yyvsp[(5) - (5)].node)); 4942 (yyval.node)->set_location(yylloc); 4943 ;} 4944 break; 4945 4946 case 262: 4947 4948 /* Line 1464 of yacc.c */ 4949 #line 1542 "glsl_parser.ypp" 4950 { 4951 void *ctx = state; 4952 (yyval.node) = new(ctx) ast_iteration_statement(ast_iteration_statement::ast_do_while, 4953 NULL, (yyvsp[(5) - (7)].expression), NULL, (yyvsp[(2) - (7)].node)); 4954 (yyval.node)->set_location(yylloc); 4955 ;} 4956 break; 4957 4958 case 263: 4959 4960 /* Line 1464 of yacc.c */ 4961 #line 1549 "glsl_parser.ypp" 4962 { 4963 void *ctx = state; 4964 (yyval.node) = new(ctx) ast_iteration_statement(ast_iteration_statement::ast_for, 4965 (yyvsp[(3) - (6)].node), (yyvsp[(4) - (6)].for_rest_statement).cond, (yyvsp[(4) - (6)].for_rest_statement).rest, (yyvsp[(6) - (6)].node)); 4966 (yyval.node)->set_location(yylloc); 4967 ;} 4968 break; 4969 4970 case 267: 4971 4972 /* Line 1464 of yacc.c */ 4973 #line 1565 "glsl_parser.ypp" 4974 { 4975 (yyval.node) = NULL; 4976 ;} 4977 break; 4978 4979 case 268: 4980 4981 /* Line 1464 of yacc.c */ 4982 #line 1572 "glsl_parser.ypp" 4983 { 4984 (yyval.for_rest_statement).cond = (yyvsp[(1) - (2)].node); 4985 (yyval.for_rest_statement).rest = NULL; 4986 ;} 4987 break; 4988 4989 case 269: 4990 4991 /* Line 1464 of yacc.c */ 4992 #line 1577 "glsl_parser.ypp" 4993 { 4994 (yyval.for_rest_statement).cond = (yyvsp[(1) - (3)].node); 4995 (yyval.for_rest_statement).rest = (yyvsp[(3) - (3)].expression); 4996 ;} 4997 break; 4998 4999 case 270: 5000 5001 /* Line 1464 of yacc.c */ 5002 #line 1586 "glsl_parser.ypp" 5003 { 5004 void *ctx = state; 5005 (yyval.node) = new(ctx) ast_jump_statement(ast_jump_statement::ast_continue, NULL); 5006 (yyval.node)->set_location(yylloc); 5007 ;} 5008 break; 5009 5010 case 271: 5011 5012 /* Line 1464 of yacc.c */ 5013 #line 1592 "glsl_parser.ypp" 5014 { 5015 void *ctx = state; 5016 (yyval.node) = new(ctx) ast_jump_statement(ast_jump_statement::ast_break, NULL); 5017 (yyval.node)->set_location(yylloc); 5018 ;} 5019 break; 5020 5021 case 272: 5022 5023 /* Line 1464 of yacc.c */ 5024 #line 1598 "glsl_parser.ypp" 5025 { 5026 void *ctx = state; 5027 (yyval.node) = new(ctx) ast_jump_statement(ast_jump_statement::ast_return, NULL); 5028 (yyval.node)->set_location(yylloc); 5029 ;} 5030 break; 5031 5032 case 273: 5033 5034 /* Line 1464 of yacc.c */ 5035 #line 1604 "glsl_parser.ypp" 5036 { 5037 void *ctx = state; 5038 (yyval.node) = new(ctx) ast_jump_statement(ast_jump_statement::ast_return, (yyvsp[(2) - (3)].expression)); 5039 (yyval.node)->set_location(yylloc); 5040 ;} 5041 break; 5042 5043 case 274: 5044 5045 /* Line 1464 of yacc.c */ 5046 #line 1610 "glsl_parser.ypp" 5047 { 5048 void *ctx = state; 5049 (yyval.node) = new(ctx) ast_jump_statement(ast_jump_statement::ast_discard, NULL); 5050 (yyval.node)->set_location(yylloc); 5051 ;} 5052 break; 5053 5054 case 275: 5055 5056 /* Line 1464 of yacc.c */ 5057 #line 1618 "glsl_parser.ypp" 5058 { (yyval.node) = (yyvsp[(1) - (1)].function_definition); ;} 5059 break; 5060 5061 case 276: 5062 5063 /* Line 1464 of yacc.c */ 5064 #line 1619 "glsl_parser.ypp" 5065 { (yyval.node) = (yyvsp[(1) - (1)].node); ;} 5066 break; 5067 5068 case 277: 5069 5070 /* Line 1464 of yacc.c */ 5071 #line 1620 "glsl_parser.ypp" 5072 { (yyval.node) = NULL; ;} 5073 break; 5074 5075 case 278: 5076 5077 /* Line 1464 of yacc.c */ 5078 #line 1625 "glsl_parser.ypp" 5079 { 5080 void *ctx = state; 5081 (yyval.function_definition) = new(ctx) ast_function_definition(); 5082 (yyval.function_definition)->set_location(yylloc); 5083 (yyval.function_definition)->prototype = (yyvsp[(1) - (2)].function); 5084 (yyval.function_definition)->body = (yyvsp[(2) - (2)].compound_statement); 5085 ;} 5086 break; 5087 5088 5089 5090 /* Line 1464 of yacc.c */ 5091 #line 5090 "glsl_parser.cpp" 5092 default: break; 5093 } 5094 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 5095 5096 YYPOPSTACK (yylen); 5097 yylen = 0; 5098 YY_STACK_PRINT (yyss, yyssp); 5099 5100 *++yyvsp = yyval; 5101 *++yylsp = yyloc; 5102 5103 /* Now `shift' the result of the reduction. Determine what state 5104 that goes to, based on the state we popped back to and the rule 5105 number reduced by. */ 5106 5107 yyn = yyr1[yyn]; 5108 5109 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 5110 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 5111 yystate = yytable[yystate]; 5112 else 5113 yystate = yydefgoto[yyn - YYNTOKENS]; 5114 5115 goto yynewstate; 5116 5117 5118 /*------------------------------------. 5119 | yyerrlab -- here on detecting error | 5120 `------------------------------------*/ 5121 yyerrlab: 5122 /* If not already recovering from an error, report this error. */ 5123 if (!yyerrstatus) 5124 { 5125 ++yynerrs; 5126 #if ! YYERROR_VERBOSE 5127 yyerror (&yylloc, state, YY_("syntax error")); 5128 #else 5129 { 5130 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); 5131 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) 5132 { 5133 YYSIZE_T yyalloc = 2 * yysize; 5134 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) 5135 yyalloc = YYSTACK_ALLOC_MAXIMUM; 5136 if (yymsg != yymsgbuf) 5137 YYSTACK_FREE (yymsg); 5138 yymsg = (char *) YYSTACK_ALLOC (yyalloc); 5139 if (yymsg) 5140 yymsg_alloc = yyalloc; 5141 else 5142 { 5143 yymsg = yymsgbuf; 5144 yymsg_alloc = sizeof yymsgbuf; 5145 } 5146 } 5147 5148 if (0 < yysize && yysize <= yymsg_alloc) 5149 { 5150 (void) yysyntax_error (yymsg, yystate, yychar); 5151 yyerror (&yylloc, state, yymsg); 5152 } 5153 else 5154 { 5155 yyerror (&yylloc, state, YY_("syntax error")); 5156 if (yysize != 0) 5157 goto yyexhaustedlab; 5158 } 5159 } 5160 #endif 5161 } 5162 5163 yyerror_range[1] = yylloc; 5164 5165 if (yyerrstatus == 3) 5166 { 5167 /* If just tried and failed to reuse lookahead token after an 5168 error, discard it. */ 5169 5170 if (yychar <= YYEOF) 5171 { 5172 /* Return failure if at end of input. */ 5173 if (yychar == YYEOF) 5174 YYABORT; 5175 } 5176 else 5177 { 5178 yydestruct ("Error: discarding", 5179 yytoken, &yylval, &yylloc, state); 5180 yychar = YYEMPTY; 5181 } 5182 } 5183 5184 /* Else will try to reuse lookahead token after shifting the error 5185 token. */ 5186 goto yyerrlab1; 5187 5188 5189 /*---------------------------------------------------. 5190 | yyerrorlab -- error raised explicitly by YYERROR. | 5191 `---------------------------------------------------*/ 5192 yyerrorlab: 5193 5194 /* Pacify compilers like GCC when the user code never invokes 5195 YYERROR and the label yyerrorlab therefore never appears in user 5196 code. */ 5197 if (/*CONSTCOND*/ 0) 5198 goto yyerrorlab; 5199 5200 yyerror_range[1] = yylsp[1-yylen]; 5201 /* Do not reclaim the symbols of the rule which action triggered 5202 this YYERROR. */ 5203 YYPOPSTACK (yylen); 5204 yylen = 0; 5205 YY_STACK_PRINT (yyss, yyssp); 5206 yystate = *yyssp; 5207 goto yyerrlab1; 5208 5209 5210 /*-------------------------------------------------------------. 5211 | yyerrlab1 -- common code for both syntax error and YYERROR. | 5212 `-------------------------------------------------------------*/ 5213 yyerrlab1: 5214 yyerrstatus = 3; /* Each real token shifted decrements this. */ 5215 5216 for (;;) 5217 { 5218 yyn = yypact[yystate]; 5219 if (yyn != YYPACT_NINF) 5220 { 5221 yyn += YYTERROR; 5222 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 5223 { 5224 yyn = yytable[yyn]; 5225 if (0 < yyn) 5226 break; 5227 } 5228 } 5229 5230 /* Pop the current state because it cannot handle the error token. */ 5231 if (yyssp == yyss) 5232 YYABORT; 5233 5234 yyerror_range[1] = *yylsp; 5235 yydestruct ("Error: popping", 5236 yystos[yystate], yyvsp, yylsp, state); 5237 YYPOPSTACK (1); 5238 yystate = *yyssp; 5239 YY_STACK_PRINT (yyss, yyssp); 5240 } 5241 5242 *++yyvsp = yylval; 5243 5244 yyerror_range[2] = yylloc; 5245 /* Using YYLLOC is tempting, but would change the location of 5246 the lookahead. YYLOC is available though. */ 5247 YYLLOC_DEFAULT (yyloc, yyerror_range, 2); 5248 *++yylsp = yyloc; 5249 5250 /* Shift the error token. */ 5251 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 5252 5253 yystate = yyn; 5254 goto yynewstate; 5255 5256 5257 /*-------------------------------------. 5258 | yyacceptlab -- YYACCEPT comes here. | 5259 `-------------------------------------*/ 5260 yyacceptlab: 5261 yyresult = 0; 5262 goto yyreturn; 5263 5264 /*-----------------------------------. 5265 | yyabortlab -- YYABORT comes here. | 5266 `-----------------------------------*/ 5267 yyabortlab: 5268 yyresult = 1; 5269 goto yyreturn; 5270 5271 #if !defined(yyoverflow) || YYERROR_VERBOSE 5272 /*-------------------------------------------------. 5273 | yyexhaustedlab -- memory exhaustion comes here. | 5274 `-------------------------------------------------*/ 5275 yyexhaustedlab: 5276 yyerror (&yylloc, state, YY_("memory exhausted")); 5277 yyresult = 2; 5278 /* Fall through. */ 5279 #endif 5280 5281 yyreturn: 5282 if (yychar != YYEMPTY) 5283 yydestruct ("Cleanup: discarding lookahead", 5284 yytoken, &yylval, &yylloc, state); 5285 /* Do not reclaim the symbols of the rule which action triggered 5286 this YYABORT or YYACCEPT. */ 5287 YYPOPSTACK (yylen); 5288 YY_STACK_PRINT (yyss, yyssp); 5289 while (yyssp != yyss) 5290 { 5291 yydestruct ("Cleanup: popping", 5292 yystos[*yyssp], yyvsp, yylsp, state); 5293 YYPOPSTACK (1); 5294 } 5295 #ifndef yyoverflow 5296 if (yyss != yyssa) 5297 YYSTACK_FREE (yyss); 5298 #endif 5299 #if YYERROR_VERBOSE 5300 if (yymsg != yymsgbuf) 5301 YYSTACK_FREE (yymsg); 5302 #endif 5303 /* Make sure YYID is used. */ 5304 return YYID (yyresult); 5305 } 5306 5307 5308 5309
