From db1555d865bb1fbddadabe017f99010137a07a0f Mon Sep 17 00:00:00 2001 From: Adrien Destugues Date: Tue, 31 Jan 2017 22:58:35 +0100 Subject: [PATCH] mesa: fix build with Bison 3.x --- sys-libs/mesa/mesa-7.9.2.recipe | 3 +- sys-libs/mesa/patches/mesa-7.9.2.patchset | 5835 ++++++++++++++++++++- 2 files changed, 5835 insertions(+), 3 deletions(-) diff --git a/sys-libs/mesa/mesa-7.9.2.recipe b/sys-libs/mesa/mesa-7.9.2.recipe index 2815f285a..90fe2b284 100644 --- a/sys-libs/mesa/mesa-7.9.2.recipe +++ b/sys-libs/mesa/mesa-7.9.2.recipe @@ -6,7 +6,7 @@ providing 3D rendering to Haiku applications." HOMEPAGE="http://www.mesa3d.org/" COPYRIGHT="1999-2013 Brian Paul" LICENSE="MIT" -REVISION="10" +REVISION="11" SOURCE_URI="https://github.com/haiku/mesa_legacy/archive/7.9.2-9.tar.gz" SOURCE_DIR="mesa_legacy-7.9.2-9" SOURCE_FILENAME="mesa_legacy-7.9.2-9.tar.gz" @@ -38,6 +38,7 @@ BUILD_REQUIRES=" BUILD_PREREQUIRES=" libxml2_python cmd:bison + cmd:cmp cmd:find cmd:flex cmd:gcc$secondaryArchSuffix diff --git a/sys-libs/mesa/patches/mesa-7.9.2.patchset b/sys-libs/mesa/patches/mesa-7.9.2.patchset index da19330a5..02fb74652 100644 --- a/sys-libs/mesa/patches/mesa-7.9.2.patchset +++ b/sys-libs/mesa/patches/mesa-7.9.2.patchset @@ -1,4 +1,4 @@ -From 6cca2462d98c1da580faeaae5e33c99daf1a6c82 Mon Sep 17 00:00:00 2001 +From 5c48eaf605605a1282782d3d6723097c4f920a51 Mon Sep 17 00:00:00 2001 From: Adrien Destugues Date: Fri, 7 Nov 2014 09:42:21 +0100 Subject: libGL: link against libbe @@ -20,5 +20,5836 @@ index 9d7d301..8195813 100644 $(GL_LIB_DEPS) $(GLAPI_LIB) $(OBJECTS) $(GLU_LIB) -- -1.8.3.4 +2.7.0 + + +From dd18a215caad3ed86c7740c470bf1817f3d3590a Mon Sep 17 00:00:00 2001 +From: Adrien Destugues +Date: Tue, 31 Jan 2017 22:42:25 +0100 +Subject: Make compatible with bison 3.x. + +Backport a patch from Mesa 9.2 days. + +diff --git a/src/glsl/glcpp/glcpp-parse.h b/src/glsl/glcpp/glcpp-parse.h +deleted file mode 100644 +index 4055685..0000000 +--- a/src/glsl/glcpp/glcpp-parse.h ++++ /dev/null +@@ -1,100 +0,0 @@ +-/* A Bison parser, made by GNU Bison 2.4.3. */ +- +-/* Skeleton interface for Bison's Yacc-like parsers in C +- +- Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006, +- 2009, 2010 Free Software Foundation, Inc. +- +- This program is free software: you can redistribute it and/or modify +- it under the terms of the GNU General Public License as published by +- the Free Software Foundation, either version 3 of the License, or +- (at your option) any later version. +- +- This program is distributed in the hope that it will be useful, +- but WITHOUT ANY WARRANTY; without even the implied warranty of +- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +- GNU General Public License for more details. +- +- You should have received a copy of the GNU General Public License +- along with this program. If not, see . */ +- +-/* As a special exception, you may create a larger work that contains +- part or all of the Bison parser skeleton and distribute that work +- under terms of your choice, so long as that work isn't itself a +- parser generator using the skeleton or a modified version thereof +- as a parser skeleton. Alternatively, if you modify or redistribute +- the parser skeleton itself, you may (at your option) remove this +- special exception, which will cause the skeleton and the resulting +- Bison output files to be licensed under the GNU General Public +- License without this special exception. +- +- This special exception was added by the Free Software Foundation in +- version 2.2 of Bison. */ +- +- +-/* Tokens. */ +-#ifndef YYTOKENTYPE +-# define YYTOKENTYPE +- /* Put the tokens into the symbol table, so that GDB and other debuggers +- know about them. */ +- enum yytokentype { +- COMMA_FINAL = 258, +- DEFINED = 259, +- ELIF_EXPANDED = 260, +- HASH = 261, +- HASH_DEFINE_FUNC = 262, +- HASH_DEFINE_OBJ = 263, +- HASH_ELIF = 264, +- HASH_ELSE = 265, +- HASH_ENDIF = 266, +- HASH_IF = 267, +- HASH_IFDEF = 268, +- HASH_IFNDEF = 269, +- HASH_UNDEF = 270, +- HASH_VERSION = 271, +- IDENTIFIER = 272, +- IF_EXPANDED = 273, +- INTEGER = 274, +- INTEGER_STRING = 275, +- NEWLINE = 276, +- OTHER = 277, +- PLACEHOLDER = 278, +- SPACE = 279, +- PASTE = 280, +- OR = 281, +- AND = 282, +- NOT_EQUAL = 283, +- EQUAL = 284, +- GREATER_OR_EQUAL = 285, +- LESS_OR_EQUAL = 286, +- RIGHT_SHIFT = 287, +- LEFT_SHIFT = 288, +- UNARY = 289 +- }; +-#endif +- +- +- +-#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED +- +-# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +-# define YYSTYPE_IS_DECLARED 1 +-#endif +- +- +- +-#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED +-typedef struct YYLTYPE +-{ +- int first_line; +- int first_column; +- int last_line; +- int last_column; +-} YYLTYPE; +-# define yyltype YYLTYPE /* obsolescent; will be withdrawn */ +-# define YYLTYPE_IS_DECLARED 1 +-# define YYLTYPE_IS_TRIVIAL 1 +-#endif +- +- +- +diff --git a/src/glsl/glsl_lexer.lpp b/src/glsl/glsl_lexer.lpp +index 02d4528..f09ba67 100644 +--- a/src/glsl/glsl_lexer.lpp ++++ b/src/glsl/glsl_lexer.lpp +@@ -74,7 +74,7 @@ static int classify_identifier(struct _mesa_glsl_parse_state *, const char *); + %option bison-bridge bison-locations reentrant noyywrap + %option nounput noyy_top_state + %option never-interactive +-%option prefix="_mesa_glsl_" ++%option prefix="_mesa_glsl_lexer_" + %option extra-type="struct _mesa_glsl_parse_state *" + + %x PP PRAGMA +@@ -415,3 +415,10 @@ _mesa_glsl_lexer_dtor(struct _mesa_glsl_parse_state *state) + { + yylex_destroy(state->scanner); + } ++ ++int ++_mesa_glsl_lex(YYSTYPE *a, YYLTYPE *b, void *c) ++{ ++ struct _mesa_glsl_parse_state* s = (_mesa_glsl_parse_state*)c; ++ return _mesa_glsl_lexer_lex(a, b, s->scanner); ++} +diff --git a/src/glsl/glsl_parser.cpp b/src/glsl/glsl_parser.cpp +deleted file mode 100644 +index 68736dc..0000000 +--- a/src/glsl/glsl_parser.cpp ++++ /dev/null +@@ -1,5354 +0,0 @@ +-/* A Bison parser, made by GNU Bison 2.4.3. */ +- +-/* Skeleton implementation for Bison's Yacc-like parsers in C +- +- Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006, +- 2009, 2010 Free Software Foundation, Inc. +- +- This program is free software: you can redistribute it and/or modify +- it under the terms of the GNU General Public License as published by +- the Free Software Foundation, either version 3 of the License, or +- (at your option) any later version. +- +- This program is distributed in the hope that it will be useful, +- but WITHOUT ANY WARRANTY; without even the implied warranty of +- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +- GNU General Public License for more details. +- +- You should have received a copy of the GNU General Public License +- along with this program. If not, see . */ +- +-/* As a special exception, you may create a larger work that contains +- part or all of the Bison parser skeleton and distribute that work +- under terms of your choice, so long as that work isn't itself a +- parser generator using the skeleton or a modified version thereof +- as a parser skeleton. Alternatively, if you modify or redistribute +- the parser skeleton itself, you may (at your option) remove this +- special exception, which will cause the skeleton and the resulting +- Bison output files to be licensed under the GNU General Public +- License without this special exception. +- +- This special exception was added by the Free Software Foundation in +- version 2.2 of Bison. */ +- +-/* C LALR(1) parser skeleton written by Richard Stallman, by +- simplifying the original so-called "semantic" parser. */ +- +-/* All symbols defined below should begin with yy or YY, to avoid +- infringing on user name space. This should be done even for local +- variables, as they might otherwise be expanded by user macros. +- There are some unavoidable exceptions within include files to +- define necessary library symbols; they are noted "INFRINGES ON +- USER NAME SPACE" below. */ +- +-/* Identify Bison output. */ +-#define YYBISON 1 +- +-/* Bison version. */ +-#define YYBISON_VERSION "2.4.3" +- +-/* Skeleton name. */ +-#define YYSKELETON_NAME "yacc.c" +- +-/* Pure parsers. */ +-#define YYPURE 1 +- +-/* Push parsers. */ +-#define YYPUSH 0 +- +-/* Pull parsers. */ +-#define YYPULL 1 +- +-/* Using locations. */ +-#define YYLSP_NEEDED 1 +- +-/* Substitute the variable and function names. */ +-#define yyparse _mesa_glsl_parse +-#define yylex _mesa_glsl_lex +-#define yyerror _mesa_glsl_error +-#define yylval _mesa_glsl_lval +-#define yychar _mesa_glsl_char +-#define yydebug _mesa_glsl_debug +-#define yynerrs _mesa_glsl_nerrs +-#define yylloc _mesa_glsl_lloc +- +-/* Copy the first part of user declarations. */ +- +-/* Line 189 of yacc.c */ +-#line 1 "glsl_parser.ypp" +- +-/* +- * Copyright © 2008, 2009 Intel Corporation +- * +- * Permission is hereby granted, free of charge, to any person obtaining a +- * copy of this software and associated documentation files (the "Software"), +- * to deal in the Software without restriction, including without limitation +- * the rights to use, copy, modify, merge, publish, distribute, sublicense, +- * and/or sell copies of the Software, and to permit persons to whom the +- * Software is furnished to do so, subject to the following conditions: +- * +- * The above copyright notice and this permission notice (including the next +- * paragraph) shall be included in all copies or substantial portions of the +- * Software. +- * +- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +- * DEALINGS IN THE SOFTWARE. +- */ +-#include +-#include +-#include +-#include +- +-#include "ast.h" +-#include "glsl_parser_extras.h" +-#include "glsl_types.h" +- +-#define YYLEX_PARAM state->scanner +- +- +- +-/* Line 189 of yacc.c */ +-#line 117 "glsl_parser.cpp" +- +-/* Enabling traces. */ +-#ifndef YYDEBUG +-# define YYDEBUG 0 +-#endif +- +-/* Enabling verbose error messages. */ +-#ifdef YYERROR_VERBOSE +-# undef YYERROR_VERBOSE +-# define YYERROR_VERBOSE 1 +-#else +-# define YYERROR_VERBOSE 1 +-#endif +- +-/* Enabling the token table. */ +-#ifndef YYTOKEN_TABLE +-# define YYTOKEN_TABLE 0 +-#endif +- +- +-/* Tokens. */ +-#ifndef YYTOKENTYPE +-# define YYTOKENTYPE +- /* Put the tokens into the symbol table, so that GDB and other debuggers +- know about them. */ +- enum yytokentype { +- ATTRIBUTE = 258, +- CONST_TOK = 259, +- BOOL_TOK = 260, +- FLOAT_TOK = 261, +- INT_TOK = 262, +- UINT_TOK = 263, +- BREAK = 264, +- CONTINUE = 265, +- DO = 266, +- ELSE = 267, +- FOR = 268, +- IF = 269, +- DISCARD = 270, +- RETURN = 271, +- SWITCH = 272, +- CASE = 273, +- DEFAULT = 274, +- BVEC2 = 275, +- BVEC3 = 276, +- BVEC4 = 277, +- IVEC2 = 278, +- IVEC3 = 279, +- IVEC4 = 280, +- UVEC2 = 281, +- UVEC3 = 282, +- UVEC4 = 283, +- VEC2 = 284, +- VEC3 = 285, +- VEC4 = 286, +- CENTROID = 287, +- IN_TOK = 288, +- OUT_TOK = 289, +- INOUT_TOK = 290, +- UNIFORM = 291, +- VARYING = 292, +- NOPERSPECTIVE = 293, +- FLAT = 294, +- SMOOTH = 295, +- MAT2X2 = 296, +- MAT2X3 = 297, +- MAT2X4 = 298, +- MAT3X2 = 299, +- MAT3X3 = 300, +- MAT3X4 = 301, +- MAT4X2 = 302, +- MAT4X3 = 303, +- MAT4X4 = 304, +- SAMPLER1D = 305, +- SAMPLER2D = 306, +- SAMPLER3D = 307, +- SAMPLERCUBE = 308, +- SAMPLER1DSHADOW = 309, +- SAMPLER2DSHADOW = 310, +- SAMPLERCUBESHADOW = 311, +- SAMPLER1DARRAY = 312, +- SAMPLER2DARRAY = 313, +- SAMPLER1DARRAYSHADOW = 314, +- SAMPLER2DARRAYSHADOW = 315, +- ISAMPLER1D = 316, +- ISAMPLER2D = 317, +- ISAMPLER3D = 318, +- ISAMPLERCUBE = 319, +- ISAMPLER1DARRAY = 320, +- ISAMPLER2DARRAY = 321, +- USAMPLER1D = 322, +- USAMPLER2D = 323, +- USAMPLER3D = 324, +- USAMPLERCUBE = 325, +- USAMPLER1DARRAY = 326, +- USAMPLER2DARRAY = 327, +- STRUCT = 328, +- VOID_TOK = 329, +- WHILE = 330, +- IDENTIFIER = 331, +- TYPE_IDENTIFIER = 332, +- NEW_IDENTIFIER = 333, +- FLOATCONSTANT = 334, +- INTCONSTANT = 335, +- UINTCONSTANT = 336, +- BOOLCONSTANT = 337, +- FIELD_SELECTION = 338, +- LEFT_OP = 339, +- RIGHT_OP = 340, +- INC_OP = 341, +- DEC_OP = 342, +- LE_OP = 343, +- GE_OP = 344, +- EQ_OP = 345, +- NE_OP = 346, +- AND_OP = 347, +- OR_OP = 348, +- XOR_OP = 349, +- MUL_ASSIGN = 350, +- DIV_ASSIGN = 351, +- ADD_ASSIGN = 352, +- MOD_ASSIGN = 353, +- LEFT_ASSIGN = 354, +- RIGHT_ASSIGN = 355, +- AND_ASSIGN = 356, +- XOR_ASSIGN = 357, +- OR_ASSIGN = 358, +- SUB_ASSIGN = 359, +- INVARIANT = 360, +- LOWP = 361, +- MEDIUMP = 362, +- HIGHP = 363, +- SUPERP = 364, +- PRECISION = 365, +- VERSION = 366, +- EXTENSION = 367, +- LINE = 368, +- COLON = 369, +- EOL = 370, +- INTERFACE = 371, +- OUTPUT = 372, +- PRAGMA_DEBUG_ON = 373, +- PRAGMA_DEBUG_OFF = 374, +- PRAGMA_OPTIMIZE_ON = 375, +- PRAGMA_OPTIMIZE_OFF = 376, +- PRAGMA_INVARIANT_ALL = 377, +- LAYOUT_TOK = 378, +- ASM = 379, +- CLASS = 380, +- UNION = 381, +- ENUM = 382, +- TYPEDEF = 383, +- TEMPLATE = 384, +- THIS = 385, +- PACKED_TOK = 386, +- GOTO = 387, +- INLINE_TOK = 388, +- NOINLINE = 389, +- VOLATILE = 390, +- PUBLIC_TOK = 391, +- STATIC = 392, +- EXTERN = 393, +- EXTERNAL = 394, +- LONG_TOK = 395, +- SHORT_TOK = 396, +- DOUBLE_TOK = 397, +- HALF = 398, +- FIXED_TOK = 399, +- UNSIGNED = 400, +- INPUT_TOK = 401, +- OUPTUT = 402, +- HVEC2 = 403, +- HVEC3 = 404, +- HVEC4 = 405, +- DVEC2 = 406, +- DVEC3 = 407, +- DVEC4 = 408, +- FVEC2 = 409, +- FVEC3 = 410, +- FVEC4 = 411, +- SAMPLER2DRECT = 412, +- SAMPLER3DRECT = 413, +- SAMPLER2DRECTSHADOW = 414, +- SIZEOF = 415, +- CAST = 416, +- NAMESPACE = 417, +- USING = 418, +- ERROR_TOK = 419, +- COMMON = 420, +- PARTITION = 421, +- ACTIVE = 422, +- SAMPLERBUFFER = 423, +- FILTER = 424, +- IMAGE1D = 425, +- IMAGE2D = 426, +- IMAGE3D = 427, +- IMAGECUBE = 428, +- IMAGE1DARRAY = 429, +- IMAGE2DARRAY = 430, +- IIMAGE1D = 431, +- IIMAGE2D = 432, +- IIMAGE3D = 433, +- IIMAGECUBE = 434, +- IIMAGE1DARRAY = 435, +- IIMAGE2DARRAY = 436, +- UIMAGE1D = 437, +- UIMAGE2D = 438, +- UIMAGE3D = 439, +- UIMAGECUBE = 440, +- UIMAGE1DARRAY = 441, +- UIMAGE2DARRAY = 442, +- IMAGE1DSHADOW = 443, +- IMAGE2DSHADOW = 444, +- IMAGEBUFFER = 445, +- IIMAGEBUFFER = 446, +- UIMAGEBUFFER = 447, +- ROW_MAJOR = 448 +- }; +-#endif +- +- +- +-#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED +-typedef union YYSTYPE +-{ +- +-/* Line 214 of yacc.c */ +-#line 52 "glsl_parser.ypp" +- +- int n; +- float real; +- char *identifier; +- +- union { +- struct ast_type_qualifier q; +- unsigned i; +- } type_qualifier; +- +- ast_node *node; +- ast_type_specifier *type_specifier; +- ast_fully_specified_type *fully_specified_type; +- ast_function *function; +- ast_parameter_declarator *parameter_declarator; +- ast_function_definition *function_definition; +- ast_compound_statement *compound_statement; +- ast_expression *expression; +- ast_declarator_list *declarator_list; +- ast_struct_specifier *struct_specifier; +- ast_declaration *declaration; +- +- struct { +- ast_node *cond; +- ast_expression *rest; +- } for_rest_statement; +- +- struct { +- ast_node *then_statement; +- ast_node *else_statement; +- } selection_rest_statement; +- +- +- +-/* Line 214 of yacc.c */ +-#line 381 "glsl_parser.cpp" +-} YYSTYPE; +-# define YYSTYPE_IS_TRIVIAL 1 +-# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +-# define YYSTYPE_IS_DECLARED 1 +-#endif +- +-#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED +-typedef struct YYLTYPE +-{ +- int first_line; +- int first_column; +- int last_line; +- int last_column; +-} YYLTYPE; +-# define yyltype YYLTYPE /* obsolescent; will be withdrawn */ +-# define YYLTYPE_IS_DECLARED 1 +-# define YYLTYPE_IS_TRIVIAL 1 +-#endif +- +- +-/* Copy the second part of user declarations. */ +- +- +-/* Line 264 of yacc.c */ +-#line 406 "glsl_parser.cpp" +- +-#ifdef short +-# undef short +-#endif +- +-#ifdef YYTYPE_UINT8 +-typedef YYTYPE_UINT8 yytype_uint8; +-#else +-typedef unsigned char yytype_uint8; +-#endif +- +-#ifdef YYTYPE_INT8 +-typedef YYTYPE_INT8 yytype_int8; +-#elif (defined __STDC__ || defined __C99__FUNC__ \ +- || defined __cplusplus || defined _MSC_VER) +-typedef signed char yytype_int8; +-#else +-typedef short int yytype_int8; +-#endif +- +-#ifdef YYTYPE_UINT16 +-typedef YYTYPE_UINT16 yytype_uint16; +-#else +-typedef unsigned short int yytype_uint16; +-#endif +- +-#ifdef YYTYPE_INT16 +-typedef YYTYPE_INT16 yytype_int16; +-#else +-typedef short int yytype_int16; +-#endif +- +-#ifndef YYSIZE_T +-# ifdef __SIZE_TYPE__ +-# define YYSIZE_T __SIZE_TYPE__ +-# elif defined size_t +-# define YYSIZE_T size_t +-# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ +- || defined __cplusplus || defined _MSC_VER) +-# include /* INFRINGES ON USER NAME SPACE */ +-# define YYSIZE_T size_t +-# else +-# define YYSIZE_T unsigned int +-# endif +-#endif +- +-#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) +- +-#ifndef YY_ +-# if defined YYENABLE_NLS && YYENABLE_NLS +-# if ENABLE_NLS +-# include /* INFRINGES ON USER NAME SPACE */ +-# define YY_(msgid) dgettext ("bison-runtime", msgid) +-# endif +-# endif +-# ifndef YY_ +-# define YY_(msgid) msgid +-# endif +-#endif +- +-/* Suppress unused-variable warnings by "using" E. */ +-#if ! defined lint || defined __GNUC__ +-# define YYUSE(e) ((void) (e)) +-#else +-# define YYUSE(e) /* empty */ +-#endif +- +-/* Identity function, used to suppress warnings about constant conditions. */ +-#ifndef lint +-# define YYID(n) (n) +-#else +-#if (defined __STDC__ || defined __C99__FUNC__ \ +- || defined __cplusplus || defined _MSC_VER) +-static int +-YYID (int yyi) +-#else +-static int +-YYID (yyi) +- int yyi; +-#endif +-{ +- return yyi; +-} +-#endif +- +-#if ! defined yyoverflow || YYERROR_VERBOSE +- +-/* The parser invokes alloca or malloc; define the necessary symbols. */ +- +-# ifdef YYSTACK_USE_ALLOCA +-# if YYSTACK_USE_ALLOCA +-# ifdef __GNUC__ +-# define YYSTACK_ALLOC __builtin_alloca +-# elif defined __BUILTIN_VA_ARG_INCR +-# include /* INFRINGES ON USER NAME SPACE */ +-# elif defined _AIX +-# define YYSTACK_ALLOC __alloca +-# elif defined _MSC_VER +-# include /* INFRINGES ON USER NAME SPACE */ +-# define alloca _alloca +-# else +-# define YYSTACK_ALLOC alloca +-# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ +- || defined __cplusplus || defined _MSC_VER) +-# include /* INFRINGES ON USER NAME SPACE */ +-# ifndef _STDLIB_H +-# define _STDLIB_H 1 +-# endif +-# endif +-# endif +-# endif +-# endif +- +-# ifdef YYSTACK_ALLOC +- /* Pacify GCC's `empty if-body' warning. */ +-# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) +-# ifndef YYSTACK_ALLOC_MAXIMUM +- /* The OS might guarantee only one guard page at the bottom of the stack, +- and a page size can be as small as 4096 bytes. So we cannot safely +- invoke alloca (N) if N exceeds 4096. Use a slightly smaller number +- to allow for a few compiler-allocated temporary stack slots. */ +-# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ +-# endif +-# else +-# define YYSTACK_ALLOC YYMALLOC +-# define YYSTACK_FREE YYFREE +-# ifndef YYSTACK_ALLOC_MAXIMUM +-# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM +-# endif +-# if (defined __cplusplus && ! defined _STDLIB_H \ +- && ! ((defined YYMALLOC || defined malloc) \ +- && (defined YYFREE || defined free))) +-# include /* INFRINGES ON USER NAME SPACE */ +-# ifndef _STDLIB_H +-# define _STDLIB_H 1 +-# endif +-# endif +-# ifndef YYMALLOC +-# define YYMALLOC malloc +-# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ +- || defined __cplusplus || defined _MSC_VER) +-void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ +-# endif +-# endif +-# ifndef YYFREE +-# define YYFREE free +-# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ +- || defined __cplusplus || defined _MSC_VER) +-void free (void *); /* INFRINGES ON USER NAME SPACE */ +-# endif +-# endif +-# endif +-#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ +- +- +-#if (! defined yyoverflow \ +- && (! defined __cplusplus \ +- || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \ +- && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) +- +-/* A type that is properly aligned for any stack member. */ +-union yyalloc +-{ +- yytype_int16 yyss_alloc; +- YYSTYPE yyvs_alloc; +- YYLTYPE yyls_alloc; +-}; +- +-/* The size of the maximum gap between one aligned stack and the next. */ +-# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) +- +-/* The size of an array large to enough to hold all stacks, each with +- N elements. */ +-# define YYSTACK_BYTES(N) \ +- ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \ +- + 2 * YYSTACK_GAP_MAXIMUM) +- +-/* Copy COUNT objects from FROM to TO. The source and destination do +- not overlap. */ +-# ifndef YYCOPY +-# if defined __GNUC__ && 1 < __GNUC__ +-# define YYCOPY(To, From, Count) \ +- __builtin_memcpy (To, From, (Count) * sizeof (*(From))) +-# else +-# define YYCOPY(To, From, Count) \ +- do \ +- { \ +- YYSIZE_T yyi; \ +- for (yyi = 0; yyi < (Count); yyi++) \ +- (To)[yyi] = (From)[yyi]; \ +- } \ +- while (YYID (0)) +-# endif +-# endif +- +-/* Relocate STACK from its old location to the new one. The +- local variables YYSIZE and YYSTACKSIZE give the old and new number of +- elements in the stack, and YYPTR gives the new location of the +- stack. Advance YYPTR to a properly aligned location for the next +- stack. */ +-# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ +- do \ +- { \ +- YYSIZE_T yynewbytes; \ +- YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ +- Stack = &yyptr->Stack_alloc; \ +- yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ +- yyptr += yynewbytes / sizeof (*yyptr); \ +- } \ +- while (YYID (0)) +- +-#endif +- +-/* YYFINAL -- State number of the termination state. */ +-#define YYFINAL 5 +-/* YYLAST -- Last index in YYTABLE. */ +-#define YYLAST 3984 +- +-/* YYNTOKENS -- Number of terminals. */ +-#define YYNTOKENS 218 +-/* YYNNTS -- Number of nonterminals. */ +-#define YYNNTS 94 +-/* YYNRULES -- Number of rules. */ +-#define YYNRULES 287 +-/* YYNRULES -- Number of states. */ +-#define YYNSTATES 430 +- +-/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ +-#define YYUNDEFTOK 2 +-#define YYMAXUTOK 448 +- +-#define YYTRANSLATE(YYX) \ +- ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) +- +-/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +-static const yytype_uint8 yytranslate[] = +-{ +- 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 202, 2, 2, 2, 206, 209, 2, +- 194, 195, 204, 200, 199, 201, 198, 205, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 213, 215, +- 207, 214, 208, 212, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 196, 2, 197, 210, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 216, 211, 217, 203, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +- 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, +- 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, +- 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, +- 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, +- 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, +- 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, +- 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, +- 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, +- 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, +- 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, +- 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, +- 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, +- 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, +- 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, +- 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, +- 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, +- 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, +- 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, +- 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, +- 185, 186, 187, 188, 189, 190, 191, 192, 193 +-}; +- +-#if YYDEBUG +-/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in +- YYRHS. */ +-static const yytype_uint16 yyprhs[] = +-{ +- 0, 0, 3, 4, 9, 10, 14, 17, 20, 23, +- 26, 29, 30, 33, 35, 37, 39, 45, 47, 50, +- 52, 54, 56, 58, 60, 62, 64, 68, 70, 75, +- 77, 81, 84, 87, 89, 91, 93, 97, 100, 103, +- 106, 108, 111, 115, 118, 120, 122, 124, 127, 130, +- 133, 135, 138, 142, 145, 147, 150, 153, 156, 158, +- 160, 162, 164, 166, 170, 174, 178, 180, 184, 188, +- 190, 194, 198, 200, 204, 208, 212, 216, 218, 222, +- 226, 228, 232, 234, 238, 240, 244, 246, 250, 252, +- 256, 258, 262, 264, 270, 272, 276, 278, 280, 282, +- 284, 286, 288, 290, 292, 294, 296, 298, 300, 304, +- 306, 309, 312, 317, 320, 322, 324, 327, 331, 335, +- 338, 344, 348, 351, 355, 358, 359, 361, 363, 365, +- 367, 369, 373, 379, 386, 394, 403, 409, 411, 414, +- 419, 425, 432, 440, 445, 448, 450, 453, 454, 456, +- 461, 463, 467, 469, 471, 473, 475, 477, 479, 482, +- 485, 487, 489, 492, 495, 498, 500, 503, 506, 508, +- 510, 513, 515, 519, 524, 526, 528, 530, 532, 534, +- 536, 538, 540, 542, 544, 546, 548, 550, 552, 554, +- 556, 558, 560, 562, 564, 566, 568, 570, 572, 574, +- 576, 578, 580, 582, 584, 586, 588, 590, 592, 594, +- 596, 598, 600, 602, 604, 606, 608, 610, 612, 614, +- 616, 618, 620, 622, 624, 626, 628, 630, 632, 634, +- 636, 638, 644, 649, 651, 654, 658, 660, 664, 666, +- 671, 673, 675, 677, 679, 681, 683, 685, 687, 689, +- 691, 693, 696, 697, 702, 704, 706, 709, 713, 715, +- 718, 720, 723, 729, 733, 735, 737, 742, 748, 752, +- 755, 761, 769, 776, 778, 780, 782, 783, 786, 790, +- 793, 796, 799, 803, 806, 808, 810, 812 +-}; +- +-/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +-static const yytype_int16 yyrhs[] = +-{ +- 219, 0, -1, -1, 221, 223, 220, 226, -1, -1, +- 111, 80, 115, -1, 118, 115, -1, 119, 115, -1, +- 120, 115, -1, 121, 115, -1, 122, 115, -1, -1, +- 223, 225, -1, 76, -1, 77, -1, 78, -1, 112, +- 224, 114, 224, 115, -1, 310, -1, 226, 310, -1, +- 76, -1, 78, -1, 227, -1, 80, -1, 81, -1, +- 79, -1, 82, -1, 194, 258, 195, -1, 228, -1, +- 229, 196, 230, 197, -1, 231, -1, 229, 198, 224, +- -1, 229, 86, -1, 229, 87, -1, 258, -1, 232, +- -1, 233, -1, 229, 198, 238, -1, 235, 195, -1, +- 234, 195, -1, 236, 74, -1, 236, -1, 236, 256, +- -1, 235, 199, 256, -1, 237, 194, -1, 280, -1, +- 227, -1, 83, -1, 240, 195, -1, 239, 195, -1, +- 241, 74, -1, 241, -1, 241, 256, -1, 240, 199, +- 256, -1, 227, 194, -1, 229, -1, 86, 242, -1, +- 87, 242, -1, 243, 242, -1, 200, -1, 201, -1, +- 202, -1, 203, -1, 242, -1, 244, 204, 242, -1, +- 244, 205, 242, -1, 244, 206, 242, -1, 244, -1, +- 245, 200, 244, -1, 245, 201, 244, -1, 245, -1, +- 246, 84, 245, -1, 246, 85, 245, -1, 246, -1, +- 247, 207, 246, -1, 247, 208, 246, -1, 247, 88, +- 246, -1, 247, 89, 246, -1, 247, -1, 248, 90, +- 247, -1, 248, 91, 247, -1, 248, -1, 249, 209, +- 248, -1, 249, -1, 250, 210, 249, -1, 250, -1, +- 251, 211, 250, -1, 251, -1, 252, 92, 251, -1, +- 252, -1, 253, 94, 252, -1, 253, -1, 254, 93, +- 253, -1, 254, -1, 254, 212, 258, 213, 256, -1, +- 255, -1, 242, 257, 256, -1, 214, -1, 95, -1, +- 96, -1, 98, -1, 97, -1, 104, -1, 99, -1, +- 100, -1, 101, -1, 102, -1, 103, -1, 256, -1, +- 258, 199, 256, -1, 255, -1, 261, 215, -1, 269, +- 215, -1, 110, 284, 281, 215, -1, 262, 195, -1, +- 264, -1, 263, -1, 264, 266, -1, 263, 199, 266, +- -1, 271, 227, 194, -1, 280, 224, -1, 280, 224, +- 196, 259, 197, -1, 277, 267, 265, -1, 267, 265, +- -1, 277, 267, 268, -1, 267, 268, -1, -1, 33, +- -1, 34, -1, 35, -1, 280, -1, 270, -1, 269, +- 199, 224, -1, 269, 199, 224, 196, 197, -1, 269, +- 199, 224, 196, 259, 197, -1, 269, 199, 224, 196, +- 197, 214, 290, -1, 269, 199, 224, 196, 259, 197, +- 214, 290, -1, 269, 199, 224, 214, 290, -1, 271, +- -1, 271, 224, -1, 271, 224, 196, 197, -1, 271, +- 224, 196, 259, 197, -1, 271, 224, 196, 197, 214, +- 290, -1, 271, 224, 196, 259, 197, 214, 290, -1, +- 271, 224, 214, 290, -1, 105, 227, -1, 280, -1, +- 278, 280, -1, -1, 273, -1, 123, 194, 274, 195, +- -1, 275, -1, 274, 199, 275, -1, 224, -1, 40, +- -1, 39, -1, 38, -1, 4, -1, 279, -1, 276, +- 278, -1, 105, 278, -1, 4, -1, 3, -1, 272, +- 37, -1, 32, 37, -1, 272, 33, -1, 34, -1, +- 32, 33, -1, 32, 34, -1, 36, -1, 281, -1, +- 284, 281, -1, 282, -1, 282, 196, 197, -1, 282, +- 196, 259, 197, -1, 283, -1, 285, -1, 77, -1, +- 74, -1, 6, -1, 7, -1, 8, -1, 5, -1, +- 29, -1, 30, -1, 31, -1, 20, -1, 21, -1, +- 22, -1, 23, -1, 24, -1, 25, -1, 26, -1, +- 27, -1, 28, -1, 41, -1, 42, -1, 43, -1, +- 44, -1, 45, -1, 46, -1, 47, -1, 48, -1, +- 49, -1, 50, -1, 51, -1, 157, -1, 52, -1, +- 53, -1, 54, -1, 55, -1, 159, -1, 56, -1, +- 57, -1, 58, -1, 59, -1, 60, -1, 61, -1, +- 62, -1, 63, -1, 64, -1, 65, -1, 66, -1, +- 67, -1, 68, -1, 69, -1, 70, -1, 71, -1, +- 72, -1, 108, -1, 107, -1, 106, -1, 73, 224, +- 216, 286, 217, -1, 73, 216, 286, 217, -1, 287, +- -1, 286, 287, -1, 280, 288, 215, -1, 289, -1, +- 288, 199, 289, -1, 224, -1, 224, 196, 259, 197, +- -1, 256, -1, 260, -1, 294, -1, 293, -1, 291, +- -1, 299, -1, 300, -1, 303, -1, 304, -1, 305, +- -1, 309, -1, 216, 217, -1, -1, 216, 295, 298, +- 217, -1, 297, -1, 293, -1, 216, 217, -1, 216, +- 298, 217, -1, 292, -1, 298, 292, -1, 215, -1, +- 258, 215, -1, 14, 194, 258, 195, 301, -1, 292, +- 12, 292, -1, 292, -1, 258, -1, 271, 224, 214, +- 290, -1, 17, 194, 258, 195, 294, -1, 18, 258, +- 213, -1, 19, 213, -1, 75, 194, 302, 195, 296, +- -1, 11, 292, 75, 194, 258, 195, 215, -1, 13, +- 194, 306, 308, 195, 296, -1, 299, -1, 291, -1, +- 302, -1, -1, 307, 215, -1, 307, 215, 258, -1, +- 10, 215, -1, 9, 215, -1, 16, 215, -1, 16, +- 258, 215, -1, 15, 215, -1, 311, -1, 260, -1, +- 222, -1, 261, 297, -1 +-}; +- +-/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +-static const yytype_uint16 yyrline[] = +-{ +- 0, 220, 220, 219, 231, 233, 273, 274, 275, 276, +- 277, 289, 291, 295, 296, 297, 301, 310, 318, 329, +- 330, 334, 341, 348, 355, 362, 369, 376, 377, 383, +- 387, 394, 400, 409, 413, 417, 418, 427, 428, 432, +- 433, 437, 443, 455, 459, 465, 472, 482, 483, 487, +- 488, 492, 498, 510, 521, 522, 528, 534, 544, 545, +- 546, 547, 551, 552, 558, 564, 573, 574, 580, 589, +- 590, 596, 605, 606, 612, 618, 624, 633, 634, 640, +- 649, 650, 659, 660, 669, 670, 679, 680, 689, 690, +- 699, 700, 709, 710, 719, 720, 729, 730, 731, 732, +- 733, 734, 735, 736, 737, 738, 739, 743, 747, 763, +- 767, 772, 776, 785, 789, 790, 794, 799, 807, 822, +- 832, 847, 854, 859, 870, 882, 883, 884, 885, 889, +- 893, 894, 904, 914, 924, 934, 944, 958, 969, 978, +- 987, 996, 1005, 1014, 1023, 1037, 1044, 1055, 1056, 1060, +- 1067, 1068, 1075, 1109, 1110, 1111, 1115, 1119, 1120, 1124, +- 1132, 1133, 1134, 1135, 1136, 1137, 1138, 1139, 1140, 1144, +- 1148, 1156, 1157, 1163, 1172, 1178, 1184, 1193, 1194, 1195, +- 1196, 1197, 1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205, +- 1206, 1207, 1208, 1209, 1210, 1211, 1212, 1213, 1214, 1215, +- 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223, 1224, 1225, +- 1226, 1227, 1228, 1229, 1230, 1231, 1232, 1233, 1234, 1235, +- 1236, 1237, 1238, 1239, 1240, 1241, 1242, 1243, 1247, 1257, +- 1267, 1280, 1287, 1296, 1301, 1309, 1324, 1329, 1337, 1344, +- 1353, 1357, 1363, 1364, 1368, 1369, 1370, 1371, 1372, 1373, +- 1374, 1378, 1385, 1384, 1398, 1399, 1403, 1409, 1418, 1428, +- 1440, 1446, 1455, 1464, 1469, 1477, 1481, 1495, 1499, 1500, +- 1504, 1511, 1518, 1528, 1529, 1533, 1535, 1541, 1546, 1555, +- 1561, 1567, 1573, 1579, 1588, 1589, 1590, 1594 +-}; +-#endif +- +-#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE +-/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. +- First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +-static const char *const yytname[] = +-{ +- "$end", "error", "$undefined", "ATTRIBUTE", "CONST_TOK", "BOOL_TOK", +- "FLOAT_TOK", "INT_TOK", "UINT_TOK", "BREAK", "CONTINUE", "DO", "ELSE", +- "FOR", "IF", "DISCARD", "RETURN", "SWITCH", "CASE", "DEFAULT", "BVEC2", +- "BVEC3", "BVEC4", "IVEC2", "IVEC3", "IVEC4", "UVEC2", "UVEC3", "UVEC4", +- "VEC2", "VEC3", "VEC4", "CENTROID", "IN_TOK", "OUT_TOK", "INOUT_TOK", +- "UNIFORM", "VARYING", "NOPERSPECTIVE", "FLAT", "SMOOTH", "MAT2X2", +- "MAT2X3", "MAT2X4", "MAT3X2", "MAT3X3", "MAT3X4", "MAT4X2", "MAT4X3", +- "MAT4X4", "SAMPLER1D", "SAMPLER2D", "SAMPLER3D", "SAMPLERCUBE", +- "SAMPLER1DSHADOW", "SAMPLER2DSHADOW", "SAMPLERCUBESHADOW", +- "SAMPLER1DARRAY", "SAMPLER2DARRAY", "SAMPLER1DARRAYSHADOW", +- "SAMPLER2DARRAYSHADOW", "ISAMPLER1D", "ISAMPLER2D", "ISAMPLER3D", +- "ISAMPLERCUBE", "ISAMPLER1DARRAY", "ISAMPLER2DARRAY", "USAMPLER1D", +- "USAMPLER2D", "USAMPLER3D", "USAMPLERCUBE", "USAMPLER1DARRAY", +- "USAMPLER2DARRAY", "STRUCT", "VOID_TOK", "WHILE", "IDENTIFIER", +- "TYPE_IDENTIFIER", "NEW_IDENTIFIER", "FLOATCONSTANT", "INTCONSTANT", +- "UINTCONSTANT", "BOOLCONSTANT", "FIELD_SELECTION", "LEFT_OP", "RIGHT_OP", +- "INC_OP", "DEC_OP", "LE_OP", "GE_OP", "EQ_OP", "NE_OP", "AND_OP", +- "OR_OP", "XOR_OP", "MUL_ASSIGN", "DIV_ASSIGN", "ADD_ASSIGN", +- "MOD_ASSIGN", "LEFT_ASSIGN", "RIGHT_ASSIGN", "AND_ASSIGN", "XOR_ASSIGN", +- "OR_ASSIGN", "SUB_ASSIGN", "INVARIANT", "LOWP", "MEDIUMP", "HIGHP", +- "SUPERP", "PRECISION", "VERSION", "EXTENSION", "LINE", "COLON", "EOL", +- "INTERFACE", "OUTPUT", "PRAGMA_DEBUG_ON", "PRAGMA_DEBUG_OFF", +- "PRAGMA_OPTIMIZE_ON", "PRAGMA_OPTIMIZE_OFF", "PRAGMA_INVARIANT_ALL", +- "LAYOUT_TOK", "ASM", "CLASS", "UNION", "ENUM", "TYPEDEF", "TEMPLATE", +- "THIS", "PACKED_TOK", "GOTO", "INLINE_TOK", "NOINLINE", "VOLATILE", +- "PUBLIC_TOK", "STATIC", "EXTERN", "EXTERNAL", "LONG_TOK", "SHORT_TOK", +- "DOUBLE_TOK", "HALF", "FIXED_TOK", "UNSIGNED", "INPUT_TOK", "OUPTUT", +- "HVEC2", "HVEC3", "HVEC4", "DVEC2", "DVEC3", "DVEC4", "FVEC2", "FVEC3", +- "FVEC4", "SAMPLER2DRECT", "SAMPLER3DRECT", "SAMPLER2DRECTSHADOW", +- "SIZEOF", "CAST", "NAMESPACE", "USING", "ERROR_TOK", "COMMON", +- "PARTITION", "ACTIVE", "SAMPLERBUFFER", "FILTER", "IMAGE1D", "IMAGE2D", +- "IMAGE3D", "IMAGECUBE", "IMAGE1DARRAY", "IMAGE2DARRAY", "IIMAGE1D", +- "IIMAGE2D", "IIMAGE3D", "IIMAGECUBE", "IIMAGE1DARRAY", "IIMAGE2DARRAY", +- "UIMAGE1D", "UIMAGE2D", "UIMAGE3D", "UIMAGECUBE", "UIMAGE1DARRAY", +- "UIMAGE2DARRAY", "IMAGE1DSHADOW", "IMAGE2DSHADOW", "IMAGEBUFFER", +- "IIMAGEBUFFER", "UIMAGEBUFFER", "ROW_MAJOR", "'('", "')'", "'['", "']'", +- "'.'", "','", "'+'", "'-'", "'!'", "'~'", "'*'", "'/'", "'%'", "'<'", +- "'>'", "'&'", "'^'", "'|'", "'?'", "':'", "'='", "';'", "'{'", "'}'", +- "$accept", "translation_unit", "$@1", "version_statement", +- "pragma_statement", "extension_statement_list", "any_identifier", +- "extension_statement", "external_declaration_list", +- "variable_identifier", "primary_expression", "postfix_expression", +- "integer_expression", "function_call", "function_call_or_method", +- "function_call_generic", "function_call_header_no_parameters", +- "function_call_header_with_parameters", "function_call_header", +- "function_identifier", "method_call_generic", +- "method_call_header_no_parameters", "method_call_header_with_parameters", +- "method_call_header", "unary_expression", "unary_operator", +- "multiplicative_expression", "additive_expression", "shift_expression", +- "relational_expression", "equality_expression", "and_expression", +- "exclusive_or_expression", "inclusive_or_expression", +- "logical_and_expression", "logical_xor_expression", +- "logical_or_expression", "conditional_expression", +- "assignment_expression", "assignment_operator", "expression", +- "constant_expression", "declaration", "function_prototype", +- "function_declarator", "function_header_with_parameters", +- "function_header", "parameter_declarator", "parameter_declaration", +- "parameter_qualifier", "parameter_type_specifier", +- "init_declarator_list", "single_declaration", "fully_specified_type", +- "opt_layout_qualifier", "layout_qualifier", "layout_qualifier_id_list", +- "layout_qualifier_id", "interpolation_qualifier", +- "parameter_type_qualifier", "type_qualifier", "storage_qualifier", +- "type_specifier", "type_specifier_no_prec", "type_specifier_nonarray", +- "basic_type_specifier_nonarray", "precision_qualifier", +- "struct_specifier", "struct_declaration_list", "struct_declaration", +- "struct_declarator_list", "struct_declarator", "initializer", +- "declaration_statement", "statement", "simple_statement", +- "compound_statement", "$@2", "statement_no_new_scope", +- "compound_statement_no_new_scope", "statement_list", +- "expression_statement", "selection_statement", +- "selection_rest_statement", "condition", "switch_statement", +- "case_label", "iteration_statement", "for_init_statement", +- "conditionopt", "for_rest_statement", "jump_statement", +- "external_declaration", "function_definition", 0 +-}; +-#endif +- +-# ifdef YYPRINT +-/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to +- token YYLEX-NUM. */ +-static const yytype_uint16 yytoknum[] = +-{ +- 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, +- 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, +- 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, +- 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, +- 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, +- 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, +- 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, +- 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, +- 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, +- 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, +- 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, +- 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, +- 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, +- 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, +- 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, +- 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, +- 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, +- 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, +- 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, +- 445, 446, 447, 448, 40, 41, 91, 93, 46, 44, +- 43, 45, 33, 126, 42, 47, 37, 60, 62, 38, +- 94, 124, 63, 58, 61, 59, 123, 125 +-}; +-# endif +- +-/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +-static const yytype_uint16 yyr1[] = +-{ +- 0, 218, 220, 219, 221, 221, 222, 222, 222, 222, +- 222, 223, 223, 224, 224, 224, 225, 226, 226, 227, +- 227, 228, 228, 228, 228, 228, 228, 229, 229, 229, +- 229, 229, 229, 230, 231, 232, 232, 233, 233, 234, +- 234, 235, 235, 236, 237, 237, 237, 238, 238, 239, +- 239, 240, 240, 241, 242, 242, 242, 242, 243, 243, +- 243, 243, 244, 244, 244, 244, 245, 245, 245, 246, +- 246, 246, 247, 247, 247, 247, 247, 248, 248, 248, +- 249, 249, 250, 250, 251, 251, 252, 252, 253, 253, +- 254, 254, 255, 255, 256, 256, 257, 257, 257, 257, +- 257, 257, 257, 257, 257, 257, 257, 258, 258, 259, +- 260, 260, 260, 261, 262, 262, 263, 263, 264, 265, +- 265, 266, 266, 266, 266, 267, 267, 267, 267, 268, +- 269, 269, 269, 269, 269, 269, 269, 270, 270, 270, +- 270, 270, 270, 270, 270, 271, 271, 272, 272, 273, +- 274, 274, 275, 276, 276, 276, 277, 278, 278, 278, +- 279, 279, 279, 279, 279, 279, 279, 279, 279, 280, +- 280, 281, 281, 281, 282, 282, 282, 283, 283, 283, +- 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, +- 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, +- 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, +- 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, +- 283, 283, 283, 283, 283, 283, 283, 283, 284, 284, +- 284, 285, 285, 286, 286, 287, 288, 288, 289, 289, +- 290, 291, 292, 292, 293, 293, 293, 293, 293, 293, +- 293, 294, 295, 294, 296, 296, 297, 297, 298, 298, +- 299, 299, 300, 301, 301, 302, 302, 303, 304, 304, +- 305, 305, 305, 306, 306, 307, 307, 308, 308, 309, +- 309, 309, 309, 309, 310, 310, 310, 311 +-}; +- +-/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +-static const yytype_uint8 yyr2[] = +-{ +- 0, 2, 0, 4, 0, 3, 2, 2, 2, 2, +- 2, 0, 2, 1, 1, 1, 5, 1, 2, 1, +- 1, 1, 1, 1, 1, 1, 3, 1, 4, 1, +- 3, 2, 2, 1, 1, 1, 3, 2, 2, 2, +- 1, 2, 3, 2, 1, 1, 1, 2, 2, 2, +- 1, 2, 3, 2, 1, 2, 2, 2, 1, 1, +- 1, 1, 1, 3, 3, 3, 1, 3, 3, 1, +- 3, 3, 1, 3, 3, 3, 3, 1, 3, 3, +- 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, +- 1, 3, 1, 5, 1, 3, 1, 1, 1, 1, +- 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, +- 2, 2, 4, 2, 1, 1, 2, 3, 3, 2, +- 5, 3, 2, 3, 2, 0, 1, 1, 1, 1, +- 1, 3, 5, 6, 7, 8, 5, 1, 2, 4, +- 5, 6, 7, 4, 2, 1, 2, 0, 1, 4, +- 1, 3, 1, 1, 1, 1, 1, 1, 2, 2, +- 1, 1, 2, 2, 2, 1, 2, 2, 1, 1, +- 2, 1, 3, 4, 1, 1, 1, 1, 1, 1, +- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, +- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, +- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, +- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, +- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, +- 1, 5, 4, 1, 2, 3, 1, 3, 1, 4, +- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, +- 1, 2, 0, 4, 1, 1, 2, 3, 1, 2, +- 1, 2, 5, 3, 1, 1, 4, 5, 3, 2, +- 5, 7, 6, 1, 1, 1, 0, 2, 3, 2, +- 2, 2, 3, 2, 1, 1, 1, 2 +-}; +- +-/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state +- STATE-NUM when YYTABLE doesn't specify something else to do. Zero +- means the default is an error. */ +-static const yytype_uint16 yydefact[] = +-{ +- 4, 0, 0, 11, 0, 1, 2, 5, 0, 147, +- 12, 13, 14, 15, 0, 161, 160, 181, 178, 179, +- 180, 185, 186, 187, 188, 189, 190, 191, 192, 193, +- 182, 183, 184, 0, 165, 168, 155, 154, 153, 194, +- 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, +- 206, 207, 208, 209, 211, 212, 213, 214, 215, 216, +- 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, +- 227, 0, 177, 176, 147, 230, 229, 228, 0, 0, +- 0, 0, 0, 0, 0, 205, 210, 286, 147, 285, +- 0, 0, 115, 125, 0, 130, 137, 0, 148, 147, +- 0, 157, 145, 169, 171, 174, 0, 175, 17, 284, +- 0, 166, 167, 163, 0, 0, 19, 20, 147, 144, +- 159, 0, 6, 7, 8, 9, 10, 0, 18, 110, +- 147, 287, 113, 125, 156, 126, 127, 128, 116, 0, +- 125, 0, 111, 13, 15, 138, 0, 164, 162, 158, +- 146, 0, 170, 0, 0, 0, 233, 0, 0, 152, +- 0, 150, 0, 0, 147, 0, 0, 0, 0, 0, +- 0, 0, 0, 24, 22, 23, 25, 46, 0, 0, +- 0, 58, 59, 60, 61, 260, 252, 256, 21, 27, +- 54, 29, 34, 35, 0, 0, 40, 0, 62, 0, +- 66, 69, 72, 77, 80, 82, 84, 86, 88, 90, +- 92, 94, 107, 0, 241, 0, 145, 244, 258, 243, +- 242, 147, 245, 246, 247, 248, 249, 250, 117, 122, +- 124, 129, 0, 131, 0, 0, 118, 172, 62, 109, +- 0, 44, 16, 238, 0, 236, 232, 234, 0, 112, +- 149, 0, 280, 279, 0, 147, 0, 283, 281, 0, +- 0, 0, 269, 147, 55, 56, 0, 251, 147, 31, +- 32, 0, 0, 38, 37, 0, 177, 41, 43, 97, +- 98, 100, 99, 102, 103, 104, 105, 106, 101, 96, +- 0, 57, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 261, 257, 259, 119, 121, 123, 0, +- 0, 139, 0, 240, 143, 173, 0, 0, 235, 231, +- 151, 0, 274, 273, 147, 0, 282, 0, 268, 265, +- 0, 0, 26, 147, 0, 33, 30, 0, 36, 0, +- 0, 50, 42, 95, 63, 64, 65, 67, 68, 70, +- 71, 75, 76, 73, 74, 78, 79, 81, 83, 85, +- 87, 89, 91, 0, 108, 0, 132, 0, 136, 0, +- 140, 0, 237, 0, 275, 0, 0, 147, 0, 0, +- 147, 253, 28, 53, 48, 47, 0, 177, 51, 0, +- 0, 0, 133, 141, 0, 239, 0, 277, 147, 264, +- 262, 267, 0, 255, 270, 254, 52, 93, 120, 134, +- 0, 142, 0, 278, 272, 147, 266, 135, 271, 263 +-}; +- +-/* YYDEFGOTO[NTERM-NUM]. */ +-static const yytype_int16 yydefgoto[] = +-{ +- -1, 2, 9, 3, 87, 6, 159, 10, 88, 188, +- 189, 190, 344, 191, 192, 193, 194, 195, 196, 197, +- 348, 349, 350, 351, 198, 199, 200, 201, 202, 203, +- 204, 205, 206, 207, 208, 209, 210, 211, 212, 290, +- 213, 240, 214, 215, 91, 92, 93, 229, 138, 139, +- 230, 94, 95, 96, 97, 98, 160, 161, 99, 140, +- 100, 101, 241, 103, 104, 105, 106, 107, 155, 156, +- 244, 245, 324, 217, 218, 219, 220, 268, 414, 415, +- 221, 222, 223, 410, 341, 224, 225, 226, 334, 385, +- 386, 227, 108, 109 +-}; +- +-/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing +- STATE-NUM. */ +-#define YYPACT_NINF -359 +-static const yytype_int16 yypact[] = +-{ +- -101, -57, 46, -359, -52, -359, -55, -359, 120, 3633, +- -359, -359, -359, -359, -36, -359, -359, -359, -359, -359, +- -359, -359, -359, -359, -359, -359, -359, -359, -359, -359, +- -359, -359, -359, 50, -359, -359, -359, -359, -359, -359, +- -359, -359, -359, -359, -359, -359, -359, -359, -359, -359, +- -359, -359, -359, -359, -359, -359, -359, -359, -359, -359, +- -359, -359, -359, -359, -359, -359, -359, -359, -359, -359, +- -359, -39, -359, -359, 234, -359, -359, -359, 96, -25, +- -22, -2, 3, 8, -106, -359, -359, -359, 3511, -359, +- -100, -66, -48, 0, -163, -359, 129, 77, -359, 15, +- 3752, -359, -359, -359, -40, -359, 3825, -359, -359, -359, +- 120, -359, -359, -359, 3752, -32, -359, -359, 15, -359, +- -359, 3825, -359, -359, -359, -359, -359, 120, -359, -359, +- 404, -359, -359, 27, -359, -359, -359, -359, -359, 3752, +- 175, 120, -359, 24, 32, -172, 33, -359, -359, -359, +- -359, 2407, -359, 115, 120, 1784, -359, 3752, 17, -359, +- -67, -359, 19, 25, 1049, 48, 49, 30, 2022, 53, +- 2959, 35, 55, -359, -359, -359, -359, -359, 2959, 2959, +- 2959, -359, -359, -359, -359, -359, 34, -359, 56, -359, +- -65, -359, -359, -359, 60, -60, 3143, 62, -27, 2959, +- 9, -1, 58, -83, 103, 51, 47, 64, 166, 167, +- -86, -359, -359, -159, -359, 52, 68, -359, -359, -359, +- -359, 619, -359, -359, -359, -359, -359, -359, -359, -359, +- -359, 120, 3752, -166, 2591, 2959, -359, -359, -359, -359, +- 67, -359, -359, 73, -117, -359, -359, -359, 1903, -359, +- -359, 120, -359, -359, 196, 1464, 2959, -359, -359, -103, +- 2959, -184, -359, 2223, -359, -359, -59, -359, 1049, -359, +- -359, 2959, 129, -359, -359, 2959, 81, -359, -359, -359, +- -359, -359, -359, -359, -359, -359, -359, -359, -359, -359, +- 2959, -359, 2959, 2959, 2959, 2959, 2959, 2959, 2959, 2959, +- 2959, 2959, 2959, 2959, 2959, 2959, 2959, 2959, 2959, 2959, +- 2959, 2959, 2959, -359, -359, -359, 82, -359, -359, 2775, +- 2959, 63, 83, -359, -359, -359, 2959, 120, -359, -359, +- -359, 85, -359, -359, 1665, -58, -359, -50, -359, 84, +- 120, 86, -359, 834, 87, 84, -359, 88, -359, 90, +- -45, 3327, -359, -359, -359, -359, -359, 9, 9, -1, +- -1, 58, 58, 58, 58, -83, -83, 103, 51, 47, +- 64, 166, 167, -118, -359, 2959, 72, 91, -359, 2959, +- 75, 93, -359, 2959, -359, 76, 92, 1049, 78, 79, +- 1263, -359, -359, -359, -359, -359, 2959, 97, -359, 2959, +- 98, 2959, 89, -359, 2959, -359, -17, 2959, 1263, 284, +- -359, -359, 2959, -359, -359, -359, -359, -359, -359, -359, +- 2959, -359, 94, 84, -359, 1049, -359, -359, -359, -359 +-}; +- +-/* YYPGOTO[NTERM-NUM]. */ +-static const yytype_int16 yypgoto[] = +-{ +- -359, -359, -359, -359, -359, -359, -7, -359, -359, -71, +- -359, -359, -359, -359, -359, -359, -359, -359, -359, -359, +- -359, -359, -359, -359, -134, -359, -79, -78, -111, -82, +- -8, -6, -5, -10, -4, -11, -359, -140, -168, -359, +- -154, -222, 4, 11, -359, -359, -359, 69, 171, 168, +- 74, -359, -359, -254, -359, -359, -359, 65, -359, -359, +- -33, -359, -9, -63, -359, -359, 229, -359, 154, -147, +- -359, -14, -293, 59, -162, -358, -73, -359, -91, 228, +- 54, 66, -359, -359, -15, -359, -359, -359, -359, -359, +- -359, -359, 235, -359 +-}; +- +-/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If +- positive, shift that token. If negative, reduce the rule which +- number is the opposite. If zero, do what YYDEFACT says. +- If YYTABLE_NINF, syntax error. */ +-#define YYTABLE_NINF -277 +-static const yytype_int16 yytable[] = +-{ +- 102, 14, 254, 119, 134, 299, 300, 310, 247, 340, +- 1, 239, 322, 89, 259, 312, 261, 238, 15, 16, +- 90, 269, 270, 4, 234, 146, 266, 378, 277, 338, +- 319, 134, 413, 135, 136, 137, 141, 11, 12, 13, +- 312, 120, 235, 152, 264, 265, 5, 33, 320, 34, +- 413, 35, 142, 36, 37, 38, 313, 8, 158, 315, +- 135, 136, 137, 7, 115, 291, 149, 323, 279, 280, +- 281, 282, 283, 284, 285, 286, 287, 288, 110, 102, +- 340, 312, 327, 111, 112, 120, 403, 113, 127, 145, +- 122, 150, 89, 123, 239, 399, 312, 377, 328, 90, +- 238, 247, 335, 153, 381, 154, 337, 352, 419, 339, +- 147, 421, 336, 124, 148, 129, 130, 345, 125, 426, +- 118, 216, 353, 126, 301, 302, 311, 427, 250, 132, +- 231, 271, 251, 272, 233, 274, 342, 387, 84, 275, +- 312, 312, 297, 298, 374, 388, 154, 243, 154, 312, +- 395, 133, 323, 400, 396, 216, 151, 373, 354, 355, +- 356, 238, 238, 238, 238, 238, 238, 238, 238, 238, +- 238, 238, 238, 238, 238, 238, 238, 114, 422, 239, +- 339, 315, 312, 398, 157, 238, 239, 289, 361, 362, +- 363, 364, 238, 303, 304, -114, 11, 12, 13, 295, +- 296, 347, 75, 76, 77, 143, 12, 144, 135, 136, +- 137, 323, 216, 292, 293, 294, 357, 358, -19, 359, +- 360, 365, 366, 231, 316, 409, -20, 236, 416, 406, +- 242, 417, 249, 323, 252, 239, 323, 15, 16, 154, +- 253, 238, 255, 256, 323, 257, 216, 260, 262, 263, +- -45, 267, 323, 423, 216, 273, 278, 306, 308, 216, +- 305, 309, -44, 429, 325, 346, 33, 129, 34, 326, +- 35, 331, 36, 37, 38, 307, -39, 379, 375, 383, +- 380, 390, 393, 312, 392, 394, 401, 408, 402, 404, +- 405, 407, -49, 412, 186, 418, 425, 367, 370, 372, +- 368, 317, 369, 420, 228, 371, 318, 121, 232, 428, +- 116, 248, 117, 382, 332, 411, 330, 424, 131, 384, +- 243, 333, 343, 128, 0, 216, 0, 0, 0, 0, +- 0, 0, 0, 389, 216, 0, 0, 0, 0, 118, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 84, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 216, 0, +- 0, 216, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 216, +- 0, 0, 0, 0, 0, 0, 0, 15, 16, 17, +- 18, 19, 20, 162, 163, 164, 216, 165, 166, 167, +- 168, 169, 170, 171, 21, 22, 23, 24, 25, 26, +- 27, 28, 29, 30, 31, 32, 33, 0, 34, 0, +- 35, 0, 36, 37, 38, 39, 40, 41, 42, 43, +- 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, +- 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, +- 64, 65, 66, 67, 68, 69, 70, 71, 72, 172, +- 116, 73, 117, 173, 174, 175, 176, 177, 0, 0, +- 178, 179, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 74, +- 75, 76, 77, 0, 78, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 84, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 85, 0, 86, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 180, 0, +- 0, 0, 0, 0, 181, 182, 183, 184, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 185, +- 186, 187, 15, 16, 17, 18, 19, 20, 162, 163, +- 164, 0, 165, 166, 167, 168, 169, 170, 171, 21, +- 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, +- 32, 33, 0, 34, 0, 35, 0, 36, 37, 38, +- 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, +- 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, +- 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, +- 69, 70, 71, 72, 172, 116, 73, 117, 173, 174, +- 175, 176, 177, 0, 0, 178, 179, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 74, 75, 76, 77, 0, 78, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 84, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 85, 0, 86, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 180, 0, 0, 0, 0, 0, 181, +- 182, 183, 184, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 185, 186, 314, 15, 16, 17, +- 18, 19, 20, 162, 163, 164, 0, 165, 166, 167, +- 168, 169, 170, 171, 21, 22, 23, 24, 25, 26, +- 27, 28, 29, 30, 31, 32, 33, 0, 34, 0, +- 35, 0, 36, 37, 38, 39, 40, 41, 42, 43, +- 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, +- 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, +- 64, 65, 66, 67, 68, 69, 70, 71, 72, 172, +- 116, 73, 117, 173, 174, 175, 176, 177, 0, 0, +- 178, 179, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 74, +- 75, 76, 77, 0, 78, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 84, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 85, 0, 86, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 180, 0, +- 0, 0, 0, 0, 181, 182, 183, 184, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 185, +- 186, 391, 15, 16, 17, 18, 19, 20, 162, 163, +- 164, 0, 165, 166, 167, 168, 169, 170, 171, 21, +- 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, +- 32, 33, 0, 34, 0, 35, 0, 36, 37, 38, +- 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, +- 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, +- 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, +- 69, 70, 71, 72, 172, 116, 73, 117, 173, 174, +- 175, 176, 177, 0, 0, 178, 179, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 74, 75, 76, 77, 0, 78, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 84, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 85, 0, 86, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 180, 0, 0, 0, 0, 0, 181, +- 182, 183, 184, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 185, 186, 15, 16, 17, 18, +- 19, 20, 162, 163, 164, 0, 165, 166, 167, 168, +- 169, 170, 171, 21, 22, 23, 24, 25, 26, 27, +- 28, 29, 30, 31, 32, 33, 0, 34, 0, 35, +- 0, 36, 37, 38, 39, 40, 41, 42, 43, 44, +- 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, +- 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, +- 65, 66, 67, 68, 69, 70, 71, 72, 172, 116, +- 73, 117, 173, 174, 175, 176, 177, 0, 0, 178, +- 179, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 74, 75, +- 76, 77, 0, 78, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 84, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 85, 0, 86, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 180, 0, 0, +- 0, 0, 0, 181, 182, 183, 184, 15, 16, 17, +- 18, 19, 20, 0, 0, 0, 0, 0, 185, 130, +- 0, 0, 0, 0, 21, 22, 23, 24, 25, 26, +- 27, 28, 29, 30, 31, 32, 33, 0, 34, 0, +- 35, 0, 36, 37, 38, 39, 40, 41, 42, 43, +- 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, +- 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, +- 64, 65, 66, 67, 68, 69, 70, 71, 72, 0, +- 116, 73, 117, 173, 174, 175, 176, 177, 0, 0, +- 178, 179, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 74, +- 75, 76, 77, 0, 78, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 84, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 85, 0, 86, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 180, 0, +- 0, 0, 0, 0, 181, 182, 183, 184, 15, 16, +- 17, 18, 19, 20, 0, 0, 0, 0, 0, 185, +- 0, 0, 0, 0, 0, 21, 22, 23, 24, 25, +- 26, 27, 28, 29, 30, 31, 32, 33, 0, 34, +- 0, 35, 0, 36, 37, 38, 39, 40, 41, 42, +- 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, +- 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, +- 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, +- 0, 116, 73, 117, 173, 174, 175, 176, 177, 0, +- 0, 178, 179, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 118, 75, 76, 77, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 84, 17, +- 18, 19, 20, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 21, 22, 23, 24, 25, 26, +- 27, 28, 29, 30, 31, 32, 0, 0, 0, 0, +- 0, 0, 85, 0, 86, 39, 40, 41, 42, 43, +- 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, +- 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, +- 64, 65, 66, 67, 68, 69, 70, 71, 72, 180, +- 0, 73, 0, 0, 0, 181, 182, 183, 184, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- -276, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 75, 76, 77, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 17, 18, +- 19, 20, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 21, 22, 23, 24, 25, 26, 27, +- 28, 29, 30, 31, 32, 0, 0, 0, 0, 0, +- 0, 85, 0, 86, 39, 40, 41, 42, 43, 44, +- 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, +- 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, +- 65, 66, 67, 68, 69, 70, 71, 72, 0, 0, +- 73, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 246, 0, 0, 0, 0, 0, 0, 0, 75, +- 76, 77, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 17, 18, 19, +- 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 21, 22, 23, 24, 25, 26, 27, 28, +- 29, 30, 31, 32, 0, 0, 0, 0, 0, 0, +- 85, 0, 86, 39, 40, 41, 42, 43, 44, 45, +- 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, +- 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, +- 66, 67, 68, 69, 70, 71, 72, 0, 116, 73, +- 117, 173, 174, 175, 176, 177, 0, 0, 178, 179, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 329, 0, 0, 0, 0, 0, 0, 0, 75, 76, +- 77, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 85, +- 0, 86, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 180, 0, 0, 0, +- 0, 0, 181, 182, 183, 184, 15, 16, 17, 18, +- 19, 20, 0, 0, 0, 0, 0, 258, 0, 0, +- 0, 0, 0, 21, 22, 23, 24, 25, 26, 27, +- 28, 29, 30, 31, 32, 33, 0, 34, 0, 35, +- 0, 36, 37, 38, 39, 40, 41, 42, 43, 44, +- 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, +- 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, +- 65, 66, 67, 68, 69, 70, 71, 72, 0, 116, +- 73, 117, 173, 174, 175, 176, 177, 0, 0, 178, +- 179, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 118, 75, +- 76, 77, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 84, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 85, 0, 86, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 17, 18, 19, 20, 0, 180, 0, 0, +- 0, 0, 0, 181, 182, 183, 184, 21, 22, 23, +- 24, 25, 26, 27, 28, 29, 30, 31, 32, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 39, 40, +- 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, +- 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, +- 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, +- 71, 72, 0, 116, 73, 117, 173, 174, 175, 176, +- 177, 0, 0, 178, 179, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 75, 76, 77, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 85, 0, 86, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 17, 18, 19, 20, +- 0, 180, 0, 0, 237, 0, 0, 181, 182, 183, +- 184, 21, 22, 23, 24, 25, 26, 27, 28, 29, +- 30, 31, 32, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 39, 40, 41, 42, 43, 44, 45, 46, +- 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, +- 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, +- 67, 68, 69, 70, 71, 72, 0, 116, 73, 117, +- 173, 174, 175, 176, 177, 0, 0, 178, 179, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 75, 76, 77, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 85, 0, +- 86, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 17, 18, 19, 20, 0, 180, 0, 0, 321, 0, +- 0, 181, 182, 183, 184, 21, 22, 23, 24, 25, +- 26, 27, 28, 29, 30, 31, 32, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 39, 40, 41, 42, +- 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, +- 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, +- 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, +- 0, 116, 73, 117, 173, 174, 175, 176, 177, 0, +- 0, 178, 179, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 75, 76, 77, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 85, 0, 86, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 17, 18, 19, 20, 0, 180, +- 0, 0, 376, 0, 0, 181, 182, 183, 184, 21, +- 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, +- 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, +- 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, +- 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, +- 69, 70, 71, 72, 0, 116, 73, 117, 173, 174, +- 175, 176, 177, 0, 0, 178, 179, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 75, 76, 77, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 85, 0, 86, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 17, 18, +- 19, 20, 0, 180, 0, 0, 0, 0, 0, 181, +- 182, 183, 184, 21, 22, 23, 24, 25, 26, 27, +- 28, 29, 30, 31, 32, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 39, 40, 41, 42, 43, 44, +- 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, +- 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, +- 65, 66, 67, 68, 69, 70, 71, 276, 0, 116, +- 73, 117, 173, 174, 175, 176, 177, 0, 0, 178, +- 179, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 75, +- 76, 77, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 85, 0, 86, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 17, 18, 19, 20, 0, 180, 0, 0, +- 0, 0, 0, 181, 182, 183, 184, 21, 22, 23, +- 24, 25, 26, 27, 28, 29, 30, 31, 32, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 39, 40, +- 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, +- 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, +- 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, +- 71, 397, 0, 116, 73, 117, 173, 174, 175, 176, +- 177, 0, 0, 178, 179, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 75, 76, 77, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 85, 0, 86, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, -3, 0, 0, 15, 16, 17, 18, 19, 20, +- 0, 180, 0, 0, 0, 0, 0, 181, 182, 183, +- 184, 21, 22, 23, 24, 25, 26, 27, 28, 29, +- 30, 31, 32, 33, 0, 34, 0, 35, 0, 36, +- 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, +- 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, +- 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, +- 67, 68, 69, 70, 71, 72, 0, 0, 73, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 74, 75, 76, 77, +- 0, 78, 0, 0, 0, 0, 0, 0, 0, 79, +- 80, 81, 82, 83, 84, 0, 15, 16, 17, 18, +- 19, 20, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 21, 22, 23, 24, 25, 26, 27, +- 28, 29, 30, 31, 32, 33, 0, 34, 85, 35, +- 86, 36, 37, 38, 39, 40, 41, 42, 43, 44, +- 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, +- 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, +- 65, 66, 67, 68, 69, 70, 71, 72, 0, 0, +- 73, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 74, 75, +- 76, 77, 0, 78, 0, 0, 0, 0, 0, 0, +- 0, 79, 80, 81, 82, 83, 84, 17, 18, 19, +- 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 21, 22, 23, 24, 25, 26, 27, 28, +- 29, 30, 31, 32, 0, 0, 0, 0, 0, 0, +- 85, 0, 86, 39, 40, 41, 42, 43, 44, 45, +- 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, +- 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, +- 66, 67, 68, 69, 70, 71, 72, 0, 0, 73, +- 17, 18, 19, 20, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 21, 22, 23, 24, 25, +- 26, 27, 28, 29, 30, 31, 32, 0, 75, 76, +- 77, 0, 0, 0, 0, 0, 39, 40, 41, 42, +- 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, +- 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, +- 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, +- 0, 0, 73, 0, 0, 0, 0, 0, 0, 85, +- 0, 86, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +- 0, 0, 85, 0, 86 +-}; +- +-static const yytype_int16 yycheck[] = +-{ +- 9, 8, 164, 74, 4, 88, 89, 93, 155, 263, +- 111, 151, 234, 9, 168, 199, 170, 151, 3, 4, +- 9, 86, 87, 80, 196, 96, 180, 320, 196, 213, +- 196, 4, 390, 33, 34, 35, 199, 76, 77, 78, +- 199, 74, 214, 106, 178, 179, 0, 32, 214, 34, +- 408, 36, 215, 38, 39, 40, 215, 112, 121, 221, +- 33, 34, 35, 115, 71, 199, 99, 235, 95, 96, +- 97, 98, 99, 100, 101, 102, 103, 104, 114, 88, +- 334, 199, 199, 33, 34, 118, 379, 37, 194, 96, +- 115, 100, 88, 115, 234, 213, 199, 319, 215, 88, +- 234, 248, 256, 110, 326, 114, 260, 275, 401, 263, +- 33, 404, 215, 115, 37, 215, 216, 271, 115, 412, +- 105, 130, 290, 115, 207, 208, 212, 420, 195, 195, +- 139, 196, 199, 198, 141, 195, 195, 195, 123, 199, +- 199, 199, 84, 85, 312, 195, 155, 154, 157, 199, +- 195, 199, 320, 375, 199, 164, 196, 311, 292, 293, +- 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, +- 304, 305, 306, 307, 308, 309, 310, 216, 195, 319, +- 334, 343, 199, 351, 216, 319, 326, 214, 299, 300, +- 301, 302, 326, 90, 91, 195, 76, 77, 78, 200, +- 201, 272, 106, 107, 108, 76, 77, 78, 33, 34, +- 35, 379, 221, 204, 205, 206, 295, 296, 194, 297, +- 298, 303, 304, 232, 231, 387, 194, 194, 396, 383, +- 115, 399, 215, 401, 215, 375, 404, 3, 4, 248, +- 215, 375, 194, 194, 412, 215, 255, 194, 213, 194, +- 194, 217, 420, 407, 263, 195, 194, 210, 92, 268, +- 209, 94, 194, 425, 197, 272, 32, 215, 34, 196, +- 36, 75, 38, 39, 40, 211, 195, 214, 196, 194, +- 197, 195, 194, 199, 197, 195, 214, 195, 197, 214, +- 197, 215, 195, 214, 216, 197, 12, 305, 308, 310, +- 306, 232, 307, 214, 133, 309, 232, 78, 140, 215, +- 76, 157, 78, 327, 255, 388, 251, 408, 90, 334, +- 327, 255, 268, 88, -1, 334, -1, -1, -1, -1, +- -1, -1, -1, 340, 343, -1, -1, -1, -1, 105, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, 123, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, 387, -1, +- -1, 390, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, 408, +- -1, -1, -1, -1, -1, -1, -1, 3, 4, 5, +- 6, 7, 8, 9, 10, 11, 425, 13, 14, 15, +- 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, +- 26, 27, 28, 29, 30, 31, 32, -1, 34, -1, +- 36, -1, 38, 39, 40, 41, 42, 43, 44, 45, +- 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, +- 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, +- 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, +- 76, 77, 78, 79, 80, 81, 82, 83, -1, -1, +- 86, 87, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, 105, +- 106, 107, 108, -1, 110, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, 123, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, 157, -1, 159, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, 194, -1, +- -1, -1, -1, -1, 200, 201, 202, 203, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, 215, +- 216, 217, 3, 4, 5, 6, 7, 8, 9, 10, +- 11, -1, 13, 14, 15, 16, 17, 18, 19, 20, +- 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, +- 31, 32, -1, 34, -1, 36, -1, 38, 39, 40, +- 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, +- 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, +- 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, +- 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, +- 81, 82, 83, -1, -1, 86, 87, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, 105, 106, 107, 108, -1, 110, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, 123, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, 157, -1, 159, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, 194, -1, -1, -1, -1, -1, 200, +- 201, 202, 203, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, 215, 216, 217, 3, 4, 5, +- 6, 7, 8, 9, 10, 11, -1, 13, 14, 15, +- 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, +- 26, 27, 28, 29, 30, 31, 32, -1, 34, -1, +- 36, -1, 38, 39, 40, 41, 42, 43, 44, 45, +- 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, +- 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, +- 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, +- 76, 77, 78, 79, 80, 81, 82, 83, -1, -1, +- 86, 87, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, 105, +- 106, 107, 108, -1, 110, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, 123, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, 157, -1, 159, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, 194, -1, +- -1, -1, -1, -1, 200, 201, 202, 203, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, 215, +- 216, 217, 3, 4, 5, 6, 7, 8, 9, 10, +- 11, -1, 13, 14, 15, 16, 17, 18, 19, 20, +- 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, +- 31, 32, -1, 34, -1, 36, -1, 38, 39, 40, +- 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, +- 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, +- 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, +- 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, +- 81, 82, 83, -1, -1, 86, 87, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, 105, 106, 107, 108, -1, 110, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, 123, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, 157, -1, 159, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, 194, -1, -1, -1, -1, -1, 200, +- 201, 202, 203, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, 215, 216, 3, 4, 5, 6, +- 7, 8, 9, 10, 11, -1, 13, 14, 15, 16, +- 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, +- 27, 28, 29, 30, 31, 32, -1, 34, -1, 36, +- -1, 38, 39, 40, 41, 42, 43, 44, 45, 46, +- 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, +- 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, +- 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, +- 77, 78, 79, 80, 81, 82, 83, -1, -1, 86, +- 87, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, 105, 106, +- 107, 108, -1, 110, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, 123, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- 157, -1, 159, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, 194, -1, -1, +- -1, -1, -1, 200, 201, 202, 203, 3, 4, 5, +- 6, 7, 8, -1, -1, -1, -1, -1, 215, 216, +- -1, -1, -1, -1, 20, 21, 22, 23, 24, 25, +- 26, 27, 28, 29, 30, 31, 32, -1, 34, -1, +- 36, -1, 38, 39, 40, 41, 42, 43, 44, 45, +- 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, +- 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, +- 66, 67, 68, 69, 70, 71, 72, 73, 74, -1, +- 76, 77, 78, 79, 80, 81, 82, 83, -1, -1, +- 86, 87, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, 105, +- 106, 107, 108, -1, 110, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, 123, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, 157, -1, 159, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, 194, -1, +- -1, -1, -1, -1, 200, 201, 202, 203, 3, 4, +- 5, 6, 7, 8, -1, -1, -1, -1, -1, 215, +- -1, -1, -1, -1, -1, 20, 21, 22, 23, 24, +- 25, 26, 27, 28, 29, 30, 31, 32, -1, 34, +- -1, 36, -1, 38, 39, 40, 41, 42, 43, 44, +- 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, +- 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, +- 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, +- -1, 76, 77, 78, 79, 80, 81, 82, 83, -1, +- -1, 86, 87, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- 105, 106, 107, 108, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, 123, 5, +- 6, 7, 8, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, 20, 21, 22, 23, 24, 25, +- 26, 27, 28, 29, 30, 31, -1, -1, -1, -1, +- -1, -1, 157, -1, 159, 41, 42, 43, 44, 45, +- 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, +- 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, +- 66, 67, 68, 69, 70, 71, 72, 73, 74, 194, +- -1, 77, -1, -1, -1, 200, 201, 202, 203, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- 215, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- 106, 107, 108, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, 5, 6, +- 7, 8, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, 20, 21, 22, 23, 24, 25, 26, +- 27, 28, 29, 30, 31, -1, -1, -1, -1, -1, +- -1, 157, -1, 159, 41, 42, 43, 44, 45, 46, +- 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, +- 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, +- 67, 68, 69, 70, 71, 72, 73, 74, -1, -1, +- 77, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, 217, -1, -1, -1, -1, -1, -1, -1, 106, +- 107, 108, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, 5, 6, 7, +- 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, 20, 21, 22, 23, 24, 25, 26, 27, +- 28, 29, 30, 31, -1, -1, -1, -1, -1, -1, +- 157, -1, 159, 41, 42, 43, 44, 45, 46, 47, +- 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, +- 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, +- 68, 69, 70, 71, 72, 73, 74, -1, 76, 77, +- 78, 79, 80, 81, 82, 83, -1, -1, 86, 87, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- 217, -1, -1, -1, -1, -1, -1, -1, 106, 107, +- 108, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, 157, +- -1, 159, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, 194, -1, -1, -1, +- -1, -1, 200, 201, 202, 203, 3, 4, 5, 6, +- 7, 8, -1, -1, -1, -1, -1, 215, -1, -1, +- -1, -1, -1, 20, 21, 22, 23, 24, 25, 26, +- 27, 28, 29, 30, 31, 32, -1, 34, -1, 36, +- -1, 38, 39, 40, 41, 42, 43, 44, 45, 46, +- 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, +- 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, +- 67, 68, 69, 70, 71, 72, 73, 74, -1, 76, +- 77, 78, 79, 80, 81, 82, 83, -1, -1, 86, +- 87, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, 105, 106, +- 107, 108, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, 123, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- 157, -1, 159, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, 5, 6, 7, 8, -1, 194, -1, -1, +- -1, -1, -1, 200, 201, 202, 203, 20, 21, 22, +- 23, 24, 25, 26, 27, 28, 29, 30, 31, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, 41, 42, +- 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, +- 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, +- 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, +- 73, 74, -1, 76, 77, 78, 79, 80, 81, 82, +- 83, -1, -1, 86, 87, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, 106, 107, 108, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, 157, -1, 159, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, 5, 6, 7, 8, +- -1, 194, -1, -1, 197, -1, -1, 200, 201, 202, +- 203, 20, 21, 22, 23, 24, 25, 26, 27, 28, +- 29, 30, 31, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, 41, 42, 43, 44, 45, 46, 47, 48, +- 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, +- 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, +- 69, 70, 71, 72, 73, 74, -1, 76, 77, 78, +- 79, 80, 81, 82, 83, -1, -1, 86, 87, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, 106, 107, 108, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, 157, -1, +- 159, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- 5, 6, 7, 8, -1, 194, -1, -1, 197, -1, +- -1, 200, 201, 202, 203, 20, 21, 22, 23, 24, +- 25, 26, 27, 28, 29, 30, 31, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, 41, 42, 43, 44, +- 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, +- 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, +- 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, +- -1, 76, 77, 78, 79, 80, 81, 82, 83, -1, +- -1, 86, 87, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, 106, 107, 108, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, 157, -1, 159, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, 5, 6, 7, 8, -1, 194, +- -1, -1, 197, -1, -1, 200, 201, 202, 203, 20, +- 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, +- 31, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, +- 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, +- 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, +- 71, 72, 73, 74, -1, 76, 77, 78, 79, 80, +- 81, 82, 83, -1, -1, 86, 87, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, 106, 107, 108, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, 157, -1, 159, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, 5, 6, +- 7, 8, -1, 194, -1, -1, -1, -1, -1, 200, +- 201, 202, 203, 20, 21, 22, 23, 24, 25, 26, +- 27, 28, 29, 30, 31, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, 41, 42, 43, 44, 45, 46, +- 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, +- 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, +- 67, 68, 69, 70, 71, 72, 73, 74, -1, 76, +- 77, 78, 79, 80, 81, 82, 83, -1, -1, 86, +- 87, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, 106, +- 107, 108, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- 157, -1, 159, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, 5, 6, 7, 8, -1, 194, -1, -1, +- -1, -1, -1, 200, 201, 202, 203, 20, 21, 22, +- 23, 24, 25, 26, 27, 28, 29, 30, 31, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, 41, 42, +- 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, +- 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, +- 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, +- 73, 74, -1, 76, 77, 78, 79, 80, 81, 82, +- 83, -1, -1, 86, 87, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, 106, 107, 108, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, 157, -1, 159, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, 0, -1, -1, 3, 4, 5, 6, 7, 8, +- -1, 194, -1, -1, -1, -1, -1, 200, 201, 202, +- 203, 20, 21, 22, 23, 24, 25, 26, 27, 28, +- 29, 30, 31, 32, -1, 34, -1, 36, -1, 38, +- 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, +- 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, +- 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, +- 69, 70, 71, 72, 73, 74, -1, -1, 77, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, 105, 106, 107, 108, +- -1, 110, -1, -1, -1, -1, -1, -1, -1, 118, +- 119, 120, 121, 122, 123, -1, 3, 4, 5, 6, +- 7, 8, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, 20, 21, 22, 23, 24, 25, 26, +- 27, 28, 29, 30, 31, 32, -1, 34, 157, 36, +- 159, 38, 39, 40, 41, 42, 43, 44, 45, 46, +- 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, +- 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, +- 67, 68, 69, 70, 71, 72, 73, 74, -1, -1, +- 77, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, 105, 106, +- 107, 108, -1, 110, -1, -1, -1, -1, -1, -1, +- -1, 118, 119, 120, 121, 122, 123, 5, 6, 7, +- 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, 20, 21, 22, 23, 24, 25, 26, 27, +- 28, 29, 30, 31, -1, -1, -1, -1, -1, -1, +- 157, -1, 159, 41, 42, 43, 44, 45, 46, 47, +- 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, +- 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, +- 68, 69, 70, 71, 72, 73, 74, -1, -1, 77, +- 5, 6, 7, 8, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, 20, 21, 22, 23, 24, +- 25, 26, 27, 28, 29, 30, 31, -1, 106, 107, +- 108, -1, -1, -1, -1, -1, 41, 42, 43, 44, +- 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, +- 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, +- 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, +- -1, -1, 77, -1, -1, -1, -1, -1, -1, 157, +- -1, 159, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +- -1, -1, 157, -1, 159 +-}; +- +-/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing +- symbol of state STATE-NUM. */ +-static const yytype_uint16 yystos[] = +-{ +- 0, 111, 219, 221, 80, 0, 223, 115, 112, 220, +- 225, 76, 77, 78, 224, 3, 4, 5, 6, 7, +- 8, 20, 21, 22, 23, 24, 25, 26, 27, 28, +- 29, 30, 31, 32, 34, 36, 38, 39, 40, 41, +- 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, +- 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, +- 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, +- 72, 73, 74, 77, 105, 106, 107, 108, 110, 118, +- 119, 120, 121, 122, 123, 157, 159, 222, 226, 260, +- 261, 262, 263, 264, 269, 270, 271, 272, 273, 276, +- 278, 279, 280, 281, 282, 283, 284, 285, 310, 311, +- 114, 33, 34, 37, 216, 224, 76, 78, 105, 227, +- 278, 284, 115, 115, 115, 115, 115, 194, 310, 215, +- 216, 297, 195, 199, 4, 33, 34, 35, 266, 267, +- 277, 199, 215, 76, 78, 224, 227, 33, 37, 278, +- 280, 196, 281, 224, 280, 286, 287, 216, 281, 224, +- 274, 275, 9, 10, 11, 13, 14, 15, 16, 17, +- 18, 19, 75, 79, 80, 81, 82, 83, 86, 87, +- 194, 200, 201, 202, 203, 215, 216, 217, 227, 228, +- 229, 231, 232, 233, 234, 235, 236, 237, 242, 243, +- 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, +- 254, 255, 256, 258, 260, 261, 280, 291, 292, 293, +- 294, 298, 299, 300, 303, 304, 305, 309, 266, 265, +- 268, 280, 267, 224, 196, 214, 194, 197, 242, 255, +- 259, 280, 115, 224, 288, 289, 217, 287, 286, 215, +- 195, 199, 215, 215, 292, 194, 194, 215, 215, 258, +- 194, 258, 213, 194, 242, 242, 258, 217, 295, 86, +- 87, 196, 198, 195, 195, 199, 74, 256, 194, 95, +- 96, 97, 98, 99, 100, 101, 102, 103, 104, 214, +- 257, 242, 204, 205, 206, 200, 201, 84, 85, 88, +- 89, 207, 208, 90, 91, 209, 210, 211, 92, 94, +- 93, 212, 199, 215, 217, 292, 224, 265, 268, 196, +- 214, 197, 259, 256, 290, 197, 196, 199, 215, 217, +- 275, 75, 291, 299, 306, 258, 215, 258, 213, 258, +- 271, 302, 195, 298, 230, 258, 224, 227, 238, 239, +- 240, 241, 256, 256, 242, 242, 242, 244, 244, 245, +- 245, 246, 246, 246, 246, 247, 247, 248, 249, 250, +- 251, 252, 253, 258, 256, 196, 197, 259, 290, 214, +- 197, 259, 289, 194, 302, 307, 308, 195, 195, 224, +- 195, 217, 197, 194, 195, 195, 199, 74, 256, 213, +- 259, 214, 197, 290, 214, 197, 258, 215, 195, 292, +- 301, 294, 214, 293, 296, 297, 256, 256, 197, 290, +- 214, 290, 195, 258, 296, 12, 290, 290, 215, 292 +-}; +- +-#define yyerrok (yyerrstatus = 0) +-#define yyclearin (yychar = YYEMPTY) +-#define YYEMPTY (-2) +-#define YYEOF 0 +- +-#define YYACCEPT goto yyacceptlab +-#define YYABORT goto yyabortlab +-#define YYERROR goto yyerrorlab +- +- +-/* Like YYERROR except do call yyerror. This remains here temporarily +- to ease the transition to the new meaning of YYERROR, for GCC. +- Once GCC version 2 has supplanted version 1, this can go. However, +- YYFAIL appears to be in use. Nevertheless, it is formally deprecated +- in Bison 2.4.2's NEWS entry, where a plan to phase it out is +- discussed. */ +- +-#define YYFAIL goto yyerrlab +-#if defined YYFAIL +- /* This is here to suppress warnings from the GCC cpp's +- -Wunused-macros. Normally we don't worry about that warning, but +- some users do, and we want to make it easy for users to remove +- YYFAIL uses, which will produce warnings from Bison 2.5. */ +-#endif +- +-#define YYRECOVERING() (!!yyerrstatus) +- +-#define YYBACKUP(Token, Value) \ +-do \ +- if (yychar == YYEMPTY && yylen == 1) \ +- { \ +- yychar = (Token); \ +- yylval = (Value); \ +- yytoken = YYTRANSLATE (yychar); \ +- YYPOPSTACK (1); \ +- goto yybackup; \ +- } \ +- else \ +- { \ +- yyerror (&yylloc, state, YY_("syntax error: cannot back up")); \ +- YYERROR; \ +- } \ +-while (YYID (0)) +- +- +-#define YYTERROR 1 +-#define YYERRCODE 256 +- +- +-/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. +- If N is 0, then set CURRENT to the empty location which ends +- the previous symbol: RHS[0] (always defined). */ +- +-#define YYRHSLOC(Rhs, K) ((Rhs)[K]) +-#ifndef YYLLOC_DEFAULT +-# define YYLLOC_DEFAULT(Current, Rhs, N) \ +- do \ +- if (YYID (N)) \ +- { \ +- (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ +- (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ +- (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ +- (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ +- } \ +- else \ +- { \ +- (Current).first_line = (Current).last_line = \ +- YYRHSLOC (Rhs, 0).last_line; \ +- (Current).first_column = (Current).last_column = \ +- YYRHSLOC (Rhs, 0).last_column; \ +- } \ +- while (YYID (0)) +-#endif +- +- +-/* YY_LOCATION_PRINT -- Print the location on the stream. +- This macro was not mandated originally: define only if we know +- we won't break user code: when these are the locations we know. */ +- +-#ifndef YY_LOCATION_PRINT +-# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL +-# define YY_LOCATION_PRINT(File, Loc) \ +- fprintf (File, "%d.%d-%d.%d", \ +- (Loc).first_line, (Loc).first_column, \ +- (Loc).last_line, (Loc).last_column) +-# else +-# define YY_LOCATION_PRINT(File, Loc) ((void) 0) +-# endif +-#endif +- +- +-/* YYLEX -- calling `yylex' with the right arguments. */ +- +-#ifdef YYLEX_PARAM +-# define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM) +-#else +-# define YYLEX yylex (&yylval, &yylloc, scanner) +-#endif +- +-/* Enable debugging if requested. */ +-#if YYDEBUG +- +-# ifndef YYFPRINTF +-# include /* INFRINGES ON USER NAME SPACE */ +-# define YYFPRINTF fprintf +-# endif +- +-# define YYDPRINTF(Args) \ +-do { \ +- if (yydebug) \ +- YYFPRINTF Args; \ +-} while (YYID (0)) +- +-# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ +-do { \ +- if (yydebug) \ +- { \ +- YYFPRINTF (stderr, "%s ", Title); \ +- yy_symbol_print (stderr, \ +- Type, Value, Location, state); \ +- YYFPRINTF (stderr, "\n"); \ +- } \ +-} while (YYID (0)) +- +- +-/*--------------------------------. +-| Print this symbol on YYOUTPUT. | +-`--------------------------------*/ +- +-/*ARGSUSED*/ +-#if (defined __STDC__ || defined __C99__FUNC__ \ +- || defined __cplusplus || defined _MSC_VER) +-static void +-yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, struct _mesa_glsl_parse_state *state) +-#else +-static void +-yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, state) +- FILE *yyoutput; +- int yytype; +- YYSTYPE const * const yyvaluep; +- YYLTYPE const * const yylocationp; +- struct _mesa_glsl_parse_state *state; +-#endif +-{ +- if (!yyvaluep) +- return; +- YYUSE (yylocationp); +- YYUSE (state); +-# ifdef YYPRINT +- if (yytype < YYNTOKENS) +- YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); +-# else +- YYUSE (yyoutput); +-# endif +- switch (yytype) +- { +- default: +- break; +- } +-} +- +- +-/*--------------------------------. +-| Print this symbol on YYOUTPUT. | +-`--------------------------------*/ +- +-#if (defined __STDC__ || defined __C99__FUNC__ \ +- || defined __cplusplus || defined _MSC_VER) +-static void +-yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, struct _mesa_glsl_parse_state *state) +-#else +-static void +-yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp, state) +- FILE *yyoutput; +- int yytype; +- YYSTYPE const * const yyvaluep; +- YYLTYPE const * const yylocationp; +- struct _mesa_glsl_parse_state *state; +-#endif +-{ +- if (yytype < YYNTOKENS) +- YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); +- else +- YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); +- +- YY_LOCATION_PRINT (yyoutput, *yylocationp); +- YYFPRINTF (yyoutput, ": "); +- yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, state); +- YYFPRINTF (yyoutput, ")"); +-} +- +-/*------------------------------------------------------------------. +-| yy_stack_print -- Print the state stack from its BOTTOM up to its | +-| TOP (included). | +-`------------------------------------------------------------------*/ +- +-#if (defined __STDC__ || defined __C99__FUNC__ \ +- || defined __cplusplus || defined _MSC_VER) +-static void +-yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) +-#else +-static void +-yy_stack_print (yybottom, yytop) +- yytype_int16 *yybottom; +- yytype_int16 *yytop; +-#endif +-{ +- YYFPRINTF (stderr, "Stack now"); +- for (; yybottom <= yytop; yybottom++) +- { +- int yybot = *yybottom; +- YYFPRINTF (stderr, " %d", yybot); +- } +- YYFPRINTF (stderr, "\n"); +-} +- +-# define YY_STACK_PRINT(Bottom, Top) \ +-do { \ +- if (yydebug) \ +- yy_stack_print ((Bottom), (Top)); \ +-} while (YYID (0)) +- +- +-/*------------------------------------------------. +-| Report that the YYRULE is going to be reduced. | +-`------------------------------------------------*/ +- +-#if (defined __STDC__ || defined __C99__FUNC__ \ +- || defined __cplusplus || defined _MSC_VER) +-static void +-yy_reduce_print (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, struct _mesa_glsl_parse_state *state) +-#else +-static void +-yy_reduce_print (yyvsp, yylsp, yyrule, state) +- YYSTYPE *yyvsp; +- YYLTYPE *yylsp; +- int yyrule; +- struct _mesa_glsl_parse_state *state; +-#endif +-{ +- int yynrhs = yyr2[yyrule]; +- int yyi; +- unsigned long int yylno = yyrline[yyrule]; +- YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", +- yyrule - 1, yylno); +- /* The symbols being reduced. */ +- for (yyi = 0; yyi < yynrhs; yyi++) +- { +- YYFPRINTF (stderr, " $%d = ", yyi + 1); +- yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], +- &(yyvsp[(yyi + 1) - (yynrhs)]) +- , &(yylsp[(yyi + 1) - (yynrhs)]) , state); +- YYFPRINTF (stderr, "\n"); +- } +-} +- +-# define YY_REDUCE_PRINT(Rule) \ +-do { \ +- if (yydebug) \ +- yy_reduce_print (yyvsp, yylsp, Rule, state); \ +-} while (YYID (0)) +- +-/* Nonzero means print parse trace. It is left uninitialized so that +- multiple parsers can coexist. */ +-int yydebug; +-#else /* !YYDEBUG */ +-# define YYDPRINTF(Args) +-# define YY_SYMBOL_PRINT(Title, Type, Value, Location) +-# define YY_STACK_PRINT(Bottom, Top) +-# define YY_REDUCE_PRINT(Rule) +-#endif /* !YYDEBUG */ +- +- +-/* YYINITDEPTH -- initial size of the parser's stacks. */ +-#ifndef YYINITDEPTH +-# define YYINITDEPTH 200 +-#endif +- +-/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only +- if the built-in stack extension method is used). +- +- Do not make this value too large; the results are undefined if +- YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) +- evaluated with infinite-precision integer arithmetic. */ +- +-#ifndef YYMAXDEPTH +-# define YYMAXDEPTH 10000 +-#endif +- +- +- +-#if YYERROR_VERBOSE +- +-# ifndef yystrlen +-# if defined __GLIBC__ && defined _STRING_H +-# define yystrlen strlen +-# else +-/* Return the length of YYSTR. */ +-#if (defined __STDC__ || defined __C99__FUNC__ \ +- || defined __cplusplus || defined _MSC_VER) +-static YYSIZE_T +-yystrlen (const char *yystr) +-#else +-static YYSIZE_T +-yystrlen (yystr) +- const char *yystr; +-#endif +-{ +- YYSIZE_T yylen; +- for (yylen = 0; yystr[yylen]; yylen++) +- continue; +- return yylen; +-} +-# endif +-# endif +- +-# ifndef yystpcpy +-# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE +-# define yystpcpy stpcpy +-# else +-/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in +- YYDEST. */ +-#if (defined __STDC__ || defined __C99__FUNC__ \ +- || defined __cplusplus || defined _MSC_VER) +-static char * +-yystpcpy (char *yydest, const char *yysrc) +-#else +-static char * +-yystpcpy (yydest, yysrc) +- char *yydest; +- const char *yysrc; +-#endif +-{ +- char *yyd = yydest; +- const char *yys = yysrc; +- +- while ((*yyd++ = *yys++) != '\0') +- continue; +- +- return yyd - 1; +-} +-# endif +-# endif +- +-# ifndef yytnamerr +-/* Copy to YYRES the contents of YYSTR after stripping away unnecessary +- quotes and backslashes, so that it's suitable for yyerror. The +- heuristic is that double-quoting is unnecessary unless the string +- contains an apostrophe, a comma, or backslash (other than +- backslash-backslash). YYSTR is taken from yytname. If YYRES is +- null, do not copy; instead, return the length of what the result +- would have been. */ +-static YYSIZE_T +-yytnamerr (char *yyres, const char *yystr) +-{ +- if (*yystr == '"') +- { +- YYSIZE_T yyn = 0; +- char const *yyp = yystr; +- +- for (;;) +- switch (*++yyp) +- { +- case '\'': +- case ',': +- goto do_not_strip_quotes; +- +- case '\\': +- if (*++yyp != '\\') +- goto do_not_strip_quotes; +- /* Fall through. */ +- default: +- if (yyres) +- yyres[yyn] = *yyp; +- yyn++; +- break; +- +- case '"': +- if (yyres) +- yyres[yyn] = '\0'; +- return yyn; +- } +- do_not_strip_quotes: ; +- } +- +- if (! yyres) +- return yystrlen (yystr); +- +- return yystpcpy (yyres, yystr) - yyres; +-} +-# endif +- +-/* Copy into YYRESULT an error message about the unexpected token +- YYCHAR while in state YYSTATE. Return the number of bytes copied, +- including the terminating null byte. If YYRESULT is null, do not +- copy anything; just return the number of bytes that would be +- copied. As a special case, return 0 if an ordinary "syntax error" +- message will do. Return YYSIZE_MAXIMUM if overflow occurs during +- size calculation. */ +-static YYSIZE_T +-yysyntax_error (char *yyresult, int yystate, int yychar) +-{ +- int yyn = yypact[yystate]; +- +- if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) +- return 0; +- else +- { +- int yytype = YYTRANSLATE (yychar); +- YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); +- YYSIZE_T yysize = yysize0; +- YYSIZE_T yysize1; +- int yysize_overflow = 0; +- enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; +- char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; +- int yyx; +- +-# if 0 +- /* This is so xgettext sees the translatable formats that are +- constructed on the fly. */ +- YY_("syntax error, unexpected %s"); +- YY_("syntax error, unexpected %s, expecting %s"); +- YY_("syntax error, unexpected %s, expecting %s or %s"); +- YY_("syntax error, unexpected %s, expecting %s or %s or %s"); +- YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); +-# endif +- char *yyfmt; +- char const *yyf; +- static char const yyunexpected[] = "syntax error, unexpected %s"; +- static char const yyexpecting[] = ", expecting %s"; +- static char const yyor[] = " or %s"; +- char yyformat[sizeof yyunexpected +- + sizeof yyexpecting - 1 +- + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) +- * (sizeof yyor - 1))]; +- char const *yyprefix = yyexpecting; +- +- /* Start YYX at -YYN if negative to avoid negative indexes in +- YYCHECK. */ +- int yyxbegin = yyn < 0 ? -yyn : 0; +- +- /* Stay within bounds of both yycheck and yytname. */ +- int yychecklim = YYLAST - yyn + 1; +- int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; +- int yycount = 1; +- +- yyarg[0] = yytname[yytype]; +- yyfmt = yystpcpy (yyformat, yyunexpected); +- +- for (yyx = yyxbegin; yyx < yyxend; ++yyx) +- if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) +- { +- if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) +- { +- yycount = 1; +- yysize = yysize0; +- yyformat[sizeof yyunexpected - 1] = '\0'; +- break; +- } +- yyarg[yycount++] = yytname[yyx]; +- yysize1 = yysize + yytnamerr (0, yytname[yyx]); +- yysize_overflow |= (yysize1 < yysize); +- yysize = yysize1; +- yyfmt = yystpcpy (yyfmt, yyprefix); +- yyprefix = yyor; +- } +- +- yyf = YY_(yyformat); +- yysize1 = yysize + yystrlen (yyf); +- yysize_overflow |= (yysize1 < yysize); +- yysize = yysize1; +- +- if (yysize_overflow) +- return YYSIZE_MAXIMUM; +- +- if (yyresult) +- { +- /* Avoid sprintf, as that infringes on the user's name space. +- Don't have undefined behavior even if the translation +- produced a string with the wrong number of "%s"s. */ +- char *yyp = yyresult; +- int yyi = 0; +- while ((*yyp = *yyf) != '\0') +- { +- if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) +- { +- yyp += yytnamerr (yyp, yyarg[yyi++]); +- yyf += 2; +- } +- else +- { +- yyp++; +- yyf++; +- } +- } +- } +- return yysize; +- } +-} +-#endif /* YYERROR_VERBOSE */ +- +- +-/*-----------------------------------------------. +-| Release the memory associated to this symbol. | +-`-----------------------------------------------*/ +- +-/*ARGSUSED*/ +-#if (defined __STDC__ || defined __C99__FUNC__ \ +- || defined __cplusplus || defined _MSC_VER) +-static void +-yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, struct _mesa_glsl_parse_state *state) +-#else +-static void +-yydestruct (yymsg, yytype, yyvaluep, yylocationp, state) +- const char *yymsg; +- int yytype; +- YYSTYPE *yyvaluep; +- YYLTYPE *yylocationp; +- struct _mesa_glsl_parse_state *state; +-#endif +-{ +- YYUSE (yyvaluep); +- YYUSE (yylocationp); +- YYUSE (state); +- +- if (!yymsg) +- yymsg = "Deleting"; +- YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); +- +- switch (yytype) +- { +- +- default: +- break; +- } +-} +- +-/* Prevent warnings from -Wmissing-prototypes. */ +-#ifdef YYPARSE_PARAM +-#if defined __STDC__ || defined __cplusplus +-int yyparse (void *YYPARSE_PARAM); +-#else +-int yyparse (); +-#endif +-#else /* ! YYPARSE_PARAM */ +-#if defined __STDC__ || defined __cplusplus +-int yyparse (struct _mesa_glsl_parse_state *state); +-#else +-int yyparse (); +-#endif +-#endif /* ! YYPARSE_PARAM */ +- +- +- +- +- +-/*-------------------------. +-| yyparse or yypush_parse. | +-`-------------------------*/ +- +-#ifdef YYPARSE_PARAM +-#if (defined __STDC__ || defined __C99__FUNC__ \ +- || defined __cplusplus || defined _MSC_VER) +-int +-yyparse (void *YYPARSE_PARAM) +-#else +-int +-yyparse (YYPARSE_PARAM) +- void *YYPARSE_PARAM; +-#endif +-#else /* ! YYPARSE_PARAM */ +-#if (defined __STDC__ || defined __C99__FUNC__ \ +- || defined __cplusplus || defined _MSC_VER) +-int +-yyparse (struct _mesa_glsl_parse_state *state) +-#else +-int +-yyparse (state) +- struct _mesa_glsl_parse_state *state; +-#endif +-#endif +-{ +-/* The lookahead symbol. */ +-int yychar; +- +-/* The semantic value of the lookahead symbol. */ +-YYSTYPE yylval; +- +-/* Location data for the lookahead symbol. */ +-YYLTYPE yylloc; +- +- /* Number of syntax errors so far. */ +- int yynerrs; +- +- int yystate; +- /* Number of tokens to shift before error messages enabled. */ +- int yyerrstatus; +- +- /* The stacks and their tools: +- `yyss': related to states. +- `yyvs': related to semantic values. +- `yyls': related to locations. +- +- Refer to the stacks thru separate pointers, to allow yyoverflow +- to reallocate them elsewhere. */ +- +- /* The state stack. */ +- yytype_int16 yyssa[YYINITDEPTH]; +- yytype_int16 *yyss; +- yytype_int16 *yyssp; +- +- /* The semantic value stack. */ +- YYSTYPE yyvsa[YYINITDEPTH]; +- YYSTYPE *yyvs; +- YYSTYPE *yyvsp; +- +- /* The location stack. */ +- YYLTYPE yylsa[YYINITDEPTH]; +- YYLTYPE *yyls; +- YYLTYPE *yylsp; +- +- /* The locations where the error started and ended. */ +- YYLTYPE yyerror_range[3]; +- +- YYSIZE_T yystacksize; +- +- int yyn; +- int yyresult; +- /* Lookahead token as an internal (translated) token number. */ +- int yytoken; +- /* The variables used to return semantic value and location from the +- action routines. */ +- YYSTYPE yyval; +- YYLTYPE yyloc; +- +-#if YYERROR_VERBOSE +- /* Buffer for error messages, and its allocated size. */ +- char yymsgbuf[128]; +- char *yymsg = yymsgbuf; +- YYSIZE_T yymsg_alloc = sizeof yymsgbuf; +-#endif +- +-#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) +- +- /* The number of symbols on the RHS of the reduced rule. +- Keep to zero when no symbol should be popped. */ +- int yylen = 0; +- +- yytoken = 0; +- yyss = yyssa; +- yyvs = yyvsa; +- yyls = yylsa; +- yystacksize = YYINITDEPTH; +- +- YYDPRINTF ((stderr, "Starting parse\n")); +- +- yystate = 0; +- yyerrstatus = 0; +- yynerrs = 0; +- yychar = YYEMPTY; /* Cause a token to be read. */ +- +- /* Initialize stack pointers. +- Waste one element of value and location stack +- so that they stay on the same level as the state stack. +- The wasted elements are never initialized. */ +- yyssp = yyss; +- yyvsp = yyvs; +- yylsp = yyls; +- +-#if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL +- /* Initialize the default location before parsing starts. */ +- yylloc.first_line = yylloc.last_line = 1; +- yylloc.first_column = yylloc.last_column = 1; +-#endif +- +-/* User initialization code. */ +- +-/* Line 1251 of yacc.c */ +-#line 41 "glsl_parser.ypp" +-{ +- yylloc.first_line = 1; +- yylloc.first_column = 1; +- yylloc.last_line = 1; +- yylloc.last_column = 1; +- yylloc.source = 0; +-} +- +-/* Line 1251 of yacc.c */ +-#line 2707 "glsl_parser.cpp" +- yylsp[0] = yylloc; +- +- goto yysetstate; +- +-/*------------------------------------------------------------. +-| yynewstate -- Push a new state, which is found in yystate. | +-`------------------------------------------------------------*/ +- yynewstate: +- /* In all cases, when you get here, the value and location stacks +- have just been pushed. So pushing a state here evens the stacks. */ +- yyssp++; +- +- yysetstate: +- *yyssp = yystate; +- +- if (yyss + yystacksize - 1 <= yyssp) +- { +- /* Get the current used size of the three stacks, in elements. */ +- YYSIZE_T yysize = yyssp - yyss + 1; +- +-#ifdef yyoverflow +- { +- /* Give user a chance to reallocate the stack. Use copies of +- these so that the &'s don't force the real ones into +- memory. */ +- YYSTYPE *yyvs1 = yyvs; +- yytype_int16 *yyss1 = yyss; +- YYLTYPE *yyls1 = yyls; +- +- /* Each stack pointer address is followed by the size of the +- data in use in that stack, in bytes. This used to be a +- conditional around just the two extra args, but that might +- be undefined if yyoverflow is a macro. */ +- yyoverflow (YY_("memory exhausted"), +- &yyss1, yysize * sizeof (*yyssp), +- &yyvs1, yysize * sizeof (*yyvsp), +- &yyls1, yysize * sizeof (*yylsp), +- &yystacksize); +- +- yyls = yyls1; +- yyss = yyss1; +- yyvs = yyvs1; +- } +-#else /* no yyoverflow */ +-# ifndef YYSTACK_RELOCATE +- goto yyexhaustedlab; +-# else +- /* Extend the stack our own way. */ +- if (YYMAXDEPTH <= yystacksize) +- goto yyexhaustedlab; +- yystacksize *= 2; +- if (YYMAXDEPTH < yystacksize) +- yystacksize = YYMAXDEPTH; +- +- { +- yytype_int16 *yyss1 = yyss; +- union yyalloc *yyptr = +- (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); +- if (! yyptr) +- goto yyexhaustedlab; +- YYSTACK_RELOCATE (yyss_alloc, yyss); +- YYSTACK_RELOCATE (yyvs_alloc, yyvs); +- YYSTACK_RELOCATE (yyls_alloc, yyls); +-# undef YYSTACK_RELOCATE +- if (yyss1 != yyssa) +- YYSTACK_FREE (yyss1); +- } +-# endif +-#endif /* no yyoverflow */ +- +- yyssp = yyss + yysize - 1; +- yyvsp = yyvs + yysize - 1; +- yylsp = yyls + yysize - 1; +- +- YYDPRINTF ((stderr, "Stack size increased to %lu\n", +- (unsigned long int) yystacksize)); +- +- if (yyss + yystacksize - 1 <= yyssp) +- YYABORT; +- } +- +- YYDPRINTF ((stderr, "Entering state %d\n", yystate)); +- +- if (yystate == YYFINAL) +- YYACCEPT; +- +- goto yybackup; +- +-/*-----------. +-| yybackup. | +-`-----------*/ +-yybackup: +- +- /* Do appropriate processing given the current state. Read a +- lookahead token if we need one and don't already have one. */ +- +- /* First try to decide what to do without reference to lookahead token. */ +- yyn = yypact[yystate]; +- if (yyn == YYPACT_NINF) +- goto yydefault; +- +- /* Not known => get a lookahead token if don't already have one. */ +- +- /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ +- if (yychar == YYEMPTY) +- { +- YYDPRINTF ((stderr, "Reading a token: ")); +- yychar = YYLEX; +- } +- +- if (yychar <= YYEOF) +- { +- yychar = yytoken = YYEOF; +- YYDPRINTF ((stderr, "Now at end of input.\n")); +- } +- else +- { +- yytoken = YYTRANSLATE (yychar); +- YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); +- } +- +- /* If the proper action on seeing token YYTOKEN is to reduce or to +- detect an error, take that action. */ +- yyn += yytoken; +- if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) +- goto yydefault; +- yyn = yytable[yyn]; +- if (yyn <= 0) +- { +- if (yyn == 0 || yyn == YYTABLE_NINF) +- goto yyerrlab; +- yyn = -yyn; +- goto yyreduce; +- } +- +- /* Count tokens shifted since error; after three, turn off error +- status. */ +- if (yyerrstatus) +- yyerrstatus--; +- +- /* Shift the lookahead token. */ +- YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); +- +- /* Discard the shifted token. */ +- yychar = YYEMPTY; +- +- yystate = yyn; +- *++yyvsp = yylval; +- *++yylsp = yylloc; +- goto yynewstate; +- +- +-/*-----------------------------------------------------------. +-| yydefault -- do the default action for the current state. | +-`-----------------------------------------------------------*/ +-yydefault: +- yyn = yydefact[yystate]; +- if (yyn == 0) +- goto yyerrlab; +- goto yyreduce; +- +- +-/*-----------------------------. +-| yyreduce -- Do a reduction. | +-`-----------------------------*/ +-yyreduce: +- /* yyn is the number of a rule to reduce with. */ +- yylen = yyr2[yyn]; +- +- /* If YYLEN is nonzero, implement the default value of the action: +- `$$ = $1'. +- +- Otherwise, the following line sets YYVAL to garbage. +- This behavior is undocumented and Bison +- users should not rely upon it. Assigning to YYVAL +- unconditionally makes the parser a bit smaller, and it avoids a +- GCC warning that YYVAL may be used uninitialized. */ +- yyval = yyvsp[1-yylen]; +- +- /* Default location. */ +- YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); +- YY_REDUCE_PRINT (yyn); +- switch (yyn) +- { +- case 2: +- +-/* Line 1464 of yacc.c */ +-#line 220 "glsl_parser.ypp" +- { +- _mesa_glsl_initialize_types(state); +- ;} +- break; +- +- case 3: +- +-/* Line 1464 of yacc.c */ +-#line 224 "glsl_parser.ypp" +- { +- delete state->symbols; +- state->symbols = new(ralloc_parent(state)) glsl_symbol_table; +- _mesa_glsl_initialize_types(state); +- ;} +- break; +- +- case 5: +- +-/* Line 1464 of yacc.c */ +-#line 234 "glsl_parser.ypp" +- { +- bool supported = false; +- +- switch ((yyvsp[(2) - (3)].n)) { +- case 100: +- state->es_shader = true; +- supported = state->Const.GLSL_100ES; +- break; +- case 110: +- supported = state->Const.GLSL_110; +- break; +- case 120: +- supported = state->Const.GLSL_120; +- break; +- case 130: +- supported = state->Const.GLSL_130; +- break; +- default: +- supported = false; +- break; +- } +- +- state->language_version = (yyvsp[(2) - (3)].n); +- state->version_string = +- ralloc_asprintf(state, "GLSL%s %d.%02d", +- state->es_shader ? " ES" : "", +- state->language_version / 100, +- state->language_version % 100); +- +- if (!supported) { +- _mesa_glsl_error(& (yylsp[(2) - (3)]), state, "%s is not supported. " +- "Supported versions are: %s\n", +- state->version_string, +- state->supported_version_string); +- } +- ;} +- break; +- +- case 10: +- +-/* Line 1464 of yacc.c */ +-#line 278 "glsl_parser.ypp" +- { +- if (state->language_version < 120) { +- _mesa_glsl_warning(& (yylsp[(1) - (2)]), state, +- "pragma `invariant(all)' not supported in %s", +- state->version_string); +- } else { +- state->all_invariant = true; +- } +- ;} +- break; +- +- case 16: +- +-/* Line 1464 of yacc.c */ +-#line 302 "glsl_parser.ypp" +- { +- if (!_mesa_glsl_process_extension((yyvsp[(2) - (5)].identifier), & (yylsp[(2) - (5)]), (yyvsp[(4) - (5)].identifier), & (yylsp[(4) - (5)]), state)) { +- YYERROR; +- } +- ;} +- break; +- +- case 17: +- +-/* Line 1464 of yacc.c */ +-#line 311 "glsl_parser.ypp" +- { +- /* FINISHME: The NULL test is required because pragmas are set to +- * FINISHME: NULL. (See production rule for external_declaration.) +- */ +- if ((yyvsp[(1) - (1)].node) != NULL) +- state->translation_unit.push_tail(& (yyvsp[(1) - (1)].node)->link); +- ;} +- break; +- +- case 18: +- +-/* Line 1464 of yacc.c */ +-#line 319 "glsl_parser.ypp" +- { +- /* FINISHME: The NULL test is required because pragmas are set to +- * FINISHME: NULL. (See production rule for external_declaration.) +- */ +- if ((yyvsp[(2) - (2)].node) != NULL) +- state->translation_unit.push_tail(& (yyvsp[(2) - (2)].node)->link); +- ;} +- break; +- +- case 21: +- +-/* Line 1464 of yacc.c */ +-#line 335 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression(ast_identifier, NULL, NULL, NULL); +- (yyval.expression)->set_location(yylloc); +- (yyval.expression)->primary_expression.identifier = (yyvsp[(1) - (1)].identifier); +- ;} +- break; +- +- case 22: +- +-/* Line 1464 of yacc.c */ +-#line 342 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression(ast_int_constant, NULL, NULL, NULL); +- (yyval.expression)->set_location(yylloc); +- (yyval.expression)->primary_expression.int_constant = (yyvsp[(1) - (1)].n); +- ;} +- break; +- +- case 23: +- +-/* Line 1464 of yacc.c */ +-#line 349 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression(ast_uint_constant, NULL, NULL, NULL); +- (yyval.expression)->set_location(yylloc); +- (yyval.expression)->primary_expression.uint_constant = (yyvsp[(1) - (1)].n); +- ;} +- break; +- +- case 24: +- +-/* Line 1464 of yacc.c */ +-#line 356 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression(ast_float_constant, NULL, NULL, NULL); +- (yyval.expression)->set_location(yylloc); +- (yyval.expression)->primary_expression.float_constant = (yyvsp[(1) - (1)].real); +- ;} +- break; +- +- case 25: +- +-/* Line 1464 of yacc.c */ +-#line 363 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression(ast_bool_constant, NULL, NULL, NULL); +- (yyval.expression)->set_location(yylloc); +- (yyval.expression)->primary_expression.bool_constant = (yyvsp[(1) - (1)].n); +- ;} +- break; +- +- case 26: +- +-/* Line 1464 of yacc.c */ +-#line 370 "glsl_parser.ypp" +- { +- (yyval.expression) = (yyvsp[(2) - (3)].expression); +- ;} +- break; +- +- case 28: +- +-/* Line 1464 of yacc.c */ +-#line 378 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression(ast_array_index, (yyvsp[(1) - (4)].expression), (yyvsp[(3) - (4)].expression), NULL); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 29: +- +-/* Line 1464 of yacc.c */ +-#line 384 "glsl_parser.ypp" +- { +- (yyval.expression) = (yyvsp[(1) - (1)].expression); +- ;} +- break; +- +- case 30: +- +-/* Line 1464 of yacc.c */ +-#line 388 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression(ast_field_selection, (yyvsp[(1) - (3)].expression), NULL, NULL); +- (yyval.expression)->set_location(yylloc); +- (yyval.expression)->primary_expression.identifier = (yyvsp[(3) - (3)].identifier); +- ;} +- break; +- +- case 31: +- +-/* Line 1464 of yacc.c */ +-#line 395 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression(ast_post_inc, (yyvsp[(1) - (2)].expression), NULL, NULL); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 32: +- +-/* Line 1464 of yacc.c */ +-#line 401 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression(ast_post_dec, (yyvsp[(1) - (2)].expression), NULL, NULL); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 36: +- +-/* Line 1464 of yacc.c */ +-#line 419 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression(ast_field_selection, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression), NULL); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 41: +- +-/* Line 1464 of yacc.c */ +-#line 438 "glsl_parser.ypp" +- { +- (yyval.expression) = (yyvsp[(1) - (2)].expression); +- (yyval.expression)->set_location(yylloc); +- (yyval.expression)->expressions.push_tail(& (yyvsp[(2) - (2)].expression)->link); +- ;} +- break; +- +- case 42: +- +-/* Line 1464 of yacc.c */ +-#line 444 "glsl_parser.ypp" +- { +- (yyval.expression) = (yyvsp[(1) - (3)].expression); +- (yyval.expression)->set_location(yylloc); +- (yyval.expression)->expressions.push_tail(& (yyvsp[(3) - (3)].expression)->link); +- ;} +- break; +- +- case 44: +- +-/* Line 1464 of yacc.c */ +-#line 460 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_function_expression((yyvsp[(1) - (1)].type_specifier)); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 45: +- +-/* Line 1464 of yacc.c */ +-#line 466 "glsl_parser.ypp" +- { +- void *ctx = state; +- ast_expression *callee = new(ctx) ast_expression((yyvsp[(1) - (1)].identifier)); +- (yyval.expression) = new(ctx) ast_function_expression(callee); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 46: +- +-/* Line 1464 of yacc.c */ +-#line 473 "glsl_parser.ypp" +- { +- void *ctx = state; +- ast_expression *callee = new(ctx) ast_expression((yyvsp[(1) - (1)].identifier)); +- (yyval.expression) = new(ctx) ast_function_expression(callee); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 51: +- +-/* Line 1464 of yacc.c */ +-#line 493 "glsl_parser.ypp" +- { +- (yyval.expression) = (yyvsp[(1) - (2)].expression); +- (yyval.expression)->set_location(yylloc); +- (yyval.expression)->expressions.push_tail(& (yyvsp[(2) - (2)].expression)->link); +- ;} +- break; +- +- case 52: +- +-/* Line 1464 of yacc.c */ +-#line 499 "glsl_parser.ypp" +- { +- (yyval.expression) = (yyvsp[(1) - (3)].expression); +- (yyval.expression)->set_location(yylloc); +- (yyval.expression)->expressions.push_tail(& (yyvsp[(3) - (3)].expression)->link); +- ;} +- break; +- +- case 53: +- +-/* Line 1464 of yacc.c */ +-#line 511 "glsl_parser.ypp" +- { +- void *ctx = state; +- ast_expression *callee = new(ctx) ast_expression((yyvsp[(1) - (2)].identifier)); +- (yyval.expression) = new(ctx) ast_function_expression(callee); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 55: +- +-/* Line 1464 of yacc.c */ +-#line 523 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression(ast_pre_inc, (yyvsp[(2) - (2)].expression), NULL, NULL); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 56: +- +-/* Line 1464 of yacc.c */ +-#line 529 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression(ast_pre_dec, (yyvsp[(2) - (2)].expression), NULL, NULL); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 57: +- +-/* Line 1464 of yacc.c */ +-#line 535 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression((yyvsp[(1) - (2)].n), (yyvsp[(2) - (2)].expression), NULL, NULL); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 58: +- +-/* Line 1464 of yacc.c */ +-#line 544 "glsl_parser.ypp" +- { (yyval.n) = ast_plus; ;} +- break; +- +- case 59: +- +-/* Line 1464 of yacc.c */ +-#line 545 "glsl_parser.ypp" +- { (yyval.n) = ast_neg; ;} +- break; +- +- case 60: +- +-/* Line 1464 of yacc.c */ +-#line 546 "glsl_parser.ypp" +- { (yyval.n) = ast_logic_not; ;} +- break; +- +- case 61: +- +-/* Line 1464 of yacc.c */ +-#line 547 "glsl_parser.ypp" +- { (yyval.n) = ast_bit_not; ;} +- break; +- +- case 63: +- +-/* Line 1464 of yacc.c */ +-#line 553 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression_bin(ast_mul, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 64: +- +-/* Line 1464 of yacc.c */ +-#line 559 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression_bin(ast_div, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 65: +- +-/* Line 1464 of yacc.c */ +-#line 565 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression_bin(ast_mod, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 67: +- +-/* Line 1464 of yacc.c */ +-#line 575 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression_bin(ast_add, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 68: +- +-/* Line 1464 of yacc.c */ +-#line 581 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression_bin(ast_sub, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 70: +- +-/* Line 1464 of yacc.c */ +-#line 591 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression_bin(ast_lshift, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 71: +- +-/* Line 1464 of yacc.c */ +-#line 597 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression_bin(ast_rshift, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 73: +- +-/* Line 1464 of yacc.c */ +-#line 607 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression_bin(ast_less, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 74: +- +-/* Line 1464 of yacc.c */ +-#line 613 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression_bin(ast_greater, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 75: +- +-/* Line 1464 of yacc.c */ +-#line 619 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression_bin(ast_lequal, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 76: +- +-/* Line 1464 of yacc.c */ +-#line 625 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression_bin(ast_gequal, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 78: +- +-/* Line 1464 of yacc.c */ +-#line 635 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression_bin(ast_equal, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 79: +- +-/* Line 1464 of yacc.c */ +-#line 641 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression_bin(ast_nequal, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 81: +- +-/* Line 1464 of yacc.c */ +-#line 651 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression_bin(ast_bit_or, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 83: +- +-/* Line 1464 of yacc.c */ +-#line 661 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression_bin(ast_bit_xor, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 85: +- +-/* Line 1464 of yacc.c */ +-#line 671 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression_bin(ast_bit_or, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 87: +- +-/* Line 1464 of yacc.c */ +-#line 681 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression_bin(ast_logic_and, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 89: +- +-/* Line 1464 of yacc.c */ +-#line 691 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression_bin(ast_logic_xor, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 91: +- +-/* Line 1464 of yacc.c */ +-#line 701 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression_bin(ast_logic_or, (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression)); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 93: +- +-/* Line 1464 of yacc.c */ +-#line 711 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression(ast_conditional, (yyvsp[(1) - (5)].expression), (yyvsp[(3) - (5)].expression), (yyvsp[(5) - (5)].expression)); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 95: +- +-/* Line 1464 of yacc.c */ +-#line 721 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.expression) = new(ctx) ast_expression((yyvsp[(2) - (3)].n), (yyvsp[(1) - (3)].expression), (yyvsp[(3) - (3)].expression), NULL); +- (yyval.expression)->set_location(yylloc); +- ;} +- break; +- +- case 96: +- +-/* Line 1464 of yacc.c */ +-#line 729 "glsl_parser.ypp" +- { (yyval.n) = ast_assign; ;} +- break; +- +- case 97: +- +-/* Line 1464 of yacc.c */ +-#line 730 "glsl_parser.ypp" +- { (yyval.n) = ast_mul_assign; ;} +- break; +- +- case 98: +- +-/* Line 1464 of yacc.c */ +-#line 731 "glsl_parser.ypp" +- { (yyval.n) = ast_div_assign; ;} +- break; +- +- case 99: +- +-/* Line 1464 of yacc.c */ +-#line 732 "glsl_parser.ypp" +- { (yyval.n) = ast_mod_assign; ;} +- break; +- +- case 100: +- +-/* Line 1464 of yacc.c */ +-#line 733 "glsl_parser.ypp" +- { (yyval.n) = ast_add_assign; ;} +- break; +- +- case 101: +- +-/* Line 1464 of yacc.c */ +-#line 734 "glsl_parser.ypp" +- { (yyval.n) = ast_sub_assign; ;} +- break; +- +- case 102: +- +-/* Line 1464 of yacc.c */ +-#line 735 "glsl_parser.ypp" +- { (yyval.n) = ast_ls_assign; ;} +- break; +- +- case 103: +- +-/* Line 1464 of yacc.c */ +-#line 736 "glsl_parser.ypp" +- { (yyval.n) = ast_rs_assign; ;} +- break; +- +- case 104: +- +-/* Line 1464 of yacc.c */ +-#line 737 "glsl_parser.ypp" +- { (yyval.n) = ast_and_assign; ;} +- break; +- +- case 105: +- +-/* Line 1464 of yacc.c */ +-#line 738 "glsl_parser.ypp" +- { (yyval.n) = ast_xor_assign; ;} +- break; +- +- case 106: +- +-/* Line 1464 of yacc.c */ +-#line 739 "glsl_parser.ypp" +- { (yyval.n) = ast_or_assign; ;} +- break; +- +- case 107: +- +-/* Line 1464 of yacc.c */ +-#line 744 "glsl_parser.ypp" +- { +- (yyval.expression) = (yyvsp[(1) - (1)].expression); +- ;} +- break; +- +- case 108: +- +-/* Line 1464 of yacc.c */ +-#line 748 "glsl_parser.ypp" +- { +- void *ctx = state; +- if ((yyvsp[(1) - (3)].expression)->oper != ast_sequence) { +- (yyval.expression) = new(ctx) ast_expression(ast_sequence, NULL, NULL, NULL); +- (yyval.expression)->set_location(yylloc); +- (yyval.expression)->expressions.push_tail(& (yyvsp[(1) - (3)].expression)->link); +- } else { +- (yyval.expression) = (yyvsp[(1) - (3)].expression); +- } +- +- (yyval.expression)->expressions.push_tail(& (yyvsp[(3) - (3)].expression)->link); +- ;} +- break; +- +- case 110: +- +-/* Line 1464 of yacc.c */ +-#line 768 "glsl_parser.ypp" +- { +- state->symbols->pop_scope(); +- (yyval.node) = (yyvsp[(1) - (2)].function); +- ;} +- break; +- +- case 111: +- +-/* Line 1464 of yacc.c */ +-#line 773 "glsl_parser.ypp" +- { +- (yyval.node) = (yyvsp[(1) - (2)].declarator_list); +- ;} +- break; +- +- case 112: +- +-/* Line 1464 of yacc.c */ +-#line 777 "glsl_parser.ypp" +- { +- (yyvsp[(3) - (4)].type_specifier)->precision = (yyvsp[(2) - (4)].n); +- (yyvsp[(3) - (4)].type_specifier)->is_precision_statement = true; +- (yyval.node) = (yyvsp[(3) - (4)].type_specifier); +- ;} +- break; +- +- case 116: +- +-/* Line 1464 of yacc.c */ +-#line 795 "glsl_parser.ypp" +- { +- (yyval.function) = (yyvsp[(1) - (2)].function); +- (yyval.function)->parameters.push_tail(& (yyvsp[(2) - (2)].parameter_declarator)->link); +- ;} +- break; +- +- case 117: +- +-/* Line 1464 of yacc.c */ +-#line 800 "glsl_parser.ypp" +- { +- (yyval.function) = (yyvsp[(1) - (3)].function); +- (yyval.function)->parameters.push_tail(& (yyvsp[(3) - (3)].parameter_declarator)->link); +- ;} +- break; +- +- case 118: +- +-/* Line 1464 of yacc.c */ +-#line 808 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.function) = new(ctx) ast_function(); +- (yyval.function)->set_location(yylloc); +- (yyval.function)->return_type = (yyvsp[(1) - (3)].fully_specified_type); +- (yyval.function)->identifier = (yyvsp[(2) - (3)].identifier); +- +- state->symbols->add_function((yyval.function)->identifier, +- new(state) ir_function((yyvsp[(2) - (3)].identifier))); +- state->symbols->push_scope(); +- ;} +- break; +- +- case 119: +- +-/* Line 1464 of yacc.c */ +-#line 823 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.parameter_declarator) = new(ctx) ast_parameter_declarator(); +- (yyval.parameter_declarator)->set_location(yylloc); +- (yyval.parameter_declarator)->type = new(ctx) ast_fully_specified_type(); +- (yyval.parameter_declarator)->type->set_location(yylloc); +- (yyval.parameter_declarator)->type->specifier = (yyvsp[(1) - (2)].type_specifier); +- (yyval.parameter_declarator)->identifier = (yyvsp[(2) - (2)].identifier); +- ;} +- break; +- +- case 120: +- +-/* Line 1464 of yacc.c */ +-#line 833 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.parameter_declarator) = new(ctx) ast_parameter_declarator(); +- (yyval.parameter_declarator)->set_location(yylloc); +- (yyval.parameter_declarator)->type = new(ctx) ast_fully_specified_type(); +- (yyval.parameter_declarator)->type->set_location(yylloc); +- (yyval.parameter_declarator)->type->specifier = (yyvsp[(1) - (5)].type_specifier); +- (yyval.parameter_declarator)->identifier = (yyvsp[(2) - (5)].identifier); +- (yyval.parameter_declarator)->is_array = true; +- (yyval.parameter_declarator)->array_size = (yyvsp[(4) - (5)].expression); +- ;} +- break; +- +- case 121: +- +-/* Line 1464 of yacc.c */ +-#line 848 "glsl_parser.ypp" +- { +- (yyvsp[(1) - (3)].type_qualifier).i |= (yyvsp[(2) - (3)].type_qualifier).i; +- +- (yyval.parameter_declarator) = (yyvsp[(3) - (3)].parameter_declarator); +- (yyval.parameter_declarator)->type->qualifier = (yyvsp[(1) - (3)].type_qualifier).q; +- ;} +- break; +- +- case 122: +- +-/* Line 1464 of yacc.c */ +-#line 855 "glsl_parser.ypp" +- { +- (yyval.parameter_declarator) = (yyvsp[(2) - (2)].parameter_declarator); +- (yyval.parameter_declarator)->type->qualifier = (yyvsp[(1) - (2)].type_qualifier).q; +- ;} +- break; +- +- case 123: +- +-/* Line 1464 of yacc.c */ +-#line 860 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyvsp[(1) - (3)].type_qualifier).i |= (yyvsp[(2) - (3)].type_qualifier).i; +- +- (yyval.parameter_declarator) = new(ctx) ast_parameter_declarator(); +- (yyval.parameter_declarator)->set_location(yylloc); +- (yyval.parameter_declarator)->type = new(ctx) ast_fully_specified_type(); +- (yyval.parameter_declarator)->type->qualifier = (yyvsp[(1) - (3)].type_qualifier).q; +- (yyval.parameter_declarator)->type->specifier = (yyvsp[(3) - (3)].type_specifier); +- ;} +- break; +- +- case 124: +- +-/* Line 1464 of yacc.c */ +-#line 871 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.parameter_declarator) = new(ctx) ast_parameter_declarator(); +- (yyval.parameter_declarator)->set_location(yylloc); +- (yyval.parameter_declarator)->type = new(ctx) ast_fully_specified_type(); +- (yyval.parameter_declarator)->type->qualifier = (yyvsp[(1) - (2)].type_qualifier).q; +- (yyval.parameter_declarator)->type->specifier = (yyvsp[(2) - (2)].type_specifier); +- ;} +- break; +- +- case 125: +- +-/* Line 1464 of yacc.c */ +-#line 882 "glsl_parser.ypp" +- { (yyval.type_qualifier).i = 0; ;} +- break; +- +- case 126: +- +-/* Line 1464 of yacc.c */ +-#line 883 "glsl_parser.ypp" +- { (yyval.type_qualifier).i = 0; (yyval.type_qualifier).q.in = 1; ;} +- break; +- +- case 127: +- +-/* Line 1464 of yacc.c */ +-#line 884 "glsl_parser.ypp" +- { (yyval.type_qualifier).i = 0; (yyval.type_qualifier).q.out = 1; ;} +- break; +- +- case 128: +- +-/* Line 1464 of yacc.c */ +-#line 885 "glsl_parser.ypp" +- { (yyval.type_qualifier).i = 0; (yyval.type_qualifier).q.in = 1; (yyval.type_qualifier).q.out = 1; ;} +- break; +- +- case 131: +- +-/* Line 1464 of yacc.c */ +-#line 895 "glsl_parser.ypp" +- { +- void *ctx = state; +- ast_declaration *decl = new(ctx) ast_declaration((yyvsp[(3) - (3)].identifier), false, NULL, NULL); +- decl->set_location(yylloc); +- +- (yyval.declarator_list) = (yyvsp[(1) - (3)].declarator_list); +- (yyval.declarator_list)->declarations.push_tail(&decl->link); +- state->symbols->add_variable((yyvsp[(3) - (3)].identifier), new(state) ir_variable(NULL, (yyvsp[(3) - (3)].identifier), ir_var_auto)); +- ;} +- break; +- +- case 132: +- +-/* Line 1464 of yacc.c */ +-#line 905 "glsl_parser.ypp" +- { +- void *ctx = state; +- ast_declaration *decl = new(ctx) ast_declaration((yyvsp[(3) - (5)].identifier), true, NULL, NULL); +- decl->set_location(yylloc); +- +- (yyval.declarator_list) = (yyvsp[(1) - (5)].declarator_list); +- (yyval.declarator_list)->declarations.push_tail(&decl->link); +- state->symbols->add_variable((yyvsp[(3) - (5)].identifier), new(state) ir_variable(NULL, (yyvsp[(3) - (5)].identifier), ir_var_auto)); +- ;} +- break; +- +- case 133: +- +-/* Line 1464 of yacc.c */ +-#line 915 "glsl_parser.ypp" +- { +- void *ctx = state; +- ast_declaration *decl = new(ctx) ast_declaration((yyvsp[(3) - (6)].identifier), true, (yyvsp[(5) - (6)].expression), NULL); +- decl->set_location(yylloc); +- +- (yyval.declarator_list) = (yyvsp[(1) - (6)].declarator_list); +- (yyval.declarator_list)->declarations.push_tail(&decl->link); +- state->symbols->add_variable((yyvsp[(3) - (6)].identifier), new(state) ir_variable(NULL, (yyvsp[(3) - (6)].identifier), ir_var_auto)); +- ;} +- break; +- +- case 134: +- +-/* Line 1464 of yacc.c */ +-#line 925 "glsl_parser.ypp" +- { +- void *ctx = state; +- ast_declaration *decl = new(ctx) ast_declaration((yyvsp[(3) - (7)].identifier), true, NULL, (yyvsp[(7) - (7)].expression)); +- decl->set_location(yylloc); +- +- (yyval.declarator_list) = (yyvsp[(1) - (7)].declarator_list); +- (yyval.declarator_list)->declarations.push_tail(&decl->link); +- state->symbols->add_variable((yyvsp[(3) - (7)].identifier), new(state) ir_variable(NULL, (yyvsp[(3) - (7)].identifier), ir_var_auto)); +- ;} +- break; +- +- case 135: +- +-/* Line 1464 of yacc.c */ +-#line 935 "glsl_parser.ypp" +- { +- void *ctx = state; +- ast_declaration *decl = new(ctx) ast_declaration((yyvsp[(3) - (8)].identifier), true, (yyvsp[(5) - (8)].expression), (yyvsp[(8) - (8)].expression)); +- decl->set_location(yylloc); +- +- (yyval.declarator_list) = (yyvsp[(1) - (8)].declarator_list); +- (yyval.declarator_list)->declarations.push_tail(&decl->link); +- state->symbols->add_variable((yyvsp[(3) - (8)].identifier), new(state) ir_variable(NULL, (yyvsp[(3) - (8)].identifier), ir_var_auto)); +- ;} +- break; +- +- case 136: +- +-/* Line 1464 of yacc.c */ +-#line 945 "glsl_parser.ypp" +- { +- void *ctx = state; +- ast_declaration *decl = new(ctx) ast_declaration((yyvsp[(3) - (5)].identifier), false, NULL, (yyvsp[(5) - (5)].expression)); +- decl->set_location(yylloc); +- +- (yyval.declarator_list) = (yyvsp[(1) - (5)].declarator_list); +- (yyval.declarator_list)->declarations.push_tail(&decl->link); +- state->symbols->add_variable((yyvsp[(3) - (5)].identifier), new(state) ir_variable(NULL, (yyvsp[(3) - (5)].identifier), ir_var_auto)); +- ;} +- break; +- +- case 137: +- +-/* Line 1464 of yacc.c */ +-#line 959 "glsl_parser.ypp" +- { +- void *ctx = state; +- if ((yyvsp[(1) - (1)].fully_specified_type)->specifier->type_specifier != ast_struct) { +- _mesa_glsl_error(& (yylsp[(1) - (1)]), state, "empty declaration list\n"); +- YYERROR; +- } else { +- (yyval.declarator_list) = new(ctx) ast_declarator_list((yyvsp[(1) - (1)].fully_specified_type)); +- (yyval.declarator_list)->set_location(yylloc); +- } +- ;} +- break; +- +- case 138: +- +-/* Line 1464 of yacc.c */ +-#line 970 "glsl_parser.ypp" +- { +- void *ctx = state; +- ast_declaration *decl = new(ctx) ast_declaration((yyvsp[(2) - (2)].identifier), false, NULL, NULL); +- +- (yyval.declarator_list) = new(ctx) ast_declarator_list((yyvsp[(1) - (2)].fully_specified_type)); +- (yyval.declarator_list)->set_location(yylloc); +- (yyval.declarator_list)->declarations.push_tail(&decl->link); +- ;} +- break; +- +- case 139: +- +-/* Line 1464 of yacc.c */ +-#line 979 "glsl_parser.ypp" +- { +- void *ctx = state; +- ast_declaration *decl = new(ctx) ast_declaration((yyvsp[(2) - (4)].identifier), true, NULL, NULL); +- +- (yyval.declarator_list) = new(ctx) ast_declarator_list((yyvsp[(1) - (4)].fully_specified_type)); +- (yyval.declarator_list)->set_location(yylloc); +- (yyval.declarator_list)->declarations.push_tail(&decl->link); +- ;} +- break; +- +- case 140: +- +-/* Line 1464 of yacc.c */ +-#line 988 "glsl_parser.ypp" +- { +- void *ctx = state; +- ast_declaration *decl = new(ctx) ast_declaration((yyvsp[(2) - (5)].identifier), true, (yyvsp[(4) - (5)].expression), NULL); +- +- (yyval.declarator_list) = new(ctx) ast_declarator_list((yyvsp[(1) - (5)].fully_specified_type)); +- (yyval.declarator_list)->set_location(yylloc); +- (yyval.declarator_list)->declarations.push_tail(&decl->link); +- ;} +- break; +- +- case 141: +- +-/* Line 1464 of yacc.c */ +-#line 997 "glsl_parser.ypp" +- { +- void *ctx = state; +- ast_declaration *decl = new(ctx) ast_declaration((yyvsp[(2) - (6)].identifier), true, NULL, (yyvsp[(6) - (6)].expression)); +- +- (yyval.declarator_list) = new(ctx) ast_declarator_list((yyvsp[(1) - (6)].fully_specified_type)); +- (yyval.declarator_list)->set_location(yylloc); +- (yyval.declarator_list)->declarations.push_tail(&decl->link); +- ;} +- break; +- +- case 142: +- +-/* Line 1464 of yacc.c */ +-#line 1006 "glsl_parser.ypp" +- { +- void *ctx = state; +- ast_declaration *decl = new(ctx) ast_declaration((yyvsp[(2) - (7)].identifier), true, (yyvsp[(4) - (7)].expression), (yyvsp[(7) - (7)].expression)); +- +- (yyval.declarator_list) = new(ctx) ast_declarator_list((yyvsp[(1) - (7)].fully_specified_type)); +- (yyval.declarator_list)->set_location(yylloc); +- (yyval.declarator_list)->declarations.push_tail(&decl->link); +- ;} +- break; +- +- case 143: +- +-/* Line 1464 of yacc.c */ +-#line 1015 "glsl_parser.ypp" +- { +- void *ctx = state; +- ast_declaration *decl = new(ctx) ast_declaration((yyvsp[(2) - (4)].identifier), false, NULL, (yyvsp[(4) - (4)].expression)); +- +- (yyval.declarator_list) = new(ctx) ast_declarator_list((yyvsp[(1) - (4)].fully_specified_type)); +- (yyval.declarator_list)->set_location(yylloc); +- (yyval.declarator_list)->declarations.push_tail(&decl->link); +- ;} +- break; +- +- case 144: +- +-/* Line 1464 of yacc.c */ +-#line 1024 "glsl_parser.ypp" +- { +- void *ctx = state; +- ast_declaration *decl = new(ctx) ast_declaration((yyvsp[(2) - (2)].identifier), false, NULL, NULL); +- +- (yyval.declarator_list) = new(ctx) ast_declarator_list(NULL); +- (yyval.declarator_list)->set_location(yylloc); +- (yyval.declarator_list)->invariant = true; +- +- (yyval.declarator_list)->declarations.push_tail(&decl->link); +- ;} +- break; +- +- case 145: +- +-/* Line 1464 of yacc.c */ +-#line 1038 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.fully_specified_type) = new(ctx) ast_fully_specified_type(); +- (yyval.fully_specified_type)->set_location(yylloc); +- (yyval.fully_specified_type)->specifier = (yyvsp[(1) - (1)].type_specifier); +- ;} +- break; +- +- case 146: +- +-/* Line 1464 of yacc.c */ +-#line 1045 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.fully_specified_type) = new(ctx) ast_fully_specified_type(); +- (yyval.fully_specified_type)->set_location(yylloc); +- (yyval.fully_specified_type)->qualifier = (yyvsp[(1) - (2)].type_qualifier).q; +- (yyval.fully_specified_type)->specifier = (yyvsp[(2) - (2)].type_specifier); +- ;} +- break; +- +- case 147: +- +-/* Line 1464 of yacc.c */ +-#line 1055 "glsl_parser.ypp" +- { (yyval.type_qualifier).i = 0; ;} +- break; +- +- case 149: +- +-/* Line 1464 of yacc.c */ +-#line 1061 "glsl_parser.ypp" +- { +- (yyval.type_qualifier) = (yyvsp[(3) - (4)].type_qualifier); +- ;} +- break; +- +- case 151: +- +-/* Line 1464 of yacc.c */ +-#line 1069 "glsl_parser.ypp" +- { +- (yyval.type_qualifier).i = (yyvsp[(1) - (3)].type_qualifier).i | (yyvsp[(3) - (3)].type_qualifier).i; +- ;} +- break; +- +- case 152: +- +-/* Line 1464 of yacc.c */ +-#line 1076 "glsl_parser.ypp" +- { +- (yyval.type_qualifier).i = 0; +- +- if (state->ARB_fragment_coord_conventions_enable) { +- bool got_one = false; +- +- if (strcmp((yyvsp[(1) - (1)].identifier), "origin_upper_left") == 0) { +- got_one = true; +- (yyval.type_qualifier).q.origin_upper_left = 1; +- } else if (strcmp((yyvsp[(1) - (1)].identifier), "pixel_center_integer") == 0) { +- got_one = true; +- (yyval.type_qualifier).q.pixel_center_integer = 1; +- } +- +- if (state->ARB_fragment_coord_conventions_warn && got_one) { +- _mesa_glsl_warning(& (yylsp[(1) - (1)]), state, +- "GL_ARB_fragment_coord_conventions layout " +- "identifier `%s' used\n", (yyvsp[(1) - (1)].identifier)); +- } +- } +- +- /* If the identifier didn't match any known layout identifiers, +- * emit an error. +- */ +- if ((yyval.type_qualifier).i == 0) { +- _mesa_glsl_error(& (yylsp[(1) - (1)]), state, "unrecognized layout identifier " +- "`%s'\n", (yyvsp[(1) - (1)].identifier)); +- YYERROR; +- } +- ;} +- break; +- +- case 153: +- +-/* Line 1464 of yacc.c */ +-#line 1109 "glsl_parser.ypp" +- { (yyval.type_qualifier).i = 0; (yyval.type_qualifier).q.smooth = 1; ;} +- break; +- +- case 154: +- +-/* Line 1464 of yacc.c */ +-#line 1110 "glsl_parser.ypp" +- { (yyval.type_qualifier).i = 0; (yyval.type_qualifier).q.flat = 1; ;} +- break; +- +- case 155: +- +-/* Line 1464 of yacc.c */ +-#line 1111 "glsl_parser.ypp" +- { (yyval.type_qualifier).i = 0; (yyval.type_qualifier).q.noperspective = 1; ;} +- break; +- +- case 156: +- +-/* Line 1464 of yacc.c */ +-#line 1115 "glsl_parser.ypp" +- { (yyval.type_qualifier).i = 0; (yyval.type_qualifier).q.constant = 1; ;} +- break; +- +- case 158: +- +-/* Line 1464 of yacc.c */ +-#line 1121 "glsl_parser.ypp" +- { +- (yyval.type_qualifier).i = (yyvsp[(1) - (2)].type_qualifier).i | (yyvsp[(2) - (2)].type_qualifier).i; +- ;} +- break; +- +- case 159: +- +-/* Line 1464 of yacc.c */ +-#line 1125 "glsl_parser.ypp" +- { +- (yyval.type_qualifier) = (yyvsp[(2) - (2)].type_qualifier); +- (yyval.type_qualifier).q.invariant = 1; +- ;} +- break; +- +- case 160: +- +-/* Line 1464 of yacc.c */ +-#line 1132 "glsl_parser.ypp" +- { (yyval.type_qualifier).i = 0; (yyval.type_qualifier).q.constant = 1; ;} +- break; +- +- case 161: +- +-/* Line 1464 of yacc.c */ +-#line 1133 "glsl_parser.ypp" +- { (yyval.type_qualifier).i = 0; (yyval.type_qualifier).q.attribute = 1; ;} +- break; +- +- case 162: +- +-/* Line 1464 of yacc.c */ +-#line 1134 "glsl_parser.ypp" +- { (yyval.type_qualifier).i = (yyvsp[(1) - (2)].type_qualifier).i; (yyval.type_qualifier).q.varying = 1; ;} +- break; +- +- case 163: +- +-/* Line 1464 of yacc.c */ +-#line 1135 "glsl_parser.ypp" +- { (yyval.type_qualifier).i = 0; (yyval.type_qualifier).q.centroid = 1; (yyval.type_qualifier).q.varying = 1; ;} +- break; +- +- case 164: +- +-/* Line 1464 of yacc.c */ +-#line 1136 "glsl_parser.ypp" +- { (yyval.type_qualifier).i = 0; (yyval.type_qualifier).q.in = 1; ;} +- break; +- +- case 165: +- +-/* Line 1464 of yacc.c */ +-#line 1137 "glsl_parser.ypp" +- { (yyval.type_qualifier).i = 0; (yyval.type_qualifier).q.out = 1; ;} +- break; +- +- case 166: +- +-/* Line 1464 of yacc.c */ +-#line 1138 "glsl_parser.ypp" +- { (yyval.type_qualifier).i = 0; (yyval.type_qualifier).q.centroid = 1; (yyval.type_qualifier).q.in = 1; ;} +- break; +- +- case 167: +- +-/* Line 1464 of yacc.c */ +-#line 1139 "glsl_parser.ypp" +- { (yyval.type_qualifier).i = 0; (yyval.type_qualifier).q.centroid = 1; (yyval.type_qualifier).q.out = 1; ;} +- break; +- +- case 168: +- +-/* Line 1464 of yacc.c */ +-#line 1140 "glsl_parser.ypp" +- { (yyval.type_qualifier).i = 0; (yyval.type_qualifier).q.uniform = 1; ;} +- break; +- +- case 169: +- +-/* Line 1464 of yacc.c */ +-#line 1145 "glsl_parser.ypp" +- { +- (yyval.type_specifier) = (yyvsp[(1) - (1)].type_specifier); +- ;} +- break; +- +- case 170: +- +-/* Line 1464 of yacc.c */ +-#line 1149 "glsl_parser.ypp" +- { +- (yyval.type_specifier) = (yyvsp[(2) - (2)].type_specifier); +- (yyval.type_specifier)->precision = (yyvsp[(1) - (2)].n); +- ;} +- break; +- +- case 172: +- +-/* Line 1464 of yacc.c */ +-#line 1158 "glsl_parser.ypp" +- { +- (yyval.type_specifier) = (yyvsp[(1) - (3)].type_specifier); +- (yyval.type_specifier)->is_array = true; +- (yyval.type_specifier)->array_size = NULL; +- ;} +- break; +- +- case 173: +- +-/* Line 1464 of yacc.c */ +-#line 1164 "glsl_parser.ypp" +- { +- (yyval.type_specifier) = (yyvsp[(1) - (4)].type_specifier); +- (yyval.type_specifier)->is_array = true; +- (yyval.type_specifier)->array_size = (yyvsp[(3) - (4)].expression); +- ;} +- break; +- +- case 174: +- +-/* Line 1464 of yacc.c */ +-#line 1173 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.type_specifier) = new(ctx) ast_type_specifier((yyvsp[(1) - (1)].n)); +- (yyval.type_specifier)->set_location(yylloc); +- ;} +- break; +- +- case 175: +- +-/* Line 1464 of yacc.c */ +-#line 1179 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.type_specifier) = new(ctx) ast_type_specifier((yyvsp[(1) - (1)].struct_specifier)); +- (yyval.type_specifier)->set_location(yylloc); +- ;} +- break; +- +- case 176: +- +-/* Line 1464 of yacc.c */ +-#line 1185 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.type_specifier) = new(ctx) ast_type_specifier((yyvsp[(1) - (1)].identifier)); +- (yyval.type_specifier)->set_location(yylloc); +- ;} +- break; +- +- case 177: +- +-/* Line 1464 of yacc.c */ +-#line 1193 "glsl_parser.ypp" +- { (yyval.n) = ast_void; ;} +- break; +- +- case 178: +- +-/* Line 1464 of yacc.c */ +-#line 1194 "glsl_parser.ypp" +- { (yyval.n) = ast_float; ;} +- break; +- +- case 179: +- +-/* Line 1464 of yacc.c */ +-#line 1195 "glsl_parser.ypp" +- { (yyval.n) = ast_int; ;} +- break; +- +- case 180: +- +-/* Line 1464 of yacc.c */ +-#line 1196 "glsl_parser.ypp" +- { (yyval.n) = ast_uint; ;} +- break; +- +- case 181: +- +-/* Line 1464 of yacc.c */ +-#line 1197 "glsl_parser.ypp" +- { (yyval.n) = ast_bool; ;} +- break; +- +- case 182: +- +-/* Line 1464 of yacc.c */ +-#line 1198 "glsl_parser.ypp" +- { (yyval.n) = ast_vec2; ;} +- break; +- +- case 183: +- +-/* Line 1464 of yacc.c */ +-#line 1199 "glsl_parser.ypp" +- { (yyval.n) = ast_vec3; ;} +- break; +- +- case 184: +- +-/* Line 1464 of yacc.c */ +-#line 1200 "glsl_parser.ypp" +- { (yyval.n) = ast_vec4; ;} +- break; +- +- case 185: +- +-/* Line 1464 of yacc.c */ +-#line 1201 "glsl_parser.ypp" +- { (yyval.n) = ast_bvec2; ;} +- break; +- +- case 186: +- +-/* Line 1464 of yacc.c */ +-#line 1202 "glsl_parser.ypp" +- { (yyval.n) = ast_bvec3; ;} +- break; +- +- case 187: +- +-/* Line 1464 of yacc.c */ +-#line 1203 "glsl_parser.ypp" +- { (yyval.n) = ast_bvec4; ;} +- break; +- +- case 188: +- +-/* Line 1464 of yacc.c */ +-#line 1204 "glsl_parser.ypp" +- { (yyval.n) = ast_ivec2; ;} +- break; +- +- case 189: +- +-/* Line 1464 of yacc.c */ +-#line 1205 "glsl_parser.ypp" +- { (yyval.n) = ast_ivec3; ;} +- break; +- +- case 190: +- +-/* Line 1464 of yacc.c */ +-#line 1206 "glsl_parser.ypp" +- { (yyval.n) = ast_ivec4; ;} +- break; +- +- case 191: +- +-/* Line 1464 of yacc.c */ +-#line 1207 "glsl_parser.ypp" +- { (yyval.n) = ast_uvec2; ;} +- break; +- +- case 192: +- +-/* Line 1464 of yacc.c */ +-#line 1208 "glsl_parser.ypp" +- { (yyval.n) = ast_uvec3; ;} +- break; +- +- case 193: +- +-/* Line 1464 of yacc.c */ +-#line 1209 "glsl_parser.ypp" +- { (yyval.n) = ast_uvec4; ;} +- break; +- +- case 194: +- +-/* Line 1464 of yacc.c */ +-#line 1210 "glsl_parser.ypp" +- { (yyval.n) = ast_mat2; ;} +- break; +- +- case 195: +- +-/* Line 1464 of yacc.c */ +-#line 1211 "glsl_parser.ypp" +- { (yyval.n) = ast_mat2x3; ;} +- break; +- +- case 196: +- +-/* Line 1464 of yacc.c */ +-#line 1212 "glsl_parser.ypp" +- { (yyval.n) = ast_mat2x4; ;} +- break; +- +- case 197: +- +-/* Line 1464 of yacc.c */ +-#line 1213 "glsl_parser.ypp" +- { (yyval.n) = ast_mat3x2; ;} +- break; +- +- case 198: +- +-/* Line 1464 of yacc.c */ +-#line 1214 "glsl_parser.ypp" +- { (yyval.n) = ast_mat3; ;} +- break; +- +- case 199: +- +-/* Line 1464 of yacc.c */ +-#line 1215 "glsl_parser.ypp" +- { (yyval.n) = ast_mat3x4; ;} +- break; +- +- case 200: +- +-/* Line 1464 of yacc.c */ +-#line 1216 "glsl_parser.ypp" +- { (yyval.n) = ast_mat4x2; ;} +- break; +- +- case 201: +- +-/* Line 1464 of yacc.c */ +-#line 1217 "glsl_parser.ypp" +- { (yyval.n) = ast_mat4x3; ;} +- break; +- +- case 202: +- +-/* Line 1464 of yacc.c */ +-#line 1218 "glsl_parser.ypp" +- { (yyval.n) = ast_mat4; ;} +- break; +- +- case 203: +- +-/* Line 1464 of yacc.c */ +-#line 1219 "glsl_parser.ypp" +- { (yyval.n) = ast_sampler1d; ;} +- break; +- +- case 204: +- +-/* Line 1464 of yacc.c */ +-#line 1220 "glsl_parser.ypp" +- { (yyval.n) = ast_sampler2d; ;} +- break; +- +- case 205: +- +-/* Line 1464 of yacc.c */ +-#line 1221 "glsl_parser.ypp" +- { (yyval.n) = ast_sampler2drect; ;} +- break; +- +- case 206: +- +-/* Line 1464 of yacc.c */ +-#line 1222 "glsl_parser.ypp" +- { (yyval.n) = ast_sampler3d; ;} +- break; +- +- case 207: +- +-/* Line 1464 of yacc.c */ +-#line 1223 "glsl_parser.ypp" +- { (yyval.n) = ast_samplercube; ;} +- break; +- +- case 208: +- +-/* Line 1464 of yacc.c */ +-#line 1224 "glsl_parser.ypp" +- { (yyval.n) = ast_sampler1dshadow; ;} +- break; +- +- case 209: +- +-/* Line 1464 of yacc.c */ +-#line 1225 "glsl_parser.ypp" +- { (yyval.n) = ast_sampler2dshadow; ;} +- break; +- +- case 210: +- +-/* Line 1464 of yacc.c */ +-#line 1226 "glsl_parser.ypp" +- { (yyval.n) = ast_sampler2drectshadow; ;} +- break; +- +- case 211: +- +-/* Line 1464 of yacc.c */ +-#line 1227 "glsl_parser.ypp" +- { (yyval.n) = ast_samplercubeshadow; ;} +- break; +- +- case 212: +- +-/* Line 1464 of yacc.c */ +-#line 1228 "glsl_parser.ypp" +- { (yyval.n) = ast_sampler1darray; ;} +- break; +- +- case 213: +- +-/* Line 1464 of yacc.c */ +-#line 1229 "glsl_parser.ypp" +- { (yyval.n) = ast_sampler2darray; ;} +- break; +- +- case 214: +- +-/* Line 1464 of yacc.c */ +-#line 1230 "glsl_parser.ypp" +- { (yyval.n) = ast_sampler1darrayshadow; ;} +- break; +- +- case 215: +- +-/* Line 1464 of yacc.c */ +-#line 1231 "glsl_parser.ypp" +- { (yyval.n) = ast_sampler2darrayshadow; ;} +- break; +- +- case 216: +- +-/* Line 1464 of yacc.c */ +-#line 1232 "glsl_parser.ypp" +- { (yyval.n) = ast_isampler1d; ;} +- break; +- +- case 217: +- +-/* Line 1464 of yacc.c */ +-#line 1233 "glsl_parser.ypp" +- { (yyval.n) = ast_isampler2d; ;} +- break; +- +- case 218: +- +-/* Line 1464 of yacc.c */ +-#line 1234 "glsl_parser.ypp" +- { (yyval.n) = ast_isampler3d; ;} +- break; +- +- case 219: +- +-/* Line 1464 of yacc.c */ +-#line 1235 "glsl_parser.ypp" +- { (yyval.n) = ast_isamplercube; ;} +- break; +- +- case 220: +- +-/* Line 1464 of yacc.c */ +-#line 1236 "glsl_parser.ypp" +- { (yyval.n) = ast_isampler1darray; ;} +- break; +- +- case 221: +- +-/* Line 1464 of yacc.c */ +-#line 1237 "glsl_parser.ypp" +- { (yyval.n) = ast_isampler2darray; ;} +- break; +- +- case 222: +- +-/* Line 1464 of yacc.c */ +-#line 1238 "glsl_parser.ypp" +- { (yyval.n) = ast_usampler1d; ;} +- break; +- +- case 223: +- +-/* Line 1464 of yacc.c */ +-#line 1239 "glsl_parser.ypp" +- { (yyval.n) = ast_usampler2d; ;} +- break; +- +- case 224: +- +-/* Line 1464 of yacc.c */ +-#line 1240 "glsl_parser.ypp" +- { (yyval.n) = ast_usampler3d; ;} +- break; +- +- case 225: +- +-/* Line 1464 of yacc.c */ +-#line 1241 "glsl_parser.ypp" +- { (yyval.n) = ast_usamplercube; ;} +- break; +- +- case 226: +- +-/* Line 1464 of yacc.c */ +-#line 1242 "glsl_parser.ypp" +- { (yyval.n) = ast_usampler1darray; ;} +- break; +- +- case 227: +- +-/* Line 1464 of yacc.c */ +-#line 1243 "glsl_parser.ypp" +- { (yyval.n) = ast_usampler2darray; ;} +- break; +- +- case 228: +- +-/* Line 1464 of yacc.c */ +-#line 1247 "glsl_parser.ypp" +- { +- if (!state->es_shader && state->language_version < 130) +- _mesa_glsl_error(& (yylsp[(1) - (1)]), state, +- "precision qualifier forbidden " +- "in %s (1.30 or later " +- "required)\n", +- state->version_string); +- +- (yyval.n) = ast_precision_high; +- ;} +- break; +- +- case 229: +- +-/* Line 1464 of yacc.c */ +-#line 1257 "glsl_parser.ypp" +- { +- if (!state->es_shader && state->language_version < 130) +- _mesa_glsl_error(& (yylsp[(1) - (1)]), state, +- "precision qualifier forbidden " +- "in %s (1.30 or later " +- "required)\n", +- state->version_string); +- +- (yyval.n) = ast_precision_medium; +- ;} +- break; +- +- case 230: +- +-/* Line 1464 of yacc.c */ +-#line 1267 "glsl_parser.ypp" +- { +- if (!state->es_shader && state->language_version < 130) +- _mesa_glsl_error(& (yylsp[(1) - (1)]), state, +- "precision qualifier forbidden " +- "in %s (1.30 or later " +- "required)\n", +- state->version_string); +- +- (yyval.n) = ast_precision_low; +- ;} +- break; +- +- case 231: +- +-/* Line 1464 of yacc.c */ +-#line 1281 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.struct_specifier) = new(ctx) ast_struct_specifier((yyvsp[(2) - (5)].identifier), (yyvsp[(4) - (5)].node)); +- (yyval.struct_specifier)->set_location(yylloc); +- state->symbols->add_type((yyvsp[(2) - (5)].identifier), glsl_type::void_type); +- ;} +- break; +- +- case 232: +- +-/* Line 1464 of yacc.c */ +-#line 1288 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.struct_specifier) = new(ctx) ast_struct_specifier(NULL, (yyvsp[(3) - (4)].node)); +- (yyval.struct_specifier)->set_location(yylloc); +- ;} +- break; +- +- case 233: +- +-/* Line 1464 of yacc.c */ +-#line 1297 "glsl_parser.ypp" +- { +- (yyval.node) = (ast_node *) (yyvsp[(1) - (1)].declarator_list); +- (yyvsp[(1) - (1)].declarator_list)->link.self_link(); +- ;} +- break; +- +- case 234: +- +-/* Line 1464 of yacc.c */ +-#line 1302 "glsl_parser.ypp" +- { +- (yyval.node) = (ast_node *) (yyvsp[(1) - (2)].node); +- (yyval.node)->link.insert_before(& (yyvsp[(2) - (2)].declarator_list)->link); +- ;} +- break; +- +- case 235: +- +-/* Line 1464 of yacc.c */ +-#line 1310 "glsl_parser.ypp" +- { +- void *ctx = state; +- ast_fully_specified_type *type = new(ctx) ast_fully_specified_type(); +- type->set_location(yylloc); +- +- type->specifier = (yyvsp[(1) - (3)].type_specifier); +- (yyval.declarator_list) = new(ctx) ast_declarator_list(type); +- (yyval.declarator_list)->set_location(yylloc); +- +- (yyval.declarator_list)->declarations.push_degenerate_list_at_head(& (yyvsp[(2) - (3)].declaration)->link); +- ;} +- break; +- +- case 236: +- +-/* Line 1464 of yacc.c */ +-#line 1325 "glsl_parser.ypp" +- { +- (yyval.declaration) = (yyvsp[(1) - (1)].declaration); +- (yyvsp[(1) - (1)].declaration)->link.self_link(); +- ;} +- break; +- +- case 237: +- +-/* Line 1464 of yacc.c */ +-#line 1330 "glsl_parser.ypp" +- { +- (yyval.declaration) = (yyvsp[(1) - (3)].declaration); +- (yyval.declaration)->link.insert_before(& (yyvsp[(3) - (3)].declaration)->link); +- ;} +- break; +- +- case 238: +- +-/* Line 1464 of yacc.c */ +-#line 1338 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.declaration) = new(ctx) ast_declaration((yyvsp[(1) - (1)].identifier), false, NULL, NULL); +- (yyval.declaration)->set_location(yylloc); +- state->symbols->add_variable((yyvsp[(1) - (1)].identifier), new(state) ir_variable(NULL, (yyvsp[(1) - (1)].identifier), ir_var_auto)); +- ;} +- break; +- +- case 239: +- +-/* Line 1464 of yacc.c */ +-#line 1345 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.declaration) = new(ctx) ast_declaration((yyvsp[(1) - (4)].identifier), true, (yyvsp[(3) - (4)].expression), NULL); +- (yyval.declaration)->set_location(yylloc); +- ;} +- break; +- +- case 242: +- +-/* Line 1464 of yacc.c */ +-#line 1363 "glsl_parser.ypp" +- { (yyval.node) = (ast_node *) (yyvsp[(1) - (1)].compound_statement); ;} +- break; +- +- case 247: +- +-/* Line 1464 of yacc.c */ +-#line 1371 "glsl_parser.ypp" +- { (yyval.node) = NULL; ;} +- break; +- +- case 248: +- +-/* Line 1464 of yacc.c */ +-#line 1372 "glsl_parser.ypp" +- { (yyval.node) = NULL; ;} +- break; +- +- case 251: +- +-/* Line 1464 of yacc.c */ +-#line 1379 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.compound_statement) = new(ctx) ast_compound_statement(true, NULL); +- (yyval.compound_statement)->set_location(yylloc); +- ;} +- break; +- +- case 252: +- +-/* Line 1464 of yacc.c */ +-#line 1385 "glsl_parser.ypp" +- { +- state->symbols->push_scope(); +- ;} +- break; +- +- case 253: +- +-/* Line 1464 of yacc.c */ +-#line 1389 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.compound_statement) = new(ctx) ast_compound_statement(true, (yyvsp[(3) - (4)].node)); +- (yyval.compound_statement)->set_location(yylloc); +- state->symbols->pop_scope(); +- ;} +- break; +- +- case 254: +- +-/* Line 1464 of yacc.c */ +-#line 1398 "glsl_parser.ypp" +- { (yyval.node) = (ast_node *) (yyvsp[(1) - (1)].compound_statement); ;} +- break; +- +- case 256: +- +-/* Line 1464 of yacc.c */ +-#line 1404 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.compound_statement) = new(ctx) ast_compound_statement(false, NULL); +- (yyval.compound_statement)->set_location(yylloc); +- ;} +- break; +- +- case 257: +- +-/* Line 1464 of yacc.c */ +-#line 1410 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.compound_statement) = new(ctx) ast_compound_statement(false, (yyvsp[(2) - (3)].node)); +- (yyval.compound_statement)->set_location(yylloc); +- ;} +- break; +- +- case 258: +- +-/* Line 1464 of yacc.c */ +-#line 1419 "glsl_parser.ypp" +- { +- if ((yyvsp[(1) - (1)].node) == NULL) { +- _mesa_glsl_error(& (yylsp[(1) - (1)]), state, " statement\n"); +- assert((yyvsp[(1) - (1)].node) != NULL); +- } +- +- (yyval.node) = (yyvsp[(1) - (1)].node); +- (yyval.node)->link.self_link(); +- ;} +- break; +- +- case 259: +- +-/* Line 1464 of yacc.c */ +-#line 1429 "glsl_parser.ypp" +- { +- if ((yyvsp[(2) - (2)].node) == NULL) { +- _mesa_glsl_error(& (yylsp[(2) - (2)]), state, " statement\n"); +- assert((yyvsp[(2) - (2)].node) != NULL); +- } +- (yyval.node) = (yyvsp[(1) - (2)].node); +- (yyval.node)->link.insert_before(& (yyvsp[(2) - (2)].node)->link); +- ;} +- break; +- +- case 260: +- +-/* Line 1464 of yacc.c */ +-#line 1441 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.node) = new(ctx) ast_expression_statement(NULL); +- (yyval.node)->set_location(yylloc); +- ;} +- break; +- +- case 261: +- +-/* Line 1464 of yacc.c */ +-#line 1447 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.node) = new(ctx) ast_expression_statement((yyvsp[(1) - (2)].expression)); +- (yyval.node)->set_location(yylloc); +- ;} +- break; +- +- case 262: +- +-/* Line 1464 of yacc.c */ +-#line 1456 "glsl_parser.ypp" +- { +- (yyval.node) = new(state) ast_selection_statement((yyvsp[(3) - (5)].expression), (yyvsp[(5) - (5)].selection_rest_statement).then_statement, +- (yyvsp[(5) - (5)].selection_rest_statement).else_statement); +- (yyval.node)->set_location(yylloc); +- ;} +- break; +- +- case 263: +- +-/* Line 1464 of yacc.c */ +-#line 1465 "glsl_parser.ypp" +- { +- (yyval.selection_rest_statement).then_statement = (yyvsp[(1) - (3)].node); +- (yyval.selection_rest_statement).else_statement = (yyvsp[(3) - (3)].node); +- ;} +- break; +- +- case 264: +- +-/* Line 1464 of yacc.c */ +-#line 1470 "glsl_parser.ypp" +- { +- (yyval.selection_rest_statement).then_statement = (yyvsp[(1) - (1)].node); +- (yyval.selection_rest_statement).else_statement = NULL; +- ;} +- break; +- +- case 265: +- +-/* Line 1464 of yacc.c */ +-#line 1478 "glsl_parser.ypp" +- { +- (yyval.node) = (ast_node *) (yyvsp[(1) - (1)].expression); +- ;} +- break; +- +- case 266: +- +-/* Line 1464 of yacc.c */ +-#line 1482 "glsl_parser.ypp" +- { +- void *ctx = state; +- ast_declaration *decl = new(ctx) ast_declaration((yyvsp[(2) - (4)].identifier), false, NULL, (yyvsp[(4) - (4)].expression)); +- ast_declarator_list *declarator = new(ctx) ast_declarator_list((yyvsp[(1) - (4)].fully_specified_type)); +- decl->set_location(yylloc); +- declarator->set_location(yylloc); +- +- declarator->declarations.push_tail(&decl->link); +- (yyval.node) = declarator; +- ;} +- break; +- +- case 270: +- +-/* Line 1464 of yacc.c */ +-#line 1505 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.node) = new(ctx) ast_iteration_statement(ast_iteration_statement::ast_while, +- NULL, (yyvsp[(3) - (5)].node), NULL, (yyvsp[(5) - (5)].node)); +- (yyval.node)->set_location(yylloc); +- ;} +- break; +- +- case 271: +- +-/* Line 1464 of yacc.c */ +-#line 1512 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.node) = new(ctx) ast_iteration_statement(ast_iteration_statement::ast_do_while, +- NULL, (yyvsp[(5) - (7)].expression), NULL, (yyvsp[(2) - (7)].node)); +- (yyval.node)->set_location(yylloc); +- ;} +- break; +- +- case 272: +- +-/* Line 1464 of yacc.c */ +-#line 1519 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.node) = new(ctx) ast_iteration_statement(ast_iteration_statement::ast_for, +- (yyvsp[(3) - (6)].node), (yyvsp[(4) - (6)].for_rest_statement).cond, (yyvsp[(4) - (6)].for_rest_statement).rest, (yyvsp[(6) - (6)].node)); +- (yyval.node)->set_location(yylloc); +- ;} +- break; +- +- case 276: +- +-/* Line 1464 of yacc.c */ +-#line 1535 "glsl_parser.ypp" +- { +- (yyval.node) = NULL; +- ;} +- break; +- +- case 277: +- +-/* Line 1464 of yacc.c */ +-#line 1542 "glsl_parser.ypp" +- { +- (yyval.for_rest_statement).cond = (yyvsp[(1) - (2)].node); +- (yyval.for_rest_statement).rest = NULL; +- ;} +- break; +- +- case 278: +- +-/* Line 1464 of yacc.c */ +-#line 1547 "glsl_parser.ypp" +- { +- (yyval.for_rest_statement).cond = (yyvsp[(1) - (3)].node); +- (yyval.for_rest_statement).rest = (yyvsp[(3) - (3)].expression); +- ;} +- break; +- +- case 279: +- +-/* Line 1464 of yacc.c */ +-#line 1556 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.node) = new(ctx) ast_jump_statement(ast_jump_statement::ast_continue, NULL); +- (yyval.node)->set_location(yylloc); +- ;} +- break; +- +- case 280: +- +-/* Line 1464 of yacc.c */ +-#line 1562 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.node) = new(ctx) ast_jump_statement(ast_jump_statement::ast_break, NULL); +- (yyval.node)->set_location(yylloc); +- ;} +- break; +- +- case 281: +- +-/* Line 1464 of yacc.c */ +-#line 1568 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.node) = new(ctx) ast_jump_statement(ast_jump_statement::ast_return, NULL); +- (yyval.node)->set_location(yylloc); +- ;} +- break; +- +- case 282: +- +-/* Line 1464 of yacc.c */ +-#line 1574 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.node) = new(ctx) ast_jump_statement(ast_jump_statement::ast_return, (yyvsp[(2) - (3)].expression)); +- (yyval.node)->set_location(yylloc); +- ;} +- break; +- +- case 283: +- +-/* Line 1464 of yacc.c */ +-#line 1580 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.node) = new(ctx) ast_jump_statement(ast_jump_statement::ast_discard, NULL); +- (yyval.node)->set_location(yylloc); +- ;} +- break; +- +- case 284: +- +-/* Line 1464 of yacc.c */ +-#line 1588 "glsl_parser.ypp" +- { (yyval.node) = (yyvsp[(1) - (1)].function_definition); ;} +- break; +- +- case 285: +- +-/* Line 1464 of yacc.c */ +-#line 1589 "glsl_parser.ypp" +- { (yyval.node) = (yyvsp[(1) - (1)].node); ;} +- break; +- +- case 286: +- +-/* Line 1464 of yacc.c */ +-#line 1590 "glsl_parser.ypp" +- { (yyval.node) = NULL; ;} +- break; +- +- case 287: +- +-/* Line 1464 of yacc.c */ +-#line 1595 "glsl_parser.ypp" +- { +- void *ctx = state; +- (yyval.function_definition) = new(ctx) ast_function_definition(); +- (yyval.function_definition)->set_location(yylloc); +- (yyval.function_definition)->prototype = (yyvsp[(1) - (2)].function); +- (yyval.function_definition)->body = (yyvsp[(2) - (2)].compound_statement); +- +- state->symbols->pop_scope(); +- ;} +- break; +- +- +- +-/* Line 1464 of yacc.c */ +-#line 5138 "glsl_parser.cpp" +- default: break; +- } +- YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); +- +- YYPOPSTACK (yylen); +- yylen = 0; +- YY_STACK_PRINT (yyss, yyssp); +- +- *++yyvsp = yyval; +- *++yylsp = yyloc; +- +- /* Now `shift' the result of the reduction. Determine what state +- that goes to, based on the state we popped back to and the rule +- number reduced by. */ +- +- yyn = yyr1[yyn]; +- +- yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; +- if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) +- yystate = yytable[yystate]; +- else +- yystate = yydefgoto[yyn - YYNTOKENS]; +- +- goto yynewstate; +- +- +-/*------------------------------------. +-| yyerrlab -- here on detecting error | +-`------------------------------------*/ +-yyerrlab: +- /* If not already recovering from an error, report this error. */ +- if (!yyerrstatus) +- { +- ++yynerrs; +-#if ! YYERROR_VERBOSE +- yyerror (&yylloc, state, YY_("syntax error")); +-#else +- { +- YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); +- if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) +- { +- YYSIZE_T yyalloc = 2 * yysize; +- if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) +- yyalloc = YYSTACK_ALLOC_MAXIMUM; +- if (yymsg != yymsgbuf) +- YYSTACK_FREE (yymsg); +- yymsg = (char *) YYSTACK_ALLOC (yyalloc); +- if (yymsg) +- yymsg_alloc = yyalloc; +- else +- { +- yymsg = yymsgbuf; +- yymsg_alloc = sizeof yymsgbuf; +- } +- } +- +- if (0 < yysize && yysize <= yymsg_alloc) +- { +- (void) yysyntax_error (yymsg, yystate, yychar); +- yyerror (&yylloc, state, yymsg); +- } +- else +- { +- yyerror (&yylloc, state, YY_("syntax error")); +- if (yysize != 0) +- goto yyexhaustedlab; +- } +- } +-#endif +- } +- +- yyerror_range[1] = yylloc; +- +- if (yyerrstatus == 3) +- { +- /* If just tried and failed to reuse lookahead token after an +- error, discard it. */ +- +- if (yychar <= YYEOF) +- { +- /* Return failure if at end of input. */ +- if (yychar == YYEOF) +- YYABORT; +- } +- else +- { +- yydestruct ("Error: discarding", +- yytoken, &yylval, &yylloc, state); +- yychar = YYEMPTY; +- } +- } +- +- /* Else will try to reuse lookahead token after shifting the error +- token. */ +- goto yyerrlab1; +- +- +-/*---------------------------------------------------. +-| yyerrorlab -- error raised explicitly by YYERROR. | +-`---------------------------------------------------*/ +-yyerrorlab: +- +- /* Pacify compilers like GCC when the user code never invokes +- YYERROR and the label yyerrorlab therefore never appears in user +- code. */ +- if (/*CONSTCOND*/ 0) +- goto yyerrorlab; +- +- yyerror_range[1] = yylsp[1-yylen]; +- /* Do not reclaim the symbols of the rule which action triggered +- this YYERROR. */ +- YYPOPSTACK (yylen); +- yylen = 0; +- YY_STACK_PRINT (yyss, yyssp); +- yystate = *yyssp; +- goto yyerrlab1; +- +- +-/*-------------------------------------------------------------. +-| yyerrlab1 -- common code for both syntax error and YYERROR. | +-`-------------------------------------------------------------*/ +-yyerrlab1: +- yyerrstatus = 3; /* Each real token shifted decrements this. */ +- +- for (;;) +- { +- yyn = yypact[yystate]; +- if (yyn != YYPACT_NINF) +- { +- yyn += YYTERROR; +- if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) +- { +- yyn = yytable[yyn]; +- if (0 < yyn) +- break; +- } +- } +- +- /* Pop the current state because it cannot handle the error token. */ +- if (yyssp == yyss) +- YYABORT; +- +- yyerror_range[1] = *yylsp; +- yydestruct ("Error: popping", +- yystos[yystate], yyvsp, yylsp, state); +- YYPOPSTACK (1); +- yystate = *yyssp; +- YY_STACK_PRINT (yyss, yyssp); +- } +- +- *++yyvsp = yylval; +- +- yyerror_range[2] = yylloc; +- /* Using YYLLOC is tempting, but would change the location of +- the lookahead. YYLOC is available though. */ +- YYLLOC_DEFAULT (yyloc, yyerror_range, 2); +- *++yylsp = yyloc; +- +- /* Shift the error token. */ +- YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); +- +- yystate = yyn; +- goto yynewstate; +- +- +-/*-------------------------------------. +-| yyacceptlab -- YYACCEPT comes here. | +-`-------------------------------------*/ +-yyacceptlab: +- yyresult = 0; +- goto yyreturn; +- +-/*-----------------------------------. +-| yyabortlab -- YYABORT comes here. | +-`-----------------------------------*/ +-yyabortlab: +- yyresult = 1; +- goto yyreturn; +- +-#if !defined(yyoverflow) || YYERROR_VERBOSE +-/*-------------------------------------------------. +-| yyexhaustedlab -- memory exhaustion comes here. | +-`-------------------------------------------------*/ +-yyexhaustedlab: +- yyerror (&yylloc, state, YY_("memory exhausted")); +- yyresult = 2; +- /* Fall through. */ +-#endif +- +-yyreturn: +- if (yychar != YYEMPTY) +- yydestruct ("Cleanup: discarding lookahead", +- yytoken, &yylval, &yylloc, state); +- /* Do not reclaim the symbols of the rule which action triggered +- this YYABORT or YYACCEPT. */ +- YYPOPSTACK (yylen); +- YY_STACK_PRINT (yyss, yyssp); +- while (yyssp != yyss) +- { +- yydestruct ("Cleanup: popping", +- yystos[*yyssp], yyvsp, yylsp, state); +- YYPOPSTACK (1); +- } +-#ifndef yyoverflow +- if (yyss != yyssa) +- YYSTACK_FREE (yyss); +-#endif +-#if YYERROR_VERBOSE +- if (yymsg != yymsgbuf) +- YYSTACK_FREE (yymsg); +-#endif +- /* Make sure YYID is used. */ +- return YYID (yyresult); +-} +- +- +- +diff --git a/src/glsl/glsl_parser.h b/src/glsl/glsl_parser.h +deleted file mode 100644 +index 4f4e1b7..0000000 +--- a/src/glsl/glsl_parser.h ++++ /dev/null +@@ -1,301 +0,0 @@ +-/* A Bison parser, made by GNU Bison 2.4.3. */ +- +-/* Skeleton interface for Bison's Yacc-like parsers in C +- +- Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006, +- 2009, 2010 Free Software Foundation, Inc. +- +- This program is free software: you can redistribute it and/or modify +- it under the terms of the GNU General Public License as published by +- the Free Software Foundation, either version 3 of the License, or +- (at your option) any later version. +- +- This program is distributed in the hope that it will be useful, +- but WITHOUT ANY WARRANTY; without even the implied warranty of +- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +- GNU General Public License for more details. +- +- You should have received a copy of the GNU General Public License +- along with this program. If not, see . */ +- +-/* As a special exception, you may create a larger work that contains +- part or all of the Bison parser skeleton and distribute that work +- under terms of your choice, so long as that work isn't itself a +- parser generator using the skeleton or a modified version thereof +- as a parser skeleton. Alternatively, if you modify or redistribute +- the parser skeleton itself, you may (at your option) remove this +- special exception, which will cause the skeleton and the resulting +- Bison output files to be licensed under the GNU General Public +- License without this special exception. +- +- This special exception was added by the Free Software Foundation in +- version 2.2 of Bison. */ +- +- +-/* Tokens. */ +-#ifndef YYTOKENTYPE +-# define YYTOKENTYPE +- /* Put the tokens into the symbol table, so that GDB and other debuggers +- know about them. */ +- enum yytokentype { +- ATTRIBUTE = 258, +- CONST_TOK = 259, +- BOOL_TOK = 260, +- FLOAT_TOK = 261, +- INT_TOK = 262, +- UINT_TOK = 263, +- BREAK = 264, +- CONTINUE = 265, +- DO = 266, +- ELSE = 267, +- FOR = 268, +- IF = 269, +- DISCARD = 270, +- RETURN = 271, +- SWITCH = 272, +- CASE = 273, +- DEFAULT = 274, +- BVEC2 = 275, +- BVEC3 = 276, +- BVEC4 = 277, +- IVEC2 = 278, +- IVEC3 = 279, +- IVEC4 = 280, +- UVEC2 = 281, +- UVEC3 = 282, +- UVEC4 = 283, +- VEC2 = 284, +- VEC3 = 285, +- VEC4 = 286, +- CENTROID = 287, +- IN_TOK = 288, +- OUT_TOK = 289, +- INOUT_TOK = 290, +- UNIFORM = 291, +- VARYING = 292, +- NOPERSPECTIVE = 293, +- FLAT = 294, +- SMOOTH = 295, +- MAT2X2 = 296, +- MAT2X3 = 297, +- MAT2X4 = 298, +- MAT3X2 = 299, +- MAT3X3 = 300, +- MAT3X4 = 301, +- MAT4X2 = 302, +- MAT4X3 = 303, +- MAT4X4 = 304, +- SAMPLER1D = 305, +- SAMPLER2D = 306, +- SAMPLER3D = 307, +- SAMPLERCUBE = 308, +- SAMPLER1DSHADOW = 309, +- SAMPLER2DSHADOW = 310, +- SAMPLERCUBESHADOW = 311, +- SAMPLER1DARRAY = 312, +- SAMPLER2DARRAY = 313, +- SAMPLER1DARRAYSHADOW = 314, +- SAMPLER2DARRAYSHADOW = 315, +- ISAMPLER1D = 316, +- ISAMPLER2D = 317, +- ISAMPLER3D = 318, +- ISAMPLERCUBE = 319, +- ISAMPLER1DARRAY = 320, +- ISAMPLER2DARRAY = 321, +- USAMPLER1D = 322, +- USAMPLER2D = 323, +- USAMPLER3D = 324, +- USAMPLERCUBE = 325, +- USAMPLER1DARRAY = 326, +- USAMPLER2DARRAY = 327, +- STRUCT = 328, +- VOID_TOK = 329, +- WHILE = 330, +- IDENTIFIER = 331, +- TYPE_IDENTIFIER = 332, +- NEW_IDENTIFIER = 333, +- FLOATCONSTANT = 334, +- INTCONSTANT = 335, +- UINTCONSTANT = 336, +- BOOLCONSTANT = 337, +- FIELD_SELECTION = 338, +- LEFT_OP = 339, +- RIGHT_OP = 340, +- INC_OP = 341, +- DEC_OP = 342, +- LE_OP = 343, +- GE_OP = 344, +- EQ_OP = 345, +- NE_OP = 346, +- AND_OP = 347, +- OR_OP = 348, +- XOR_OP = 349, +- MUL_ASSIGN = 350, +- DIV_ASSIGN = 351, +- ADD_ASSIGN = 352, +- MOD_ASSIGN = 353, +- LEFT_ASSIGN = 354, +- RIGHT_ASSIGN = 355, +- AND_ASSIGN = 356, +- XOR_ASSIGN = 357, +- OR_ASSIGN = 358, +- SUB_ASSIGN = 359, +- INVARIANT = 360, +- LOWP = 361, +- MEDIUMP = 362, +- HIGHP = 363, +- SUPERP = 364, +- PRECISION = 365, +- VERSION = 366, +- EXTENSION = 367, +- LINE = 368, +- COLON = 369, +- EOL = 370, +- INTERFACE = 371, +- OUTPUT = 372, +- PRAGMA_DEBUG_ON = 373, +- PRAGMA_DEBUG_OFF = 374, +- PRAGMA_OPTIMIZE_ON = 375, +- PRAGMA_OPTIMIZE_OFF = 376, +- PRAGMA_INVARIANT_ALL = 377, +- LAYOUT_TOK = 378, +- ASM = 379, +- CLASS = 380, +- UNION = 381, +- ENUM = 382, +- TYPEDEF = 383, +- TEMPLATE = 384, +- THIS = 385, +- PACKED_TOK = 386, +- GOTO = 387, +- INLINE_TOK = 388, +- NOINLINE = 389, +- VOLATILE = 390, +- PUBLIC_TOK = 391, +- STATIC = 392, +- EXTERN = 393, +- EXTERNAL = 394, +- LONG_TOK = 395, +- SHORT_TOK = 396, +- DOUBLE_TOK = 397, +- HALF = 398, +- FIXED_TOK = 399, +- UNSIGNED = 400, +- INPUT_TOK = 401, +- OUPTUT = 402, +- HVEC2 = 403, +- HVEC3 = 404, +- HVEC4 = 405, +- DVEC2 = 406, +- DVEC3 = 407, +- DVEC4 = 408, +- FVEC2 = 409, +- FVEC3 = 410, +- FVEC4 = 411, +- SAMPLER2DRECT = 412, +- SAMPLER3DRECT = 413, +- SAMPLER2DRECTSHADOW = 414, +- SIZEOF = 415, +- CAST = 416, +- NAMESPACE = 417, +- USING = 418, +- ERROR_TOK = 419, +- COMMON = 420, +- PARTITION = 421, +- ACTIVE = 422, +- SAMPLERBUFFER = 423, +- FILTER = 424, +- IMAGE1D = 425, +- IMAGE2D = 426, +- IMAGE3D = 427, +- IMAGECUBE = 428, +- IMAGE1DARRAY = 429, +- IMAGE2DARRAY = 430, +- IIMAGE1D = 431, +- IIMAGE2D = 432, +- IIMAGE3D = 433, +- IIMAGECUBE = 434, +- IIMAGE1DARRAY = 435, +- IIMAGE2DARRAY = 436, +- UIMAGE1D = 437, +- UIMAGE2D = 438, +- UIMAGE3D = 439, +- UIMAGECUBE = 440, +- UIMAGE1DARRAY = 441, +- UIMAGE2DARRAY = 442, +- IMAGE1DSHADOW = 443, +- IMAGE2DSHADOW = 444, +- IMAGEBUFFER = 445, +- IIMAGEBUFFER = 446, +- UIMAGEBUFFER = 447, +- ROW_MAJOR = 448 +- }; +-#endif +- +- +- +-#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED +-typedef union YYSTYPE +-{ +- +-/* Line 1685 of yacc.c */ +-#line 52 "glsl_parser.ypp" +- +- int n; +- float real; +- char *identifier; +- +- union { +- struct ast_type_qualifier q; +- unsigned i; +- } type_qualifier; +- +- ast_node *node; +- ast_type_specifier *type_specifier; +- ast_fully_specified_type *fully_specified_type; +- ast_function *function; +- ast_parameter_declarator *parameter_declarator; +- ast_function_definition *function_definition; +- ast_compound_statement *compound_statement; +- ast_expression *expression; +- ast_declarator_list *declarator_list; +- ast_struct_specifier *struct_specifier; +- ast_declaration *declaration; +- +- struct { +- ast_node *cond; +- ast_expression *rest; +- } for_rest_statement; +- +- struct { +- ast_node *then_statement; +- ast_node *else_statement; +- } selection_rest_statement; +- +- +- +-/* Line 1685 of yacc.c */ +-#line 279 "glsl_parser.h" +-} YYSTYPE; +-# define YYSTYPE_IS_TRIVIAL 1 +-# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +-# define YYSTYPE_IS_DECLARED 1 +-#endif +- +- +- +-#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED +-typedef struct YYLTYPE +-{ +- int first_line; +- int first_column; +- int last_line; +- int last_column; +-} YYLTYPE; +-# define yyltype YYLTYPE /* obsolescent; will be withdrawn */ +-# define YYLTYPE_IS_DECLARED 1 +-# define YYLTYPE_IS_TRIVIAL 1 +-#endif +- +- +- +diff --git a/src/glsl/glsl_parser.ypp b/src/glsl/glsl_parser.ypp +index 041a49f..6a1ef0f 100644 +--- a/src/glsl/glsl_parser.ypp ++++ b/src/glsl/glsl_parser.ypp +@@ -29,9 +29,6 @@ + #include "ast.h" + #include "glsl_parser_extras.h" + #include "glsl_types.h" +- +-#define YYLEX_PARAM state->scanner +- + %} + + %pure-parser +@@ -46,7 +43,7 @@ + @$.source = 0; + } + +-%lex-param {void *scanner} ++%lex-param {struct _mesa_glsl_parse_state *state} + %parse-param {struct _mesa_glsl_parse_state *state} + + %union { +-- +2.7.0