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