1/* A Bison parser, made by GNU Bison 2.5. */ 2 3/* Bison implementation for Yacc-like parsers in C 4 5 Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc. 6 7 This program is free software: you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation, either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20/* As a special exception, you may create a larger work that contains 21 part or all of the Bison parser skeleton and distribute that work 22 under terms of your choice, so long as that work isn't itself a 23 parser generator using the skeleton or a modified version thereof 24 as a parser skeleton. Alternatively, if you modify or redistribute 25 the parser skeleton itself, you may (at your option) remove this 26 special exception, which will cause the skeleton and the resulting 27 Bison output files to be licensed under the GNU General Public 28 License without this special exception. 29 30 This special exception was added by the Free Software Foundation in 31 version 2.2 of Bison. */ 32 33/* C LALR(1) parser skeleton written by Richard Stallman, by 34 simplifying the original so-called "semantic" parser. */ 35 36/* All symbols defined below should begin with yy or YY, to avoid 37 infringing on user name space. This should be done even for local 38 variables, as they might otherwise be expanded by user macros. 39 There are some unavoidable exceptions within include files to 40 define necessary library symbols; they are noted "INFRINGES ON 41 USER NAME SPACE" below. */ 42 43/* Identify Bison output. */ 44#define YYBISON 1 45 46/* Bison version. */ 47#define YYBISON_VERSION "2.5" 48 49/* Skeleton name. */ 50#define YYSKELETON_NAME "yacc.c" 51 52/* Pure parsers. */ 53#define YYPURE 1 54 55/* Push parsers. */ 56#define YYPUSH 0 57 58/* Pull parsers. */ 59#define YYPULL 1 60 61/* Using locations. */ 62#define YYLSP_NEEDED 1 63 64/* Substitute the variable and function names. */ 65#define yyparse _mesa_program_parse 66#define yylex _mesa_program_lex 67#define yyerror _mesa_program_error 68#define yylval _mesa_program_lval 69#define yychar _mesa_program_char 70#define yydebug _mesa_program_debug 71#define yynerrs _mesa_program_nerrs 72#define yylloc _mesa_program_lloc 73 74/* Copy the first part of user declarations. */ 75 76/* Line 268 of yacc.c */ 77#line 1 "src/src/mesa/program/program_parse.y" 78 79/* 80 * Copyright © 2009 Intel Corporation 81 * 82 * Permission is hereby granted, free of charge, to any person obtaining a 83 * copy of this software and associated documentation files (the "Software"), 84 * to deal in the Software without restriction, including without limitation 85 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 86 * and/or sell copies of the Software, and to permit persons to whom the 87 * Software is furnished to do so, subject to the following conditions: 88 * 89 * The above copyright notice and this permission notice (including the next 90 * paragraph) shall be included in all copies or substantial portions of the 91 * Software. 92 * 93 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 94 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 95 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 96 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 97 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 98 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 99 * DEALINGS IN THE SOFTWARE. 100 */ 101#include <stdio.h> 102#include <stdlib.h> 103#include <string.h> 104 105#include "main/mtypes.h" 106#include "main/imports.h" 107#include "program/program.h" 108#include "program/prog_parameter.h" 109#include "program/prog_parameter_layout.h" 110#include "program/prog_statevars.h" 111#include "program/prog_instruction.h" 112 113#include "program/symbol_table.h" 114#include "program/program_parser.h" 115 116extern void *yy_scan_string(char *); 117extern void yy_delete_buffer(void *); 118 119static struct asm_symbol *declare_variable(struct asm_parser_state *state, 120 char *name, enum asm_type t, struct YYLTYPE *locp); 121 122static int add_state_reference(struct gl_program_parameter_list *param_list, 123 const gl_state_index tokens[STATE_LENGTH]); 124 125static int initialize_symbol_from_state(struct gl_program *prog, 126 struct asm_symbol *param_var, const gl_state_index tokens[STATE_LENGTH]); 127 128static int initialize_symbol_from_param(struct gl_program *prog, 129 struct asm_symbol *param_var, const gl_state_index tokens[STATE_LENGTH]); 130 131static int initialize_symbol_from_const(struct gl_program *prog, 132 struct asm_symbol *param_var, const struct asm_vector *vec, 133 GLboolean allowSwizzle); 134 135static int yyparse(struct asm_parser_state *state); 136 137static char *make_error_string(const char *fmt, ...); 138 139static void yyerror(struct YYLTYPE *locp, struct asm_parser_state *state, 140 const char *s); 141 142static int validate_inputs(struct YYLTYPE *locp, 143 struct asm_parser_state *state); 144 145static void init_dst_reg(struct prog_dst_register *r); 146 147static void set_dst_reg(struct prog_dst_register *r, 148 gl_register_file file, GLint index); 149 150static void init_src_reg(struct asm_src_register *r); 151 152static void set_src_reg(struct asm_src_register *r, 153 gl_register_file file, GLint index); 154 155static void set_src_reg_swz(struct asm_src_register *r, 156 gl_register_file file, GLint index, GLuint swizzle); 157 158static void asm_instruction_set_operands(struct asm_instruction *inst, 159 const struct prog_dst_register *dst, const struct asm_src_register *src0, 160 const struct asm_src_register *src1, const struct asm_src_register *src2); 161 162static struct asm_instruction *asm_instruction_ctor(gl_inst_opcode op, 163 const struct prog_dst_register *dst, const struct asm_src_register *src0, 164 const struct asm_src_register *src1, const struct asm_src_register *src2); 165 166static struct asm_instruction *asm_instruction_copy_ctor( 167 const struct prog_instruction *base, const struct prog_dst_register *dst, 168 const struct asm_src_register *src0, const struct asm_src_register *src1, 169 const struct asm_src_register *src2); 170 171#ifndef FALSE 172#define FALSE 0 173#define TRUE (!FALSE) 174#endif 175 176#define YYLLOC_DEFAULT(Current, Rhs, N) \ 177 do { \ 178 if (YYID(N)) { \ 179 (Current).first_line = YYRHSLOC(Rhs, 1).first_line; \ 180 (Current).first_column = YYRHSLOC(Rhs, 1).first_column; \ 181 (Current).position = YYRHSLOC(Rhs, 1).position; \ 182 (Current).last_line = YYRHSLOC(Rhs, N).last_line; \ 183 (Current).last_column = YYRHSLOC(Rhs, N).last_column; \ 184 } else { \ 185 (Current).first_line = YYRHSLOC(Rhs, 0).last_line; \ 186 (Current).last_line = (Current).first_line; \ 187 (Current).first_column = YYRHSLOC(Rhs, 0).last_column; \ 188 (Current).last_column = (Current).first_column; \ 189 (Current).position = YYRHSLOC(Rhs, 0).position \ 190 + (Current).first_column; \ 191 } \ 192 } while(YYID(0)) 193 194#define YYLEX_PARAM state->scanner 195 196 197/* Line 268 of yacc.c */ 198#line 199 "src/chromium_gensrc/mesa/program/program_parse.tab.c" 199 200/* Enabling traces. */ 201#ifndef YYDEBUG 202# define YYDEBUG 0 203#endif 204 205/* Enabling verbose error messages. */ 206#ifdef YYERROR_VERBOSE 207# undef YYERROR_VERBOSE 208# define YYERROR_VERBOSE 1 209#else 210# define YYERROR_VERBOSE 1 211#endif 212 213/* Enabling the token table. */ 214#ifndef YYTOKEN_TABLE 215# define YYTOKEN_TABLE 0 216#endif 217 218 219/* Tokens. */ 220#ifndef YYTOKENTYPE 221# define YYTOKENTYPE 222 /* Put the tokens into the symbol table, so that GDB and other debuggers 223 know about them. */ 224 enum yytokentype { 225 ARBvp_10 = 258, 226 ARBfp_10 = 259, 227 ADDRESS = 260, 228 ALIAS = 261, 229 ATTRIB = 262, 230 OPTION = 263, 231 OUTPUT = 264, 232 PARAM = 265, 233 TEMP = 266, 234 END = 267, 235 BIN_OP = 268, 236 BINSC_OP = 269, 237 SAMPLE_OP = 270, 238 SCALAR_OP = 271, 239 TRI_OP = 272, 240 VECTOR_OP = 273, 241 ARL = 274, 242 KIL = 275, 243 SWZ = 276, 244 TXD_OP = 277, 245 INTEGER = 278, 246 REAL = 279, 247 AMBIENT = 280, 248 ATTENUATION = 281, 249 BACK = 282, 250 CLIP = 283, 251 COLOR = 284, 252 DEPTH = 285, 253 DIFFUSE = 286, 254 DIRECTION = 287, 255 EMISSION = 288, 256 ENV = 289, 257 EYE = 290, 258 FOG = 291, 259 FOGCOORD = 292, 260 FRAGMENT = 293, 261 FRONT = 294, 262 HALF = 295, 263 INVERSE = 296, 264 INVTRANS = 297, 265 LIGHT = 298, 266 LIGHTMODEL = 299, 267 LIGHTPROD = 300, 268 LOCAL = 301, 269 MATERIAL = 302, 270 MAT_PROGRAM = 303, 271 MATRIX = 304, 272 MATRIXINDEX = 305, 273 MODELVIEW = 306, 274 MVP = 307, 275 NORMAL = 308, 276 OBJECT = 309, 277 PALETTE = 310, 278 PARAMS = 311, 279 PLANE = 312, 280 POINT_TOK = 313, 281 POINTSIZE = 314, 282 POSITION = 315, 283 PRIMARY = 316, 284 PROGRAM = 317, 285 PROJECTION = 318, 286 RANGE = 319, 287 RESULT = 320, 288 ROW = 321, 289 SCENECOLOR = 322, 290 SECONDARY = 323, 291 SHININESS = 324, 292 SIZE_TOK = 325, 293 SPECULAR = 326, 294 SPOT = 327, 295 STATE = 328, 296 TEXCOORD = 329, 297 TEXENV = 330, 298 TEXGEN = 331, 299 TEXGEN_Q = 332, 300 TEXGEN_R = 333, 301 TEXGEN_S = 334, 302 TEXGEN_T = 335, 303 TEXTURE = 336, 304 TRANSPOSE = 337, 305 TEXTURE_UNIT = 338, 306 TEX_1D = 339, 307 TEX_2D = 340, 308 TEX_3D = 341, 309 TEX_CUBE = 342, 310 TEX_RECT = 343, 311 TEX_SHADOW1D = 344, 312 TEX_SHADOW2D = 345, 313 TEX_SHADOWRECT = 346, 314 TEX_ARRAY1D = 347, 315 TEX_ARRAY2D = 348, 316 TEX_ARRAYSHADOW1D = 349, 317 TEX_ARRAYSHADOW2D = 350, 318 VERTEX = 351, 319 VTXATTRIB = 352, 320 WEIGHT = 353, 321 IDENTIFIER = 354, 322 USED_IDENTIFIER = 355, 323 MASK4 = 356, 324 MASK3 = 357, 325 MASK2 = 358, 326 MASK1 = 359, 327 SWIZZLE = 360, 328 DOT_DOT = 361, 329 DOT = 362 330 }; 331#endif 332/* Tokens. */ 333#define ARBvp_10 258 334#define ARBfp_10 259 335#define ADDRESS 260 336#define ALIAS 261 337#define ATTRIB 262 338#define OPTION 263 339#define OUTPUT 264 340#define PARAM 265 341#define TEMP 266 342#define END 267 343#define BIN_OP 268 344#define BINSC_OP 269 345#define SAMPLE_OP 270 346#define SCALAR_OP 271 347#define TRI_OP 272 348#define VECTOR_OP 273 349#define ARL 274 350#define KIL 275 351#define SWZ 276 352#define TXD_OP 277 353#define INTEGER 278 354#define REAL 279 355#define AMBIENT 280 356#define ATTENUATION 281 357#define BACK 282 358#define CLIP 283 359#define COLOR 284 360#define DEPTH 285 361#define DIFFUSE 286 362#define DIRECTION 287 363#define EMISSION 288 364#define ENV 289 365#define EYE 290 366#define FOG 291 367#define FOGCOORD 292 368#define FRAGMENT 293 369#define FRONT 294 370#define HALF 295 371#define INVERSE 296 372#define INVTRANS 297 373#define LIGHT 298 374#define LIGHTMODEL 299 375#define LIGHTPROD 300 376#define LOCAL 301 377#define MATERIAL 302 378#define MAT_PROGRAM 303 379#define MATRIX 304 380#define MATRIXINDEX 305 381#define MODELVIEW 306 382#define MVP 307 383#define NORMAL 308 384#define OBJECT 309 385#define PALETTE 310 386#define PARAMS 311 387#define PLANE 312 388#define POINT_TOK 313 389#define POINTSIZE 314 390#define POSITION 315 391#define PRIMARY 316 392#define PROGRAM 317 393#define PROJECTION 318 394#define RANGE 319 395#define RESULT 320 396#define ROW 321 397#define SCENECOLOR 322 398#define SECONDARY 323 399#define SHININESS 324 400#define SIZE_TOK 325 401#define SPECULAR 326 402#define SPOT 327 403#define STATE 328 404#define TEXCOORD 329 405#define TEXENV 330 406#define TEXGEN 331 407#define TEXGEN_Q 332 408#define TEXGEN_R 333 409#define TEXGEN_S 334 410#define TEXGEN_T 335 411#define TEXTURE 336 412#define TRANSPOSE 337 413#define TEXTURE_UNIT 338 414#define TEX_1D 339 415#define TEX_2D 340 416#define TEX_3D 341 417#define TEX_CUBE 342 418#define TEX_RECT 343 419#define TEX_SHADOW1D 344 420#define TEX_SHADOW2D 345 421#define TEX_SHADOWRECT 346 422#define TEX_ARRAY1D 347 423#define TEX_ARRAY2D 348 424#define TEX_ARRAYSHADOW1D 349 425#define TEX_ARRAYSHADOW2D 350 426#define VERTEX 351 427#define VTXATTRIB 352 428#define WEIGHT 353 429#define IDENTIFIER 354 430#define USED_IDENTIFIER 355 431#define MASK4 356 432#define MASK3 357 433#define MASK2 358 434#define MASK1 359 435#define SWIZZLE 360 436#define DOT_DOT 361 437#define DOT 362 438 439 440 441 442#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 443typedef union YYSTYPE 444{ 445 446/* Line 293 of yacc.c */ 447#line 126 "src/src/mesa/program/program_parse.y" 448 449 struct asm_instruction *inst; 450 struct asm_symbol *sym; 451 struct asm_symbol temp_sym; 452 struct asm_swizzle_mask swiz_mask; 453 struct asm_src_register src_reg; 454 struct prog_dst_register dst_reg; 455 struct prog_instruction temp_inst; 456 char *string; 457 unsigned result; 458 unsigned attrib; 459 int integer; 460 float real; 461 gl_state_index state[STATE_LENGTH]; 462 int negate; 463 struct asm_vector vector; 464 gl_inst_opcode opcode; 465 466 struct { 467 unsigned swz; 468 unsigned rgba_valid:1; 469 unsigned xyzw_valid:1; 470 unsigned negate:1; 471 } ext_swizzle; 472 473 474 475/* Line 293 of yacc.c */ 476#line 477 "src/chromium_gensrc/mesa/program/program_parse.tab.c" 477} YYSTYPE; 478# define YYSTYPE_IS_TRIVIAL 1 479# define yystype YYSTYPE /* obsolescent; will be withdrawn */ 480# define YYSTYPE_IS_DECLARED 1 481#endif 482 483#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED 484typedef struct YYLTYPE 485{ 486 int first_line; 487 int first_column; 488 int last_line; 489 int last_column; 490} YYLTYPE; 491# define yyltype YYLTYPE /* obsolescent; will be withdrawn */ 492# define YYLTYPE_IS_DECLARED 1 493# define YYLTYPE_IS_TRIVIAL 1 494#endif 495 496 497/* Copy the second part of user declarations. */ 498 499/* Line 343 of yacc.c */ 500#line 271 "src/src/mesa/program/program_parse.y" 501 502extern int yylex(YYSTYPE *yylval_param, YYLTYPE *yylloc_param, 503 void *yyscanner); 504 505 506/* Line 343 of yacc.c */ 507#line 508 "src/chromium_gensrc/mesa/program/program_parse.tab.c" 508 509#ifdef short 510# undef short 511#endif 512 513#ifdef YYTYPE_UINT8 514typedef YYTYPE_UINT8 yytype_uint8; 515#else 516typedef unsigned char yytype_uint8; 517#endif 518 519#ifdef YYTYPE_INT8 520typedef YYTYPE_INT8 yytype_int8; 521#elif (defined __STDC__ || defined __C99__FUNC__ \ 522 || defined __cplusplus || defined _MSC_VER) 523typedef signed char yytype_int8; 524#else 525typedef short int yytype_int8; 526#endif 527 528#ifdef YYTYPE_UINT16 529typedef YYTYPE_UINT16 yytype_uint16; 530#else 531typedef unsigned short int yytype_uint16; 532#endif 533 534#ifdef YYTYPE_INT16 535typedef YYTYPE_INT16 yytype_int16; 536#else 537typedef short int yytype_int16; 538#endif 539 540#ifndef YYSIZE_T 541# ifdef __SIZE_TYPE__ 542# define YYSIZE_T __SIZE_TYPE__ 543# elif defined size_t 544# define YYSIZE_T size_t 545# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ 546 || defined __cplusplus || defined _MSC_VER) 547# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 548# define YYSIZE_T size_t 549# else 550# define YYSIZE_T unsigned int 551# endif 552#endif 553 554#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 555 556#ifndef YY_ 557# if defined YYENABLE_NLS && YYENABLE_NLS 558# if ENABLE_NLS 559# include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 560# define YY_(msgid) dgettext ("bison-runtime", msgid) 561# endif 562# endif 563# ifndef YY_ 564# define YY_(msgid) msgid 565# endif 566#endif 567 568/* Suppress unused-variable warnings by "using" E. */ 569#if ! defined lint || defined __GNUC__ 570# define YYUSE(e) ((void) (e)) 571#else 572# define YYUSE(e) /* empty */ 573#endif 574 575/* Identity function, used to suppress warnings about constant conditions. */ 576#ifndef lint 577# define YYID(n) (n) 578#else 579#if (defined __STDC__ || defined __C99__FUNC__ \ 580 || defined __cplusplus || defined _MSC_VER) 581static int 582YYID (int yyi) 583#else 584static int 585YYID (yyi) 586 int yyi; 587#endif 588{ 589 return yyi; 590} 591#endif 592 593#if ! defined yyoverflow || YYERROR_VERBOSE 594 595/* The parser invokes alloca or malloc; define the necessary symbols. */ 596 597# ifdef YYSTACK_USE_ALLOCA 598# if YYSTACK_USE_ALLOCA 599# ifdef __GNUC__ 600# define YYSTACK_ALLOC __builtin_alloca 601# elif defined __BUILTIN_VA_ARG_INCR 602# include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 603# elif defined _AIX 604# define YYSTACK_ALLOC __alloca 605# elif defined _MSC_VER 606# include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 607# define alloca _alloca 608# else 609# define YYSTACK_ALLOC alloca 610# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 611 || defined __cplusplus || defined _MSC_VER) 612# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 613# ifndef EXIT_SUCCESS 614# define EXIT_SUCCESS 0 615# endif 616# endif 617# endif 618# endif 619# endif 620 621# ifdef YYSTACK_ALLOC 622 /* Pacify GCC's `empty if-body' warning. */ 623# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) 624# ifndef YYSTACK_ALLOC_MAXIMUM 625 /* The OS might guarantee only one guard page at the bottom of the stack, 626 and a page size can be as small as 4096 bytes. So we cannot safely 627 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 628 to allow for a few compiler-allocated temporary stack slots. */ 629# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 630# endif 631# else 632# define YYSTACK_ALLOC YYMALLOC 633# define YYSTACK_FREE YYFREE 634# ifndef YYSTACK_ALLOC_MAXIMUM 635# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 636# endif 637# if (defined __cplusplus && ! defined EXIT_SUCCESS \ 638 && ! ((defined YYMALLOC || defined malloc) \ 639 && (defined YYFREE || defined free))) 640# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 641# ifndef EXIT_SUCCESS 642# define EXIT_SUCCESS 0 643# endif 644# endif 645# ifndef YYMALLOC 646# define YYMALLOC malloc 647# if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 648 || defined __cplusplus || defined _MSC_VER) 649void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 650# endif 651# endif 652# ifndef YYFREE 653# define YYFREE free 654# if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 655 || defined __cplusplus || defined _MSC_VER) 656void free (void *); /* INFRINGES ON USER NAME SPACE */ 657# endif 658# endif 659# endif 660#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 661 662 663#if (! defined yyoverflow \ 664 && (! defined __cplusplus \ 665 || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \ 666 && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 667 668/* A type that is properly aligned for any stack member. */ 669union yyalloc 670{ 671 yytype_int16 yyss_alloc; 672 YYSTYPE yyvs_alloc; 673 YYLTYPE yyls_alloc; 674}; 675 676/* The size of the maximum gap between one aligned stack and the next. */ 677# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 678 679/* The size of an array large to enough to hold all stacks, each with 680 N elements. */ 681# define YYSTACK_BYTES(N) \ 682 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \ 683 + 2 * YYSTACK_GAP_MAXIMUM) 684 685# define YYCOPY_NEEDED 1 686 687/* Relocate STACK from its old location to the new one. The 688 local variables YYSIZE and YYSTACKSIZE give the old and new number of 689 elements in the stack, and YYPTR gives the new location of the 690 stack. Advance YYPTR to a properly aligned location for the next 691 stack. */ 692# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 693 do \ 694 { \ 695 YYSIZE_T yynewbytes; \ 696 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 697 Stack = &yyptr->Stack_alloc; \ 698 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 699 yyptr += yynewbytes / sizeof (*yyptr); \ 700 } \ 701 while (YYID (0)) 702 703#endif 704 705#if defined YYCOPY_NEEDED && YYCOPY_NEEDED 706/* Copy COUNT objects from FROM to TO. The source and destination do 707 not overlap. */ 708# ifndef YYCOPY 709# if defined __GNUC__ && 1 < __GNUC__ 710# define YYCOPY(To, From, Count) \ 711 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 712# else 713# define YYCOPY(To, From, Count) \ 714 do \ 715 { \ 716 YYSIZE_T yyi; \ 717 for (yyi = 0; yyi < (Count); yyi++) \ 718 (To)[yyi] = (From)[yyi]; \ 719 } \ 720 while (YYID (0)) 721# endif 722# endif 723#endif /* !YYCOPY_NEEDED */ 724 725/* YYFINAL -- State number of the termination state. */ 726#define YYFINAL 5 727/* YYLAST -- Last index in YYTABLE. */ 728#define YYLAST 402 729 730/* YYNTOKENS -- Number of terminals. */ 731#define YYNTOKENS 120 732/* YYNNTS -- Number of nonterminals. */ 733#define YYNNTS 143 734/* YYNRULES -- Number of rules. */ 735#define YYNRULES 283 736/* YYNRULES -- Number of states. */ 737#define YYNSTATES 478 738 739/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 740#define YYUNDEFTOK 2 741#define YYMAXUTOK 362 742 743#define YYTRANSLATE(YYX) \ 744 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 745 746/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 747static const yytype_uint8 yytranslate[] = 748{ 749 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 750 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 751 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 752 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 753 115, 116, 2, 113, 109, 114, 2, 2, 2, 2, 754 2, 2, 2, 2, 2, 2, 2, 2, 2, 108, 755 2, 117, 2, 2, 2, 2, 2, 2, 2, 2, 756 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 757 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 758 2, 111, 2, 112, 2, 2, 2, 2, 2, 2, 759 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 760 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 761 2, 2, 2, 118, 110, 119, 2, 2, 2, 2, 762 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 763 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 764 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 765 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 766 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 767 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 768 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 769 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 770 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 771 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 772 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 773 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 774 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 775 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 776 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 777 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 778 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 779 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 780 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 781 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 782 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 783 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 784 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 785 105, 106, 107 786}; 787 788#if YYDEBUG 789/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 790 YYRHS. */ 791static const yytype_uint16 yyprhs[] = 792{ 793 0, 0, 3, 8, 10, 12, 15, 16, 20, 23, 794 24, 27, 30, 32, 34, 36, 38, 40, 42, 44, 795 46, 48, 50, 52, 54, 59, 64, 69, 76, 83, 796 92, 101, 104, 107, 120, 123, 125, 127, 129, 131, 797 133, 135, 137, 139, 141, 143, 145, 147, 154, 157, 798 162, 165, 167, 171, 177, 181, 184, 192, 195, 197, 799 199, 201, 203, 208, 210, 212, 214, 216, 218, 220, 800 222, 226, 227, 230, 233, 235, 237, 239, 241, 243, 801 245, 247, 249, 251, 252, 254, 256, 258, 260, 261, 802 265, 269, 270, 273, 276, 278, 280, 282, 284, 286, 803 288, 290, 292, 297, 300, 303, 305, 308, 310, 313, 804 315, 318, 323, 328, 330, 331, 335, 337, 339, 342, 805 344, 347, 349, 351, 355, 362, 363, 365, 368, 373, 806 375, 379, 381, 383, 385, 387, 389, 391, 393, 395, 807 397, 399, 402, 405, 408, 411, 414, 417, 420, 423, 808 426, 429, 432, 435, 439, 441, 443, 445, 451, 453, 809 455, 457, 460, 462, 464, 467, 469, 472, 479, 481, 810 485, 487, 489, 491, 493, 495, 500, 502, 504, 506, 811 508, 510, 512, 515, 517, 519, 525, 527, 530, 532, 812 534, 540, 543, 544, 551, 555, 556, 558, 560, 562, 813 564, 566, 569, 571, 573, 576, 581, 586, 587, 591, 814 593, 595, 597, 600, 602, 604, 606, 608, 614, 616, 815 620, 626, 632, 634, 638, 644, 646, 648, 650, 652, 816 654, 656, 658, 660, 662, 666, 672, 680, 690, 693, 817 696, 698, 700, 701, 702, 707, 709, 710, 711, 715, 818 719, 721, 727, 730, 733, 736, 739, 743, 746, 750, 819 751, 755, 757, 759, 760, 762, 764, 765, 767, 769, 820 770, 772, 774, 775, 779, 780, 784, 785, 789, 791, 821 793, 795, 800, 802 822}; 823 824/* YYRHS -- A `-1'-separated list of the rules' RHS. */ 825static const yytype_int16 yyrhs[] = 826{ 827 121, 0, -1, 122, 123, 125, 12, -1, 3, -1, 828 4, -1, 123, 124, -1, -1, 8, 262, 108, -1, 829 125, 126, -1, -1, 127, 108, -1, 170, 108, -1, 830 128, -1, 129, -1, 130, -1, 131, -1, 132, -1, 831 133, -1, 134, -1, 135, -1, 141, -1, 136, -1, 832 137, -1, 138, -1, 19, 146, 109, 142, -1, 18, 833 145, 109, 144, -1, 16, 145, 109, 142, -1, 14, 834 145, 109, 142, 109, 142, -1, 13, 145, 109, 144, 835 109, 144, -1, 17, 145, 109, 144, 109, 144, 109, 836 144, -1, 15, 145, 109, 144, 109, 139, 109, 140, 837 -1, 20, 144, -1, 20, 166, -1, 22, 145, 109, 838 144, 109, 144, 109, 144, 109, 139, 109, 140, -1, 839 83, 256, -1, 84, -1, 85, -1, 86, -1, 87, 840 -1, 88, -1, 89, -1, 90, -1, 91, -1, 92, 841 -1, 93, -1, 94, -1, 95, -1, 21, 145, 109, 842 150, 109, 147, -1, 241, 143, -1, 241, 110, 143, 843 110, -1, 150, 162, -1, 238, -1, 241, 150, 163, 844 -1, 241, 110, 150, 163, 110, -1, 151, 164, 165, 845 -1, 159, 161, -1, 148, 109, 148, 109, 148, 109, 846 148, -1, 241, 149, -1, 23, -1, 262, -1, 100, 847 -1, 172, -1, 152, 111, 153, 112, -1, 186, -1, 848 249, -1, 100, -1, 100, -1, 154, -1, 155, -1, 849 23, -1, 159, 160, 156, -1, -1, 113, 157, -1, 850 114, 158, -1, 23, -1, 23, -1, 100, -1, 104, 851 -1, 104, -1, 104, -1, 104, -1, 101, -1, 105, 852 -1, -1, 101, -1, 102, -1, 103, -1, 104, -1, 853 -1, 115, 166, 116, -1, 115, 167, 116, -1, -1, 854 168, 163, -1, 169, 163, -1, 99, -1, 100, -1, 855 171, -1, 178, -1, 242, -1, 245, -1, 248, -1, 856 261, -1, 7, 99, 117, 172, -1, 96, 173, -1, 857 38, 177, -1, 60, -1, 98, 175, -1, 53, -1, 858 29, 254, -1, 37, -1, 74, 255, -1, 50, 111, 859 176, 112, -1, 97, 111, 174, 112, -1, 23, -1, 860 -1, 111, 176, 112, -1, 23, -1, 60, -1, 29, 861 254, -1, 37, -1, 74, 255, -1, 179, -1, 180, 862 -1, 10, 99, 182, -1, 10, 99, 111, 181, 112, 863 183, -1, -1, 23, -1, 117, 185, -1, 117, 118, 864 184, 119, -1, 187, -1, 184, 109, 187, -1, 189, 865 -1, 225, -1, 235, -1, 189, -1, 225, -1, 236, 866 -1, 188, -1, 226, -1, 235, -1, 189, -1, 73, 867 213, -1, 73, 190, -1, 73, 192, -1, 73, 195, 868 -1, 73, 197, -1, 73, 203, -1, 73, 199, -1, 869 73, 206, -1, 73, 208, -1, 73, 210, -1, 73, 870 212, -1, 73, 224, -1, 47, 253, 191, -1, 201, 871 -1, 33, -1, 69, -1, 43, 111, 202, 112, 193, 872 -1, 201, -1, 60, -1, 26, -1, 72, 194, -1, 873 40, -1, 32, -1, 44, 196, -1, 25, -1, 253, 874 67, -1, 45, 111, 202, 112, 253, 198, -1, 201, 875 -1, 75, 257, 200, -1, 29, -1, 25, -1, 31, 876 -1, 71, -1, 23, -1, 76, 255, 204, 205, -1, 877 35, -1, 54, -1, 79, -1, 80, -1, 78, -1, 878 77, -1, 36, 207, -1, 29, -1, 56, -1, 28, 879 111, 209, 112, 57, -1, 23, -1, 58, 211, -1, 880 70, -1, 26, -1, 215, 66, 111, 218, 112, -1, 881 215, 214, -1, -1, 66, 111, 218, 106, 218, 112, 882 -1, 49, 219, 216, -1, -1, 217, -1, 41, -1, 883 82, -1, 42, -1, 23, -1, 51, 220, -1, 63, 884 -1, 52, -1, 81, 255, -1, 55, 111, 222, 112, 885 -1, 48, 111, 223, 112, -1, -1, 111, 221, 112, 886 -1, 23, -1, 23, -1, 23, -1, 30, 64, -1, 887 229, -1, 232, -1, 227, -1, 230, -1, 62, 34, 888 111, 228, 112, -1, 233, -1, 233, 106, 233, -1, 889 62, 34, 111, 233, 112, -1, 62, 46, 111, 231, 890 112, -1, 234, -1, 234, 106, 234, -1, 62, 46, 891 111, 234, 112, -1, 23, -1, 23, -1, 237, -1, 892 239, -1, 238, -1, 239, -1, 240, -1, 24, -1, 893 23, -1, 118, 240, 119, -1, 118, 240, 109, 240, 894 119, -1, 118, 240, 109, 240, 109, 240, 119, -1, 895 118, 240, 109, 240, 109, 240, 109, 240, 119, -1, 896 241, 24, -1, 241, 23, -1, 113, -1, 114, -1, 897 -1, -1, 244, 11, 243, 247, -1, 262, -1, -1, 898 -1, 5, 246, 247, -1, 247, 109, 99, -1, 99, 899 -1, 244, 9, 99, 117, 249, -1, 65, 60, -1, 900 65, 37, -1, 65, 250, -1, 65, 59, -1, 65, 901 74, 255, -1, 65, 30, -1, 29, 251, 252, -1, 902 -1, 111, 23, 112, -1, 39, -1, 27, -1, -1, 903 61, -1, 68, -1, -1, 39, -1, 27, -1, -1, 904 61, -1, 68, -1, -1, 111, 258, 112, -1, -1, 905 111, 259, 112, -1, -1, 111, 260, 112, -1, 23, 906 -1, 23, -1, 23, -1, 6, 99, 117, 100, -1, 907 99, -1, 100, -1 908}; 909 910/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 911static const yytype_uint16 yyrline[] = 912{ 913 0, 278, 278, 281, 289, 301, 302, 305, 329, 330, 914 333, 348, 351, 356, 363, 364, 365, 366, 367, 368, 915 369, 372, 373, 374, 377, 383, 391, 397, 404, 410, 916 417, 461, 466, 476, 520, 526, 527, 528, 529, 530, 917 531, 532, 533, 534, 535, 536, 537, 540, 552, 560, 918 577, 584, 603, 614, 634, 659, 666, 699, 706, 721, 919 776, 819, 828, 850, 860, 864, 893, 912, 912, 914, 920 921, 933, 934, 935, 938, 952, 966, 986, 997, 1009, 921 1011, 1012, 1013, 1014, 1017, 1017, 1017, 1017, 1018, 1021, 922 1025, 1030, 1037, 1044, 1051, 1074, 1097, 1098, 1099, 1100, 923 1101, 1102, 1105, 1124, 1128, 1134, 1138, 1142, 1146, 1155, 924 1164, 1168, 1173, 1179, 1190, 1190, 1191, 1193, 1197, 1201, 925 1205, 1211, 1211, 1213, 1231, 1257, 1260, 1275, 1281, 1287, 926 1288, 1295, 1301, 1307, 1315, 1321, 1327, 1335, 1341, 1347, 927 1355, 1356, 1359, 1360, 1361, 1362, 1363, 1364, 1365, 1366, 928 1367, 1368, 1369, 1372, 1381, 1385, 1389, 1395, 1404, 1408, 929 1412, 1421, 1425, 1431, 1437, 1444, 1449, 1457, 1467, 1469, 930 1477, 1483, 1487, 1491, 1497, 1508, 1517, 1521, 1526, 1530, 931 1534, 1538, 1544, 1551, 1555, 1561, 1569, 1580, 1587, 1591, 932 1597, 1607, 1618, 1622, 1640, 1649, 1652, 1658, 1662, 1666, 933 1672, 1683, 1688, 1693, 1698, 1703, 1708, 1716, 1719, 1724, 934 1737, 1745, 1756, 1764, 1764, 1766, 1766, 1768, 1778, 1783, 935 1790, 1800, 1809, 1814, 1821, 1831, 1841, 1853, 1853, 1854, 936 1854, 1856, 1866, 1874, 1884, 1892, 1900, 1909, 1920, 1924, 937 1930, 1931, 1932, 1935, 1935, 1938, 1973, 1977, 1977, 1980, 938 1987, 1996, 2010, 2019, 2028, 2032, 2041, 2050, 2061, 2068, 939 2078, 2106, 2115, 2127, 2130, 2139, 2150, 2151, 2152, 2155, 940 2156, 2157, 2160, 2161, 2164, 2165, 2168, 2169, 2172, 2183, 941 2194, 2205, 2231, 2232 942}; 943#endif 944 945#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE 946/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 947 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 948static const char *const yytname[] = 949{ 950 "$end", "error", "$undefined", "ARBvp_10", "ARBfp_10", "ADDRESS", 951 "ALIAS", "ATTRIB", "OPTION", "OUTPUT", "PARAM", "TEMP", "END", "BIN_OP", 952 "BINSC_OP", "SAMPLE_OP", "SCALAR_OP", "TRI_OP", "VECTOR_OP", "ARL", 953 "KIL", "SWZ", "TXD_OP", "INTEGER", "REAL", "AMBIENT", "ATTENUATION", 954 "BACK", "CLIP", "COLOR", "DEPTH", "DIFFUSE", "DIRECTION", "EMISSION", 955 "ENV", "EYE", "FOG", "FOGCOORD", "FRAGMENT", "FRONT", "HALF", "INVERSE", 956 "INVTRANS", "LIGHT", "LIGHTMODEL", "LIGHTPROD", "LOCAL", "MATERIAL", 957 "MAT_PROGRAM", "MATRIX", "MATRIXINDEX", "MODELVIEW", "MVP", "NORMAL", 958 "OBJECT", "PALETTE", "PARAMS", "PLANE", "POINT_TOK", "POINTSIZE", 959 "POSITION", "PRIMARY", "PROGRAM", "PROJECTION", "RANGE", "RESULT", "ROW", 960 "SCENECOLOR", "SECONDARY", "SHININESS", "SIZE_TOK", "SPECULAR", "SPOT", 961 "STATE", "TEXCOORD", "TEXENV", "TEXGEN", "TEXGEN_Q", "TEXGEN_R", 962 "TEXGEN_S", "TEXGEN_T", "TEXTURE", "TRANSPOSE", "TEXTURE_UNIT", "TEX_1D", 963 "TEX_2D", "TEX_3D", "TEX_CUBE", "TEX_RECT", "TEX_SHADOW1D", 964 "TEX_SHADOW2D", "TEX_SHADOWRECT", "TEX_ARRAY1D", "TEX_ARRAY2D", 965 "TEX_ARRAYSHADOW1D", "TEX_ARRAYSHADOW2D", "VERTEX", "VTXATTRIB", 966 "WEIGHT", "IDENTIFIER", "USED_IDENTIFIER", "MASK4", "MASK3", "MASK2", 967 "MASK1", "SWIZZLE", "DOT_DOT", "DOT", "';'", "','", "'|'", "'['", "']'", 968 "'+'", "'-'", "'('", "')'", "'='", "'{'", "'}'", "$accept", "program", 969 "language", "optionSequence", "option", "statementSequence", "statement", 970 "instruction", "ALU_instruction", "TexInstruction", "ARL_instruction", 971 "VECTORop_instruction", "SCALARop_instruction", "BINSCop_instruction", 972 "BINop_instruction", "TRIop_instruction", "SAMPLE_instruction", 973 "KIL_instruction", "TXD_instruction", "texImageUnit", "texTarget", 974 "SWZ_instruction", "scalarSrcReg", "scalarUse", "swizzleSrcReg", 975 "maskedDstReg", "maskedAddrReg", "extendedSwizzle", "extSwizComp", 976 "extSwizSel", "srcReg", "dstReg", "progParamArray", "progParamArrayMem", 977 "progParamArrayAbs", "progParamArrayRel", "addrRegRelOffset", 978 "addrRegPosOffset", "addrRegNegOffset", "addrReg", "addrComponent", 979 "addrWriteMask", "scalarSuffix", "swizzleSuffix", "optionalMask", 980 "optionalCcMask", "ccTest", "ccTest2", "ccMaskRule", "ccMaskRule2", 981 "namingStatement", "ATTRIB_statement", "attribBinding", "vtxAttribItem", 982 "vtxAttribNum", "vtxOptWeightNum", "vtxWeightNum", "fragAttribItem", 983 "PARAM_statement", "PARAM_singleStmt", "PARAM_multipleStmt", 984 "optArraySize", "paramSingleInit", "paramMultipleInit", 985 "paramMultInitList", "paramSingleItemDecl", "paramSingleItemUse", 986 "paramMultipleItem", "stateMultipleItem", "stateSingleItem", 987 "stateMaterialItem", "stateMatProperty", "stateLightItem", 988 "stateLightProperty", "stateSpotProperty", "stateLightModelItem", 989 "stateLModProperty", "stateLightProdItem", "stateLProdProperty", 990 "stateTexEnvItem", "stateTexEnvProperty", "ambDiffSpecProperty", 991 "stateLightNumber", "stateTexGenItem", "stateTexGenType", 992 "stateTexGenCoord", "stateFogItem", "stateFogProperty", 993 "stateClipPlaneItem", "stateClipPlaneNum", "statePointItem", 994 "statePointProperty", "stateMatrixRow", "stateMatrixRows", 995 "optMatrixRows", "stateMatrixItem", "stateOptMatModifier", 996 "stateMatModifier", "stateMatrixRowNum", "stateMatrixName", 997 "stateOptModMatNum", "stateModMatNum", "statePaletteMatNum", 998 "stateProgramMatNum", "stateDepthItem", "programSingleItem", 999 "programMultipleItem", "progEnvParams", "progEnvParamNums", 1000 "progEnvParam", "progLocalParams", "progLocalParamNums", 1001 "progLocalParam", "progEnvParamNum", "progLocalParamNum", 1002 "paramConstDecl", "paramConstUse", "paramConstScalarDecl", 1003 "paramConstScalarUse", "paramConstVector", "signedFloatConstant", 1004 "optionalSign", "TEMP_statement", "@1", "optVarSize", 1005 "ADDRESS_statement", "@2", "varNameList", "OUTPUT_statement", 1006 "resultBinding", "resultColBinding", "optResultFaceType", 1007 "optResultColorType", "optFaceType", "optColorType", 1008 "optTexCoordUnitNum", "optTexImageUnitNum", "optLegacyTexUnitNum", 1009 "texCoordUnitNum", "texImageUnitNum", "legacyTexUnitNum", 1010 "ALIAS_statement", "string", 0 1011}; 1012#endif 1013 1014# ifdef YYPRINT 1015/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 1016 token YYLEX-NUM. */ 1017static const yytype_uint16 yytoknum[] = 1018{ 1019 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 1020 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 1021 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 1022 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 1023 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 1024 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 1025 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 1026 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 1027 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 1028 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 1029 355, 356, 357, 358, 359, 360, 361, 362, 59, 44, 1030 124, 91, 93, 43, 45, 40, 41, 61, 123, 125 1031}; 1032# endif 1033 1034/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 1035static const yytype_uint16 yyr1[] = 1036{ 1037 0, 120, 121, 122, 122, 123, 123, 124, 125, 125, 1038 126, 126, 127, 127, 128, 128, 128, 128, 128, 128, 1039 128, 129, 129, 129, 130, 131, 132, 133, 134, 135, 1040 136, 137, 137, 138, 139, 140, 140, 140, 140, 140, 1041 140, 140, 140, 140, 140, 140, 140, 141, 142, 142, 1042 143, 143, 144, 144, 145, 146, 147, 148, 149, 149, 1043 150, 150, 150, 150, 151, 151, 152, 153, 153, 154, 1044 155, 156, 156, 156, 157, 158, 159, 160, 161, 162, 1045 163, 163, 163, 163, 164, 164, 164, 164, 164, 165, 1046 165, 165, 166, 167, 168, 169, 170, 170, 170, 170, 1047 170, 170, 171, 172, 172, 173, 173, 173, 173, 173, 1048 173, 173, 173, 174, 175, 175, 176, 177, 177, 177, 1049 177, 178, 178, 179, 180, 181, 181, 182, 183, 184, 1050 184, 185, 185, 185, 186, 186, 186, 187, 187, 187, 1051 188, 188, 189, 189, 189, 189, 189, 189, 189, 189, 1052 189, 189, 189, 190, 191, 191, 191, 192, 193, 193, 1053 193, 193, 193, 194, 195, 196, 196, 197, 198, 199, 1054 200, 201, 201, 201, 202, 203, 204, 204, 205, 205, 1055 205, 205, 206, 207, 207, 208, 209, 210, 211, 211, 1056 212, 213, 214, 214, 215, 216, 216, 217, 217, 217, 1057 218, 219, 219, 219, 219, 219, 219, 220, 220, 221, 1058 222, 223, 224, 225, 225, 226, 226, 227, 228, 228, 1059 229, 230, 231, 231, 232, 233, 234, 235, 235, 236, 1060 236, 237, 238, 238, 239, 239, 239, 239, 240, 240, 1061 241, 241, 241, 243, 242, 244, 244, 246, 245, 247, 1062 247, 248, 249, 249, 249, 249, 249, 249, 250, 251, 1063 251, 251, 251, 252, 252, 252, 253, 253, 253, 254, 1064 254, 254, 255, 255, 256, 256, 257, 257, 258, 259, 1065 260, 261, 262, 262 1066}; 1067 1068/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 1069static const yytype_uint8 yyr2[] = 1070{ 1071 0, 2, 4, 1, 1, 2, 0, 3, 2, 0, 1072 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1073 1, 1, 1, 1, 4, 4, 4, 6, 6, 8, 1074 8, 2, 2, 12, 2, 1, 1, 1, 1, 1, 1075 1, 1, 1, 1, 1, 1, 1, 6, 2, 4, 1076 2, 1, 3, 5, 3, 2, 7, 2, 1, 1, 1077 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 1078 3, 0, 2, 2, 1, 1, 1, 1, 1, 1, 1079 1, 1, 1, 0, 1, 1, 1, 1, 0, 3, 1080 3, 0, 2, 2, 1, 1, 1, 1, 1, 1, 1081 1, 1, 4, 2, 2, 1, 2, 1, 2, 1, 1082 2, 4, 4, 1, 0, 3, 1, 1, 2, 1, 1083 2, 1, 1, 3, 6, 0, 1, 2, 4, 1, 1084 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1085 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1086 2, 2, 2, 3, 1, 1, 1, 5, 1, 1, 1087 1, 2, 1, 1, 2, 1, 2, 6, 1, 3, 1088 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1089 1, 1, 2, 1, 1, 5, 1, 2, 1, 1, 1090 5, 2, 0, 6, 3, 0, 1, 1, 1, 1, 1091 1, 2, 1, 1, 2, 4, 4, 0, 3, 1, 1092 1, 1, 2, 1, 1, 1, 1, 5, 1, 3, 1093 5, 5, 1, 3, 5, 1, 1, 1, 1, 1, 1094 1, 1, 1, 1, 3, 5, 7, 9, 2, 2, 1095 1, 1, 0, 0, 4, 1, 0, 0, 3, 3, 1096 1, 5, 2, 2, 2, 2, 3, 2, 3, 0, 1097 3, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1098 1, 1, 0, 3, 0, 3, 0, 3, 1, 1, 1099 1, 4, 1, 1 1100}; 1101 1102/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM. 1103 Performed when YYTABLE doesn't specify something else to do. Zero 1104 means the default is an error. */ 1105static const yytype_uint16 yydefact[] = 1106{ 1107 0, 3, 4, 0, 6, 1, 9, 0, 5, 246, 1108 282, 283, 0, 247, 0, 0, 0, 2, 0, 0, 1109 0, 0, 0, 0, 0, 242, 0, 0, 8, 0, 1110 12, 13, 14, 15, 16, 17, 18, 19, 21, 22, 1111 23, 20, 0, 96, 97, 121, 122, 98, 0, 99, 1112 100, 101, 245, 7, 0, 0, 0, 0, 0, 65, 1113 0, 88, 64, 0, 0, 0, 0, 0, 76, 0, 1114 0, 94, 240, 241, 31, 32, 83, 0, 0, 0, 1115 10, 11, 0, 243, 250, 248, 0, 0, 125, 242, 1116 123, 259, 257, 253, 255, 252, 272, 254, 242, 84, 1117 85, 86, 87, 91, 242, 242, 242, 242, 242, 242, 1118 78, 55, 81, 80, 82, 92, 233, 232, 0, 0, 1119 0, 0, 60, 0, 242, 83, 0, 61, 63, 134, 1120 135, 213, 214, 136, 229, 230, 0, 242, 0, 0, 1121 0, 281, 102, 126, 0, 127, 131, 132, 133, 227, 1122 228, 231, 0, 262, 261, 0, 263, 0, 256, 0, 1123 0, 54, 0, 0, 0, 26, 0, 25, 24, 269, 1124 119, 117, 272, 104, 0, 0, 0, 0, 0, 0, 1125 266, 0, 266, 0, 0, 276, 272, 142, 143, 144, 1126 145, 147, 146, 148, 149, 150, 151, 0, 152, 269, 1127 109, 0, 107, 105, 272, 0, 114, 103, 83, 0, 1128 52, 0, 0, 0, 0, 244, 249, 0, 239, 238, 1129 0, 264, 265, 258, 278, 0, 242, 95, 0, 0, 1130 83, 242, 0, 48, 0, 51, 0, 242, 270, 271, 1131 118, 120, 0, 0, 0, 212, 183, 184, 182, 0, 1132 165, 268, 267, 164, 0, 0, 0, 0, 207, 203, 1133 0, 202, 272, 195, 189, 188, 187, 0, 0, 0, 1134 0, 108, 0, 110, 0, 0, 106, 0, 242, 234, 1135 69, 0, 67, 68, 0, 242, 242, 251, 0, 124, 1136 260, 273, 28, 89, 90, 93, 27, 0, 79, 50, 1137 274, 0, 0, 225, 0, 226, 0, 186, 0, 174, 1138 0, 166, 0, 171, 172, 155, 156, 173, 153, 154, 1139 0, 0, 201, 0, 204, 197, 199, 198, 194, 196, 1140 280, 0, 170, 169, 176, 177, 0, 0, 116, 0, 1141 113, 0, 0, 53, 0, 62, 77, 71, 47, 0, 1142 0, 0, 242, 49, 0, 34, 0, 242, 220, 224, 1143 0, 0, 266, 211, 0, 209, 0, 210, 0, 277, 1144 181, 180, 178, 179, 175, 200, 0, 111, 112, 115, 1145 242, 235, 0, 0, 70, 242, 58, 57, 59, 242, 1146 0, 0, 0, 129, 137, 140, 138, 215, 216, 139, 1147 279, 0, 35, 36, 37, 38, 39, 40, 41, 42, 1148 43, 44, 45, 46, 30, 29, 185, 160, 162, 159, 1149 0, 157, 158, 0, 206, 208, 205, 190, 0, 74, 1150 72, 75, 73, 0, 0, 0, 0, 141, 192, 242, 1151 128, 275, 163, 161, 167, 168, 242, 236, 242, 0, 1152 0, 0, 0, 191, 130, 0, 0, 0, 0, 218, 1153 0, 222, 0, 237, 242, 0, 217, 0, 221, 0, 1154 0, 56, 33, 219, 223, 0, 0, 193 1155}; 1156 1157/* YYDEFGOTO[NTERM-NUM]. */ 1158static const yytype_int16 yydefgoto[] = 1159{ 1160 -1, 3, 4, 6, 8, 9, 28, 29, 30, 31, 1161 32, 33, 34, 35, 36, 37, 38, 39, 40, 301, 1162 414, 41, 162, 233, 74, 60, 69, 348, 349, 387, 1163 234, 61, 126, 281, 282, 283, 384, 430, 432, 70, 1164 347, 111, 299, 115, 103, 161, 75, 229, 76, 230, 1165 42, 43, 127, 207, 341, 276, 339, 173, 44, 45, 1166 46, 144, 90, 289, 392, 145, 128, 393, 394, 129, 1167 187, 318, 188, 421, 443, 189, 253, 190, 444, 191, 1168 333, 319, 310, 192, 336, 374, 193, 248, 194, 308, 1169 195, 266, 196, 437, 453, 197, 328, 329, 376, 263, 1170 322, 366, 368, 364, 198, 130, 396, 397, 458, 131, 1171 398, 460, 132, 304, 306, 399, 133, 149, 134, 135, 1172 151, 77, 47, 139, 48, 49, 54, 85, 50, 62, 1173 97, 156, 223, 254, 240, 158, 355, 268, 225, 401, 1174 331, 51, 12 1175}; 1176 1177/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 1178 STATE-NUM. */ 1179#define YYPACT_NINF -398 1180static const yytype_int16 yypact[] = 1181{ 1182 52, -398, -398, 14, -398, -398, 67, 152, -398, 24, 1183 -398, -398, 5, -398, 47, 81, 99, -398, -1, -1, 1184 -1, -1, -1, -1, 43, 56, -1, -1, -398, 97, 1185 -398, -398, -398, -398, -398, -398, -398, -398, -398, -398, 1186 -398, -398, 112, -398, -398, -398, -398, -398, 156, -398, 1187 -398, -398, -398, -398, 111, 98, 141, 95, 127, -398, 1188 84, 142, -398, 146, 150, 153, 157, 158, -398, 159, 1189 165, -398, -398, -398, -398, -398, 113, -13, 161, 163, 1190 -398, -398, 162, -398, -398, 164, 174, 10, 252, -3, 1191 -398, -11, -398, -398, -398, -398, 166, -398, -20, -398, 1192 -398, -398, -398, 167, -20, -20, -20, -20, -20, -20, 1193 -398, -398, -398, -398, -398, -398, -398, -398, 137, 70, 1194 132, 85, 168, 34, -20, 113, 169, -398, -398, -398, 1195 -398, -398, -398, -398, -398, -398, 34, -20, 171, 111, 1196 179, -398, -398, -398, 172, -398, -398, -398, -398, -398, 1197 -398, -398, 216, -398, -398, 253, 76, 258, -398, 176, 1198 154, -398, 178, 29, 180, -398, 181, -398, -398, 110, 1199 -398, -398, 166, -398, 175, 182, 183, 219, 32, 184, 1200 177, 186, 94, 140, 7, 187, 166, -398, -398, -398, 1201 -398, -398, -398, -398, -398, -398, -398, 226, -398, 110, 1202 -398, 188, -398, -398, 166, 189, 190, -398, 113, 9, 1203 -398, 1, 193, 195, 240, 164, -398, 191, -398, -398, 1204 194, -398, -398, -398, -398, 197, -20, -398, 196, 198, 1205 113, -20, 34, -398, 203, 206, 228, -20, -398, -398, 1206 -398, -398, 290, 292, 293, -398, -398, -398, -398, 294, 1207 -398, -398, -398, -398, 251, 294, 48, 208, 209, -398, 1208 210, -398, 166, 21, -398, -398, -398, 299, 295, 12, 1209 212, -398, 302, -398, 304, 302, -398, 218, -20, -398, 1210 -398, 217, -398, -398, 227, -20, -20, -398, 214, -398, 1211 -398, -398, -398, -398, -398, -398, -398, 220, -398, -398, 1212 222, 225, 229, -398, 223, -398, 224, -398, 230, -398, 1213 231, -398, 233, -398, -398, -398, -398, -398, -398, -398, 1214 314, 316, -398, 317, -398, -398, -398, -398, -398, -398, 1215 -398, 234, -398, -398, -398, -398, 170, 318, -398, 235, 1216 -398, 236, 237, -398, 44, -398, -398, 143, -398, 244, 1217 -15, 245, 36, -398, 332, -398, 138, -20, -398, -398, 1218 301, 101, 94, -398, 248, -398, 249, -398, 250, -398, 1219 -398, -398, -398, -398, -398, -398, 254, -398, -398, -398, 1220 -20, -398, 333, 340, -398, -20, -398, -398, -398, -20, 1221 102, 132, 75, -398, -398, -398, -398, -398, -398, -398, 1222 -398, 255, -398, -398, -398, -398, -398, -398, -398, -398, 1223 -398, -398, -398, -398, -398, -398, -398, -398, -398, -398, 1224 336, -398, -398, 49, -398, -398, -398, -398, 90, -398, 1225 -398, -398, -398, 256, 260, 259, 261, -398, 298, 36, 1226 -398, -398, -398, -398, -398, -398, -20, -398, -20, 228, 1227 290, 292, 262, -398, -398, 257, 265, 268, 266, 273, 1228 269, 274, 318, -398, -20, 138, -398, 290, -398, 292, 1229 107, -398, -398, -398, -398, 318, 270, -398 1230}; 1231 1232/* YYPGOTO[NTERM-NUM]. */ 1233static const yytype_int16 yypgoto[] = 1234{ 1235 -398, -398, -398, -398, -398, -398, -398, -398, -398, -398, 1236 -398, -398, -398, -398, -398, -398, -398, -398, -398, -78, 1237 -82, -398, -100, 155, -86, 215, -398, -398, -372, -398, 1238 -54, -398, -398, -398, -398, -398, -398, -398, -398, 173, 1239 -398, -398, -398, -118, -398, -398, 232, -398, -398, -398, 1240 -398, -398, 303, -398, -398, -398, 114, -398, -398, -398, 1241 -398, -398, -398, -398, -398, -398, -398, -53, -398, -88, 1242 -398, -398, -398, -398, -398, -398, -398, -398, -398, -398, 1243 -398, -334, 130, -398, -398, -398, -398, -398, -398, -398, 1244 -398, -398, -398, -398, -398, 0, -398, -398, -397, -398, 1245 -398, -398, -398, -398, -398, 305, -398, -398, -398, -398, 1246 -398, -398, -398, -396, -383, 306, -398, -398, -137, -87, 1247 -120, -89, -398, -398, -398, -398, -398, 263, -398, 185, 1248 -398, -398, -398, -177, 199, -154, -398, -398, -398, -398, 1249 -398, -398, -6 1250}; 1251 1252/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 1253 positive, shift that token. If negative, reduce the rule which 1254 number is the opposite. If YYTABLE_NINF, syntax error. */ 1255#define YYTABLE_NINF -230 1256static const yytype_int16 yytable[] = 1257{ 1258 152, 146, 150, 52, 209, 256, 165, 210, 386, 168, 1259 116, 117, 159, 433, 5, 163, 153, 163, 241, 164, 1260 163, 166, 167, 125, 280, 118, 235, 422, 154, 13, 1261 14, 15, 269, 264, 16, 152, 17, 18, 19, 20, 1262 21, 22, 23, 24, 25, 26, 27, 334, 118, 119, 1263 273, 213, 116, 117, 459, 1, 2, 116, 117, 119, 1264 120, 246, 325, 326, 58, 470, 335, 118, 461, 208, 1265 120, 473, 118, 313, 313, 7, 456, 265, 476, 314, 1266 314, 315, 212, 121, 10, 11, 474, 122, 247, 445, 1267 277, 119, 471, 72, 73, 235, 119, 123, 390, 59, 1268 155, 68, 120, 327, 174, 124, 121, 120, 324, 391, 1269 72, 73, 295, 53, 199, 124, 175, 316, 278, 317, 1270 317, 251, 200, 10, 11, 121, 313, 417, 279, 122, 1271 121, 296, 314, 252, 122, 201, 435, 221, 202, 232, 1272 292, 418, 163, 68, 222, 203, 55, 124, 436, 72, 1273 73, 302, 124, 380, 124, 71, 91, 92, 344, 204, 1274 176, 419, 177, 381, 93, 82, 169, 83, 178, 72, 1275 73, 238, 317, 420, 170, 179, 180, 181, 239, 182, 1276 56, 183, 205, 206, 439, 423, 94, 95, 257, 152, 1277 184, 258, 259, 98, 440, 260, 350, 171, 57, 446, 1278 351, 96, 250, 261, 251, 80, 88, 185, 186, 447, 1279 84, 172, 89, 475, 112, 86, 252, 113, 114, 427, 1280 81, 262, 402, 403, 404, 405, 406, 407, 408, 409, 1281 410, 411, 412, 413, 63, 64, 65, 66, 67, 218, 1282 219, 78, 79, 99, 100, 101, 102, 370, 371, 372, 1283 373, 10, 11, 71, 227, 104, 382, 383, 87, 105, 1284 428, 138, 106, 152, 395, 150, 107, 108, 109, 110, 1285 136, 415, 137, 140, 141, 143, 220, 157, 216, -66, 1286 211, 224, 160, 245, 217, 226, 242, 231, 214, 236, 1287 237, 152, 270, 243, 244, 249, 350, 255, 267, 272, 1288 274, 275, 285, 434, 286, 58, 290, 298, 288, 291, 1289 -229, 300, 293, 303, 294, 305, 307, 309, 311, 320, 1290 321, 323, 330, 337, 332, 338, 455, 340, 343, 345, 1291 353, 346, 352, 354, 356, 358, 359, 363, 357, 365, 1292 367, 375, 360, 361, 388, 362, 369, 377, 378, 379, 1293 152, 395, 150, 385, 389, 400, 429, 152, 416, 350, 1294 424, 425, 426, 431, 452, 448, 427, 441, 442, 449, 1295 450, 457, 451, 462, 464, 350, 463, 465, 466, 467, 1296 469, 468, 477, 472, 284, 312, 454, 297, 0, 342, 1297 142, 438, 228, 0, 147, 148, 0, 0, 271, 287, 1298 0, 0, 215 1299}; 1300 1301#define yypact_value_is_default(yystate) \ 1302 ((yystate) == (-398)) 1303 1304#define yytable_value_is_error(yytable_value) \ 1305 YYID (0) 1306 1307static const yytype_int16 yycheck[] = 1308{ 1309 89, 89, 89, 9, 124, 182, 106, 125, 23, 109, 1310 23, 24, 98, 385, 0, 104, 27, 106, 172, 105, 1311 109, 107, 108, 77, 23, 38, 163, 361, 39, 5, 1312 6, 7, 186, 26, 10, 124, 12, 13, 14, 15, 1313 16, 17, 18, 19, 20, 21, 22, 35, 38, 62, 1314 204, 137, 23, 24, 450, 3, 4, 23, 24, 62, 1315 73, 29, 41, 42, 65, 462, 54, 38, 451, 123, 1316 73, 467, 38, 25, 25, 8, 448, 70, 475, 31, 1317 31, 33, 136, 96, 99, 100, 469, 100, 56, 423, 1318 208, 62, 464, 113, 114, 232, 62, 110, 62, 100, 1319 111, 100, 73, 82, 34, 118, 96, 73, 262, 73, 1320 113, 114, 230, 108, 29, 118, 46, 69, 109, 71, 1321 71, 27, 37, 99, 100, 96, 25, 26, 119, 100, 1322 96, 231, 31, 39, 100, 50, 34, 61, 53, 110, 1323 226, 40, 231, 100, 68, 60, 99, 118, 46, 113, 1324 114, 237, 118, 109, 118, 99, 29, 30, 278, 74, 1325 28, 60, 30, 119, 37, 9, 29, 11, 36, 113, 1326 114, 61, 71, 72, 37, 43, 44, 45, 68, 47, 1327 99, 49, 97, 98, 109, 362, 59, 60, 48, 278, 1328 58, 51, 52, 109, 119, 55, 285, 60, 99, 109, 1329 286, 74, 25, 63, 27, 108, 111, 75, 76, 119, 1330 99, 74, 117, 106, 101, 117, 39, 104, 105, 112, 1331 108, 81, 84, 85, 86, 87, 88, 89, 90, 91, 1332 92, 93, 94, 95, 19, 20, 21, 22, 23, 23, 1333 24, 26, 27, 101, 102, 103, 104, 77, 78, 79, 1334 80, 99, 100, 99, 100, 109, 113, 114, 117, 109, 1335 380, 99, 109, 352, 352, 352, 109, 109, 109, 104, 1336 109, 357, 109, 109, 100, 23, 23, 111, 99, 111, 1337 111, 23, 115, 64, 112, 109, 111, 109, 117, 109, 1338 109, 380, 66, 111, 111, 111, 385, 111, 111, 111, 1339 111, 111, 109, 389, 109, 65, 112, 104, 117, 112, 1340 104, 83, 116, 23, 116, 23, 23, 23, 67, 111, 1341 111, 111, 23, 111, 29, 23, 446, 23, 110, 112, 1342 110, 104, 118, 111, 109, 112, 112, 23, 109, 23, 1343 23, 23, 112, 112, 350, 112, 112, 112, 112, 112, 1344 439, 439, 439, 109, 109, 23, 23, 446, 57, 448, 1345 112, 112, 112, 23, 66, 109, 112, 112, 32, 109, 1346 111, 449, 111, 111, 109, 464, 119, 109, 112, 106, 1347 106, 112, 112, 465, 211, 255, 439, 232, -1, 275, 1348 87, 391, 160, -1, 89, 89, -1, -1, 199, 214, 1349 -1, -1, 139 1350}; 1351 1352/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 1353 symbol of state STATE-NUM. */ 1354static const yytype_uint16 yystos[] = 1355{ 1356 0, 3, 4, 121, 122, 0, 123, 8, 124, 125, 1357 99, 100, 262, 5, 6, 7, 10, 12, 13, 14, 1358 15, 16, 17, 18, 19, 20, 21, 22, 126, 127, 1359 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 1360 138, 141, 170, 171, 178, 179, 180, 242, 244, 245, 1361 248, 261, 262, 108, 246, 99, 99, 99, 65, 100, 1362 145, 151, 249, 145, 145, 145, 145, 145, 100, 146, 1363 159, 99, 113, 114, 144, 166, 168, 241, 145, 145, 1364 108, 108, 9, 11, 99, 247, 117, 117, 111, 117, 1365 182, 29, 30, 37, 59, 60, 74, 250, 109, 101, 1366 102, 103, 104, 164, 109, 109, 109, 109, 109, 109, 1367 104, 161, 101, 104, 105, 163, 23, 24, 38, 62, 1368 73, 96, 100, 110, 118, 150, 152, 172, 186, 189, 1369 225, 229, 232, 236, 238, 239, 109, 109, 99, 243, 1370 109, 100, 172, 23, 181, 185, 189, 225, 235, 237, 1371 239, 240, 241, 27, 39, 111, 251, 111, 255, 144, 1372 115, 165, 142, 241, 144, 142, 144, 144, 142, 29, 1373 37, 60, 74, 177, 34, 46, 28, 30, 36, 43, 1374 44, 45, 47, 49, 58, 75, 76, 190, 192, 195, 1375 197, 199, 203, 206, 208, 210, 212, 215, 224, 29, 1376 37, 50, 53, 60, 74, 97, 98, 173, 150, 240, 1377 163, 111, 150, 144, 117, 247, 99, 112, 23, 24, 1378 23, 61, 68, 252, 23, 258, 109, 100, 166, 167, 1379 169, 109, 110, 143, 150, 238, 109, 109, 61, 68, 1380 254, 255, 111, 111, 111, 64, 29, 56, 207, 111, 1381 25, 27, 39, 196, 253, 111, 253, 48, 51, 52, 1382 55, 63, 81, 219, 26, 70, 211, 111, 257, 255, 1383 66, 254, 111, 255, 111, 111, 175, 163, 109, 119, 1384 23, 153, 154, 155, 159, 109, 109, 249, 117, 183, 1385 112, 112, 144, 116, 116, 163, 142, 143, 104, 162, 1386 83, 139, 144, 23, 233, 23, 234, 23, 209, 23, 1387 202, 67, 202, 25, 31, 33, 69, 71, 191, 201, 1388 111, 111, 220, 111, 255, 41, 42, 82, 216, 217, 1389 23, 260, 29, 200, 35, 54, 204, 111, 23, 176, 1390 23, 174, 176, 110, 240, 112, 104, 160, 147, 148, 1391 241, 144, 118, 110, 111, 256, 109, 109, 112, 112, 1392 112, 112, 112, 23, 223, 23, 221, 23, 222, 112, 1393 77, 78, 79, 80, 205, 23, 218, 112, 112, 112, 1394 109, 119, 113, 114, 156, 109, 23, 149, 262, 109, 1395 62, 73, 184, 187, 188, 189, 226, 227, 230, 235, 1396 23, 259, 84, 85, 86, 87, 88, 89, 90, 91, 1397 92, 93, 94, 95, 140, 144, 57, 26, 40, 60, 1398 72, 193, 201, 253, 112, 112, 112, 112, 240, 23, 1399 157, 23, 158, 148, 144, 34, 46, 213, 215, 109, 1400 119, 112, 32, 194, 198, 201, 109, 119, 109, 109, 1401 111, 111, 66, 214, 187, 240, 148, 139, 228, 233, 1402 231, 234, 111, 119, 109, 109, 112, 106, 112, 106, 1403 218, 148, 140, 233, 234, 106, 218, 112 1404}; 1405 1406#define yyerrok (yyerrstatus = 0) 1407#define yyclearin (yychar = YYEMPTY) 1408#define YYEMPTY (-2) 1409#define YYEOF 0 1410 1411#define YYACCEPT goto yyacceptlab 1412#define YYABORT goto yyabortlab 1413#define YYERROR goto yyerrorlab 1414 1415 1416/* Like YYERROR except do call yyerror. This remains here temporarily 1417 to ease the transition to the new meaning of YYERROR, for GCC. 1418 Once GCC version 2 has supplanted version 1, this can go. However, 1419 YYFAIL appears to be in use. Nevertheless, it is formally deprecated 1420 in Bison 2.4.2's NEWS entry, where a plan to phase it out is 1421 discussed. */ 1422 1423#define YYFAIL goto yyerrlab 1424#if defined YYFAIL 1425 /* This is here to suppress warnings from the GCC cpp's 1426 -Wunused-macros. Normally we don't worry about that warning, but 1427 some users do, and we want to make it easy for users to remove 1428 YYFAIL uses, which will produce warnings from Bison 2.5. */ 1429#endif 1430 1431#define YYRECOVERING() (!!yyerrstatus) 1432 1433#define YYBACKUP(Token, Value) \ 1434do \ 1435 if (yychar == YYEMPTY && yylen == 1) \ 1436 { \ 1437 yychar = (Token); \ 1438 yylval = (Value); \ 1439 YYPOPSTACK (1); \ 1440 goto yybackup; \ 1441 } \ 1442 else \ 1443 { \ 1444 yyerror (&yylloc, state, YY_("syntax error: cannot back up")); \ 1445 YYERROR; \ 1446 } \ 1447while (YYID (0)) 1448 1449 1450#define YYTERROR 1 1451#define YYERRCODE 256 1452 1453 1454/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 1455 If N is 0, then set CURRENT to the empty location which ends 1456 the previous symbol: RHS[0] (always defined). */ 1457 1458#define YYRHSLOC(Rhs, K) ((Rhs)[K]) 1459#ifndef YYLLOC_DEFAULT 1460# define YYLLOC_DEFAULT(Current, Rhs, N) \ 1461 do \ 1462 if (YYID (N)) \ 1463 { \ 1464 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 1465 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 1466 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 1467 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 1468 } \ 1469 else \ 1470 { \ 1471 (Current).first_line = (Current).last_line = \ 1472 YYRHSLOC (Rhs, 0).last_line; \ 1473 (Current).first_column = (Current).last_column = \ 1474 YYRHSLOC (Rhs, 0).last_column; \ 1475 } \ 1476 while (YYID (0)) 1477#endif 1478 1479 1480/* YY_LOCATION_PRINT -- Print the location on the stream. 1481 This macro was not mandated originally: define only if we know 1482 we won't break user code: when these are the locations we know. */ 1483 1484#ifndef YY_LOCATION_PRINT 1485# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL 1486# define YY_LOCATION_PRINT(File, Loc) \ 1487 fprintf (File, "%d.%d-%d.%d", \ 1488 (Loc).first_line, (Loc).first_column, \ 1489 (Loc).last_line, (Loc).last_column) 1490# else 1491# define YY_LOCATION_PRINT(File, Loc) ((void) 0) 1492# endif 1493#endif 1494 1495 1496/* YYLEX -- calling `yylex' with the right arguments. */ 1497 1498#ifdef YYLEX_PARAM 1499# define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM) 1500#else 1501# define YYLEX yylex (&yylval, &yylloc, scanner) 1502#endif 1503 1504/* Enable debugging if requested. */ 1505#if YYDEBUG 1506 1507# ifndef YYFPRINTF 1508# include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 1509# define YYFPRINTF fprintf 1510# endif 1511 1512# define YYDPRINTF(Args) \ 1513do { \ 1514 if (yydebug) \ 1515 YYFPRINTF Args; \ 1516} while (YYID (0)) 1517 1518# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 1519do { \ 1520 if (yydebug) \ 1521 { \ 1522 YYFPRINTF (stderr, "%s ", Title); \ 1523 yy_symbol_print (stderr, \ 1524 Type, Value, Location, state); \ 1525 YYFPRINTF (stderr, "\n"); \ 1526 } \ 1527} while (YYID (0)) 1528 1529 1530/*--------------------------------. 1531| Print this symbol on YYOUTPUT. | 1532`--------------------------------*/ 1533 1534/*ARGSUSED*/ 1535#if (defined __STDC__ || defined __C99__FUNC__ \ 1536 || defined __cplusplus || defined _MSC_VER) 1537static void 1538yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, struct asm_parser_state *state) 1539#else 1540static void 1541yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, state) 1542 FILE *yyoutput; 1543 int yytype; 1544 YYSTYPE const * const yyvaluep; 1545 YYLTYPE const * const yylocationp; 1546 struct asm_parser_state *state; 1547#endif 1548{ 1549 if (!yyvaluep) 1550 return; 1551 YYUSE (yylocationp); 1552 YYUSE (state); 1553# ifdef YYPRINT 1554 if (yytype < YYNTOKENS) 1555 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 1556# else 1557 YYUSE (yyoutput); 1558# endif 1559 switch (yytype) 1560 { 1561 default: 1562 break; 1563 } 1564} 1565 1566 1567/*--------------------------------. 1568| Print this symbol on YYOUTPUT. | 1569`--------------------------------*/ 1570 1571#if (defined __STDC__ || defined __C99__FUNC__ \ 1572 || defined __cplusplus || defined _MSC_VER) 1573static void 1574yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, struct asm_parser_state *state) 1575#else 1576static void 1577yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp, state) 1578 FILE *yyoutput; 1579 int yytype; 1580 YYSTYPE const * const yyvaluep; 1581 YYLTYPE const * const yylocationp; 1582 struct asm_parser_state *state; 1583#endif 1584{ 1585 if (yytype < YYNTOKENS) 1586 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 1587 else 1588 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 1589 1590 YY_LOCATION_PRINT (yyoutput, *yylocationp); 1591 YYFPRINTF (yyoutput, ": "); 1592 yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, state); 1593 YYFPRINTF (yyoutput, ")"); 1594} 1595 1596/*------------------------------------------------------------------. 1597| yy_stack_print -- Print the state stack from its BOTTOM up to its | 1598| TOP (included). | 1599`------------------------------------------------------------------*/ 1600 1601#if (defined __STDC__ || defined __C99__FUNC__ \ 1602 || defined __cplusplus || defined _MSC_VER) 1603static void 1604yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 1605#else 1606static void 1607yy_stack_print (yybottom, yytop) 1608 yytype_int16 *yybottom; 1609 yytype_int16 *yytop; 1610#endif 1611{ 1612 YYFPRINTF (stderr, "Stack now"); 1613 for (; yybottom <= yytop; yybottom++) 1614 { 1615 int yybot = *yybottom; 1616 YYFPRINTF (stderr, " %d", yybot); 1617 } 1618 YYFPRINTF (stderr, "\n"); 1619} 1620 1621# define YY_STACK_PRINT(Bottom, Top) \ 1622do { \ 1623 if (yydebug) \ 1624 yy_stack_print ((Bottom), (Top)); \ 1625} while (YYID (0)) 1626 1627 1628/*------------------------------------------------. 1629| Report that the YYRULE is going to be reduced. | 1630`------------------------------------------------*/ 1631 1632#if (defined __STDC__ || defined __C99__FUNC__ \ 1633 || defined __cplusplus || defined _MSC_VER) 1634static void 1635yy_reduce_print (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, struct asm_parser_state *state) 1636#else 1637static void 1638yy_reduce_print (yyvsp, yylsp, yyrule, state) 1639 YYSTYPE *yyvsp; 1640 YYLTYPE *yylsp; 1641 int yyrule; 1642 struct asm_parser_state *state; 1643#endif 1644{ 1645 int yynrhs = yyr2[yyrule]; 1646 int yyi; 1647 unsigned long int yylno = yyrline[yyrule]; 1648 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 1649 yyrule - 1, yylno); 1650 /* The symbols being reduced. */ 1651 for (yyi = 0; yyi < yynrhs; yyi++) 1652 { 1653 YYFPRINTF (stderr, " $%d = ", yyi + 1); 1654 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 1655 &(yyvsp[(yyi + 1) - (yynrhs)]) 1656 , &(yylsp[(yyi + 1) - (yynrhs)]) , state); 1657 YYFPRINTF (stderr, "\n"); 1658 } 1659} 1660 1661# define YY_REDUCE_PRINT(Rule) \ 1662do { \ 1663 if (yydebug) \ 1664 yy_reduce_print (yyvsp, yylsp, Rule, state); \ 1665} while (YYID (0)) 1666 1667/* Nonzero means print parse trace. It is left uninitialized so that 1668 multiple parsers can coexist. */ 1669int yydebug; 1670#else /* !YYDEBUG */ 1671# define YYDPRINTF(Args) 1672# define YY_SYMBOL_PRINT(Title, Type, Value, Location) 1673# define YY_STACK_PRINT(Bottom, Top) 1674# define YY_REDUCE_PRINT(Rule) 1675#endif /* !YYDEBUG */ 1676 1677 1678/* YYINITDEPTH -- initial size of the parser's stacks. */ 1679#ifndef YYINITDEPTH 1680# define YYINITDEPTH 200 1681#endif 1682 1683/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 1684 if the built-in stack extension method is used). 1685 1686 Do not make this value too large; the results are undefined if 1687 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 1688 evaluated with infinite-precision integer arithmetic. */ 1689 1690#ifndef YYMAXDEPTH 1691# define YYMAXDEPTH 10000 1692#endif 1693 1694 1695#if YYERROR_VERBOSE 1696 1697# ifndef yystrlen 1698# if defined __GLIBC__ && defined _STRING_H 1699# define yystrlen strlen 1700# else 1701/* Return the length of YYSTR. */ 1702#if (defined __STDC__ || defined __C99__FUNC__ \ 1703 || defined __cplusplus || defined _MSC_VER) 1704static YYSIZE_T 1705yystrlen (const char *yystr) 1706#else 1707static YYSIZE_T 1708yystrlen (yystr) 1709 const char *yystr; 1710#endif 1711{ 1712 YYSIZE_T yylen; 1713 for (yylen = 0; yystr[yylen]; yylen++) 1714 continue; 1715 return yylen; 1716} 1717# endif 1718# endif 1719 1720# ifndef yystpcpy 1721# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 1722# define yystpcpy stpcpy 1723# else 1724/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 1725 YYDEST. */ 1726#if (defined __STDC__ || defined __C99__FUNC__ \ 1727 || defined __cplusplus || defined _MSC_VER) 1728static char * 1729yystpcpy (char *yydest, const char *yysrc) 1730#else 1731static char * 1732yystpcpy (yydest, yysrc) 1733 char *yydest; 1734 const char *yysrc; 1735#endif 1736{ 1737 char *yyd = yydest; 1738 const char *yys = yysrc; 1739 1740 while ((*yyd++ = *yys++) != '\0') 1741 continue; 1742 1743 return yyd - 1; 1744} 1745# endif 1746# endif 1747 1748# ifndef yytnamerr 1749/* Copy to YYRES the contents of YYSTR after stripping away unnecessary 1750 quotes and backslashes, so that it's suitable for yyerror. The 1751 heuristic is that double-quoting is unnecessary unless the string 1752 contains an apostrophe, a comma, or backslash (other than 1753 backslash-backslash). YYSTR is taken from yytname. If YYRES is 1754 null, do not copy; instead, return the length of what the result 1755 would have been. */ 1756static YYSIZE_T 1757yytnamerr (char *yyres, const char *yystr) 1758{ 1759 if (*yystr == '"') 1760 { 1761 YYSIZE_T yyn = 0; 1762 char const *yyp = yystr; 1763 1764 for (;;) 1765 switch (*++yyp) 1766 { 1767 case '\'': 1768 case ',': 1769 goto do_not_strip_quotes; 1770 1771 case '\\': 1772 if (*++yyp != '\\') 1773 goto do_not_strip_quotes; 1774 /* Fall through. */ 1775 default: 1776 if (yyres) 1777 yyres[yyn] = *yyp; 1778 yyn++; 1779 break; 1780 1781 case '"': 1782 if (yyres) 1783 yyres[yyn] = '\0'; 1784 return yyn; 1785 } 1786 do_not_strip_quotes: ; 1787 } 1788 1789 if (! yyres) 1790 return yystrlen (yystr); 1791 1792 return yystpcpy (yyres, yystr) - yyres; 1793} 1794# endif 1795 1796/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message 1797 about the unexpected token YYTOKEN for the state stack whose top is 1798 YYSSP. 1799 1800 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is 1801 not large enough to hold the message. In that case, also set 1802 *YYMSG_ALLOC to the required number of bytes. Return 2 if the 1803 required number of bytes is too large to store. */ 1804static int 1805yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, 1806 yytype_int16 *yyssp, int yytoken) 1807{ 1808 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]); 1809 YYSIZE_T yysize = yysize0; 1810 YYSIZE_T yysize1; 1811 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1812 /* Internationalized format string. */ 1813 const char *yyformat = 0; 1814 /* Arguments of yyformat. */ 1815 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1816 /* Number of reported tokens (one for the "unexpected", one per 1817 "expected"). */ 1818 int yycount = 0; 1819 1820 /* There are many possibilities here to consider: 1821 - Assume YYFAIL is not used. It's too flawed to consider. See 1822 <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html> 1823 for details. YYERROR is fine as it does not invoke this 1824 function. 1825 - If this state is a consistent state with a default action, then 1826 the only way this function was invoked is if the default action 1827 is an error action. In that case, don't check for expected 1828 tokens because there are none. 1829 - The only way there can be no lookahead present (in yychar) is if 1830 this state is a consistent state with a default action. Thus, 1831 detecting the absence of a lookahead is sufficient to determine 1832 that there is no unexpected or expected token to report. In that 1833 case, just report a simple "syntax error". 1834 - Don't assume there isn't a lookahead just because this state is a 1835 consistent state with a default action. There might have been a 1836 previous inconsistent state, consistent state with a non-default 1837 action, or user semantic action that manipulated yychar. 1838 - Of course, the expected token list depends on states to have 1839 correct lookahead information, and it depends on the parser not 1840 to perform extra reductions after fetching a lookahead from the 1841 scanner and before detecting a syntax error. Thus, state merging 1842 (from LALR or IELR) and default reductions corrupt the expected 1843 token list. However, the list is correct for canonical LR with 1844 one exception: it will still contain any token that will not be 1845 accepted due to an error action in a later state. 1846 */ 1847 if (yytoken != YYEMPTY) 1848 { 1849 int yyn = yypact[*yyssp]; 1850 yyarg[yycount++] = yytname[yytoken]; 1851 if (!yypact_value_is_default (yyn)) 1852 { 1853 /* Start YYX at -YYN if negative to avoid negative indexes in 1854 YYCHECK. In other words, skip the first -YYN actions for 1855 this state because they are default actions. */ 1856 int yyxbegin = yyn < 0 ? -yyn : 0; 1857 /* Stay within bounds of both yycheck and yytname. */ 1858 int yychecklim = YYLAST - yyn + 1; 1859 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 1860 int yyx; 1861 1862 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 1863 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR 1864 && !yytable_value_is_error (yytable[yyx + yyn])) 1865 { 1866 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 1867 { 1868 yycount = 1; 1869 yysize = yysize0; 1870 break; 1871 } 1872 yyarg[yycount++] = yytname[yyx]; 1873 yysize1 = yysize + yytnamerr (0, yytname[yyx]); 1874 if (! (yysize <= yysize1 1875 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 1876 return 2; 1877 yysize = yysize1; 1878 } 1879 } 1880 } 1881 1882 switch (yycount) 1883 { 1884# define YYCASE_(N, S) \ 1885 case N: \ 1886 yyformat = S; \ 1887 break 1888 YYCASE_(0, YY_("syntax error")); 1889 YYCASE_(1, YY_("syntax error, unexpected %s")); 1890 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); 1891 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); 1892 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); 1893 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); 1894# undef YYCASE_ 1895 } 1896 1897 yysize1 = yysize + yystrlen (yyformat); 1898 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 1899 return 2; 1900 yysize = yysize1; 1901 1902 if (*yymsg_alloc < yysize) 1903 { 1904 *yymsg_alloc = 2 * yysize; 1905 if (! (yysize <= *yymsg_alloc 1906 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) 1907 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; 1908 return 1; 1909 } 1910 1911 /* Avoid sprintf, as that infringes on the user's name space. 1912 Don't have undefined behavior even if the translation 1913 produced a string with the wrong number of "%s"s. */ 1914 { 1915 char *yyp = *yymsg; 1916 int yyi = 0; 1917 while ((*yyp = *yyformat) != '\0') 1918 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) 1919 { 1920 yyp += yytnamerr (yyp, yyarg[yyi++]); 1921 yyformat += 2; 1922 } 1923 else 1924 { 1925 yyp++; 1926 yyformat++; 1927 } 1928 } 1929 return 0; 1930} 1931#endif /* YYERROR_VERBOSE */ 1932 1933/*-----------------------------------------------. 1934| Release the memory associated to this symbol. | 1935`-----------------------------------------------*/ 1936 1937/*ARGSUSED*/ 1938#if (defined __STDC__ || defined __C99__FUNC__ \ 1939 || defined __cplusplus || defined _MSC_VER) 1940static void 1941yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, struct asm_parser_state *state) 1942#else 1943static void 1944yydestruct (yymsg, yytype, yyvaluep, yylocationp, state) 1945 const char *yymsg; 1946 int yytype; 1947 YYSTYPE *yyvaluep; 1948 YYLTYPE *yylocationp; 1949 struct asm_parser_state *state; 1950#endif 1951{ 1952 YYUSE (yyvaluep); 1953 YYUSE (yylocationp); 1954 YYUSE (state); 1955 1956 if (!yymsg) 1957 yymsg = "Deleting"; 1958 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1959 1960 switch (yytype) 1961 { 1962 1963 default: 1964 break; 1965 } 1966} 1967 1968 1969/* Prevent warnings from -Wmissing-prototypes. */ 1970#ifdef YYPARSE_PARAM 1971#if defined __STDC__ || defined __cplusplus 1972int yyparse (void *YYPARSE_PARAM); 1973#else 1974int yyparse (); 1975#endif 1976#else /* ! YYPARSE_PARAM */ 1977#if defined __STDC__ || defined __cplusplus 1978int yyparse (struct asm_parser_state *state); 1979#else 1980int yyparse (); 1981#endif 1982#endif /* ! YYPARSE_PARAM */ 1983 1984 1985/*----------. 1986| yyparse. | 1987`----------*/ 1988 1989#ifdef YYPARSE_PARAM 1990#if (defined __STDC__ || defined __C99__FUNC__ \ 1991 || defined __cplusplus || defined _MSC_VER) 1992int 1993yyparse (void *YYPARSE_PARAM) 1994#else 1995int 1996yyparse (YYPARSE_PARAM) 1997 void *YYPARSE_PARAM; 1998#endif 1999#else /* ! YYPARSE_PARAM */ 2000#if (defined __STDC__ || defined __C99__FUNC__ \ 2001 || defined __cplusplus || defined _MSC_VER) 2002int 2003yyparse (struct asm_parser_state *state) 2004#else 2005int 2006yyparse (state) 2007 struct asm_parser_state *state; 2008#endif 2009#endif 2010{ 2011/* The lookahead symbol. */ 2012int yychar; 2013 2014/* The semantic value of the lookahead symbol. */ 2015YYSTYPE yylval; 2016 2017/* Location data for the lookahead symbol. */ 2018YYLTYPE yylloc; 2019 2020 /* Number of syntax errors so far. */ 2021 int yynerrs; 2022 2023 int yystate; 2024 /* Number of tokens to shift before error messages enabled. */ 2025 int yyerrstatus; 2026 2027 /* The stacks and their tools: 2028 `yyss': related to states. 2029 `yyvs': related to semantic values. 2030 `yyls': related to locations. 2031 2032 Refer to the stacks thru separate pointers, to allow yyoverflow 2033 to reallocate them elsewhere. */ 2034 2035 /* The state stack. */ 2036 yytype_int16 yyssa[YYINITDEPTH]; 2037 yytype_int16 *yyss; 2038 yytype_int16 *yyssp; 2039 2040 /* The semantic value stack. */ 2041 YYSTYPE yyvsa[YYINITDEPTH]; 2042 YYSTYPE *yyvs; 2043 YYSTYPE *yyvsp; 2044 2045 /* The location stack. */ 2046 YYLTYPE yylsa[YYINITDEPTH]; 2047 YYLTYPE *yyls; 2048 YYLTYPE *yylsp; 2049 2050 /* The locations where the error started and ended. */ 2051 YYLTYPE yyerror_range[3]; 2052 2053 YYSIZE_T yystacksize; 2054 2055 int yyn; 2056 int yyresult; 2057 /* Lookahead token as an internal (translated) token number. */ 2058 int yytoken; 2059 /* The variables used to return semantic value and location from the 2060 action routines. */ 2061 YYSTYPE yyval; 2062 YYLTYPE yyloc; 2063 2064#if YYERROR_VERBOSE 2065 /* Buffer for error messages, and its allocated size. */ 2066 char yymsgbuf[128]; 2067 char *yymsg = yymsgbuf; 2068 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 2069#endif 2070 2071#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) 2072 2073 /* The number of symbols on the RHS of the reduced rule. 2074 Keep to zero when no symbol should be popped. */ 2075 int yylen = 0; 2076 2077 yytoken = 0; 2078 yyss = yyssa; 2079 yyvs = yyvsa; 2080 yyls = yylsa; 2081 yystacksize = YYINITDEPTH; 2082 2083 YYDPRINTF ((stderr, "Starting parse\n")); 2084 2085 yystate = 0; 2086 yyerrstatus = 0; 2087 yynerrs = 0; 2088 yychar = YYEMPTY; /* Cause a token to be read. */ 2089 2090 /* Initialize stack pointers. 2091 Waste one element of value and location stack 2092 so that they stay on the same level as the state stack. 2093 The wasted elements are never initialized. */ 2094 yyssp = yyss; 2095 yyvsp = yyvs; 2096 yylsp = yyls; 2097 2098#if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL 2099 /* Initialize the default location before parsing starts. */ 2100 yylloc.first_line = yylloc.last_line = 1; 2101 yylloc.first_column = yylloc.last_column = 1; 2102#endif 2103 2104 goto yysetstate; 2105 2106/*------------------------------------------------------------. 2107| yynewstate -- Push a new state, which is found in yystate. | 2108`------------------------------------------------------------*/ 2109 yynewstate: 2110 /* In all cases, when you get here, the value and location stacks 2111 have just been pushed. So pushing a state here evens the stacks. */ 2112 yyssp++; 2113 2114 yysetstate: 2115 *yyssp = yystate; 2116 2117 if (yyss + yystacksize - 1 <= yyssp) 2118 { 2119 /* Get the current used size of the three stacks, in elements. */ 2120 YYSIZE_T yysize = yyssp - yyss + 1; 2121 2122#ifdef yyoverflow 2123 { 2124 /* Give user a chance to reallocate the stack. Use copies of 2125 these so that the &'s don't force the real ones into 2126 memory. */ 2127 YYSTYPE *yyvs1 = yyvs; 2128 yytype_int16 *yyss1 = yyss; 2129 YYLTYPE *yyls1 = yyls; 2130 2131 /* Each stack pointer address is followed by the size of the 2132 data in use in that stack, in bytes. This used to be a 2133 conditional around just the two extra args, but that might 2134 be undefined if yyoverflow is a macro. */ 2135 yyoverflow (YY_("memory exhausted"), 2136 &yyss1, yysize * sizeof (*yyssp), 2137 &yyvs1, yysize * sizeof (*yyvsp), 2138 &yyls1, yysize * sizeof (*yylsp), 2139 &yystacksize); 2140 2141 yyls = yyls1; 2142 yyss = yyss1; 2143 yyvs = yyvs1; 2144 } 2145#else /* no yyoverflow */ 2146# ifndef YYSTACK_RELOCATE 2147 goto yyexhaustedlab; 2148# else 2149 /* Extend the stack our own way. */ 2150 if (YYMAXDEPTH <= yystacksize) 2151 goto yyexhaustedlab; 2152 yystacksize *= 2; 2153 if (YYMAXDEPTH < yystacksize) 2154 yystacksize = YYMAXDEPTH; 2155 2156 { 2157 yytype_int16 *yyss1 = yyss; 2158 union yyalloc *yyptr = 2159 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 2160 if (! yyptr) 2161 goto yyexhaustedlab; 2162 YYSTACK_RELOCATE (yyss_alloc, yyss); 2163 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 2164 YYSTACK_RELOCATE (yyls_alloc, yyls); 2165# undef YYSTACK_RELOCATE 2166 if (yyss1 != yyssa) 2167 YYSTACK_FREE (yyss1); 2168 } 2169# endif 2170#endif /* no yyoverflow */ 2171 2172 yyssp = yyss + yysize - 1; 2173 yyvsp = yyvs + yysize - 1; 2174 yylsp = yyls + yysize - 1; 2175 2176 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 2177 (unsigned long int) yystacksize)); 2178 2179 if (yyss + yystacksize - 1 <= yyssp) 2180 YYABORT; 2181 } 2182 2183 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 2184 2185 if (yystate == YYFINAL) 2186 YYACCEPT; 2187 2188 goto yybackup; 2189 2190/*-----------. 2191| yybackup. | 2192`-----------*/ 2193yybackup: 2194 2195 /* Do appropriate processing given the current state. Read a 2196 lookahead token if we need one and don't already have one. */ 2197 2198 /* First try to decide what to do without reference to lookahead token. */ 2199 yyn = yypact[yystate]; 2200 if (yypact_value_is_default (yyn)) 2201 goto yydefault; 2202 2203 /* Not known => get a lookahead token if don't already have one. */ 2204 2205 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 2206 if (yychar == YYEMPTY) 2207 { 2208 YYDPRINTF ((stderr, "Reading a token: ")); 2209 yychar = YYLEX; 2210 } 2211 2212 if (yychar <= YYEOF) 2213 { 2214 yychar = yytoken = YYEOF; 2215 YYDPRINTF ((stderr, "Now at end of input.\n")); 2216 } 2217 else 2218 { 2219 yytoken = YYTRANSLATE (yychar); 2220 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 2221 } 2222 2223 /* If the proper action on seeing token YYTOKEN is to reduce or to 2224 detect an error, take that action. */ 2225 yyn += yytoken; 2226 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 2227 goto yydefault; 2228 yyn = yytable[yyn]; 2229 if (yyn <= 0) 2230 { 2231 if (yytable_value_is_error (yyn)) 2232 goto yyerrlab; 2233 yyn = -yyn; 2234 goto yyreduce; 2235 } 2236 2237 /* Count tokens shifted since error; after three, turn off error 2238 status. */ 2239 if (yyerrstatus) 2240 yyerrstatus--; 2241 2242 /* Shift the lookahead token. */ 2243 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 2244 2245 /* Discard the shifted token. */ 2246 yychar = YYEMPTY; 2247 2248 yystate = yyn; 2249 *++yyvsp = yylval; 2250 *++yylsp = yylloc; 2251 goto yynewstate; 2252 2253 2254/*-----------------------------------------------------------. 2255| yydefault -- do the default action for the current state. | 2256`-----------------------------------------------------------*/ 2257yydefault: 2258 yyn = yydefact[yystate]; 2259 if (yyn == 0) 2260 goto yyerrlab; 2261 goto yyreduce; 2262 2263 2264/*-----------------------------. 2265| yyreduce -- Do a reduction. | 2266`-----------------------------*/ 2267yyreduce: 2268 /* yyn is the number of a rule to reduce with. */ 2269 yylen = yyr2[yyn]; 2270 2271 /* If YYLEN is nonzero, implement the default value of the action: 2272 `$$ = $1'. 2273 2274 Otherwise, the following line sets YYVAL to garbage. 2275 This behavior is undocumented and Bison 2276 users should not rely upon it. Assigning to YYVAL 2277 unconditionally makes the parser a bit smaller, and it avoids a 2278 GCC warning that YYVAL may be used uninitialized. */ 2279 yyval = yyvsp[1-yylen]; 2280 2281 /* Default location. */ 2282 YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); 2283 YY_REDUCE_PRINT (yyn); 2284 switch (yyn) 2285 { 2286 case 3: 2287 2288/* Line 1806 of yacc.c */ 2289#line 282 "src/src/mesa/program/program_parse.y" 2290 { 2291 if (state->prog->Target != GL_VERTEX_PROGRAM_ARB) { 2292 yyerror(& (yylsp[(1) - (1)]), state, "invalid fragment program header"); 2293 2294 } 2295 state->mode = ARB_vertex; 2296 } 2297 break; 2298 2299 case 4: 2300 2301/* Line 1806 of yacc.c */ 2302#line 290 "src/src/mesa/program/program_parse.y" 2303 { 2304 if (state->prog->Target != GL_FRAGMENT_PROGRAM_ARB) { 2305 yyerror(& (yylsp[(1) - (1)]), state, "invalid vertex program header"); 2306 } 2307 state->mode = ARB_fragment; 2308 2309 state->option.TexRect = 2310 (state->ctx->Extensions.NV_texture_rectangle != GL_FALSE); 2311 } 2312 break; 2313 2314 case 7: 2315 2316/* Line 1806 of yacc.c */ 2317#line 306 "src/src/mesa/program/program_parse.y" 2318 { 2319 int valid = 0; 2320 2321 if (state->mode == ARB_vertex) { 2322 valid = _mesa_ARBvp_parse_option(state, (yyvsp[(2) - (3)].string)); 2323 } else if (state->mode == ARB_fragment) { 2324 valid = _mesa_ARBfp_parse_option(state, (yyvsp[(2) - (3)].string)); 2325 } 2326 2327 2328 free((yyvsp[(2) - (3)].string)); 2329 2330 if (!valid) { 2331 const char *const err_str = (state->mode == ARB_vertex) 2332 ? "invalid ARB vertex program option" 2333 : "invalid ARB fragment program option"; 2334 2335 yyerror(& (yylsp[(2) - (3)]), state, err_str); 2336 YYERROR; 2337 } 2338 } 2339 break; 2340 2341 case 10: 2342 2343/* Line 1806 of yacc.c */ 2344#line 334 "src/src/mesa/program/program_parse.y" 2345 { 2346 if ((yyvsp[(1) - (2)].inst) != NULL) { 2347 if (state->inst_tail == NULL) { 2348 state->inst_head = (yyvsp[(1) - (2)].inst); 2349 } else { 2350 state->inst_tail->next = (yyvsp[(1) - (2)].inst); 2351 } 2352 2353 state->inst_tail = (yyvsp[(1) - (2)].inst); 2354 (yyvsp[(1) - (2)].inst)->next = NULL; 2355 2356 state->prog->NumInstructions++; 2357 } 2358 } 2359 break; 2360 2361 case 12: 2362 2363/* Line 1806 of yacc.c */ 2364#line 352 "src/src/mesa/program/program_parse.y" 2365 { 2366 (yyval.inst) = (yyvsp[(1) - (1)].inst); 2367 state->prog->NumAluInstructions++; 2368 } 2369 break; 2370 2371 case 13: 2372 2373/* Line 1806 of yacc.c */ 2374#line 357 "src/src/mesa/program/program_parse.y" 2375 { 2376 (yyval.inst) = (yyvsp[(1) - (1)].inst); 2377 state->prog->NumTexInstructions++; 2378 } 2379 break; 2380 2381 case 24: 2382 2383/* Line 1806 of yacc.c */ 2384#line 378 "src/src/mesa/program/program_parse.y" 2385 { 2386 (yyval.inst) = asm_instruction_ctor(OPCODE_ARL, & (yyvsp[(2) - (4)].dst_reg), & (yyvsp[(4) - (4)].src_reg), NULL, NULL); 2387 } 2388 break; 2389 2390 case 25: 2391 2392/* Line 1806 of yacc.c */ 2393#line 384 "src/src/mesa/program/program_parse.y" 2394 { 2395 if ((yyvsp[(1) - (4)].temp_inst).Opcode == OPCODE_DDY) 2396 state->fragment.UsesDFdy = 1; 2397 (yyval.inst) = asm_instruction_copy_ctor(& (yyvsp[(1) - (4)].temp_inst), & (yyvsp[(2) - (4)].dst_reg), & (yyvsp[(4) - (4)].src_reg), NULL, NULL); 2398 } 2399 break; 2400 2401 case 26: 2402 2403/* Line 1806 of yacc.c */ 2404#line 392 "src/src/mesa/program/program_parse.y" 2405 { 2406 (yyval.inst) = asm_instruction_copy_ctor(& (yyvsp[(1) - (4)].temp_inst), & (yyvsp[(2) - (4)].dst_reg), & (yyvsp[(4) - (4)].src_reg), NULL, NULL); 2407 } 2408 break; 2409 2410 case 27: 2411 2412/* Line 1806 of yacc.c */ 2413#line 398 "src/src/mesa/program/program_parse.y" 2414 { 2415 (yyval.inst) = asm_instruction_copy_ctor(& (yyvsp[(1) - (6)].temp_inst), & (yyvsp[(2) - (6)].dst_reg), & (yyvsp[(4) - (6)].src_reg), & (yyvsp[(6) - (6)].src_reg), NULL); 2416 } 2417 break; 2418 2419 case 28: 2420 2421/* Line 1806 of yacc.c */ 2422#line 405 "src/src/mesa/program/program_parse.y" 2423 { 2424 (yyval.inst) = asm_instruction_copy_ctor(& (yyvsp[(1) - (6)].temp_inst), & (yyvsp[(2) - (6)].dst_reg), & (yyvsp[(4) - (6)].src_reg), & (yyvsp[(6) - (6)].src_reg), NULL); 2425 } 2426 break; 2427 2428 case 29: 2429 2430/* Line 1806 of yacc.c */ 2431#line 412 "src/src/mesa/program/program_parse.y" 2432 { 2433 (yyval.inst) = asm_instruction_copy_ctor(& (yyvsp[(1) - (8)].temp_inst), & (yyvsp[(2) - (8)].dst_reg), & (yyvsp[(4) - (8)].src_reg), & (yyvsp[(6) - (8)].src_reg), & (yyvsp[(8) - (8)].src_reg)); 2434 } 2435 break; 2436 2437 case 30: 2438 2439/* Line 1806 of yacc.c */ 2440#line 418 "src/src/mesa/program/program_parse.y" 2441 { 2442 (yyval.inst) = asm_instruction_copy_ctor(& (yyvsp[(1) - (8)].temp_inst), & (yyvsp[(2) - (8)].dst_reg), & (yyvsp[(4) - (8)].src_reg), NULL, NULL); 2443 if ((yyval.inst) != NULL) { 2444 const GLbitfield tex_mask = (1U << (yyvsp[(6) - (8)].integer)); 2445 GLbitfield shadow_tex = 0; 2446 GLbitfield target_mask = 0; 2447 2448 2449 (yyval.inst)->Base.TexSrcUnit = (yyvsp[(6) - (8)].integer); 2450 2451 if ((yyvsp[(8) - (8)].integer) < 0) { 2452 shadow_tex = tex_mask; 2453 2454 (yyval.inst)->Base.TexSrcTarget = -(yyvsp[(8) - (8)].integer); 2455 (yyval.inst)->Base.TexShadow = 1; 2456 } else { 2457 (yyval.inst)->Base.TexSrcTarget = (yyvsp[(8) - (8)].integer); 2458 } 2459 2460 target_mask = (1U << (yyval.inst)->Base.TexSrcTarget); 2461 2462 /* If this texture unit was previously accessed and that access 2463 * had a different texture target, generate an error. 2464 * 2465 * If this texture unit was previously accessed and that access 2466 * had a different shadow mode, generate an error. 2467 */ 2468 if ((state->prog->TexturesUsed[(yyvsp[(6) - (8)].integer)] != 0) 2469 && ((state->prog->TexturesUsed[(yyvsp[(6) - (8)].integer)] != target_mask) 2470 || ((state->prog->ShadowSamplers & tex_mask) 2471 != shadow_tex))) { 2472 yyerror(& (yylsp[(8) - (8)]), state, 2473 "multiple targets used on one texture image unit"); 2474 YYERROR; 2475 } 2476 2477 2478 state->prog->TexturesUsed[(yyvsp[(6) - (8)].integer)] |= target_mask; 2479 state->prog->ShadowSamplers |= shadow_tex; 2480 } 2481 } 2482 break; 2483 2484 case 31: 2485 2486/* Line 1806 of yacc.c */ 2487#line 462 "src/src/mesa/program/program_parse.y" 2488 { 2489 (yyval.inst) = asm_instruction_ctor(OPCODE_KIL, NULL, & (yyvsp[(2) - (2)].src_reg), NULL, NULL); 2490 state->fragment.UsesKill = 1; 2491 } 2492 break; 2493 2494 case 32: 2495 2496/* Line 1806 of yacc.c */ 2497#line 467 "src/src/mesa/program/program_parse.y" 2498 { 2499 (yyval.inst) = asm_instruction_ctor(OPCODE_KIL_NV, NULL, NULL, NULL, NULL); 2500 (yyval.inst)->Base.DstReg.CondMask = (yyvsp[(2) - (2)].dst_reg).CondMask; 2501 (yyval.inst)->Base.DstReg.CondSwizzle = (yyvsp[(2) - (2)].dst_reg).CondSwizzle; 2502 (yyval.inst)->Base.DstReg.CondSrc = (yyvsp[(2) - (2)].dst_reg).CondSrc; 2503 state->fragment.UsesKill = 1; 2504 } 2505 break; 2506 2507 case 33: 2508 2509/* Line 1806 of yacc.c */ 2510#line 477 "src/src/mesa/program/program_parse.y" 2511 { 2512 (yyval.inst) = asm_instruction_copy_ctor(& (yyvsp[(1) - (12)].temp_inst), & (yyvsp[(2) - (12)].dst_reg), & (yyvsp[(4) - (12)].src_reg), & (yyvsp[(6) - (12)].src_reg), & (yyvsp[(8) - (12)].src_reg)); 2513 if ((yyval.inst) != NULL) { 2514 const GLbitfield tex_mask = (1U << (yyvsp[(10) - (12)].integer)); 2515 GLbitfield shadow_tex = 0; 2516 GLbitfield target_mask = 0; 2517 2518 2519 (yyval.inst)->Base.TexSrcUnit = (yyvsp[(10) - (12)].integer); 2520 2521 if ((yyvsp[(12) - (12)].integer) < 0) { 2522 shadow_tex = tex_mask; 2523 2524 (yyval.inst)->Base.TexSrcTarget = -(yyvsp[(12) - (12)].integer); 2525 (yyval.inst)->Base.TexShadow = 1; 2526 } else { 2527 (yyval.inst)->Base.TexSrcTarget = (yyvsp[(12) - (12)].integer); 2528 } 2529 2530 target_mask = (1U << (yyval.inst)->Base.TexSrcTarget); 2531 2532 /* If this texture unit was previously accessed and that access 2533 * had a different texture target, generate an error. 2534 * 2535 * If this texture unit was previously accessed and that access 2536 * had a different shadow mode, generate an error. 2537 */ 2538 if ((state->prog->TexturesUsed[(yyvsp[(10) - (12)].integer)] != 0) 2539 && ((state->prog->TexturesUsed[(yyvsp[(10) - (12)].integer)] != target_mask) 2540 || ((state->prog->ShadowSamplers & tex_mask) 2541 != shadow_tex))) { 2542 yyerror(& (yylsp[(12) - (12)]), state, 2543 "multiple targets used on one texture image unit"); 2544 YYERROR; 2545 } 2546 2547 2548 state->prog->TexturesUsed[(yyvsp[(10) - (12)].integer)] |= target_mask; 2549 state->prog->ShadowSamplers |= shadow_tex; 2550 } 2551 } 2552 break; 2553 2554 case 34: 2555 2556/* Line 1806 of yacc.c */ 2557#line 521 "src/src/mesa/program/program_parse.y" 2558 { 2559 (yyval.integer) = (yyvsp[(2) - (2)].integer); 2560 } 2561 break; 2562 2563 case 35: 2564 2565/* Line 1806 of yacc.c */ 2566#line 526 "src/src/mesa/program/program_parse.y" 2567 { (yyval.integer) = TEXTURE_1D_INDEX; } 2568 break; 2569 2570 case 36: 2571 2572/* Line 1806 of yacc.c */ 2573#line 527 "src/src/mesa/program/program_parse.y" 2574 { (yyval.integer) = TEXTURE_2D_INDEX; } 2575 break; 2576 2577 case 37: 2578 2579/* Line 1806 of yacc.c */ 2580#line 528 "src/src/mesa/program/program_parse.y" 2581 { (yyval.integer) = TEXTURE_3D_INDEX; } 2582 break; 2583 2584 case 38: 2585 2586/* Line 1806 of yacc.c */ 2587#line 529 "src/src/mesa/program/program_parse.y" 2588 { (yyval.integer) = TEXTURE_CUBE_INDEX; } 2589 break; 2590 2591 case 39: 2592 2593/* Line 1806 of yacc.c */ 2594#line 530 "src/src/mesa/program/program_parse.y" 2595 { (yyval.integer) = TEXTURE_RECT_INDEX; } 2596 break; 2597 2598 case 40: 2599 2600/* Line 1806 of yacc.c */ 2601#line 531 "src/src/mesa/program/program_parse.y" 2602 { (yyval.integer) = -TEXTURE_1D_INDEX; } 2603 break; 2604 2605 case 41: 2606 2607/* Line 1806 of yacc.c */ 2608#line 532 "src/src/mesa/program/program_parse.y" 2609 { (yyval.integer) = -TEXTURE_2D_INDEX; } 2610 break; 2611 2612 case 42: 2613 2614/* Line 1806 of yacc.c */ 2615#line 533 "src/src/mesa/program/program_parse.y" 2616 { (yyval.integer) = -TEXTURE_RECT_INDEX; } 2617 break; 2618 2619 case 43: 2620 2621/* Line 1806 of yacc.c */ 2622#line 534 "src/src/mesa/program/program_parse.y" 2623 { (yyval.integer) = TEXTURE_1D_ARRAY_INDEX; } 2624 break; 2625 2626 case 44: 2627 2628/* Line 1806 of yacc.c */ 2629#line 535 "src/src/mesa/program/program_parse.y" 2630 { (yyval.integer) = TEXTURE_2D_ARRAY_INDEX; } 2631 break; 2632 2633 case 45: 2634 2635/* Line 1806 of yacc.c */ 2636#line 536 "src/src/mesa/program/program_parse.y" 2637 { (yyval.integer) = -TEXTURE_1D_ARRAY_INDEX; } 2638 break; 2639 2640 case 46: 2641 2642/* Line 1806 of yacc.c */ 2643#line 537 "src/src/mesa/program/program_parse.y" 2644 { (yyval.integer) = -TEXTURE_2D_ARRAY_INDEX; } 2645 break; 2646 2647 case 47: 2648 2649/* Line 1806 of yacc.c */ 2650#line 541 "src/src/mesa/program/program_parse.y" 2651 { 2652 /* FIXME: Is this correct? Should the extenedSwizzle be applied 2653 * FIXME: to the existing swizzle? 2654 */ 2655 (yyvsp[(4) - (6)].src_reg).Base.Swizzle = (yyvsp[(6) - (6)].swiz_mask).swizzle; 2656 (yyvsp[(4) - (6)].src_reg).Base.Negate = (yyvsp[(6) - (6)].swiz_mask).mask; 2657 2658 (yyval.inst) = asm_instruction_copy_ctor(& (yyvsp[(1) - (6)].temp_inst), & (yyvsp[(2) - (6)].dst_reg), & (yyvsp[(4) - (6)].src_reg), NULL, NULL); 2659 } 2660 break; 2661 2662 case 48: 2663 2664/* Line 1806 of yacc.c */ 2665#line 553 "src/src/mesa/program/program_parse.y" 2666 { 2667 (yyval.src_reg) = (yyvsp[(2) - (2)].src_reg); 2668 2669 if ((yyvsp[(1) - (2)].negate)) { 2670 (yyval.src_reg).Base.Negate = ~(yyval.src_reg).Base.Negate; 2671 } 2672 } 2673 break; 2674 2675 case 49: 2676 2677/* Line 1806 of yacc.c */ 2678#line 561 "src/src/mesa/program/program_parse.y" 2679 { 2680 (yyval.src_reg) = (yyvsp[(3) - (4)].src_reg); 2681 2682 if (!state->option.NV_fragment) { 2683 yyerror(& (yylsp[(2) - (4)]), state, "unexpected character '|'"); 2684 YYERROR; 2685 } 2686 2687 if ((yyvsp[(1) - (4)].negate)) { 2688 (yyval.src_reg).Base.Negate = ~(yyval.src_reg).Base.Negate; 2689 } 2690 2691 (yyval.src_reg).Base.Abs = 1; 2692 } 2693 break; 2694 2695 case 50: 2696 2697/* Line 1806 of yacc.c */ 2698#line 578 "src/src/mesa/program/program_parse.y" 2699 { 2700 (yyval.src_reg) = (yyvsp[(1) - (2)].src_reg); 2701 2702 (yyval.src_reg).Base.Swizzle = _mesa_combine_swizzles((yyval.src_reg).Base.Swizzle, 2703 (yyvsp[(2) - (2)].swiz_mask).swizzle); 2704 } 2705 break; 2706 2707 case 51: 2708 2709/* Line 1806 of yacc.c */ 2710#line 585 "src/src/mesa/program/program_parse.y" 2711 { 2712 struct asm_symbol temp_sym; 2713 2714 if (!state->option.NV_fragment) { 2715 yyerror(& (yylsp[(1) - (1)]), state, "expected scalar suffix"); 2716 YYERROR; 2717 } 2718 2719 memset(& temp_sym, 0, sizeof(temp_sym)); 2720 temp_sym.param_binding_begin = ~0; 2721 initialize_symbol_from_const(state->prog, & temp_sym, & (yyvsp[(1) - (1)].vector), GL_TRUE); 2722 2723 set_src_reg_swz(& (yyval.src_reg), PROGRAM_CONSTANT, 2724 temp_sym.param_binding_begin, 2725 temp_sym.param_binding_swizzle); 2726 } 2727 break; 2728 2729 case 52: 2730 2731/* Line 1806 of yacc.c */ 2732#line 604 "src/src/mesa/program/program_parse.y" 2733 { 2734 (yyval.src_reg) = (yyvsp[(2) - (3)].src_reg); 2735 2736 if ((yyvsp[(1) - (3)].negate)) { 2737 (yyval.src_reg).Base.Negate = ~(yyval.src_reg).Base.Negate; 2738 } 2739 2740 (yyval.src_reg).Base.Swizzle = _mesa_combine_swizzles((yyval.src_reg).Base.Swizzle, 2741 (yyvsp[(3) - (3)].swiz_mask).swizzle); 2742 } 2743 break; 2744 2745 case 53: 2746 2747/* Line 1806 of yacc.c */ 2748#line 615 "src/src/mesa/program/program_parse.y" 2749 { 2750 (yyval.src_reg) = (yyvsp[(3) - (5)].src_reg); 2751 2752 if (!state->option.NV_fragment) { 2753 yyerror(& (yylsp[(2) - (5)]), state, "unexpected character '|'"); 2754 YYERROR; 2755 } 2756 2757 if ((yyvsp[(1) - (5)].negate)) { 2758 (yyval.src_reg).Base.Negate = ~(yyval.src_reg).Base.Negate; 2759 } 2760 2761 (yyval.src_reg).Base.Abs = 1; 2762 (yyval.src_reg).Base.Swizzle = _mesa_combine_swizzles((yyval.src_reg).Base.Swizzle, 2763 (yyvsp[(4) - (5)].swiz_mask).swizzle); 2764 } 2765 break; 2766 2767 case 54: 2768 2769/* Line 1806 of yacc.c */ 2770#line 635 "src/src/mesa/program/program_parse.y" 2771 { 2772 (yyval.dst_reg) = (yyvsp[(1) - (3)].dst_reg); 2773 (yyval.dst_reg).WriteMask = (yyvsp[(2) - (3)].swiz_mask).mask; 2774 (yyval.dst_reg).CondMask = (yyvsp[(3) - (3)].dst_reg).CondMask; 2775 (yyval.dst_reg).CondSwizzle = (yyvsp[(3) - (3)].dst_reg).CondSwizzle; 2776 (yyval.dst_reg).CondSrc = (yyvsp[(3) - (3)].dst_reg).CondSrc; 2777 2778 if ((yyval.dst_reg).File == PROGRAM_OUTPUT) { 2779 /* Technically speaking, this should check that it is in 2780 * vertex program mode. However, PositionInvariant can never be 2781 * set in fragment program mode, so it is somewhat irrelevant. 2782 */ 2783 if (state->option.PositionInvariant 2784 && ((yyval.dst_reg).Index == VERT_RESULT_HPOS)) { 2785 yyerror(& (yylsp[(1) - (3)]), state, "position-invariant programs cannot " 2786 "write position"); 2787 YYERROR; 2788 } 2789 2790 state->prog->OutputsWritten |= BITFIELD64_BIT((yyval.dst_reg).Index); 2791 } 2792 } 2793 break; 2794 2795 case 55: 2796 2797/* Line 1806 of yacc.c */ 2798#line 660 "src/src/mesa/program/program_parse.y" 2799 { 2800 set_dst_reg(& (yyval.dst_reg), PROGRAM_ADDRESS, 0); 2801 (yyval.dst_reg).WriteMask = (yyvsp[(2) - (2)].swiz_mask).mask; 2802 } 2803 break; 2804 2805 case 56: 2806 2807/* Line 1806 of yacc.c */ 2808#line 667 "src/src/mesa/program/program_parse.y" 2809 { 2810 const unsigned xyzw_valid = 2811 ((yyvsp[(1) - (7)].ext_swizzle).xyzw_valid << 0) 2812 | ((yyvsp[(3) - (7)].ext_swizzle).xyzw_valid << 1) 2813 | ((yyvsp[(5) - (7)].ext_swizzle).xyzw_valid << 2) 2814 | ((yyvsp[(7) - (7)].ext_swizzle).xyzw_valid << 3); 2815 const unsigned rgba_valid = 2816 ((yyvsp[(1) - (7)].ext_swizzle).rgba_valid << 0) 2817 | ((yyvsp[(3) - (7)].ext_swizzle).rgba_valid << 1) 2818 | ((yyvsp[(5) - (7)].ext_swizzle).rgba_valid << 2) 2819 | ((yyvsp[(7) - (7)].ext_swizzle).rgba_valid << 3); 2820 2821 /* All of the swizzle components have to be valid in either RGBA 2822 * or XYZW. Note that 0 and 1 are valid in both, so both masks 2823 * can have some bits set. 2824 * 2825 * We somewhat deviate from the spec here. It would be really hard 2826 * to figure out which component is the error, and there probably 2827 * isn't a lot of benefit. 2828 */ 2829 if ((rgba_valid != 0x0f) && (xyzw_valid != 0x0f)) { 2830 yyerror(& (yylsp[(1) - (7)]), state, "cannot combine RGBA and XYZW swizzle " 2831 "components"); 2832 YYERROR; 2833 } 2834 2835 (yyval.swiz_mask).swizzle = MAKE_SWIZZLE4((yyvsp[(1) - (7)].ext_swizzle).swz, (yyvsp[(3) - (7)].ext_swizzle).swz, (yyvsp[(5) - (7)].ext_swizzle).swz, (yyvsp[(7) - (7)].ext_swizzle).swz); 2836 (yyval.swiz_mask).mask = ((yyvsp[(1) - (7)].ext_swizzle).negate) | ((yyvsp[(3) - (7)].ext_swizzle).negate << 1) | ((yyvsp[(5) - (7)].ext_swizzle).negate << 2) 2837 | ((yyvsp[(7) - (7)].ext_swizzle).negate << 3); 2838 } 2839 break; 2840 2841 case 57: 2842 2843/* Line 1806 of yacc.c */ 2844#line 700 "src/src/mesa/program/program_parse.y" 2845 { 2846 (yyval.ext_swizzle) = (yyvsp[(2) - (2)].ext_swizzle); 2847 (yyval.ext_swizzle).negate = ((yyvsp[(1) - (2)].negate)) ? 1 : 0; 2848 } 2849 break; 2850 2851 case 58: 2852 2853/* Line 1806 of yacc.c */ 2854#line 707 "src/src/mesa/program/program_parse.y" 2855 { 2856 if (((yyvsp[(1) - (1)].integer) != 0) && ((yyvsp[(1) - (1)].integer) != 1)) { 2857 yyerror(& (yylsp[(1) - (1)]), state, "invalid extended swizzle selector"); 2858 YYERROR; 2859 } 2860 2861 (yyval.ext_swizzle).swz = ((yyvsp[(1) - (1)].integer) == 0) ? SWIZZLE_ZERO : SWIZZLE_ONE; 2862 2863 /* 0 and 1 are valid for both RGBA swizzle names and XYZW 2864 * swizzle names. 2865 */ 2866 (yyval.ext_swizzle).xyzw_valid = 1; 2867 (yyval.ext_swizzle).rgba_valid = 1; 2868 } 2869 break; 2870 2871 case 59: 2872 2873/* Line 1806 of yacc.c */ 2874#line 722 "src/src/mesa/program/program_parse.y" 2875 { 2876 char s; 2877 2878 if (strlen((yyvsp[(1) - (1)].string)) > 1) { 2879 yyerror(& (yylsp[(1) - (1)]), state, "invalid extended swizzle selector"); 2880 YYERROR; 2881 } 2882 2883 s = (yyvsp[(1) - (1)].string)[0]; 2884 free((yyvsp[(1) - (1)].string)); 2885 2886 switch (s) { 2887 case 'x': 2888 (yyval.ext_swizzle).swz = SWIZZLE_X; 2889 (yyval.ext_swizzle).xyzw_valid = 1; 2890 break; 2891 case 'y': 2892 (yyval.ext_swizzle).swz = SWIZZLE_Y; 2893 (yyval.ext_swizzle).xyzw_valid = 1; 2894 break; 2895 case 'z': 2896 (yyval.ext_swizzle).swz = SWIZZLE_Z; 2897 (yyval.ext_swizzle).xyzw_valid = 1; 2898 break; 2899 case 'w': 2900 (yyval.ext_swizzle).swz = SWIZZLE_W; 2901 (yyval.ext_swizzle).xyzw_valid = 1; 2902 break; 2903 2904 case 'r': 2905 (yyval.ext_swizzle).swz = SWIZZLE_X; 2906 (yyval.ext_swizzle).rgba_valid = 1; 2907 break; 2908 case 'g': 2909 (yyval.ext_swizzle).swz = SWIZZLE_Y; 2910 (yyval.ext_swizzle).rgba_valid = 1; 2911 break; 2912 case 'b': 2913 (yyval.ext_swizzle).swz = SWIZZLE_Z; 2914 (yyval.ext_swizzle).rgba_valid = 1; 2915 break; 2916 case 'a': 2917 (yyval.ext_swizzle).swz = SWIZZLE_W; 2918 (yyval.ext_swizzle).rgba_valid = 1; 2919 break; 2920 2921 default: 2922 yyerror(& (yylsp[(1) - (1)]), state, "invalid extended swizzle selector"); 2923 YYERROR; 2924 break; 2925 } 2926 } 2927 break; 2928 2929 case 60: 2930 2931/* Line 1806 of yacc.c */ 2932#line 777 "src/src/mesa/program/program_parse.y" 2933 { 2934 struct asm_symbol *const s = (struct asm_symbol *) 2935 _mesa_symbol_table_find_symbol(state->st, 0, (yyvsp[(1) - (1)].string)); 2936 2937 free((yyvsp[(1) - (1)].string)); 2938 2939 if (s == NULL) { 2940 yyerror(& (yylsp[(1) - (1)]), state, "invalid operand variable"); 2941 YYERROR; 2942 } else if ((s->type != at_param) && (s->type != at_temp) 2943 && (s->type != at_attrib)) { 2944 yyerror(& (yylsp[(1) - (1)]), state, "invalid operand variable"); 2945 YYERROR; 2946 } else if ((s->type == at_param) && s->param_is_array) { 2947 yyerror(& (yylsp[(1) - (1)]), state, "non-array access to array PARAM"); 2948 YYERROR; 2949 } 2950 2951 init_src_reg(& (yyval.src_reg)); 2952 switch (s->type) { 2953 case at_temp: 2954 set_src_reg(& (yyval.src_reg), PROGRAM_TEMPORARY, s->temp_binding); 2955 break; 2956 case at_param: 2957 set_src_reg_swz(& (yyval.src_reg), s->param_binding_type, 2958 s->param_binding_begin, 2959 s->param_binding_swizzle); 2960 break; 2961 case at_attrib: 2962 set_src_reg(& (yyval.src_reg), PROGRAM_INPUT, s->attrib_binding); 2963 state->prog->InputsRead |= BITFIELD64_BIT((yyval.src_reg).Base.Index); 2964 2965 if (!validate_inputs(& (yylsp[(1) - (1)]), state)) { 2966 YYERROR; 2967 } 2968 break; 2969 2970 default: 2971 YYERROR; 2972 break; 2973 } 2974 } 2975 break; 2976 2977 case 61: 2978 2979/* Line 1806 of yacc.c */ 2980#line 820 "src/src/mesa/program/program_parse.y" 2981 { 2982 set_src_reg(& (yyval.src_reg), PROGRAM_INPUT, (yyvsp[(1) - (1)].attrib)); 2983 state->prog->InputsRead |= BITFIELD64_BIT((yyval.src_reg).Base.Index); 2984 2985 if (!validate_inputs(& (yylsp[(1) - (1)]), state)) { 2986 YYERROR; 2987 } 2988 } 2989 break; 2990 2991 case 62: 2992 2993/* Line 1806 of yacc.c */ 2994#line 829 "src/src/mesa/program/program_parse.y" 2995 { 2996 if (! (yyvsp[(3) - (4)].src_reg).Base.RelAddr 2997 && ((unsigned) (yyvsp[(3) - (4)].src_reg).Base.Index >= (yyvsp[(1) - (4)].sym)->param_binding_length)) { 2998 yyerror(& (yylsp[(3) - (4)]), state, "out of bounds array access"); 2999 YYERROR; 3000 } 3001 3002 init_src_reg(& (yyval.src_reg)); 3003 (yyval.src_reg).Base.File = (yyvsp[(1) - (4)].sym)->param_binding_type; 3004 3005 if ((yyvsp[(3) - (4)].src_reg).Base.RelAddr) { 3006 state->prog->IndirectRegisterFiles |= (1 << (yyval.src_reg).Base.File); 3007 (yyvsp[(1) - (4)].sym)->param_accessed_indirectly = 1; 3008 3009 (yyval.src_reg).Base.RelAddr = 1; 3010 (yyval.src_reg).Base.Index = (yyvsp[(3) - (4)].src_reg).Base.Index; 3011 (yyval.src_reg).Symbol = (yyvsp[(1) - (4)].sym); 3012 } else { 3013 (yyval.src_reg).Base.Index = (yyvsp[(1) - (4)].sym)->param_binding_begin + (yyvsp[(3) - (4)].src_reg).Base.Index; 3014 } 3015 } 3016 break; 3017 3018 case 63: 3019 3020/* Line 1806 of yacc.c */ 3021#line 851 "src/src/mesa/program/program_parse.y" 3022 { 3023 gl_register_file file = ((yyvsp[(1) - (1)].temp_sym).name != NULL) 3024 ? (yyvsp[(1) - (1)].temp_sym).param_binding_type 3025 : PROGRAM_CONSTANT; 3026 set_src_reg_swz(& (yyval.src_reg), file, (yyvsp[(1) - (1)].temp_sym).param_binding_begin, 3027 (yyvsp[(1) - (1)].temp_sym).param_binding_swizzle); 3028 } 3029 break; 3030 3031 case 64: 3032 3033/* Line 1806 of yacc.c */ 3034#line 861 "src/src/mesa/program/program_parse.y" 3035 { 3036 set_dst_reg(& (yyval.dst_reg), PROGRAM_OUTPUT, (yyvsp[(1) - (1)].result)); 3037 } 3038 break; 3039 3040 case 65: 3041 3042/* Line 1806 of yacc.c */ 3043#line 865 "src/src/mesa/program/program_parse.y" 3044 { 3045 struct asm_symbol *const s = (struct asm_symbol *) 3046 _mesa_symbol_table_find_symbol(state->st, 0, (yyvsp[(1) - (1)].string)); 3047 3048 free((yyvsp[(1) - (1)].string)); 3049 3050 if (s == NULL) { 3051 yyerror(& (yylsp[(1) - (1)]), state, "invalid operand variable"); 3052 YYERROR; 3053 } else if ((s->type != at_output) && (s->type != at_temp)) { 3054 yyerror(& (yylsp[(1) - (1)]), state, "invalid operand variable"); 3055 YYERROR; 3056 } 3057 3058 switch (s->type) { 3059 case at_temp: 3060 set_dst_reg(& (yyval.dst_reg), PROGRAM_TEMPORARY, s->temp_binding); 3061 break; 3062 case at_output: 3063 set_dst_reg(& (yyval.dst_reg), PROGRAM_OUTPUT, s->output_binding); 3064 break; 3065 default: 3066 set_dst_reg(& (yyval.dst_reg), s->param_binding_type, s->param_binding_begin); 3067 break; 3068 } 3069 } 3070 break; 3071 3072 case 66: 3073 3074/* Line 1806 of yacc.c */ 3075#line 894 "src/src/mesa/program/program_parse.y" 3076 { 3077 struct asm_symbol *const s = (struct asm_symbol *) 3078 _mesa_symbol_table_find_symbol(state->st, 0, (yyvsp[(1) - (1)].string)); 3079 3080 free((yyvsp[(1) - (1)].string)); 3081 3082 if (s == NULL) { 3083 yyerror(& (yylsp[(1) - (1)]), state, "invalid operand variable"); 3084 YYERROR; 3085 } else if ((s->type != at_param) || !s->param_is_array) { 3086 yyerror(& (yylsp[(1) - (1)]), state, "array access to non-PARAM variable"); 3087 YYERROR; 3088 } else { 3089 (yyval.sym) = s; 3090 } 3091 } 3092 break; 3093 3094 case 69: 3095 3096/* Line 1806 of yacc.c */ 3097#line 915 "src/src/mesa/program/program_parse.y" 3098 { 3099 init_src_reg(& (yyval.src_reg)); 3100 (yyval.src_reg).Base.Index = (yyvsp[(1) - (1)].integer); 3101 } 3102 break; 3103 3104 case 70: 3105 3106/* Line 1806 of yacc.c */ 3107#line 922 "src/src/mesa/program/program_parse.y" 3108 { 3109 /* FINISHME: Add support for multiple address registers. 3110 */ 3111 /* FINISHME: Add support for 4-component address registers. 3112 */ 3113 init_src_reg(& (yyval.src_reg)); 3114 (yyval.src_reg).Base.RelAddr = 1; 3115 (yyval.src_reg).Base.Index = (yyvsp[(3) - (3)].integer); 3116 } 3117 break; 3118 3119 case 71: 3120 3121/* Line 1806 of yacc.c */ 3122#line 933 "src/src/mesa/program/program_parse.y" 3123 { (yyval.integer) = 0; } 3124 break; 3125 3126 case 72: 3127 3128/* Line 1806 of yacc.c */ 3129#line 934 "src/src/mesa/program/program_parse.y" 3130 { (yyval.integer) = (yyvsp[(2) - (2)].integer); } 3131 break; 3132 3133 case 73: 3134 3135/* Line 1806 of yacc.c */ 3136#line 935 "src/src/mesa/program/program_parse.y" 3137 { (yyval.integer) = -(yyvsp[(2) - (2)].integer); } 3138 break; 3139 3140 case 74: 3141 3142/* Line 1806 of yacc.c */ 3143#line 939 "src/src/mesa/program/program_parse.y" 3144 { 3145 if (((yyvsp[(1) - (1)].integer) < 0) || ((yyvsp[(1) - (1)].integer) > (state->limits->MaxAddressOffset - 1))) { 3146 char s[100]; 3147 _mesa_snprintf(s, sizeof(s), 3148 "relative address offset too large (%d)", (yyvsp[(1) - (1)].integer)); 3149 yyerror(& (yylsp[(1) - (1)]), state, s); 3150 YYERROR; 3151 } else { 3152 (yyval.integer) = (yyvsp[(1) - (1)].integer); 3153 } 3154 } 3155 break; 3156 3157 case 75: 3158 3159/* Line 1806 of yacc.c */ 3160#line 953 "src/src/mesa/program/program_parse.y" 3161 { 3162 if (((yyvsp[(1) - (1)].integer) < 0) || ((yyvsp[(1) - (1)].integer) > state->limits->MaxAddressOffset)) { 3163 char s[100]; 3164 _mesa_snprintf(s, sizeof(s), 3165 "relative address offset too large (%d)", (yyvsp[(1) - (1)].integer)); 3166 yyerror(& (yylsp[(1) - (1)]), state, s); 3167 YYERROR; 3168 } else { 3169 (yyval.integer) = (yyvsp[(1) - (1)].integer); 3170 } 3171 } 3172 break; 3173 3174 case 76: 3175 3176/* Line 1806 of yacc.c */ 3177#line 967 "src/src/mesa/program/program_parse.y" 3178 { 3179 struct asm_symbol *const s = (struct asm_symbol *) 3180 _mesa_symbol_table_find_symbol(state->st, 0, (yyvsp[(1) - (1)].string)); 3181 3182 free((yyvsp[(1) - (1)].string)); 3183 3184 if (s == NULL) { 3185 yyerror(& (yylsp[(1) - (1)]), state, "invalid array member"); 3186 YYERROR; 3187 } else if (s->type != at_address) { 3188 yyerror(& (yylsp[(1) - (1)]), state, 3189 "invalid variable for indexed array access"); 3190 YYERROR; 3191 } else { 3192 (yyval.sym) = s; 3193 } 3194 } 3195 break; 3196 3197 case 77: 3198 3199/* Line 1806 of yacc.c */ 3200#line 987 "src/src/mesa/program/program_parse.y" 3201 { 3202 if ((yyvsp[(1) - (1)].swiz_mask).mask != WRITEMASK_X) { 3203 yyerror(& (yylsp[(1) - (1)]), state, "invalid address component selector"); 3204 YYERROR; 3205 } else { 3206 (yyval.swiz_mask) = (yyvsp[(1) - (1)].swiz_mask); 3207 } 3208 } 3209 break; 3210 3211 case 78: 3212 3213/* Line 1806 of yacc.c */ 3214#line 998 "src/src/mesa/program/program_parse.y" 3215 { 3216 if ((yyvsp[(1) - (1)].swiz_mask).mask != WRITEMASK_X) { 3217 yyerror(& (yylsp[(1) - (1)]), state, 3218 "address register write mask must be \".x\""); 3219 YYERROR; 3220 } else { 3221 (yyval.swiz_mask) = (yyvsp[(1) - (1)].swiz_mask); 3222 } 3223 } 3224 break; 3225 3226 case 83: 3227 3228/* Line 1806 of yacc.c */ 3229#line 1014 "src/src/mesa/program/program_parse.y" 3230 { (yyval.swiz_mask).swizzle = SWIZZLE_NOOP; (yyval.swiz_mask).mask = WRITEMASK_XYZW; } 3231 break; 3232 3233 case 88: 3234 3235/* Line 1806 of yacc.c */ 3236#line 1018 "src/src/mesa/program/program_parse.y" 3237 { (yyval.swiz_mask).swizzle = SWIZZLE_NOOP; (yyval.swiz_mask).mask = WRITEMASK_XYZW; } 3238 break; 3239 3240 case 89: 3241 3242/* Line 1806 of yacc.c */ 3243#line 1022 "src/src/mesa/program/program_parse.y" 3244 { 3245 (yyval.dst_reg) = (yyvsp[(2) - (3)].dst_reg); 3246 } 3247 break; 3248 3249 case 90: 3250 3251/* Line 1806 of yacc.c */ 3252#line 1026 "src/src/mesa/program/program_parse.y" 3253 { 3254 (yyval.dst_reg) = (yyvsp[(2) - (3)].dst_reg); 3255 } 3256 break; 3257 3258 case 91: 3259 3260/* Line 1806 of yacc.c */ 3261#line 1030 "src/src/mesa/program/program_parse.y" 3262 { 3263 (yyval.dst_reg).CondMask = COND_TR; 3264 (yyval.dst_reg).CondSwizzle = SWIZZLE_NOOP; 3265 (yyval.dst_reg).CondSrc = 0; 3266 } 3267 break; 3268 3269 case 92: 3270 3271/* Line 1806 of yacc.c */ 3272#line 1038 "src/src/mesa/program/program_parse.y" 3273 { 3274 (yyval.dst_reg) = (yyvsp[(1) - (2)].dst_reg); 3275 (yyval.dst_reg).CondSwizzle = (yyvsp[(2) - (2)].swiz_mask).swizzle; 3276 } 3277 break; 3278 3279 case 93: 3280 3281/* Line 1806 of yacc.c */ 3282#line 1045 "src/src/mesa/program/program_parse.y" 3283 { 3284 (yyval.dst_reg) = (yyvsp[(1) - (2)].dst_reg); 3285 (yyval.dst_reg).CondSwizzle = (yyvsp[(2) - (2)].swiz_mask).swizzle; 3286 } 3287 break; 3288 3289 case 94: 3290 3291/* Line 1806 of yacc.c */ 3292#line 1052 "src/src/mesa/program/program_parse.y" 3293 { 3294 const int cond = _mesa_parse_cc((yyvsp[(1) - (1)].string)); 3295 if ((cond == 0) || ((yyvsp[(1) - (1)].string)[2] != '\0')) { 3296 char *const err_str = 3297 make_error_string("invalid condition code \"%s\"", (yyvsp[(1) - (1)].string)); 3298 3299 yyerror(& (yylsp[(1) - (1)]), state, (err_str != NULL) 3300 ? err_str : "invalid condition code"); 3301 3302 if (err_str != NULL) { 3303 free(err_str); 3304 } 3305 3306 YYERROR; 3307 } 3308 3309 (yyval.dst_reg).CondMask = cond; 3310 (yyval.dst_reg).CondSwizzle = SWIZZLE_NOOP; 3311 (yyval.dst_reg).CondSrc = 0; 3312 } 3313 break; 3314 3315 case 95: 3316 3317/* Line 1806 of yacc.c */ 3318#line 1075 "src/src/mesa/program/program_parse.y" 3319 { 3320 const int cond = _mesa_parse_cc((yyvsp[(1) - (1)].string)); 3321 if ((cond == 0) || ((yyvsp[(1) - (1)].string)[2] != '\0')) { 3322 char *const err_str = 3323 make_error_string("invalid condition code \"%s\"", (yyvsp[(1) - (1)].string)); 3324 3325 yyerror(& (yylsp[(1) - (1)]), state, (err_str != NULL) 3326 ? err_str : "invalid condition code"); 3327 3328 if (err_str != NULL) { 3329 free(err_str); 3330 } 3331 3332 YYERROR; 3333 } 3334 3335 (yyval.dst_reg).CondMask = cond; 3336 (yyval.dst_reg).CondSwizzle = SWIZZLE_NOOP; 3337 (yyval.dst_reg).CondSrc = 0; 3338 } 3339 break; 3340 3341 case 102: 3342 3343/* Line 1806 of yacc.c */ 3344#line 1106 "src/src/mesa/program/program_parse.y" 3345 { 3346 struct asm_symbol *const s = 3347 declare_variable(state, (yyvsp[(2) - (4)].string), at_attrib, & (yylsp[(2) - (4)])); 3348 3349 if (s == NULL) { 3350 free((yyvsp[(2) - (4)].string)); 3351 YYERROR; 3352 } else { 3353 s->attrib_binding = (yyvsp[(4) - (4)].attrib); 3354 state->InputsBound |= BITFIELD64_BIT(s->attrib_binding); 3355 3356 if (!validate_inputs(& (yylsp[(4) - (4)]), state)) { 3357 YYERROR; 3358 } 3359 } 3360 } 3361 break; 3362 3363 case 103: 3364 3365/* Line 1806 of yacc.c */ 3366#line 1125 "src/src/mesa/program/program_parse.y" 3367 { 3368 (yyval.attrib) = (yyvsp[(2) - (2)].attrib); 3369 } 3370 break; 3371 3372 case 104: 3373 3374/* Line 1806 of yacc.c */ 3375#line 1129 "src/src/mesa/program/program_parse.y" 3376 { 3377 (yyval.attrib) = (yyvsp[(2) - (2)].attrib); 3378 } 3379 break; 3380 3381 case 105: 3382 3383/* Line 1806 of yacc.c */ 3384#line 1135 "src/src/mesa/program/program_parse.y" 3385 { 3386 (yyval.attrib) = VERT_ATTRIB_POS; 3387 } 3388 break; 3389 3390 case 106: 3391 3392/* Line 1806 of yacc.c */ 3393#line 1139 "src/src/mesa/program/program_parse.y" 3394 { 3395 (yyval.attrib) = VERT_ATTRIB_WEIGHT; 3396 } 3397 break; 3398 3399 case 107: 3400 3401/* Line 1806 of yacc.c */ 3402#line 1143 "src/src/mesa/program/program_parse.y" 3403 { 3404 (yyval.attrib) = VERT_ATTRIB_NORMAL; 3405 } 3406 break; 3407 3408 case 108: 3409 3410/* Line 1806 of yacc.c */ 3411#line 1147 "src/src/mesa/program/program_parse.y" 3412 { 3413 if (!state->ctx->Extensions.EXT_secondary_color) { 3414 yyerror(& (yylsp[(2) - (2)]), state, "GL_EXT_secondary_color not supported"); 3415 YYERROR; 3416 } 3417 3418 (yyval.attrib) = VERT_ATTRIB_COLOR0 + (yyvsp[(2) - (2)].integer); 3419 } 3420 break; 3421 3422 case 109: 3423 3424/* Line 1806 of yacc.c */ 3425#line 1156 "src/src/mesa/program/program_parse.y" 3426 { 3427 if (!state->ctx->Extensions.EXT_fog_coord) { 3428 yyerror(& (yylsp[(1) - (1)]), state, "GL_EXT_fog_coord not supported"); 3429 YYERROR; 3430 } 3431 3432 (yyval.attrib) = VERT_ATTRIB_FOG; 3433 } 3434 break; 3435 3436 case 110: 3437 3438/* Line 1806 of yacc.c */ 3439#line 1165 "src/src/mesa/program/program_parse.y" 3440 { 3441 (yyval.attrib) = VERT_ATTRIB_TEX0 + (yyvsp[(2) - (2)].integer); 3442 } 3443 break; 3444 3445 case 111: 3446 3447/* Line 1806 of yacc.c */ 3448#line 1169 "src/src/mesa/program/program_parse.y" 3449 { 3450 yyerror(& (yylsp[(1) - (4)]), state, "GL_ARB_matrix_palette not supported"); 3451 YYERROR; 3452 } 3453 break; 3454 3455 case 112: 3456 3457/* Line 1806 of yacc.c */ 3458#line 1174 "src/src/mesa/program/program_parse.y" 3459 { 3460 (yyval.attrib) = VERT_ATTRIB_GENERIC0 + (yyvsp[(3) - (4)].integer); 3461 } 3462 break; 3463 3464 case 113: 3465 3466/* Line 1806 of yacc.c */ 3467#line 1180 "src/src/mesa/program/program_parse.y" 3468 { 3469 if ((unsigned) (yyvsp[(1) - (1)].integer) >= state->limits->MaxAttribs) { 3470 yyerror(& (yylsp[(1) - (1)]), state, "invalid vertex attribute reference"); 3471 YYERROR; 3472 } 3473 3474 (yyval.integer) = (yyvsp[(1) - (1)].integer); 3475 } 3476 break; 3477 3478 case 117: 3479 3480/* Line 1806 of yacc.c */ 3481#line 1194 "src/src/mesa/program/program_parse.y" 3482 { 3483 (yyval.attrib) = FRAG_ATTRIB_WPOS; 3484 } 3485 break; 3486 3487 case 118: 3488 3489/* Line 1806 of yacc.c */ 3490#line 1198 "src/src/mesa/program/program_parse.y" 3491 { 3492 (yyval.attrib) = FRAG_ATTRIB_COL0 + (yyvsp[(2) - (2)].integer); 3493 } 3494 break; 3495 3496 case 119: 3497 3498/* Line 1806 of yacc.c */ 3499#line 1202 "src/src/mesa/program/program_parse.y" 3500 { 3501 (yyval.attrib) = FRAG_ATTRIB_FOGC; 3502 } 3503 break; 3504 3505 case 120: 3506 3507/* Line 1806 of yacc.c */ 3508#line 1206 "src/src/mesa/program/program_parse.y" 3509 { 3510 (yyval.attrib) = FRAG_ATTRIB_TEX0 + (yyvsp[(2) - (2)].integer); 3511 } 3512 break; 3513 3514 case 123: 3515 3516/* Line 1806 of yacc.c */ 3517#line 1214 "src/src/mesa/program/program_parse.y" 3518 { 3519 struct asm_symbol *const s = 3520 declare_variable(state, (yyvsp[(2) - (3)].string), at_param, & (yylsp[(2) - (3)])); 3521 3522 if (s == NULL) { 3523 free((yyvsp[(2) - (3)].string)); 3524 YYERROR; 3525 } else { 3526 s->param_binding_type = (yyvsp[(3) - (3)].temp_sym).param_binding_type; 3527 s->param_binding_begin = (yyvsp[(3) - (3)].temp_sym).param_binding_begin; 3528 s->param_binding_length = (yyvsp[(3) - (3)].temp_sym).param_binding_length; 3529 s->param_binding_swizzle = (yyvsp[(3) - (3)].temp_sym).param_binding_swizzle; 3530 s->param_is_array = 0; 3531 } 3532 } 3533 break; 3534 3535 case 124: 3536 3537/* Line 1806 of yacc.c */ 3538#line 1232 "src/src/mesa/program/program_parse.y" 3539 { 3540 if (((yyvsp[(4) - (6)].integer) != 0) && ((unsigned) (yyvsp[(4) - (6)].integer) != (yyvsp[(6) - (6)].temp_sym).param_binding_length)) { 3541 free((yyvsp[(2) - (6)].string)); 3542 yyerror(& (yylsp[(4) - (6)]), state, 3543 "parameter array size and number of bindings must match"); 3544 YYERROR; 3545 } else { 3546 struct asm_symbol *const s = 3547 declare_variable(state, (yyvsp[(2) - (6)].string), (yyvsp[(6) - (6)].temp_sym).type, & (yylsp[(2) - (6)])); 3548 3549 if (s == NULL) { 3550 free((yyvsp[(2) - (6)].string)); 3551 YYERROR; 3552 } else { 3553 s->param_binding_type = (yyvsp[(6) - (6)].temp_sym).param_binding_type; 3554 s->param_binding_begin = (yyvsp[(6) - (6)].temp_sym).param_binding_begin; 3555 s->param_binding_length = (yyvsp[(6) - (6)].temp_sym).param_binding_length; 3556 s->param_binding_swizzle = SWIZZLE_XYZW; 3557 s->param_is_array = 1; 3558 } 3559 } 3560 } 3561 break; 3562 3563 case 125: 3564 3565/* Line 1806 of yacc.c */ 3566#line 1257 "src/src/mesa/program/program_parse.y" 3567 { 3568 (yyval.integer) = 0; 3569 } 3570 break; 3571 3572 case 126: 3573 3574/* Line 1806 of yacc.c */ 3575#line 1261 "src/src/mesa/program/program_parse.y" 3576 { 3577 if (((yyvsp[(1) - (1)].integer) < 1) || ((unsigned) (yyvsp[(1) - (1)].integer) > state->limits->MaxParameters)) { 3578 char msg[100]; 3579 _mesa_snprintf(msg, sizeof(msg), 3580 "invalid parameter array size (size=%d max=%u)", 3581 (yyvsp[(1) - (1)].integer), state->limits->MaxParameters); 3582 yyerror(& (yylsp[(1) - (1)]), state, msg); 3583 YYERROR; 3584 } else { 3585 (yyval.integer) = (yyvsp[(1) - (1)].integer); 3586 } 3587 } 3588 break; 3589 3590 case 127: 3591 3592/* Line 1806 of yacc.c */ 3593#line 1276 "src/src/mesa/program/program_parse.y" 3594 { 3595 (yyval.temp_sym) = (yyvsp[(2) - (2)].temp_sym); 3596 } 3597 break; 3598 3599 case 128: 3600 3601/* Line 1806 of yacc.c */ 3602#line 1282 "src/src/mesa/program/program_parse.y" 3603 { 3604 (yyval.temp_sym) = (yyvsp[(3) - (4)].temp_sym); 3605 } 3606 break; 3607 3608 case 130: 3609 3610/* Line 1806 of yacc.c */ 3611#line 1289 "src/src/mesa/program/program_parse.y" 3612 { 3613 (yyvsp[(1) - (3)].temp_sym).param_binding_length += (yyvsp[(3) - (3)].temp_sym).param_binding_length; 3614 (yyval.temp_sym) = (yyvsp[(1) - (3)].temp_sym); 3615 } 3616 break; 3617 3618 case 131: 3619 3620/* Line 1806 of yacc.c */ 3621#line 1296 "src/src/mesa/program/program_parse.y" 3622 { 3623 memset(& (yyval.temp_sym), 0, sizeof((yyval.temp_sym))); 3624 (yyval.temp_sym).param_binding_begin = ~0; 3625 initialize_symbol_from_state(state->prog, & (yyval.temp_sym), (yyvsp[(1) - (1)].state)); 3626 } 3627 break; 3628 3629 case 132: 3630 3631/* Line 1806 of yacc.c */ 3632#line 1302 "src/src/mesa/program/program_parse.y" 3633 { 3634 memset(& (yyval.temp_sym), 0, sizeof((yyval.temp_sym))); 3635 (yyval.temp_sym).param_binding_begin = ~0; 3636 initialize_symbol_from_param(state->prog, & (yyval.temp_sym), (yyvsp[(1) - (1)].state)); 3637 } 3638 break; 3639 3640 case 133: 3641 3642/* Line 1806 of yacc.c */ 3643#line 1308 "src/src/mesa/program/program_parse.y" 3644 { 3645 memset(& (yyval.temp_sym), 0, sizeof((yyval.temp_sym))); 3646 (yyval.temp_sym).param_binding_begin = ~0; 3647 initialize_symbol_from_const(state->prog, & (yyval.temp_sym), & (yyvsp[(1) - (1)].vector), GL_TRUE); 3648 } 3649 break; 3650 3651 case 134: 3652 3653/* Line 1806 of yacc.c */ 3654#line 1316 "src/src/mesa/program/program_parse.y" 3655 { 3656 memset(& (yyval.temp_sym), 0, sizeof((yyval.temp_sym))); 3657 (yyval.temp_sym).param_binding_begin = ~0; 3658 initialize_symbol_from_state(state->prog, & (yyval.temp_sym), (yyvsp[(1) - (1)].state)); 3659 } 3660 break; 3661 3662 case 135: 3663 3664/* Line 1806 of yacc.c */ 3665#line 1322 "src/src/mesa/program/program_parse.y" 3666 { 3667 memset(& (yyval.temp_sym), 0, sizeof((yyval.temp_sym))); 3668 (yyval.temp_sym).param_binding_begin = ~0; 3669 initialize_symbol_from_param(state->prog, & (yyval.temp_sym), (yyvsp[(1) - (1)].state)); 3670 } 3671 break; 3672 3673 case 136: 3674 3675/* Line 1806 of yacc.c */ 3676#line 1328 "src/src/mesa/program/program_parse.y" 3677 { 3678 memset(& (yyval.temp_sym), 0, sizeof((yyval.temp_sym))); 3679 (yyval.temp_sym).param_binding_begin = ~0; 3680 initialize_symbol_from_const(state->prog, & (yyval.temp_sym), & (yyvsp[(1) - (1)].vector), GL_TRUE); 3681 } 3682 break; 3683 3684 case 137: 3685 3686/* Line 1806 of yacc.c */ 3687#line 1336 "src/src/mesa/program/program_parse.y" 3688 { 3689 memset(& (yyval.temp_sym), 0, sizeof((yyval.temp_sym))); 3690 (yyval.temp_sym).param_binding_begin = ~0; 3691 initialize_symbol_from_state(state->prog, & (yyval.temp_sym), (yyvsp[(1) - (1)].state)); 3692 } 3693 break; 3694 3695 case 138: 3696 3697/* Line 1806 of yacc.c */ 3698#line 1342 "src/src/mesa/program/program_parse.y" 3699 { 3700 memset(& (yyval.temp_sym), 0, sizeof((yyval.temp_sym))); 3701 (yyval.temp_sym).param_binding_begin = ~0; 3702 initialize_symbol_from_param(state->prog, & (yyval.temp_sym), (yyvsp[(1) - (1)].state)); 3703 } 3704 break; 3705 3706 case 139: 3707 3708/* Line 1806 of yacc.c */ 3709#line 1348 "src/src/mesa/program/program_parse.y" 3710 { 3711 memset(& (yyval.temp_sym), 0, sizeof((yyval.temp_sym))); 3712 (yyval.temp_sym).param_binding_begin = ~0; 3713 initialize_symbol_from_const(state->prog, & (yyval.temp_sym), & (yyvsp[(1) - (1)].vector), GL_FALSE); 3714 } 3715 break; 3716 3717 case 140: 3718 3719/* Line 1806 of yacc.c */ 3720#line 1355 "src/src/mesa/program/program_parse.y" 3721 { memcpy((yyval.state), (yyvsp[(1) - (1)].state), sizeof((yyval.state))); } 3722 break; 3723 3724 case 141: 3725 3726/* Line 1806 of yacc.c */ 3727#line 1356 "src/src/mesa/program/program_parse.y" 3728 { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); } 3729 break; 3730 3731 case 142: 3732 3733/* Line 1806 of yacc.c */ 3734#line 1359 "src/src/mesa/program/program_parse.y" 3735 { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); } 3736 break; 3737 3738 case 143: 3739 3740/* Line 1806 of yacc.c */ 3741#line 1360 "src/src/mesa/program/program_parse.y" 3742 { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); } 3743 break; 3744 3745 case 144: 3746 3747/* Line 1806 of yacc.c */ 3748#line 1361 "src/src/mesa/program/program_parse.y" 3749 { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); } 3750 break; 3751 3752 case 145: 3753 3754/* Line 1806 of yacc.c */ 3755#line 1362 "src/src/mesa/program/program_parse.y" 3756 { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); } 3757 break; 3758 3759 case 146: 3760 3761/* Line 1806 of yacc.c */ 3762#line 1363 "src/src/mesa/program/program_parse.y" 3763 { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); } 3764 break; 3765 3766 case 147: 3767 3768/* Line 1806 of yacc.c */ 3769#line 1364 "src/src/mesa/program/program_parse.y" 3770 { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); } 3771 break; 3772 3773 case 148: 3774 3775/* Line 1806 of yacc.c */ 3776#line 1365 "src/src/mesa/program/program_parse.y" 3777 { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); } 3778 break; 3779 3780 case 149: 3781 3782/* Line 1806 of yacc.c */ 3783#line 1366 "src/src/mesa/program/program_parse.y" 3784 { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); } 3785 break; 3786 3787 case 150: 3788 3789/* Line 1806 of yacc.c */ 3790#line 1367 "src/src/mesa/program/program_parse.y" 3791 { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); } 3792 break; 3793 3794 case 151: 3795 3796/* Line 1806 of yacc.c */ 3797#line 1368 "src/src/mesa/program/program_parse.y" 3798 { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); } 3799 break; 3800 3801 case 152: 3802 3803/* Line 1806 of yacc.c */ 3804#line 1369 "src/src/mesa/program/program_parse.y" 3805 { memcpy((yyval.state), (yyvsp[(2) - (2)].state), sizeof((yyval.state))); } 3806 break; 3807 3808 case 153: 3809 3810/* Line 1806 of yacc.c */ 3811#line 1373 "src/src/mesa/program/program_parse.y" 3812 { 3813 memset((yyval.state), 0, sizeof((yyval.state))); 3814 (yyval.state)[0] = STATE_MATERIAL; 3815 (yyval.state)[1] = (yyvsp[(2) - (3)].integer); 3816 (yyval.state)[2] = (yyvsp[(3) - (3)].integer); 3817 } 3818 break; 3819 3820 case 154: 3821 3822/* Line 1806 of yacc.c */ 3823#line 1382 "src/src/mesa/program/program_parse.y" 3824 { 3825 (yyval.integer) = (yyvsp[(1) - (1)].integer); 3826 } 3827 break; 3828 3829 case 155: 3830 3831/* Line 1806 of yacc.c */ 3832#line 1386 "src/src/mesa/program/program_parse.y" 3833 { 3834 (yyval.integer) = STATE_EMISSION; 3835 } 3836 break; 3837 3838 case 156: 3839 3840/* Line 1806 of yacc.c */ 3841#line 1390 "src/src/mesa/program/program_parse.y" 3842 { 3843 (yyval.integer) = STATE_SHININESS; 3844 } 3845 break; 3846 3847 case 157: 3848 3849/* Line 1806 of yacc.c */ 3850#line 1396 "src/src/mesa/program/program_parse.y" 3851 { 3852 memset((yyval.state), 0, sizeof((yyval.state))); 3853 (yyval.state)[0] = STATE_LIGHT; 3854 (yyval.state)[1] = (yyvsp[(3) - (5)].integer); 3855 (yyval.state)[2] = (yyvsp[(5) - (5)].integer); 3856 } 3857 break; 3858 3859 case 158: 3860 3861/* Line 1806 of yacc.c */ 3862#line 1405 "src/src/mesa/program/program_parse.y" 3863 { 3864 (yyval.integer) = (yyvsp[(1) - (1)].integer); 3865 } 3866 break; 3867 3868 case 159: 3869 3870/* Line 1806 of yacc.c */ 3871#line 1409 "src/src/mesa/program/program_parse.y" 3872 { 3873 (yyval.integer) = STATE_POSITION; 3874 } 3875 break; 3876 3877 case 160: 3878 3879/* Line 1806 of yacc.c */ 3880#line 1413 "src/src/mesa/program/program_parse.y" 3881 { 3882 if (!state->ctx->Extensions.EXT_point_parameters) { 3883 yyerror(& (yylsp[(1) - (1)]), state, "GL_ARB_point_parameters not supported"); 3884 YYERROR; 3885 } 3886 3887 (yyval.integer) = STATE_ATTENUATION; 3888 } 3889 break; 3890 3891 case 161: 3892 3893/* Line 1806 of yacc.c */ 3894#line 1422 "src/src/mesa/program/program_parse.y" 3895 { 3896 (yyval.integer) = (yyvsp[(2) - (2)].integer); 3897 } 3898 break; 3899 3900 case 162: 3901 3902/* Line 1806 of yacc.c */ 3903#line 1426 "src/src/mesa/program/program_parse.y" 3904 { 3905 (yyval.integer) = STATE_HALF_VECTOR; 3906 } 3907 break; 3908 3909 case 163: 3910 3911/* Line 1806 of yacc.c */ 3912#line 1432 "src/src/mesa/program/program_parse.y" 3913 { 3914 (yyval.integer) = STATE_SPOT_DIRECTION; 3915 } 3916 break; 3917 3918 case 164: 3919 3920/* Line 1806 of yacc.c */ 3921#line 1438 "src/src/mesa/program/program_parse.y" 3922 { 3923 (yyval.state)[0] = (yyvsp[(2) - (2)].state)[0]; 3924 (yyval.state)[1] = (yyvsp[(2) - (2)].state)[1]; 3925 } 3926 break; 3927 3928 case 165: 3929 3930/* Line 1806 of yacc.c */ 3931#line 1445 "src/src/mesa/program/program_parse.y" 3932 { 3933 memset((yyval.state), 0, sizeof((yyval.state))); 3934 (yyval.state)[0] = STATE_LIGHTMODEL_AMBIENT; 3935 } 3936 break; 3937 3938 case 166: 3939 3940/* Line 1806 of yacc.c */ 3941#line 1450 "src/src/mesa/program/program_parse.y" 3942 { 3943 memset((yyval.state), 0, sizeof((yyval.state))); 3944 (yyval.state)[0] = STATE_LIGHTMODEL_SCENECOLOR; 3945 (yyval.state)[1] = (yyvsp[(1) - (2)].integer); 3946 } 3947 break; 3948 3949 case 167: 3950 3951/* Line 1806 of yacc.c */ 3952#line 1458 "src/src/mesa/program/program_parse.y" 3953 { 3954 memset((yyval.state), 0, sizeof((yyval.state))); 3955 (yyval.state)[0] = STATE_LIGHTPROD; 3956 (yyval.state)[1] = (yyvsp[(3) - (6)].integer); 3957 (yyval.state)[2] = (yyvsp[(5) - (6)].integer); 3958 (yyval.state)[3] = (yyvsp[(6) - (6)].integer); 3959 } 3960 break; 3961 3962 case 169: 3963 3964/* Line 1806 of yacc.c */ 3965#line 1470 "src/src/mesa/program/program_parse.y" 3966 { 3967 memset((yyval.state), 0, sizeof((yyval.state))); 3968 (yyval.state)[0] = (yyvsp[(3) - (3)].integer); 3969 (yyval.state)[1] = (yyvsp[(2) - (3)].integer); 3970 } 3971 break; 3972 3973 case 170: 3974 3975/* Line 1806 of yacc.c */ 3976#line 1478 "src/src/mesa/program/program_parse.y" 3977 { 3978 (yyval.integer) = STATE_TEXENV_COLOR; 3979 } 3980 break; 3981 3982 case 171: 3983 3984/* Line 1806 of yacc.c */ 3985#line 1484 "src/src/mesa/program/program_parse.y" 3986 { 3987 (yyval.integer) = STATE_AMBIENT; 3988 } 3989 break; 3990 3991 case 172: 3992 3993/* Line 1806 of yacc.c */ 3994#line 1488 "src/src/mesa/program/program_parse.y" 3995 { 3996 (yyval.integer) = STATE_DIFFUSE; 3997 } 3998 break; 3999 4000 case 173: 4001 4002/* Line 1806 of yacc.c */ 4003#line 1492 "src/src/mesa/program/program_parse.y" 4004 { 4005 (yyval.integer) = STATE_SPECULAR; 4006 } 4007 break; 4008 4009 case 174: 4010 4011/* Line 1806 of yacc.c */ 4012#line 1498 "src/src/mesa/program/program_parse.y" 4013 { 4014 if ((unsigned) (yyvsp[(1) - (1)].integer) >= state->MaxLights) { 4015 yyerror(& (yylsp[(1) - (1)]), state, "invalid light selector"); 4016 YYERROR; 4017 } 4018 4019 (yyval.integer) = (yyvsp[(1) - (1)].integer); 4020 } 4021 break; 4022 4023 case 175: 4024 4025/* Line 1806 of yacc.c */ 4026#line 1509 "src/src/mesa/program/program_parse.y" 4027 { 4028 memset((yyval.state), 0, sizeof((yyval.state))); 4029 (yyval.state)[0] = STATE_TEXGEN; 4030 (yyval.state)[1] = (yyvsp[(2) - (4)].integer); 4031 (yyval.state)[2] = (yyvsp[(3) - (4)].integer) + (yyvsp[(4) - (4)].integer); 4032 } 4033 break; 4034 4035 case 176: 4036 4037/* Line 1806 of yacc.c */ 4038#line 1518 "src/src/mesa/program/program_parse.y" 4039 { 4040 (yyval.integer) = STATE_TEXGEN_EYE_S; 4041 } 4042 break; 4043 4044 case 177: 4045 4046/* Line 1806 of yacc.c */ 4047#line 1522 "src/src/mesa/program/program_parse.y" 4048 { 4049 (yyval.integer) = STATE_TEXGEN_OBJECT_S; 4050 } 4051 break; 4052 4053 case 178: 4054 4055/* Line 1806 of yacc.c */ 4056#line 1527 "src/src/mesa/program/program_parse.y" 4057 { 4058 (yyval.integer) = STATE_TEXGEN_EYE_S - STATE_TEXGEN_EYE_S; 4059 } 4060 break; 4061 4062 case 179: 4063 4064/* Line 1806 of yacc.c */ 4065#line 1531 "src/src/mesa/program/program_parse.y" 4066 { 4067 (yyval.integer) = STATE_TEXGEN_EYE_T - STATE_TEXGEN_EYE_S; 4068 } 4069 break; 4070 4071 case 180: 4072 4073/* Line 1806 of yacc.c */ 4074#line 1535 "src/src/mesa/program/program_parse.y" 4075 { 4076 (yyval.integer) = STATE_TEXGEN_EYE_R - STATE_TEXGEN_EYE_S; 4077 } 4078 break; 4079 4080 case 181: 4081 4082/* Line 1806 of yacc.c */ 4083#line 1539 "src/src/mesa/program/program_parse.y" 4084 { 4085 (yyval.integer) = STATE_TEXGEN_EYE_Q - STATE_TEXGEN_EYE_S; 4086 } 4087 break; 4088 4089 case 182: 4090 4091/* Line 1806 of yacc.c */ 4092#line 1545 "src/src/mesa/program/program_parse.y" 4093 { 4094 memset((yyval.state), 0, sizeof((yyval.state))); 4095 (yyval.state)[0] = (yyvsp[(2) - (2)].integer); 4096 } 4097 break; 4098 4099 case 183: 4100 4101/* Line 1806 of yacc.c */ 4102#line 1552 "src/src/mesa/program/program_parse.y" 4103 { 4104 (yyval.integer) = STATE_FOG_COLOR; 4105 } 4106 break; 4107 4108 case 184: 4109 4110/* Line 1806 of yacc.c */ 4111#line 1556 "src/src/mesa/program/program_parse.y" 4112 { 4113 (yyval.integer) = STATE_FOG_PARAMS; 4114 } 4115 break; 4116 4117 case 185: 4118 4119/* Line 1806 of yacc.c */ 4120#line 1562 "src/src/mesa/program/program_parse.y" 4121 { 4122 memset((yyval.state), 0, sizeof((yyval.state))); 4123 (yyval.state)[0] = STATE_CLIPPLANE; 4124 (yyval.state)[1] = (yyvsp[(3) - (5)].integer); 4125 } 4126 break; 4127 4128 case 186: 4129 4130/* Line 1806 of yacc.c */ 4131#line 1570 "src/src/mesa/program/program_parse.y" 4132 { 4133 if ((unsigned) (yyvsp[(1) - (1)].integer) >= state->MaxClipPlanes) { 4134 yyerror(& (yylsp[(1) - (1)]), state, "invalid clip plane selector"); 4135 YYERROR; 4136 } 4137 4138 (yyval.integer) = (yyvsp[(1) - (1)].integer); 4139 } 4140 break; 4141 4142 case 187: 4143 4144/* Line 1806 of yacc.c */ 4145#line 1581 "src/src/mesa/program/program_parse.y" 4146 { 4147 memset((yyval.state), 0, sizeof((yyval.state))); 4148 (yyval.state)[0] = (yyvsp[(2) - (2)].integer); 4149 } 4150 break; 4151 4152 case 188: 4153 4154/* Line 1806 of yacc.c */ 4155#line 1588 "src/src/mesa/program/program_parse.y" 4156 { 4157 (yyval.integer) = STATE_POINT_SIZE; 4158 } 4159 break; 4160 4161 case 189: 4162 4163/* Line 1806 of yacc.c */ 4164#line 1592 "src/src/mesa/program/program_parse.y" 4165 { 4166 (yyval.integer) = STATE_POINT_ATTENUATION; 4167 } 4168 break; 4169 4170 case 190: 4171 4172/* Line 1806 of yacc.c */ 4173#line 1598 "src/src/mesa/program/program_parse.y" 4174 { 4175 (yyval.state)[0] = (yyvsp[(1) - (5)].state)[0]; 4176 (yyval.state)[1] = (yyvsp[(1) - (5)].state)[1]; 4177 (yyval.state)[2] = (yyvsp[(4) - (5)].integer); 4178 (yyval.state)[3] = (yyvsp[(4) - (5)].integer); 4179 (yyval.state)[4] = (yyvsp[(1) - (5)].state)[2]; 4180 } 4181 break; 4182 4183 case 191: 4184 4185/* Line 1806 of yacc.c */ 4186#line 1608 "src/src/mesa/program/program_parse.y" 4187 { 4188 (yyval.state)[0] = (yyvsp[(1) - (2)].state)[0]; 4189 (yyval.state)[1] = (yyvsp[(1) - (2)].state)[1]; 4190 (yyval.state)[2] = (yyvsp[(2) - (2)].state)[2]; 4191 (yyval.state)[3] = (yyvsp[(2) - (2)].state)[3]; 4192 (yyval.state)[4] = (yyvsp[(1) - (2)].state)[2]; 4193 } 4194 break; 4195 4196 case 192: 4197 4198/* Line 1806 of yacc.c */ 4199#line 1618 "src/src/mesa/program/program_parse.y" 4200 { 4201 (yyval.state)[2] = 0; 4202 (yyval.state)[3] = 3; 4203 } 4204 break; 4205 4206 case 193: 4207 4208/* Line 1806 of yacc.c */ 4209#line 1623 "src/src/mesa/program/program_parse.y" 4210 { 4211 /* It seems logical that the matrix row range specifier would have 4212 * to specify a range or more than one row (i.e., $5 > $3). 4213 * However, the ARB_vertex_program spec says "a program will fail 4214 * to load if <a> is greater than <b>." This means that $3 == $5 4215 * is valid. 4216 */ 4217 if ((yyvsp[(3) - (6)].integer) > (yyvsp[(5) - (6)].integer)) { 4218 yyerror(& (yylsp[(3) - (6)]), state, "invalid matrix row range"); 4219 YYERROR; 4220 } 4221 4222 (yyval.state)[2] = (yyvsp[(3) - (6)].integer); 4223 (yyval.state)[3] = (yyvsp[(5) - (6)].integer); 4224 } 4225 break; 4226 4227 case 194: 4228 4229/* Line 1806 of yacc.c */ 4230#line 1641 "src/src/mesa/program/program_parse.y" 4231 { 4232 (yyval.state)[0] = (yyvsp[(2) - (3)].state)[0]; 4233 (yyval.state)[1] = (yyvsp[(2) - (3)].state)[1]; 4234 (yyval.state)[2] = (yyvsp[(3) - (3)].integer); 4235 } 4236 break; 4237 4238 case 195: 4239 4240/* Line 1806 of yacc.c */ 4241#line 1649 "src/src/mesa/program/program_parse.y" 4242 { 4243 (yyval.integer) = 0; 4244 } 4245 break; 4246 4247 case 196: 4248 4249/* Line 1806 of yacc.c */ 4250#line 1653 "src/src/mesa/program/program_parse.y" 4251 { 4252 (yyval.integer) = (yyvsp[(1) - (1)].integer); 4253 } 4254 break; 4255 4256 case 197: 4257 4258/* Line 1806 of yacc.c */ 4259#line 1659 "src/src/mesa/program/program_parse.y" 4260 { 4261 (yyval.integer) = STATE_MATRIX_INVERSE; 4262 } 4263 break; 4264 4265 case 198: 4266 4267/* Line 1806 of yacc.c */ 4268#line 1663 "src/src/mesa/program/program_parse.y" 4269 { 4270 (yyval.integer) = STATE_MATRIX_TRANSPOSE; 4271 } 4272 break; 4273 4274 case 199: 4275 4276/* Line 1806 of yacc.c */ 4277#line 1667 "src/src/mesa/program/program_parse.y" 4278 { 4279 (yyval.integer) = STATE_MATRIX_INVTRANS; 4280 } 4281 break; 4282 4283 case 200: 4284 4285/* Line 1806 of yacc.c */ 4286#line 1673 "src/src/mesa/program/program_parse.y" 4287 { 4288 if ((yyvsp[(1) - (1)].integer) > 3) { 4289 yyerror(& (yylsp[(1) - (1)]), state, "invalid matrix row reference"); 4290 YYERROR; 4291 } 4292 4293 (yyval.integer) = (yyvsp[(1) - (1)].integer); 4294 } 4295 break; 4296 4297 case 201: 4298 4299/* Line 1806 of yacc.c */ 4300#line 1684 "src/src/mesa/program/program_parse.y" 4301 { 4302 (yyval.state)[0] = STATE_MODELVIEW_MATRIX; 4303 (yyval.state)[1] = (yyvsp[(2) - (2)].integer); 4304 } 4305 break; 4306 4307 case 202: 4308 4309/* Line 1806 of yacc.c */ 4310#line 1689 "src/src/mesa/program/program_parse.y" 4311 { 4312 (yyval.state)[0] = STATE_PROJECTION_MATRIX; 4313 (yyval.state)[1] = 0; 4314 } 4315 break; 4316 4317 case 203: 4318 4319/* Line 1806 of yacc.c */ 4320#line 1694 "src/src/mesa/program/program_parse.y" 4321 { 4322 (yyval.state)[0] = STATE_MVP_MATRIX; 4323 (yyval.state)[1] = 0; 4324 } 4325 break; 4326 4327 case 204: 4328 4329/* Line 1806 of yacc.c */ 4330#line 1699 "src/src/mesa/program/program_parse.y" 4331 { 4332 (yyval.state)[0] = STATE_TEXTURE_MATRIX; 4333 (yyval.state)[1] = (yyvsp[(2) - (2)].integer); 4334 } 4335 break; 4336 4337 case 205: 4338 4339/* Line 1806 of yacc.c */ 4340#line 1704 "src/src/mesa/program/program_parse.y" 4341 { 4342 yyerror(& (yylsp[(1) - (4)]), state, "GL_ARB_matrix_palette not supported"); 4343 YYERROR; 4344 } 4345 break; 4346 4347 case 206: 4348 4349/* Line 1806 of yacc.c */ 4350#line 1709 "src/src/mesa/program/program_parse.y" 4351 { 4352 (yyval.state)[0] = STATE_PROGRAM_MATRIX; 4353 (yyval.state)[1] = (yyvsp[(3) - (4)].integer); 4354 } 4355 break; 4356 4357 case 207: 4358 4359/* Line 1806 of yacc.c */ 4360#line 1716 "src/src/mesa/program/program_parse.y" 4361 { 4362 (yyval.integer) = 0; 4363 } 4364 break; 4365 4366 case 208: 4367 4368/* Line 1806 of yacc.c */ 4369#line 1720 "src/src/mesa/program/program_parse.y" 4370 { 4371 (yyval.integer) = (yyvsp[(2) - (3)].integer); 4372 } 4373 break; 4374 4375 case 209: 4376 4377/* Line 1806 of yacc.c */ 4378#line 1725 "src/src/mesa/program/program_parse.y" 4379 { 4380 /* Since GL_ARB_vertex_blend isn't supported, only modelview matrix 4381 * zero is valid. 4382 */ 4383 if ((yyvsp[(1) - (1)].integer) != 0) { 4384 yyerror(& (yylsp[(1) - (1)]), state, "invalid modelview matrix index"); 4385 YYERROR; 4386 } 4387 4388 (yyval.integer) = (yyvsp[(1) - (1)].integer); 4389 } 4390 break; 4391 4392 case 210: 4393 4394/* Line 1806 of yacc.c */ 4395#line 1738 "src/src/mesa/program/program_parse.y" 4396 { 4397 /* Since GL_ARB_matrix_palette isn't supported, just let any value 4398 * through here. The error will be generated later. 4399 */ 4400 (yyval.integer) = (yyvsp[(1) - (1)].integer); 4401 } 4402 break; 4403 4404 case 211: 4405 4406/* Line 1806 of yacc.c */ 4407#line 1746 "src/src/mesa/program/program_parse.y" 4408 { 4409 if ((unsigned) (yyvsp[(1) - (1)].integer) >= state->MaxProgramMatrices) { 4410 yyerror(& (yylsp[(1) - (1)]), state, "invalid program matrix selector"); 4411 YYERROR; 4412 } 4413 4414 (yyval.integer) = (yyvsp[(1) - (1)].integer); 4415 } 4416 break; 4417 4418 case 212: 4419 4420/* Line 1806 of yacc.c */ 4421#line 1757 "src/src/mesa/program/program_parse.y" 4422 { 4423 memset((yyval.state), 0, sizeof((yyval.state))); 4424 (yyval.state)[0] = STATE_DEPTH_RANGE; 4425 } 4426 break; 4427 4428 case 217: 4429 4430/* Line 1806 of yacc.c */ 4431#line 1769 "src/src/mesa/program/program_parse.y" 4432 { 4433 memset((yyval.state), 0, sizeof((yyval.state))); 4434 (yyval.state)[0] = state->state_param_enum; 4435 (yyval.state)[1] = STATE_ENV; 4436 (yyval.state)[2] = (yyvsp[(4) - (5)].state)[0]; 4437 (yyval.state)[3] = (yyvsp[(4) - (5)].state)[1]; 4438 } 4439 break; 4440 4441 case 218: 4442 4443/* Line 1806 of yacc.c */ 4444#line 1779 "src/src/mesa/program/program_parse.y" 4445 { 4446 (yyval.state)[0] = (yyvsp[(1) - (1)].integer); 4447 (yyval.state)[1] = (yyvsp[(1) - (1)].integer); 4448 } 4449 break; 4450 4451 case 219: 4452 4453/* Line 1806 of yacc.c */ 4454#line 1784 "src/src/mesa/program/program_parse.y" 4455 { 4456 (yyval.state)[0] = (yyvsp[(1) - (3)].integer); 4457 (yyval.state)[1] = (yyvsp[(3) - (3)].integer); 4458 } 4459 break; 4460 4461 case 220: 4462 4463/* Line 1806 of yacc.c */ 4464#line 1791 "src/src/mesa/program/program_parse.y" 4465 { 4466 memset((yyval.state), 0, sizeof((yyval.state))); 4467 (yyval.state)[0] = state->state_param_enum; 4468 (yyval.state)[1] = STATE_ENV; 4469 (yyval.state)[2] = (yyvsp[(4) - (5)].integer); 4470 (yyval.state)[3] = (yyvsp[(4) - (5)].integer); 4471 } 4472 break; 4473 4474 case 221: 4475 4476/* Line 1806 of yacc.c */ 4477#line 1801 "src/src/mesa/program/program_parse.y" 4478 { 4479 memset((yyval.state), 0, sizeof((yyval.state))); 4480 (yyval.state)[0] = state->state_param_enum; 4481 (yyval.state)[1] = STATE_LOCAL; 4482 (yyval.state)[2] = (yyvsp[(4) - (5)].state)[0]; 4483 (yyval.state)[3] = (yyvsp[(4) - (5)].state)[1]; 4484 } 4485 break; 4486 4487 case 222: 4488 4489/* Line 1806 of yacc.c */ 4490#line 1810 "src/src/mesa/program/program_parse.y" 4491 { 4492 (yyval.state)[0] = (yyvsp[(1) - (1)].integer); 4493 (yyval.state)[1] = (yyvsp[(1) - (1)].integer); 4494 } 4495 break; 4496 4497 case 223: 4498 4499/* Line 1806 of yacc.c */ 4500#line 1815 "src/src/mesa/program/program_parse.y" 4501 { 4502 (yyval.state)[0] = (yyvsp[(1) - (3)].integer); 4503 (yyval.state)[1] = (yyvsp[(3) - (3)].integer); 4504 } 4505 break; 4506 4507 case 224: 4508 4509/* Line 1806 of yacc.c */ 4510#line 1822 "src/src/mesa/program/program_parse.y" 4511 { 4512 memset((yyval.state), 0, sizeof((yyval.state))); 4513 (yyval.state)[0] = state->state_param_enum; 4514 (yyval.state)[1] = STATE_LOCAL; 4515 (yyval.state)[2] = (yyvsp[(4) - (5)].integer); 4516 (yyval.state)[3] = (yyvsp[(4) - (5)].integer); 4517 } 4518 break; 4519 4520 case 225: 4521 4522/* Line 1806 of yacc.c */ 4523#line 1832 "src/src/mesa/program/program_parse.y" 4524 { 4525 if ((unsigned) (yyvsp[(1) - (1)].integer) >= state->limits->MaxEnvParams) { 4526 yyerror(& (yylsp[(1) - (1)]), state, "invalid environment parameter reference"); 4527 YYERROR; 4528 } 4529 (yyval.integer) = (yyvsp[(1) - (1)].integer); 4530 } 4531 break; 4532 4533 case 226: 4534 4535/* Line 1806 of yacc.c */ 4536#line 1842 "src/src/mesa/program/program_parse.y" 4537 { 4538 if ((unsigned) (yyvsp[(1) - (1)].integer) >= state->limits->MaxLocalParams) { 4539 yyerror(& (yylsp[(1) - (1)]), state, "invalid local parameter reference"); 4540 YYERROR; 4541 } 4542 (yyval.integer) = (yyvsp[(1) - (1)].integer); 4543 } 4544 break; 4545 4546 case 231: 4547 4548/* Line 1806 of yacc.c */ 4549#line 1857 "src/src/mesa/program/program_parse.y" 4550 { 4551 (yyval.vector).count = 4; 4552 (yyval.vector).data[0].f = (yyvsp[(1) - (1)].real); 4553 (yyval.vector).data[1].f = (yyvsp[(1) - (1)].real); 4554 (yyval.vector).data[2].f = (yyvsp[(1) - (1)].real); 4555 (yyval.vector).data[3].f = (yyvsp[(1) - (1)].real); 4556 } 4557 break; 4558 4559 case 232: 4560 4561/* Line 1806 of yacc.c */ 4562#line 1867 "src/src/mesa/program/program_parse.y" 4563 { 4564 (yyval.vector).count = 1; 4565 (yyval.vector).data[0].f = (yyvsp[(1) - (1)].real); 4566 (yyval.vector).data[1].f = (yyvsp[(1) - (1)].real); 4567 (yyval.vector).data[2].f = (yyvsp[(1) - (1)].real); 4568 (yyval.vector).data[3].f = (yyvsp[(1) - (1)].real); 4569 } 4570 break; 4571 4572 case 233: 4573 4574/* Line 1806 of yacc.c */ 4575#line 1875 "src/src/mesa/program/program_parse.y" 4576 { 4577 (yyval.vector).count = 1; 4578 (yyval.vector).data[0].f = (float) (yyvsp[(1) - (1)].integer); 4579 (yyval.vector).data[1].f = (float) (yyvsp[(1) - (1)].integer); 4580 (yyval.vector).data[2].f = (float) (yyvsp[(1) - (1)].integer); 4581 (yyval.vector).data[3].f = (float) (yyvsp[(1) - (1)].integer); 4582 } 4583 break; 4584 4585 case 234: 4586 4587/* Line 1806 of yacc.c */ 4588#line 1885 "src/src/mesa/program/program_parse.y" 4589 { 4590 (yyval.vector).count = 4; 4591 (yyval.vector).data[0].f = (yyvsp[(2) - (3)].real); 4592 (yyval.vector).data[1].f = 0.0f; 4593 (yyval.vector).data[2].f = 0.0f; 4594 (yyval.vector).data[3].f = 1.0f; 4595 } 4596 break; 4597 4598 case 235: 4599 4600/* Line 1806 of yacc.c */ 4601#line 1893 "src/src/mesa/program/program_parse.y" 4602 { 4603 (yyval.vector).count = 4; 4604 (yyval.vector).data[0].f = (yyvsp[(2) - (5)].real); 4605 (yyval.vector).data[1].f = (yyvsp[(4) - (5)].real); 4606 (yyval.vector).data[2].f = 0.0f; 4607 (yyval.vector).data[3].f = 1.0f; 4608 } 4609 break; 4610 4611 case 236: 4612 4613/* Line 1806 of yacc.c */ 4614#line 1902 "src/src/mesa/program/program_parse.y" 4615 { 4616 (yyval.vector).count = 4; 4617 (yyval.vector).data[0].f = (yyvsp[(2) - (7)].real); 4618 (yyval.vector).data[1].f = (yyvsp[(4) - (7)].real); 4619 (yyval.vector).data[2].f = (yyvsp[(6) - (7)].real); 4620 (yyval.vector).data[3].f = 1.0f; 4621 } 4622 break; 4623 4624 case 237: 4625 4626/* Line 1806 of yacc.c */ 4627#line 1911 "src/src/mesa/program/program_parse.y" 4628 { 4629 (yyval.vector).count = 4; 4630 (yyval.vector).data[0].f = (yyvsp[(2) - (9)].real); 4631 (yyval.vector).data[1].f = (yyvsp[(4) - (9)].real); 4632 (yyval.vector).data[2].f = (yyvsp[(6) - (9)].real); 4633 (yyval.vector).data[3].f = (yyvsp[(8) - (9)].real); 4634 } 4635 break; 4636 4637 case 238: 4638 4639/* Line 1806 of yacc.c */ 4640#line 1921 "src/src/mesa/program/program_parse.y" 4641 { 4642 (yyval.real) = ((yyvsp[(1) - (2)].negate)) ? -(yyvsp[(2) - (2)].real) : (yyvsp[(2) - (2)].real); 4643 } 4644 break; 4645 4646 case 239: 4647 4648/* Line 1806 of yacc.c */ 4649#line 1925 "src/src/mesa/program/program_parse.y" 4650 { 4651 (yyval.real) = (float)(((yyvsp[(1) - (2)].negate)) ? -(yyvsp[(2) - (2)].integer) : (yyvsp[(2) - (2)].integer)); 4652 } 4653 break; 4654 4655 case 240: 4656 4657/* Line 1806 of yacc.c */ 4658#line 1930 "src/src/mesa/program/program_parse.y" 4659 { (yyval.negate) = FALSE; } 4660 break; 4661 4662 case 241: 4663 4664/* Line 1806 of yacc.c */ 4665#line 1931 "src/src/mesa/program/program_parse.y" 4666 { (yyval.negate) = TRUE; } 4667 break; 4668 4669 case 242: 4670 4671/* Line 1806 of yacc.c */ 4672#line 1932 "src/src/mesa/program/program_parse.y" 4673 { (yyval.negate) = FALSE; } 4674 break; 4675 4676 case 243: 4677 4678/* Line 1806 of yacc.c */ 4679#line 1935 "src/src/mesa/program/program_parse.y" 4680 { (yyval.integer) = (yyvsp[(2) - (2)].integer); } 4681 break; 4682 4683 case 245: 4684 4685/* Line 1806 of yacc.c */ 4686#line 1939 "src/src/mesa/program/program_parse.y" 4687 { 4688 /* NV_fragment_program_option defines the size qualifiers in a 4689 * fairly broken way. "SHORT" or "LONG" can optionally be used 4690 * before TEMP or OUTPUT. However, neither is a reserved word! 4691 * This means that we have to parse it as an identifier, then check 4692 * to make sure it's one of the valid values. *sigh* 4693 * 4694 * In addition, the grammar in the extension spec does *not* allow 4695 * the size specifier to be optional, but all known implementations 4696 * do. 4697 */ 4698 if (!state->option.NV_fragment) { 4699 yyerror(& (yylsp[(1) - (1)]), state, "unexpected IDENTIFIER"); 4700 YYERROR; 4701 } 4702 4703 if (strcmp("SHORT", (yyvsp[(1) - (1)].string)) == 0) { 4704 } else if (strcmp("LONG", (yyvsp[(1) - (1)].string)) == 0) { 4705 } else { 4706 char *const err_str = 4707 make_error_string("invalid storage size specifier \"%s\"", 4708 (yyvsp[(1) - (1)].string)); 4709 4710 yyerror(& (yylsp[(1) - (1)]), state, (err_str != NULL) 4711 ? err_str : "invalid storage size specifier"); 4712 4713 if (err_str != NULL) { 4714 free(err_str); 4715 } 4716 4717 YYERROR; 4718 } 4719 } 4720 break; 4721 4722 case 246: 4723 4724/* Line 1806 of yacc.c */ 4725#line 1973 "src/src/mesa/program/program_parse.y" 4726 { 4727 } 4728 break; 4729 4730 case 247: 4731 4732/* Line 1806 of yacc.c */ 4733#line 1977 "src/src/mesa/program/program_parse.y" 4734 { (yyval.integer) = (yyvsp[(1) - (1)].integer); } 4735 break; 4736 4737 case 249: 4738 4739/* Line 1806 of yacc.c */ 4740#line 1981 "src/src/mesa/program/program_parse.y" 4741 { 4742 if (!declare_variable(state, (yyvsp[(3) - (3)].string), (yyvsp[(0) - (3)].integer), & (yylsp[(3) - (3)]))) { 4743 free((yyvsp[(3) - (3)].string)); 4744 YYERROR; 4745 } 4746 } 4747 break; 4748 4749 case 250: 4750 4751/* Line 1806 of yacc.c */ 4752#line 1988 "src/src/mesa/program/program_parse.y" 4753 { 4754 if (!declare_variable(state, (yyvsp[(1) - (1)].string), (yyvsp[(0) - (1)].integer), & (yylsp[(1) - (1)]))) { 4755 free((yyvsp[(1) - (1)].string)); 4756 YYERROR; 4757 } 4758 } 4759 break; 4760 4761 case 251: 4762 4763/* Line 1806 of yacc.c */ 4764#line 1997 "src/src/mesa/program/program_parse.y" 4765 { 4766 struct asm_symbol *const s = 4767 declare_variable(state, (yyvsp[(3) - (5)].string), at_output, & (yylsp[(3) - (5)])); 4768 4769 if (s == NULL) { 4770 free((yyvsp[(3) - (5)].string)); 4771 YYERROR; 4772 } else { 4773 s->output_binding = (yyvsp[(5) - (5)].result); 4774 } 4775 } 4776 break; 4777 4778 case 252: 4779 4780/* Line 1806 of yacc.c */ 4781#line 2011 "src/src/mesa/program/program_parse.y" 4782 { 4783 if (state->mode == ARB_vertex) { 4784 (yyval.result) = VERT_RESULT_HPOS; 4785 } else { 4786 yyerror(& (yylsp[(2) - (2)]), state, "invalid program result name"); 4787 YYERROR; 4788 } 4789 } 4790 break; 4791 4792 case 253: 4793 4794/* Line 1806 of yacc.c */ 4795#line 2020 "src/src/mesa/program/program_parse.y" 4796 { 4797 if (state->mode == ARB_vertex) { 4798 (yyval.result) = VERT_RESULT_FOGC; 4799 } else { 4800 yyerror(& (yylsp[(2) - (2)]), state, "invalid program result name"); 4801 YYERROR; 4802 } 4803 } 4804 break; 4805 4806 case 254: 4807 4808/* Line 1806 of yacc.c */ 4809#line 2029 "src/src/mesa/program/program_parse.y" 4810 { 4811 (yyval.result) = (yyvsp[(2) - (2)].result); 4812 } 4813 break; 4814 4815 case 255: 4816 4817/* Line 1806 of yacc.c */ 4818#line 2033 "src/src/mesa/program/program_parse.y" 4819 { 4820 if (state->mode == ARB_vertex) { 4821 (yyval.result) = VERT_RESULT_PSIZ; 4822 } else { 4823 yyerror(& (yylsp[(2) - (2)]), state, "invalid program result name"); 4824 YYERROR; 4825 } 4826 } 4827 break; 4828 4829 case 256: 4830 4831/* Line 1806 of yacc.c */ 4832#line 2042 "src/src/mesa/program/program_parse.y" 4833 { 4834 if (state->mode == ARB_vertex) { 4835 (yyval.result) = VERT_RESULT_TEX0 + (yyvsp[(3) - (3)].integer); 4836 } else { 4837 yyerror(& (yylsp[(2) - (3)]), state, "invalid program result name"); 4838 YYERROR; 4839 } 4840 } 4841 break; 4842 4843 case 257: 4844 4845/* Line 1806 of yacc.c */ 4846#line 2051 "src/src/mesa/program/program_parse.y" 4847 { 4848 if (state->mode == ARB_fragment) { 4849 (yyval.result) = FRAG_RESULT_DEPTH; 4850 } else { 4851 yyerror(& (yylsp[(2) - (2)]), state, "invalid program result name"); 4852 YYERROR; 4853 } 4854 } 4855 break; 4856 4857 case 258: 4858 4859/* Line 1806 of yacc.c */ 4860#line 2062 "src/src/mesa/program/program_parse.y" 4861 { 4862 (yyval.result) = (yyvsp[(2) - (3)].integer) + (yyvsp[(3) - (3)].integer); 4863 } 4864 break; 4865 4866 case 259: 4867 4868/* Line 1806 of yacc.c */ 4869#line 2068 "src/src/mesa/program/program_parse.y" 4870 { 4871 if (state->mode == ARB_vertex) { 4872 (yyval.integer) = VERT_RESULT_COL0; 4873 } else { 4874 if (state->option.DrawBuffers) 4875 (yyval.integer) = FRAG_RESULT_DATA0; 4876 else 4877 (yyval.integer) = FRAG_RESULT_COLOR; 4878 } 4879 } 4880 break; 4881 4882 case 260: 4883 4884/* Line 1806 of yacc.c */ 4885#line 2079 "src/src/mesa/program/program_parse.y" 4886 { 4887 if (state->mode == ARB_vertex) { 4888 yyerror(& (yylsp[(1) - (3)]), state, "invalid program result name"); 4889 YYERROR; 4890 } else { 4891 if (!state->option.DrawBuffers) { 4892 /* From the ARB_draw_buffers spec (same text exists 4893 * for ATI_draw_buffers): 4894 * 4895 * If this option is not specified, a fragment 4896 * program that attempts to bind 4897 * "result.color[n]" will fail to load, and only 4898 * "result.color" will be allowed. 4899 */ 4900 yyerror(& (yylsp[(1) - (3)]), state, 4901 "result.color[] used without " 4902 "`OPTION ARB_draw_buffers' or " 4903 "`OPTION ATI_draw_buffers'"); 4904 YYERROR; 4905 } else if ((yyvsp[(2) - (3)].integer) >= state->MaxDrawBuffers) { 4906 yyerror(& (yylsp[(1) - (3)]), state, 4907 "result.color[] exceeds MAX_DRAW_BUFFERS_ARB"); 4908 YYERROR; 4909 } 4910 (yyval.integer) = FRAG_RESULT_DATA0 + (yyvsp[(2) - (3)].integer); 4911 } 4912 } 4913 break; 4914 4915 case 261: 4916 4917/* Line 1806 of yacc.c */ 4918#line 2107 "src/src/mesa/program/program_parse.y" 4919 { 4920 if (state->mode == ARB_vertex) { 4921 (yyval.integer) = VERT_RESULT_COL0; 4922 } else { 4923 yyerror(& (yylsp[(1) - (1)]), state, "invalid program result name"); 4924 YYERROR; 4925 } 4926 } 4927 break; 4928 4929 case 262: 4930 4931/* Line 1806 of yacc.c */ 4932#line 2116 "src/src/mesa/program/program_parse.y" 4933 { 4934 if (state->mode == ARB_vertex) { 4935 (yyval.integer) = VERT_RESULT_BFC0; 4936 } else { 4937 yyerror(& (yylsp[(1) - (1)]), state, "invalid program result name"); 4938 YYERROR; 4939 } 4940 } 4941 break; 4942 4943 case 263: 4944 4945/* Line 1806 of yacc.c */ 4946#line 2127 "src/src/mesa/program/program_parse.y" 4947 { 4948 (yyval.integer) = 0; 4949 } 4950 break; 4951 4952 case 264: 4953 4954/* Line 1806 of yacc.c */ 4955#line 2131 "src/src/mesa/program/program_parse.y" 4956 { 4957 if (state->mode == ARB_vertex) { 4958 (yyval.integer) = 0; 4959 } else { 4960 yyerror(& (yylsp[(1) - (1)]), state, "invalid program result name"); 4961 YYERROR; 4962 } 4963 } 4964 break; 4965 4966 case 265: 4967 4968/* Line 1806 of yacc.c */ 4969#line 2140 "src/src/mesa/program/program_parse.y" 4970 { 4971 if (state->mode == ARB_vertex) { 4972 (yyval.integer) = 1; 4973 } else { 4974 yyerror(& (yylsp[(1) - (1)]), state, "invalid program result name"); 4975 YYERROR; 4976 } 4977 } 4978 break; 4979 4980 case 266: 4981 4982/* Line 1806 of yacc.c */ 4983#line 2150 "src/src/mesa/program/program_parse.y" 4984 { (yyval.integer) = 0; } 4985 break; 4986 4987 case 267: 4988 4989/* Line 1806 of yacc.c */ 4990#line 2151 "src/src/mesa/program/program_parse.y" 4991 { (yyval.integer) = 0; } 4992 break; 4993 4994 case 268: 4995 4996/* Line 1806 of yacc.c */ 4997#line 2152 "src/src/mesa/program/program_parse.y" 4998 { (yyval.integer) = 1; } 4999 break; 5000 5001 case 269: 5002 5003/* Line 1806 of yacc.c */ 5004#line 2155 "src/src/mesa/program/program_parse.y" 5005 { (yyval.integer) = 0; } 5006 break; 5007 5008 case 270: 5009 5010/* Line 1806 of yacc.c */ 5011#line 2156 "src/src/mesa/program/program_parse.y" 5012 { (yyval.integer) = 0; } 5013 break; 5014 5015 case 271: 5016 5017/* Line 1806 of yacc.c */ 5018#line 2157 "src/src/mesa/program/program_parse.y" 5019 { (yyval.integer) = 1; } 5020 break; 5021 5022 case 272: 5023 5024/* Line 1806 of yacc.c */ 5025#line 2160 "src/src/mesa/program/program_parse.y" 5026 { (yyval.integer) = 0; } 5027 break; 5028 5029 case 273: 5030 5031/* Line 1806 of yacc.c */ 5032#line 2161 "src/src/mesa/program/program_parse.y" 5033 { (yyval.integer) = (yyvsp[(2) - (3)].integer); } 5034 break; 5035 5036 case 274: 5037 5038/* Line 1806 of yacc.c */ 5039#line 2164 "src/src/mesa/program/program_parse.y" 5040 { (yyval.integer) = 0; } 5041 break; 5042 5043 case 275: 5044 5045/* Line 1806 of yacc.c */ 5046#line 2165 "src/src/mesa/program/program_parse.y" 5047 { (yyval.integer) = (yyvsp[(2) - (3)].integer); } 5048 break; 5049 5050 case 276: 5051 5052/* Line 1806 of yacc.c */ 5053#line 2168 "src/src/mesa/program/program_parse.y" 5054 { (yyval.integer) = 0; } 5055 break; 5056 5057 case 277: 5058 5059/* Line 1806 of yacc.c */ 5060#line 2169 "src/src/mesa/program/program_parse.y" 5061 { (yyval.integer) = (yyvsp[(2) - (3)].integer); } 5062 break; 5063 5064 case 278: 5065 5066/* Line 1806 of yacc.c */ 5067#line 2173 "src/src/mesa/program/program_parse.y" 5068 { 5069 if ((unsigned) (yyvsp[(1) - (1)].integer) >= state->MaxTextureCoordUnits) { 5070 yyerror(& (yylsp[(1) - (1)]), state, "invalid texture coordinate unit selector"); 5071 YYERROR; 5072 } 5073 5074 (yyval.integer) = (yyvsp[(1) - (1)].integer); 5075 } 5076 break; 5077 5078 case 279: 5079 5080/* Line 1806 of yacc.c */ 5081#line 2184 "src/src/mesa/program/program_parse.y" 5082 { 5083 if ((unsigned) (yyvsp[(1) - (1)].integer) >= state->MaxTextureImageUnits) { 5084 yyerror(& (yylsp[(1) - (1)]), state, "invalid texture image unit selector"); 5085 YYERROR; 5086 } 5087 5088 (yyval.integer) = (yyvsp[(1) - (1)].integer); 5089 } 5090 break; 5091 5092 case 280: 5093 5094/* Line 1806 of yacc.c */ 5095#line 2195 "src/src/mesa/program/program_parse.y" 5096 { 5097 if ((unsigned) (yyvsp[(1) - (1)].integer) >= state->MaxTextureUnits) { 5098 yyerror(& (yylsp[(1) - (1)]), state, "invalid texture unit selector"); 5099 YYERROR; 5100 } 5101 5102 (yyval.integer) = (yyvsp[(1) - (1)].integer); 5103 } 5104 break; 5105 5106 case 281: 5107 5108/* Line 1806 of yacc.c */ 5109#line 2206 "src/src/mesa/program/program_parse.y" 5110 { 5111 struct asm_symbol *exist = (struct asm_symbol *) 5112 _mesa_symbol_table_find_symbol(state->st, 0, (yyvsp[(2) - (4)].string)); 5113 struct asm_symbol *target = (struct asm_symbol *) 5114 _mesa_symbol_table_find_symbol(state->st, 0, (yyvsp[(4) - (4)].string)); 5115 5116 free((yyvsp[(4) - (4)].string)); 5117 5118 if (exist != NULL) { 5119 char m[1000]; 5120 _mesa_snprintf(m, sizeof(m), "redeclared identifier: %s", (yyvsp[(2) - (4)].string)); 5121 free((yyvsp[(2) - (4)].string)); 5122 yyerror(& (yylsp[(2) - (4)]), state, m); 5123 YYERROR; 5124 } else if (target == NULL) { 5125 free((yyvsp[(2) - (4)].string)); 5126 yyerror(& (yylsp[(4) - (4)]), state, 5127 "undefined variable binding in ALIAS statement"); 5128 YYERROR; 5129 } else { 5130 _mesa_symbol_table_add_symbol(state->st, 0, (yyvsp[(2) - (4)].string), target); 5131 } 5132 } 5133 break; 5134 5135 5136 5137/* Line 1806 of yacc.c */ 5138#line 5139 "src/chromium_gensrc/mesa/program/program_parse.tab.c" 5139 default: break; 5140 } 5141 /* User semantic actions sometimes alter yychar, and that requires 5142 that yytoken be updated with the new translation. We take the 5143 approach of translating immediately before every use of yytoken. 5144 One alternative is translating here after every semantic action, 5145 but that translation would be missed if the semantic action invokes 5146 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 5147 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 5148 incorrect destructor might then be invoked immediately. In the 5149 case of YYERROR or YYBACKUP, subsequent parser actions might lead 5150 to an incorrect destructor call or verbose syntax error message 5151 before the lookahead is translated. */ 5152 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 5153 5154 YYPOPSTACK (yylen); 5155 yylen = 0; 5156 YY_STACK_PRINT (yyss, yyssp); 5157 5158 *++yyvsp = yyval; 5159 *++yylsp = yyloc; 5160 5161 /* Now `shift' the result of the reduction. Determine what state 5162 that goes to, based on the state we popped back to and the rule 5163 number reduced by. */ 5164 5165 yyn = yyr1[yyn]; 5166 5167 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 5168 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 5169 yystate = yytable[yystate]; 5170 else 5171 yystate = yydefgoto[yyn - YYNTOKENS]; 5172 5173 goto yynewstate; 5174 5175 5176/*------------------------------------. 5177| yyerrlab -- here on detecting error | 5178`------------------------------------*/ 5179yyerrlab: 5180 /* Make sure we have latest lookahead translation. See comments at 5181 user semantic actions for why this is necessary. */ 5182 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); 5183 5184 /* If not already recovering from an error, report this error. */ 5185 if (!yyerrstatus) 5186 { 5187 ++yynerrs; 5188#if ! YYERROR_VERBOSE 5189 yyerror (&yylloc, state, YY_("syntax error")); 5190#else 5191# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 5192 yyssp, yytoken) 5193 { 5194 char const *yymsgp = YY_("syntax error"); 5195 int yysyntax_error_status; 5196 yysyntax_error_status = YYSYNTAX_ERROR; 5197 if (yysyntax_error_status == 0) 5198 yymsgp = yymsg; 5199 else if (yysyntax_error_status == 1) 5200 { 5201 if (yymsg != yymsgbuf) 5202 YYSTACK_FREE (yymsg); 5203 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); 5204 if (!yymsg) 5205 { 5206 yymsg = yymsgbuf; 5207 yymsg_alloc = sizeof yymsgbuf; 5208 yysyntax_error_status = 2; 5209 } 5210 else 5211 { 5212 yysyntax_error_status = YYSYNTAX_ERROR; 5213 yymsgp = yymsg; 5214 } 5215 } 5216 yyerror (&yylloc, state, yymsgp); 5217 if (yysyntax_error_status == 2) 5218 goto yyexhaustedlab; 5219 } 5220# undef YYSYNTAX_ERROR 5221#endif 5222 } 5223 5224 yyerror_range[1] = yylloc; 5225 5226 if (yyerrstatus == 3) 5227 { 5228 /* If just tried and failed to reuse lookahead token after an 5229 error, discard it. */ 5230 5231 if (yychar <= YYEOF) 5232 { 5233 /* Return failure if at end of input. */ 5234 if (yychar == YYEOF) 5235 YYABORT; 5236 } 5237 else 5238 { 5239 yydestruct ("Error: discarding", 5240 yytoken, &yylval, &yylloc, state); 5241 yychar = YYEMPTY; 5242 } 5243 } 5244 5245 /* Else will try to reuse lookahead token after shifting the error 5246 token. */ 5247 goto yyerrlab1; 5248 5249 5250/*---------------------------------------------------. 5251| yyerrorlab -- error raised explicitly by YYERROR. | 5252`---------------------------------------------------*/ 5253yyerrorlab: 5254 5255 /* Pacify compilers like GCC when the user code never invokes 5256 YYERROR and the label yyerrorlab therefore never appears in user 5257 code. */ 5258 if (/*CONSTCOND*/ 0) 5259 goto yyerrorlab; 5260 5261 yyerror_range[1] = yylsp[1-yylen]; 5262 /* Do not reclaim the symbols of the rule which action triggered 5263 this YYERROR. */ 5264 YYPOPSTACK (yylen); 5265 yylen = 0; 5266 YY_STACK_PRINT (yyss, yyssp); 5267 yystate = *yyssp; 5268 goto yyerrlab1; 5269 5270 5271/*-------------------------------------------------------------. 5272| yyerrlab1 -- common code for both syntax error and YYERROR. | 5273`-------------------------------------------------------------*/ 5274yyerrlab1: 5275 yyerrstatus = 3; /* Each real token shifted decrements this. */ 5276 5277 for (;;) 5278 { 5279 yyn = yypact[yystate]; 5280 if (!yypact_value_is_default (yyn)) 5281 { 5282 yyn += YYTERROR; 5283 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 5284 { 5285 yyn = yytable[yyn]; 5286 if (0 < yyn) 5287 break; 5288 } 5289 } 5290 5291 /* Pop the current state because it cannot handle the error token. */ 5292 if (yyssp == yyss) 5293 YYABORT; 5294 5295 yyerror_range[1] = *yylsp; 5296 yydestruct ("Error: popping", 5297 yystos[yystate], yyvsp, yylsp, state); 5298 YYPOPSTACK (1); 5299 yystate = *yyssp; 5300 YY_STACK_PRINT (yyss, yyssp); 5301 } 5302 5303 *++yyvsp = yylval; 5304 5305 yyerror_range[2] = yylloc; 5306 /* Using YYLLOC is tempting, but would change the location of 5307 the lookahead. YYLOC is available though. */ 5308 YYLLOC_DEFAULT (yyloc, yyerror_range, 2); 5309 *++yylsp = yyloc; 5310 5311 /* Shift the error token. */ 5312 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 5313 5314 yystate = yyn; 5315 goto yynewstate; 5316 5317 5318/*-------------------------------------. 5319| yyacceptlab -- YYACCEPT comes here. | 5320`-------------------------------------*/ 5321yyacceptlab: 5322 yyresult = 0; 5323 goto yyreturn; 5324 5325/*-----------------------------------. 5326| yyabortlab -- YYABORT comes here. | 5327`-----------------------------------*/ 5328yyabortlab: 5329 yyresult = 1; 5330 goto yyreturn; 5331 5332#if !defined(yyoverflow) || YYERROR_VERBOSE 5333/*-------------------------------------------------. 5334| yyexhaustedlab -- memory exhaustion comes here. | 5335`-------------------------------------------------*/ 5336yyexhaustedlab: 5337 yyerror (&yylloc, state, YY_("memory exhausted")); 5338 yyresult = 2; 5339 /* Fall through. */ 5340#endif 5341 5342yyreturn: 5343 if (yychar != YYEMPTY) 5344 { 5345 /* Make sure we have latest lookahead translation. See comments at 5346 user semantic actions for why this is necessary. */ 5347 yytoken = YYTRANSLATE (yychar); 5348 yydestruct ("Cleanup: discarding lookahead", 5349 yytoken, &yylval, &yylloc, state); 5350 } 5351 /* Do not reclaim the symbols of the rule which action triggered 5352 this YYABORT or YYACCEPT. */ 5353 YYPOPSTACK (yylen); 5354 YY_STACK_PRINT (yyss, yyssp); 5355 while (yyssp != yyss) 5356 { 5357 yydestruct ("Cleanup: popping", 5358 yystos[*yyssp], yyvsp, yylsp, state); 5359 YYPOPSTACK (1); 5360 } 5361#ifndef yyoverflow 5362 if (yyss != yyssa) 5363 YYSTACK_FREE (yyss); 5364#endif 5365#if YYERROR_VERBOSE 5366 if (yymsg != yymsgbuf) 5367 YYSTACK_FREE (yymsg); 5368#endif 5369 /* Make sure YYID is used. */ 5370 return YYID (yyresult); 5371} 5372 5373 5374 5375/* Line 2067 of yacc.c */ 5376#line 2235 "src/src/mesa/program/program_parse.y" 5377 5378 5379void 5380asm_instruction_set_operands(struct asm_instruction *inst, 5381 const struct prog_dst_register *dst, 5382 const struct asm_src_register *src0, 5383 const struct asm_src_register *src1, 5384 const struct asm_src_register *src2) 5385{ 5386 /* In the core ARB extensions only the KIL instruction doesn't have a 5387 * destination register. 5388 */ 5389 if (dst == NULL) { 5390 init_dst_reg(& inst->Base.DstReg); 5391 } else { 5392 inst->Base.DstReg = *dst; 5393 } 5394 5395 /* The only instruction that doesn't have any source registers is the 5396 * condition-code based KIL instruction added by NV_fragment_program_option. 5397 */ 5398 if (src0 != NULL) { 5399 inst->Base.SrcReg[0] = src0->Base; 5400 inst->SrcReg[0] = *src0; 5401 } else { 5402 init_src_reg(& inst->SrcReg[0]); 5403 } 5404 5405 if (src1 != NULL) { 5406 inst->Base.SrcReg[1] = src1->Base; 5407 inst->SrcReg[1] = *src1; 5408 } else { 5409 init_src_reg(& inst->SrcReg[1]); 5410 } 5411 5412 if (src2 != NULL) { 5413 inst->Base.SrcReg[2] = src2->Base; 5414 inst->SrcReg[2] = *src2; 5415 } else { 5416 init_src_reg(& inst->SrcReg[2]); 5417 } 5418} 5419 5420 5421struct asm_instruction * 5422asm_instruction_ctor(gl_inst_opcode op, 5423 const struct prog_dst_register *dst, 5424 const struct asm_src_register *src0, 5425 const struct asm_src_register *src1, 5426 const struct asm_src_register *src2) 5427{ 5428 struct asm_instruction *inst = CALLOC_STRUCT(asm_instruction); 5429 5430 if (inst) { 5431 _mesa_init_instructions(& inst->Base, 1); 5432 inst->Base.Opcode = op; 5433 5434 asm_instruction_set_operands(inst, dst, src0, src1, src2); 5435 } 5436 5437 return inst; 5438} 5439 5440 5441struct asm_instruction * 5442asm_instruction_copy_ctor(const struct prog_instruction *base, 5443 const struct prog_dst_register *dst, 5444 const struct asm_src_register *src0, 5445 const struct asm_src_register *src1, 5446 const struct asm_src_register *src2) 5447{ 5448 struct asm_instruction *inst = CALLOC_STRUCT(asm_instruction); 5449 5450 if (inst) { 5451 _mesa_init_instructions(& inst->Base, 1); 5452 inst->Base.Opcode = base->Opcode; 5453 inst->Base.CondUpdate = base->CondUpdate; 5454 inst->Base.CondDst = base->CondDst; 5455 inst->Base.SaturateMode = base->SaturateMode; 5456 inst->Base.Precision = base->Precision; 5457 5458 asm_instruction_set_operands(inst, dst, src0, src1, src2); 5459 } 5460 5461 return inst; 5462} 5463 5464 5465void 5466init_dst_reg(struct prog_dst_register *r) 5467{ 5468 memset(r, 0, sizeof(*r)); 5469 r->File = PROGRAM_UNDEFINED; 5470 r->WriteMask = WRITEMASK_XYZW; 5471 r->CondMask = COND_TR; 5472 r->CondSwizzle = SWIZZLE_NOOP; 5473} 5474 5475 5476/** Like init_dst_reg() but set the File and Index fields. */ 5477void 5478set_dst_reg(struct prog_dst_register *r, gl_register_file file, GLint index) 5479{ 5480 const GLint maxIndex = 1 << INST_INDEX_BITS; 5481 const GLint minIndex = 0; 5482 ASSERT(index >= minIndex); 5483 (void) minIndex; 5484 ASSERT(index <= maxIndex); 5485 (void) maxIndex; 5486 ASSERT(file == PROGRAM_TEMPORARY || 5487 file == PROGRAM_ADDRESS || 5488 file == PROGRAM_OUTPUT); 5489 memset(r, 0, sizeof(*r)); 5490 r->File = file; 5491 r->Index = index; 5492 r->WriteMask = WRITEMASK_XYZW; 5493 r->CondMask = COND_TR; 5494 r->CondSwizzle = SWIZZLE_NOOP; 5495} 5496 5497 5498void 5499init_src_reg(struct asm_src_register *r) 5500{ 5501 memset(r, 0, sizeof(*r)); 5502 r->Base.File = PROGRAM_UNDEFINED; 5503 r->Base.Swizzle = SWIZZLE_NOOP; 5504 r->Symbol = NULL; 5505} 5506 5507 5508/** Like init_src_reg() but set the File and Index fields. 5509 * \return GL_TRUE if a valid src register, GL_FALSE otherwise 5510 */ 5511void 5512set_src_reg(struct asm_src_register *r, gl_register_file file, GLint index) 5513{ 5514 set_src_reg_swz(r, file, index, SWIZZLE_XYZW); 5515} 5516 5517 5518void 5519set_src_reg_swz(struct asm_src_register *r, gl_register_file file, GLint index, 5520 GLuint swizzle) 5521{ 5522 const GLint maxIndex = (1 << INST_INDEX_BITS) - 1; 5523 const GLint minIndex = -(1 << INST_INDEX_BITS); 5524 ASSERT(file < PROGRAM_FILE_MAX); 5525 ASSERT(index >= minIndex); 5526 (void) minIndex; 5527 ASSERT(index <= maxIndex); 5528 (void) maxIndex; 5529 memset(r, 0, sizeof(*r)); 5530 r->Base.File = file; 5531 r->Base.Index = index; 5532 r->Base.Swizzle = swizzle; 5533 r->Symbol = NULL; 5534} 5535 5536 5537/** 5538 * Validate the set of inputs used by a program 5539 * 5540 * Validates that legal sets of inputs are used by the program. In this case 5541 * "used" included both reading the input or binding the input to a name using 5542 * the \c ATTRIB command. 5543 * 5544 * \return 5545 * \c TRUE if the combination of inputs used is valid, \c FALSE otherwise. 5546 */ 5547int 5548validate_inputs(struct YYLTYPE *locp, struct asm_parser_state *state) 5549{ 5550 const GLbitfield64 inputs = state->prog->InputsRead | state->InputsBound; 5551 5552 if (((inputs & VERT_BIT_FF_ALL) & (inputs >> VERT_ATTRIB_GENERIC0)) != 0) { 5553 yyerror(locp, state, "illegal use of generic attribute and name attribute"); 5554 return 0; 5555 } 5556 5557 return 1; 5558} 5559 5560 5561struct asm_symbol * 5562declare_variable(struct asm_parser_state *state, char *name, enum asm_type t, 5563 struct YYLTYPE *locp) 5564{ 5565 struct asm_symbol *s = NULL; 5566 struct asm_symbol *exist = (struct asm_symbol *) 5567 _mesa_symbol_table_find_symbol(state->st, 0, name); 5568 5569 5570 if (exist != NULL) { 5571 yyerror(locp, state, "redeclared identifier"); 5572 } else { 5573 s = calloc(1, sizeof(struct asm_symbol)); 5574 s->name = name; 5575 s->type = t; 5576 5577 switch (t) { 5578 case at_temp: 5579 if (state->prog->NumTemporaries >= state->limits->MaxTemps) { 5580 yyerror(locp, state, "too many temporaries declared"); 5581 free(s); 5582 return NULL; 5583 } 5584 5585 s->temp_binding = state->prog->NumTemporaries; 5586 state->prog->NumTemporaries++; 5587 break; 5588 5589 case at_address: 5590 if (state->prog->NumAddressRegs >= state->limits->MaxAddressRegs) { 5591 yyerror(locp, state, "too many address registers declared"); 5592 free(s); 5593 return NULL; 5594 } 5595 5596 /* FINISHME: Add support for multiple address registers. 5597 */ 5598 state->prog->NumAddressRegs++; 5599 break; 5600 5601 default: 5602 break; 5603 } 5604 5605 _mesa_symbol_table_add_symbol(state->st, 0, s->name, s); 5606 s->next = state->sym; 5607 state->sym = s; 5608 } 5609 5610 return s; 5611} 5612 5613 5614int add_state_reference(struct gl_program_parameter_list *param_list, 5615 const gl_state_index tokens[STATE_LENGTH]) 5616{ 5617 const GLuint size = 4; /* XXX fix */ 5618 char *name; 5619 GLint index; 5620 5621 name = _mesa_program_state_string(tokens); 5622 index = _mesa_add_parameter(param_list, PROGRAM_STATE_VAR, name, 5623 size, GL_NONE, NULL, tokens, 0x0); 5624 param_list->StateFlags |= _mesa_program_state_flags(tokens); 5625 5626 /* free name string here since we duplicated it in add_parameter() */ 5627 free(name); 5628 5629 return index; 5630} 5631 5632 5633int 5634initialize_symbol_from_state(struct gl_program *prog, 5635 struct asm_symbol *param_var, 5636 const gl_state_index tokens[STATE_LENGTH]) 5637{ 5638 int idx = -1; 5639 gl_state_index state_tokens[STATE_LENGTH]; 5640 5641 5642 memcpy(state_tokens, tokens, sizeof(state_tokens)); 5643 5644 param_var->type = at_param; 5645 param_var->param_binding_type = PROGRAM_STATE_VAR; 5646 5647 /* If we are adding a STATE_MATRIX that has multiple rows, we need to 5648 * unroll it and call add_state_reference() for each row 5649 */ 5650 if ((state_tokens[0] == STATE_MODELVIEW_MATRIX || 5651 state_tokens[0] == STATE_PROJECTION_MATRIX || 5652 state_tokens[0] == STATE_MVP_MATRIX || 5653 state_tokens[0] == STATE_TEXTURE_MATRIX || 5654 state_tokens[0] == STATE_PROGRAM_MATRIX) 5655 && (state_tokens[2] != state_tokens[3])) { 5656 int row; 5657 const int first_row = state_tokens[2]; 5658 const int last_row = state_tokens[3]; 5659 5660 for (row = first_row; row <= last_row; row++) { 5661 state_tokens[2] = state_tokens[3] = row; 5662 5663 idx = add_state_reference(prog->Parameters, state_tokens); 5664 if (param_var->param_binding_begin == ~0U) { 5665 param_var->param_binding_begin = idx; 5666 param_var->param_binding_swizzle = SWIZZLE_XYZW; 5667 } 5668 5669 param_var->param_binding_length++; 5670 } 5671 } 5672 else { 5673 idx = add_state_reference(prog->Parameters, state_tokens); 5674 if (param_var->param_binding_begin == ~0U) { 5675 param_var->param_binding_begin = idx; 5676 param_var->param_binding_swizzle = SWIZZLE_XYZW; 5677 } 5678 param_var->param_binding_length++; 5679 } 5680 5681 return idx; 5682} 5683 5684 5685int 5686initialize_symbol_from_param(struct gl_program *prog, 5687 struct asm_symbol *param_var, 5688 const gl_state_index tokens[STATE_LENGTH]) 5689{ 5690 int idx = -1; 5691 gl_state_index state_tokens[STATE_LENGTH]; 5692 5693 5694 memcpy(state_tokens, tokens, sizeof(state_tokens)); 5695 5696 assert((state_tokens[0] == STATE_VERTEX_PROGRAM) 5697 || (state_tokens[0] == STATE_FRAGMENT_PROGRAM)); 5698 assert((state_tokens[1] == STATE_ENV) 5699 || (state_tokens[1] == STATE_LOCAL)); 5700 5701 /* 5702 * The param type is STATE_VAR. The program parameter entry will 5703 * effectively be a pointer into the LOCAL or ENV parameter array. 5704 */ 5705 param_var->type = at_param; 5706 param_var->param_binding_type = PROGRAM_STATE_VAR; 5707 5708 /* If we are adding a STATE_ENV or STATE_LOCAL that has multiple elements, 5709 * we need to unroll it and call add_state_reference() for each row 5710 */ 5711 if (state_tokens[2] != state_tokens[3]) { 5712 int row; 5713 const int first_row = state_tokens[2]; 5714 const int last_row = state_tokens[3]; 5715 5716 for (row = first_row; row <= last_row; row++) { 5717 state_tokens[2] = state_tokens[3] = row; 5718 5719 idx = add_state_reference(prog->Parameters, state_tokens); 5720 if (param_var->param_binding_begin == ~0U) { 5721 param_var->param_binding_begin = idx; 5722 param_var->param_binding_swizzle = SWIZZLE_XYZW; 5723 } 5724 param_var->param_binding_length++; 5725 } 5726 } 5727 else { 5728 idx = add_state_reference(prog->Parameters, state_tokens); 5729 if (param_var->param_binding_begin == ~0U) { 5730 param_var->param_binding_begin = idx; 5731 param_var->param_binding_swizzle = SWIZZLE_XYZW; 5732 } 5733 param_var->param_binding_length++; 5734 } 5735 5736 return idx; 5737} 5738 5739 5740/** 5741 * Put a float/vector constant/literal into the parameter list. 5742 * \param param_var returns info about the parameter/constant's location, 5743 * binding, type, etc. 5744 * \param vec the vector/constant to add 5745 * \param allowSwizzle if true, try to consolidate constants which only differ 5746 * by a swizzle. We don't want to do this when building 5747 * arrays of constants that may be indexed indirectly. 5748 * \return index of the constant in the parameter list. 5749 */ 5750int 5751initialize_symbol_from_const(struct gl_program *prog, 5752 struct asm_symbol *param_var, 5753 const struct asm_vector *vec, 5754 GLboolean allowSwizzle) 5755{ 5756 unsigned swizzle; 5757 const int idx = _mesa_add_unnamed_constant(prog->Parameters, 5758 vec->data, vec->count, 5759 allowSwizzle ? &swizzle : NULL); 5760 5761 param_var->type = at_param; 5762 param_var->param_binding_type = PROGRAM_CONSTANT; 5763 5764 if (param_var->param_binding_begin == ~0U) { 5765 param_var->param_binding_begin = idx; 5766 param_var->param_binding_swizzle = allowSwizzle ? swizzle : SWIZZLE_XYZW; 5767 } 5768 param_var->param_binding_length++; 5769 5770 return idx; 5771} 5772 5773 5774char * 5775make_error_string(const char *fmt, ...) 5776{ 5777 int length; 5778 char *str; 5779 va_list args; 5780 5781 5782 /* Call vsnprintf once to determine how large the final string is. Call it 5783 * again to do the actual formatting. from the vsnprintf manual page: 5784 * 5785 * Upon successful return, these functions return the number of 5786 * characters printed (not including the trailing '\0' used to end 5787 * output to strings). 5788 */ 5789 va_start(args, fmt); 5790 length = 1 + vsnprintf(NULL, 0, fmt, args); 5791 va_end(args); 5792 5793 str = malloc(length); 5794 if (str) { 5795 va_start(args, fmt); 5796 vsnprintf(str, length, fmt, args); 5797 va_end(args); 5798 } 5799 5800 return str; 5801} 5802 5803 5804void 5805yyerror(YYLTYPE *locp, struct asm_parser_state *state, const char *s) 5806{ 5807 char *err_str; 5808 5809 5810 err_str = make_error_string("glProgramStringARB(%s)\n", s); 5811 if (err_str) { 5812 _mesa_error(state->ctx, GL_INVALID_OPERATION, "%s", err_str); 5813 free(err_str); 5814 } 5815 5816 err_str = make_error_string("line %u, char %u: error: %s\n", 5817 locp->first_line, locp->first_column, s); 5818 _mesa_set_program_error(state->ctx, locp->position, err_str); 5819 5820 if (err_str) { 5821 free(err_str); 5822 } 5823} 5824 5825 5826GLboolean 5827_mesa_parse_arb_program(struct gl_context *ctx, GLenum target, const GLubyte *str, 5828 GLsizei len, struct asm_parser_state *state) 5829{ 5830 struct asm_instruction *inst; 5831 unsigned i; 5832 GLubyte *strz; 5833 GLboolean result = GL_FALSE; 5834 void *temp; 5835 struct asm_symbol *sym; 5836 5837 state->ctx = ctx; 5838 state->prog->Target = target; 5839 state->prog->Parameters = _mesa_new_parameter_list(); 5840 5841 /* Make a copy of the program string and force it to be NUL-terminated. 5842 */ 5843 strz = (GLubyte *) malloc(len + 1); 5844 if (strz == NULL) { 5845 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glProgramStringARB"); 5846 return GL_FALSE; 5847 } 5848 memcpy (strz, str, len); 5849 strz[len] = '\0'; 5850 5851 state->prog->String = strz; 5852 5853 state->st = _mesa_symbol_table_ctor(); 5854 5855 state->limits = (target == GL_VERTEX_PROGRAM_ARB) 5856 ? & ctx->Const.VertexProgram 5857 : & ctx->Const.FragmentProgram; 5858 5859 state->MaxTextureImageUnits = ctx->Const.MaxTextureImageUnits; 5860 state->MaxTextureCoordUnits = ctx->Const.MaxTextureCoordUnits; 5861 state->MaxTextureUnits = ctx->Const.MaxTextureUnits; 5862 state->MaxClipPlanes = ctx->Const.MaxClipPlanes; 5863 state->MaxLights = ctx->Const.MaxLights; 5864 state->MaxProgramMatrices = ctx->Const.MaxProgramMatrices; 5865 state->MaxDrawBuffers = ctx->Const.MaxDrawBuffers; 5866 5867 state->state_param_enum = (target == GL_VERTEX_PROGRAM_ARB) 5868 ? STATE_VERTEX_PROGRAM : STATE_FRAGMENT_PROGRAM; 5869 5870 _mesa_set_program_error(ctx, -1, NULL); 5871 5872 _mesa_program_lexer_ctor(& state->scanner, state, (const char *) str, len); 5873 yyparse(state); 5874 _mesa_program_lexer_dtor(state->scanner); 5875 5876 5877 if (ctx->Program.ErrorPos != -1) { 5878 goto error; 5879 } 5880 5881 if (! _mesa_layout_parameters(state)) { 5882 struct YYLTYPE loc; 5883 5884 loc.first_line = 0; 5885 loc.first_column = 0; 5886 loc.position = len; 5887 5888 yyerror(& loc, state, "invalid PARAM usage"); 5889 goto error; 5890 } 5891 5892 5893 5894 /* Add one instruction to store the "END" instruction. 5895 */ 5896 state->prog->Instructions = 5897 _mesa_alloc_instructions(state->prog->NumInstructions + 1); 5898 inst = state->inst_head; 5899 for (i = 0; i < state->prog->NumInstructions; i++) { 5900 struct asm_instruction *const temp = inst->next; 5901 5902 state->prog->Instructions[i] = inst->Base; 5903 inst = temp; 5904 } 5905 5906 /* Finally, tag on an OPCODE_END instruction */ 5907 { 5908 const GLuint numInst = state->prog->NumInstructions; 5909 _mesa_init_instructions(state->prog->Instructions + numInst, 1); 5910 state->prog->Instructions[numInst].Opcode = OPCODE_END; 5911 } 5912 state->prog->NumInstructions++; 5913 5914 state->prog->NumParameters = state->prog->Parameters->NumParameters; 5915 state->prog->NumAttributes = _mesa_bitcount_64(state->prog->InputsRead); 5916 5917 /* 5918 * Initialize native counts to logical counts. The device driver may 5919 * change them if program is translated into a hardware program. 5920 */ 5921 state->prog->NumNativeInstructions = state->prog->NumInstructions; 5922 state->prog->NumNativeTemporaries = state->prog->NumTemporaries; 5923 state->prog->NumNativeParameters = state->prog->NumParameters; 5924 state->prog->NumNativeAttributes = state->prog->NumAttributes; 5925 state->prog->NumNativeAddressRegs = state->prog->NumAddressRegs; 5926 5927 result = GL_TRUE; 5928 5929error: 5930 for (inst = state->inst_head; inst != NULL; inst = temp) { 5931 temp = inst->next; 5932 free(inst); 5933 } 5934 5935 state->inst_head = NULL; 5936 state->inst_tail = NULL; 5937 5938 for (sym = state->sym; sym != NULL; sym = temp) { 5939 temp = sym->next; 5940 5941 free((void *) sym->name); 5942 free(sym); 5943 } 5944 state->sym = NULL; 5945 5946 _mesa_symbol_table_dtor(state->st); 5947 state->st = NULL; 5948 5949 return result; 5950} 5951 5952