1 /* A Bison parser, made by GNU Bison 2.5. */ 2 3 /* Bison implementation for Yacc-like parsers in C 4 5 Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc. 6 7 This program is free software: you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation, either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 /* As a special exception, you may create a larger work that contains 21 part or all of the Bison parser skeleton and distribute that work 22 under terms of your choice, so long as that work isn't itself a 23 parser generator using the skeleton or a modified version thereof 24 as a parser skeleton. Alternatively, if you modify or redistribute 25 the parser skeleton itself, you may (at your option) remove this 26 special exception, which will cause the skeleton and the resulting 27 Bison output files to be licensed under the GNU General Public 28 License without this special exception. 29 30 This special exception was added by the Free Software Foundation in 31 version 2.2 of Bison. */ 32 33 /* C LALR(1) parser skeleton written by Richard Stallman, by 34 simplifying the original so-called "semantic" parser. */ 35 36 /* All symbols defined below should begin with yy or YY, to avoid 37 infringing on user name space. This should be done even for local 38 variables, as they might otherwise be expanded by user macros. 39 There are some unavoidable exceptions within include files to 40 define necessary library symbols; they are noted "INFRINGES ON 41 USER NAME SPACE" below. */ 42 43 /* Identify Bison output. */ 44 #define YYBISON 1 45 46 /* Bison version. */ 47 #define YYBISON_VERSION "2.5" 48 49 /* Skeleton name. */ 50 #define YYSKELETON_NAME "yacc.c" 51 52 /* Pure parsers. */ 53 #define YYPURE 1 54 55 /* Push parsers. */ 56 #define YYPUSH 0 57 58 /* Pull parsers. */ 59 #define YYPULL 1 60 61 /* Using locations. */ 62 #define YYLSP_NEEDED 1 63 64 /* Substitute the variable and function names. */ 65 #define yyparse glcpp_parser_parse 66 #define yylex glcpp_parser_lex 67 #define yyerror glcpp_parser_error 68 #define yylval glcpp_parser_lval 69 #define yychar glcpp_parser_char 70 #define yydebug glcpp_parser_debug 71 #define yynerrs glcpp_parser_nerrs 72 #define yylloc glcpp_parser_lloc 73 74 /* Copy the first part of user declarations. */ 75 76 /* Line 268 of yacc.c */ 77 #line 1 "src/src/glsl/glcpp/glcpp-parse.y" 78 79 /* 80 * Copyright 2010 Intel Corporation 81 * 82 * Permission is hereby granted, free of charge, to any person obtaining a 83 * copy of this software and associated documentation files (the "Software"), 84 * to deal in the Software without restriction, including without limitation 85 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 86 * and/or sell copies of the Software, and to permit persons to whom the 87 * Software is furnished to do so, subject to the following conditions: 88 * 89 * The above copyright notice and this permission notice (including the next 90 * paragraph) shall be included in all copies or substantial portions of the 91 * Software. 92 * 93 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 94 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 95 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 96 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 97 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 98 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 99 * DEALINGS IN THE SOFTWARE. 100 */ 101 102 #include <stdio.h> 103 #include <stdlib.h> 104 #include <string.h> 105 #include <assert.h> 106 #include <inttypes.h> 107 108 #include "glcpp.h" 109 #include "main/core.h" /* for struct gl_extensions */ 110 #include "main/mtypes.h" /* for gl_api enum */ 111 112 static void 113 yyerror (YYLTYPE *locp, glcpp_parser_t *parser, const char *error); 114 115 static void 116 _define_object_macro (glcpp_parser_t *parser, 117 YYLTYPE *loc, 118 const char *macro, 119 token_list_t *replacements); 120 121 static void 122 _define_function_macro (glcpp_parser_t *parser, 123 YYLTYPE *loc, 124 const char *macro, 125 string_list_t *parameters, 126 token_list_t *replacements); 127 128 static string_list_t * 129 _string_list_create (void *ctx); 130 131 static void 132 _string_list_append_item (string_list_t *list, const char *str); 133 134 static int 135 _string_list_contains (string_list_t *list, const char *member, int *index); 136 137 static int 138 _string_list_length (string_list_t *list); 139 140 static int 141 _string_list_equal (string_list_t *a, string_list_t *b); 142 143 static argument_list_t * 144 _argument_list_create (void *ctx); 145 146 static void 147 _argument_list_append (argument_list_t *list, token_list_t *argument); 148 149 static int 150 _argument_list_length (argument_list_t *list); 151 152 static token_list_t * 153 _argument_list_member_at (argument_list_t *list, int index); 154 155 /* Note: This function ralloc_steal()s the str pointer. */ 156 static token_t * 157 _token_create_str (void *ctx, int type, char *str); 158 159 static token_t * 160 _token_create_ival (void *ctx, int type, int ival); 161 162 static token_list_t * 163 _token_list_create (void *ctx); 164 165 static void 166 _token_list_append (token_list_t *list, token_t *token); 167 168 static void 169 _token_list_append_list (token_list_t *list, token_list_t *tail); 170 171 static int 172 _token_list_equal_ignoring_space (token_list_t *a, token_list_t *b); 173 174 static void 175 _parser_active_list_push (glcpp_parser_t *parser, 176 const char *identifier, 177 token_node_t *marker); 178 179 static void 180 _parser_active_list_pop (glcpp_parser_t *parser); 181 182 static int 183 _parser_active_list_contains (glcpp_parser_t *parser, const char *identifier); 184 185 /* Expand list, and begin lexing from the result (after first 186 * prefixing a token of type 'head_token_type'). 187 */ 188 static void 189 _glcpp_parser_expand_and_lex_from (glcpp_parser_t *parser, 190 int head_token_type, 191 token_list_t *list); 192 193 /* Perform macro expansion in-place on the given list. */ 194 static void 195 _glcpp_parser_expand_token_list (glcpp_parser_t *parser, 196 token_list_t *list); 197 198 static void 199 _glcpp_parser_print_expanded_token_list (glcpp_parser_t *parser, 200 token_list_t *list); 201 202 static void 203 _glcpp_parser_skip_stack_push_if (glcpp_parser_t *parser, YYLTYPE *loc, 204 int condition); 205 206 static void 207 _glcpp_parser_skip_stack_change_if (glcpp_parser_t *parser, YYLTYPE *loc, 208 const char *type, int condition); 209 210 static void 211 _glcpp_parser_skip_stack_pop (glcpp_parser_t *parser, YYLTYPE *loc); 212 213 static int 214 glcpp_parser_lex (YYSTYPE *yylval, YYLTYPE *yylloc, glcpp_parser_t *parser); 215 216 static void 217 glcpp_parser_lex_from (glcpp_parser_t *parser, token_list_t *list); 218 219 static void 220 add_builtin_define(glcpp_parser_t *parser, const char *name, int value); 221 222 223 224 /* Line 268 of yacc.c */ 225 #line 226 "src/chromium_gensrc/mesa/glcpp-parse.c" 226 227 /* Enabling traces. */ 228 #ifndef YYDEBUG 229 # define YYDEBUG 0 230 #endif 231 232 /* Enabling verbose error messages. */ 233 #ifdef YYERROR_VERBOSE 234 # undef YYERROR_VERBOSE 235 # define YYERROR_VERBOSE 1 236 #else 237 # define YYERROR_VERBOSE 1 238 #endif 239 240 /* Enabling the token table. */ 241 #ifndef YYTOKEN_TABLE 242 # define YYTOKEN_TABLE 0 243 #endif 244 245 246 /* Tokens. */ 247 #ifndef YYTOKENTYPE 248 # define YYTOKENTYPE 249 /* Put the tokens into the symbol table, so that GDB and other debuggers 250 know about them. */ 251 enum yytokentype { 252 COMMA_FINAL = 258, 253 DEFINED = 259, 254 ELIF_EXPANDED = 260, 255 HASH = 261, 256 HASH_DEFINE = 262, 257 FUNC_IDENTIFIER = 263, 258 OBJ_IDENTIFIER = 264, 259 HASH_ELIF = 265, 260 HASH_ELSE = 266, 261 HASH_ENDIF = 267, 262 HASH_IF = 268, 263 HASH_IFDEF = 269, 264 HASH_IFNDEF = 270, 265 HASH_LINE = 271, 266 HASH_UNDEF = 272, 267 HASH_VERSION = 273, 268 IDENTIFIER = 274, 269 IF_EXPANDED = 275, 270 INTEGER = 276, 271 INTEGER_STRING = 277, 272 LINE_EXPANDED = 278, 273 NEWLINE = 279, 274 OTHER = 280, 275 PLACEHOLDER = 281, 276 SPACE = 282, 277 PASTE = 283, 278 OR = 284, 279 AND = 285, 280 NOT_EQUAL = 286, 281 EQUAL = 287, 282 GREATER_OR_EQUAL = 288, 283 LESS_OR_EQUAL = 289, 284 RIGHT_SHIFT = 290, 285 LEFT_SHIFT = 291, 286 UNARY = 292 287 }; 288 #endif 289 /* Tokens. */ 290 #define COMMA_FINAL 258 291 #define DEFINED 259 292 #define ELIF_EXPANDED 260 293 #define HASH 261 294 #define HASH_DEFINE 262 295 #define FUNC_IDENTIFIER 263 296 #define OBJ_IDENTIFIER 264 297 #define HASH_ELIF 265 298 #define HASH_ELSE 266 299 #define HASH_ENDIF 267 300 #define HASH_IF 268 301 #define HASH_IFDEF 269 302 #define HASH_IFNDEF 270 303 #define HASH_LINE 271 304 #define HASH_UNDEF 272 305 #define HASH_VERSION 273 306 #define IDENTIFIER 274 307 #define IF_EXPANDED 275 308 #define INTEGER 276 309 #define INTEGER_STRING 277 310 #define LINE_EXPANDED 278 311 #define NEWLINE 279 312 #define OTHER 280 313 #define PLACEHOLDER 281 314 #define SPACE 282 315 #define PASTE 283 316 #define OR 284 317 #define AND 285 318 #define NOT_EQUAL 286 319 #define EQUAL 287 320 #define GREATER_OR_EQUAL 288 321 #define LESS_OR_EQUAL 289 322 #define RIGHT_SHIFT 290 323 #define LEFT_SHIFT 291 324 #define UNARY 292 325 326 327 328 329 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 330 331 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 332 # define YYSTYPE_IS_DECLARED 1 333 #endif 334 335 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED 336 typedef struct YYLTYPE 337 { 338 int first_line; 339 int first_column; 340 int last_line; 341 int last_column; 342 } YYLTYPE; 343 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */ 344 # define YYLTYPE_IS_DECLARED 1 345 # define YYLTYPE_IS_TRIVIAL 1 346 #endif 347 348 349 /* Copy the second part of user declarations. */ 350 351 352 /* Line 343 of yacc.c */ 353 #line 354 "src/chromium_gensrc/mesa/glcpp-parse.c" 354 355 #ifdef short 356 # undef short 357 #endif 358 359 #ifdef YYTYPE_UINT8 360 typedef YYTYPE_UINT8 yytype_uint8; 361 #else 362 typedef unsigned char yytype_uint8; 363 #endif 364 365 #ifdef YYTYPE_INT8 366 typedef YYTYPE_INT8 yytype_int8; 367 #elif (defined __STDC__ || defined __C99__FUNC__ \ 368 || defined __cplusplus || defined _MSC_VER) 369 typedef signed char yytype_int8; 370 #else 371 typedef short int yytype_int8; 372 #endif 373 374 #ifdef YYTYPE_UINT16 375 typedef YYTYPE_UINT16 yytype_uint16; 376 #else 377 typedef unsigned short int yytype_uint16; 378 #endif 379 380 #ifdef YYTYPE_INT16 381 typedef YYTYPE_INT16 yytype_int16; 382 #else 383 typedef short int yytype_int16; 384 #endif 385 386 #ifndef YYSIZE_T 387 # ifdef __SIZE_TYPE__ 388 # define YYSIZE_T __SIZE_TYPE__ 389 # elif defined size_t 390 # define YYSIZE_T size_t 391 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ 392 || defined __cplusplus || defined _MSC_VER) 393 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 394 # define YYSIZE_T size_t 395 # else 396 # define YYSIZE_T unsigned int 397 # endif 398 #endif 399 400 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 401 402 #ifndef YY_ 403 # if defined YYENABLE_NLS && YYENABLE_NLS 404 # if ENABLE_NLS 405 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 406 # define YY_(msgid) dgettext ("bison-runtime", msgid) 407 # endif 408 # endif 409 # ifndef YY_ 410 # define YY_(msgid) msgid 411 # endif 412 #endif 413 414 /* Suppress unused-variable warnings by "using" E. */ 415 #if ! defined lint || defined __GNUC__ 416 # define YYUSE(e) ((void) (e)) 417 #else 418 # define YYUSE(e) /* empty */ 419 #endif 420 421 /* Identity function, used to suppress warnings about constant conditions. */ 422 #ifndef lint 423 # define YYID(n) (n) 424 #else 425 #if (defined __STDC__ || defined __C99__FUNC__ \ 426 || defined __cplusplus || defined _MSC_VER) 427 static int 428 YYID (int yyi) 429 #else 430 static int 431 YYID (yyi) 432 int yyi; 433 #endif 434 { 435 return yyi; 436 } 437 #endif 438 439 #if ! defined yyoverflow || YYERROR_VERBOSE 440 441 /* The parser invokes alloca or malloc; define the necessary symbols. */ 442 443 # ifdef YYSTACK_USE_ALLOCA 444 # if YYSTACK_USE_ALLOCA 445 # ifdef __GNUC__ 446 # define YYSTACK_ALLOC __builtin_alloca 447 # elif defined __BUILTIN_VA_ARG_INCR 448 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 449 # elif defined _AIX 450 # define YYSTACK_ALLOC __alloca 451 # elif defined _MSC_VER 452 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 453 # define alloca _alloca 454 # else 455 # define YYSTACK_ALLOC alloca 456 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 457 || defined __cplusplus || defined _MSC_VER) 458 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 459 # ifndef EXIT_SUCCESS 460 # define EXIT_SUCCESS 0 461 # endif 462 # endif 463 # endif 464 # endif 465 # endif 466 467 # ifdef YYSTACK_ALLOC 468 /* Pacify GCC's `empty if-body' warning. */ 469 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) 470 # ifndef YYSTACK_ALLOC_MAXIMUM 471 /* The OS might guarantee only one guard page at the bottom of the stack, 472 and a page size can be as small as 4096 bytes. So we cannot safely 473 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 474 to allow for a few compiler-allocated temporary stack slots. */ 475 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 476 # endif 477 # else 478 # define YYSTACK_ALLOC YYMALLOC 479 # define YYSTACK_FREE YYFREE 480 # ifndef YYSTACK_ALLOC_MAXIMUM 481 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 482 # endif 483 # if (defined __cplusplus && ! defined EXIT_SUCCESS \ 484 && ! ((defined YYMALLOC || defined malloc) \ 485 && (defined YYFREE || defined free))) 486 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 487 # ifndef EXIT_SUCCESS 488 # define EXIT_SUCCESS 0 489 # endif 490 # endif 491 # ifndef YYMALLOC 492 # define YYMALLOC malloc 493 # if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 494 || defined __cplusplus || defined _MSC_VER) 495 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 496 # endif 497 # endif 498 # ifndef YYFREE 499 # define YYFREE free 500 # if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 501 || defined __cplusplus || defined _MSC_VER) 502 void free (void *); /* INFRINGES ON USER NAME SPACE */ 503 # endif 504 # endif 505 # endif 506 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 507 508 509 #if (! defined yyoverflow \ 510 && (! defined __cplusplus \ 511 || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \ 512 && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 513 514 /* A type that is properly aligned for any stack member. */ 515 union yyalloc 516 { 517 yytype_int16 yyss_alloc; 518 YYSTYPE yyvs_alloc; 519 YYLTYPE yyls_alloc; 520 }; 521 522 /* The size of the maximum gap between one aligned stack and the next. */ 523 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 524 525 /* The size of an array large to enough to hold all stacks, each with 526 N elements. */ 527 # define YYSTACK_BYTES(N) \ 528 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \ 529 + 2 * YYSTACK_GAP_MAXIMUM) 530 531 # define YYCOPY_NEEDED 1 532 533 /* Relocate STACK from its old location to the new one. The 534 local variables YYSIZE and YYSTACKSIZE give the old and new number of 535 elements in the stack, and YYPTR gives the new location of the 536 stack. Advance YYPTR to a properly aligned location for the next 537 stack. */ 538 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 539 do \ 540 { \ 541 YYSIZE_T yynewbytes; \ 542 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 543 Stack = &yyptr->Stack_alloc; \ 544 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 545 yyptr += yynewbytes / sizeof (*yyptr); \ 546 } \ 547 while (YYID (0)) 548 549 #endif 550 551 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED 552 /* Copy COUNT objects from FROM to TO. The source and destination do 553 not overlap. */ 554 # ifndef YYCOPY 555 # if defined __GNUC__ && 1 < __GNUC__ 556 # define YYCOPY(To, From, Count) \ 557 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 558 # else 559 # define YYCOPY(To, From, Count) \ 560 do \ 561 { \ 562 YYSIZE_T yyi; \ 563 for (yyi = 0; yyi < (Count); yyi++) \ 564 (To)[yyi] = (From)[yyi]; \ 565 } \ 566 while (YYID (0)) 567 # endif 568 # endif 569 #endif /* !YYCOPY_NEEDED */ 570 571 /* YYFINAL -- State number of the termination state. */ 572 #define YYFINAL 2 573 /* YYLAST -- Last index in YYTABLE. */ 574 #define YYLAST 670 575 576 /* YYNTOKENS -- Number of terminals. */ 577 #define YYNTOKENS 60 578 /* YYNNTS -- Number of nonterminals. */ 579 #define YYNNTS 19 580 /* YYNRULES -- Number of rules. */ 581 #define YYNRULES 107 582 /* YYNRULES -- Number of states. */ 583 #define YYNSTATES 172 584 585 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 586 #define YYUNDEFTOK 2 587 #define YYMAXUTOK 292 588 589 #define YYTRANSLATE(YYX) \ 590 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 591 592 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 593 static const yytype_uint8 yytranslate[] = 594 { 595 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 596 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 597 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 598 2, 2, 2, 50, 2, 2, 2, 46, 33, 2, 599 48, 49, 44, 42, 52, 43, 57, 45, 2, 2, 600 2, 2, 2, 2, 2, 2, 2, 2, 2, 58, 601 36, 59, 37, 2, 2, 2, 2, 2, 2, 2, 602 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 603 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 604 2, 53, 2, 54, 32, 2, 2, 2, 2, 2, 605 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 606 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 607 2, 2, 2, 55, 31, 56, 51, 2, 2, 2, 608 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 609 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 610 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 611 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 612 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 613 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 614 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 615 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 616 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 617 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 618 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 619 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 620 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 621 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 622 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 623 25, 26, 27, 28, 29, 30, 34, 35, 38, 39, 624 40, 41, 47 625 }; 626 627 #if YYDEBUG 628 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 629 YYRHS. */ 630 static const yytype_uint16 yyprhs[] = 631 { 632 0, 0, 3, 4, 7, 9, 11, 13, 16, 20, 633 24, 28, 33, 38, 45, 53, 57, 61, 65, 68, 634 73, 78, 82, 85, 86, 90, 91, 95, 99, 102, 635 104, 106, 108, 110, 114, 118, 122, 126, 130, 134, 636 138, 142, 146, 150, 154, 158, 162, 166, 170, 174, 637 178, 182, 185, 188, 191, 194, 198, 200, 204, 206, 638 209, 212, 213, 215, 216, 218, 221, 226, 228, 230, 639 233, 235, 238, 240, 242, 244, 246, 248, 250, 252, 640 254, 256, 258, 260, 262, 264, 266, 268, 270, 272, 641 274, 276, 278, 280, 282, 284, 286, 288, 290, 292, 642 294, 296, 298, 300, 302, 304, 306, 308 643 }; 644 645 /* YYRHS -- A `-1'-separated list of the rules' RHS. */ 646 static const yytype_int8 yyrhs[] = 647 { 648 61, 0, -1, -1, 61, 62, -1, 64, -1, 70, 649 -1, 63, -1, 6, 71, -1, 20, 68, 24, -1, 650 5, 68, 24, -1, 23, 67, 24, -1, 23, 67, 651 67, 24, -1, 7, 9, 72, 24, -1, 7, 8, 652 48, 49, 72, 24, -1, 7, 8, 48, 69, 49, 653 72, 24, -1, 17, 19, 24, -1, 16, 76, 24, 654 -1, 13, 75, 24, -1, 13, 24, -1, 14, 19, 655 73, 24, -1, 15, 19, 73, 24, -1, 10, 75, 656 24, -1, 10, 24, -1, -1, 11, 65, 24, -1, 657 -1, 12, 66, 24, -1, 18, 67, 24, -1, 6, 658 24, -1, 22, -1, 21, -1, 67, -1, 19, -1, 659 68, 29, 68, -1, 68, 30, 68, -1, 68, 31, 660 68, -1, 68, 32, 68, -1, 68, 33, 68, -1, 661 68, 34, 68, -1, 68, 35, 68, -1, 68, 38, 662 68, -1, 68, 39, 68, -1, 68, 37, 68, -1, 663 68, 36, 68, -1, 68, 40, 68, -1, 68, 41, 664 68, -1, 68, 43, 68, -1, 68, 42, 68, -1, 665 68, 46, 68, -1, 68, 45, 68, -1, 68, 44, 666 68, -1, 50, 68, -1, 51, 68, -1, 43, 68, 667 -1, 42, 68, -1, 48, 68, 49, -1, 19, -1, 668 69, 52, 19, -1, 24, -1, 76, 24, -1, 76, 669 24, -1, -1, 76, -1, -1, 76, -1, 4, 19, 670 -1, 4, 48, 19, 49, -1, 77, -1, 74, -1, 671 75, 74, -1, 77, -1, 76, 77, -1, 19, -1, 672 22, -1, 78, -1, 25, -1, 27, -1, 53, -1, 673 54, -1, 48, -1, 49, -1, 55, -1, 56, -1, 674 57, -1, 33, -1, 44, -1, 42, -1, 43, -1, 675 51, -1, 50, -1, 45, -1, 46, -1, 41, -1, 676 40, -1, 36, -1, 37, -1, 39, -1, 38, -1, 677 35, -1, 34, -1, 32, -1, 31, -1, 30, -1, 678 29, -1, 58, -1, 52, -1, 59, -1, 28, -1 679 }; 680 681 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 682 static const yytype_uint16 yyrline[] = 683 { 684 0, 184, 184, 186, 190, 193, 198, 199, 203, 206, 685 209, 217, 230, 233, 236, 239, 247, 255, 275, 285, 686 290, 295, 315, 330, 330, 333, 333, 336, 357, 361, 687 370, 375, 376, 379, 382, 385, 388, 391, 394, 397, 688 400, 403, 406, 409, 412, 415, 418, 421, 424, 432, 689 440, 443, 446, 449, 452, 455, 461, 466, 474, 475, 690 479, 485, 486, 489, 491, 498, 502, 506, 511, 515, 691 522, 527, 534, 538, 542, 546, 550, 557, 558, 559, 692 560, 561, 562, 563, 564, 565, 566, 567, 568, 569, 693 570, 571, 572, 573, 574, 575, 576, 577, 578, 579, 694 580, 581, 582, 583, 584, 585, 586, 587 695 }; 696 #endif 697 698 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE 699 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 700 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 701 static const char *const yytname[] = 702 { 703 "$end", "error", "$undefined", "COMMA_FINAL", "DEFINED", 704 "ELIF_EXPANDED", "HASH", "HASH_DEFINE", "FUNC_IDENTIFIER", 705 "OBJ_IDENTIFIER", "HASH_ELIF", "HASH_ELSE", "HASH_ENDIF", "HASH_IF", 706 "HASH_IFDEF", "HASH_IFNDEF", "HASH_LINE", "HASH_UNDEF", "HASH_VERSION", 707 "IDENTIFIER", "IF_EXPANDED", "INTEGER", "INTEGER_STRING", 708 "LINE_EXPANDED", "NEWLINE", "OTHER", "PLACEHOLDER", "SPACE", "PASTE", 709 "OR", "AND", "'|'", "'^'", "'&'", "NOT_EQUAL", "EQUAL", "'<'", "'>'", 710 "GREATER_OR_EQUAL", "LESS_OR_EQUAL", "RIGHT_SHIFT", "LEFT_SHIFT", "'+'", 711 "'-'", "'*'", "'/'", "'%'", "UNARY", "'('", "')'", "'!'", "'~'", "','", 712 "'['", "']'", "'{'", "'}'", "'.'", "';'", "'='", "$accept", "input", 713 "line", "expanded_line", "control_line", "$@1", "$@2", 714 "integer_constant", "expression", "identifier_list", "text_line", 715 "non_directive", "replacement_list", "junk", "conditional_token", 716 "conditional_tokens", "pp_tokens", "preprocessing_token", "operator", 0 717 }; 718 #endif 719 720 # ifdef YYPRINT 721 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 722 token YYLEX-NUM. */ 723 static const yytype_uint16 yytoknum[] = 724 { 725 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 726 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 727 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 728 285, 124, 94, 38, 286, 287, 60, 62, 288, 289, 729 290, 291, 43, 45, 42, 47, 37, 292, 40, 41, 730 33, 126, 44, 91, 93, 123, 125, 46, 59, 61 731 }; 732 # endif 733 734 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 735 static const yytype_uint8 yyr1[] = 736 { 737 0, 60, 61, 61, 62, 62, 62, 62, 63, 63, 738 63, 63, 64, 64, 64, 64, 64, 64, 64, 64, 739 64, 64, 64, 65, 64, 66, 64, 64, 64, 67, 740 67, 68, 68, 68, 68, 68, 68, 68, 68, 68, 741 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 742 68, 68, 68, 68, 68, 68, 69, 69, 70, 70, 743 71, 72, 72, 73, 73, 74, 74, 74, 75, 75, 744 76, 76, 77, 77, 77, 77, 77, 78, 78, 78, 745 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 746 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 747 78, 78, 78, 78, 78, 78, 78, 78 748 }; 749 750 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 751 static const yytype_uint8 yyr2[] = 752 { 753 0, 2, 0, 2, 1, 1, 1, 2, 3, 3, 754 3, 4, 4, 6, 7, 3, 3, 3, 2, 4, 755 4, 3, 2, 0, 3, 0, 3, 3, 2, 1, 756 1, 1, 1, 3, 3, 3, 3, 3, 3, 3, 757 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 758 3, 2, 2, 2, 2, 3, 1, 3, 1, 2, 759 2, 0, 1, 0, 1, 2, 4, 1, 1, 2, 760 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 761 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 762 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 763 1, 1, 1, 1, 1, 1, 1, 1 764 }; 765 766 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM. 767 Performed when YYTABLE doesn't specify something else to do. Zero 768 means the default is an error. */ 769 static const yytype_uint8 yydefact[] = 770 { 771 2, 0, 1, 0, 0, 0, 0, 23, 25, 0, 772 0, 0, 0, 0, 0, 72, 0, 73, 0, 58, 773 75, 76, 107, 103, 102, 101, 100, 84, 99, 98, 774 94, 95, 97, 96, 93, 92, 86, 87, 85, 90, 775 91, 79, 80, 89, 88, 105, 77, 78, 81, 82, 776 83, 104, 106, 3, 6, 4, 5, 0, 70, 74, 777 32, 30, 29, 0, 0, 0, 0, 0, 31, 0, 778 28, 7, 0, 0, 61, 0, 22, 68, 0, 67, 779 0, 0, 18, 0, 63, 63, 0, 0, 0, 0, 780 0, 59, 71, 54, 53, 0, 51, 52, 9, 0, 781 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 782 0, 0, 0, 0, 0, 0, 0, 60, 0, 0, 783 62, 65, 0, 21, 69, 24, 26, 17, 0, 64, 784 0, 16, 15, 27, 8, 10, 0, 55, 33, 34, 785 35, 36, 37, 38, 39, 43, 42, 40, 41, 44, 786 45, 47, 46, 50, 49, 48, 56, 61, 0, 12, 787 0, 19, 20, 11, 0, 61, 0, 66, 13, 0, 788 57, 14 789 }; 790 791 /* YYDEFGOTO[NTERM-NUM]. */ 792 static const yytype_int16 yydefgoto[] = 793 { 794 -1, 1, 53, 54, 55, 80, 81, 68, 69, 158, 795 56, 71, 119, 128, 77, 78, 120, 58, 59 796 }; 797 798 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 799 STATE-NUM. */ 800 #define YYPACT_NINF -149 801 static const yytype_int16 yypact[] = 802 { 803 -149, 115, -149, 492, -9, 103, 158, -149, -149, 201, 804 -5, 48, 451, 50, 95, -149, 492, -149, 95, -149, 805 -149, -149, -149, -149, -149, -149, -149, -149, -149, -149, 806 -149, -149, -149, -149, -149, -149, -149, -149, -149, -149, 807 -149, -149, -149, -149, -149, -149, -149, -149, -149, -149, 808 -149, -149, -149, -149, -149, -149, -149, 328, -149, -149, 809 -149, -149, -149, 492, 492, 492, 492, 492, -149, 515, 810 -149, -149, 369, 23, 451, 38, -149, -149, 244, -149, 811 -17, 51, -149, 287, 451, 451, 410, 55, 63, 538, 812 52, -149, -149, -149, -149, 487, -149, -149, -149, 492, 813 492, 492, 492, 492, 492, 492, 492, 492, 492, 492, 814 492, 492, 492, 492, 492, 492, 492, -149, 19, 89, 815 451, -149, 99, -149, -149, -149, -149, -149, 100, 451, 816 112, -149, -149, -149, -149, -149, 117, -149, 555, 571, 817 586, 600, 613, 624, 624, 18, 18, 18, 18, 64, 818 64, 37, 37, -149, -149, -149, -149, 451, -41, -149, 819 70, -149, -149, -149, 151, 451, 157, -149, -149, 154, 820 -149, -149 821 }; 822 823 /* YYPGOTO[NTERM-NUM]. */ 824 static const yytype_int16 yypgoto[] = 825 { 826 -149, -149, -149, -149, -149, -149, -149, -12, -11, -149, 827 -149, -149, -148, 94, -13, 172, 0, -6, -149 828 }; 829 830 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 831 positive, shift that token. If negative, reduce the rule which 832 number is the opposite. If YYTABLE_NINF, syntax error. */ 833 #define YYTABLE_NINF -1 834 static const yytype_uint8 yytable[] = 835 { 836 79, 57, 88, 79, 72, 89, 90, 125, 165, 164, 837 15, 166, 86, 17, 84, 70, 20, 169, 21, 22, 838 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 839 33, 34, 35, 36, 37, 38, 39, 40, 156, 41, 840 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 841 52, 92, 93, 94, 95, 96, 97, 121, 110, 111, 842 112, 113, 114, 115, 116, 124, 92, 85, 157, 87, 843 124, 118, 79, 61, 62, 126, 135, 79, 136, 132, 844 92, 114, 115, 116, 129, 129, 122, 133, 138, 139, 845 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 846 150, 151, 152, 153, 154, 155, 112, 113, 114, 115, 847 116, 73, 74, 159, 92, 2, 61, 62, 160, 167, 848 3, 4, 5, 92, 161, 6, 7, 8, 9, 10, 849 11, 12, 13, 14, 15, 16, 162, 17, 18, 19, 850 20, 163, 21, 22, 23, 24, 25, 26, 27, 28, 851 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 852 39, 40, 75, 41, 42, 43, 44, 45, 46, 47, 853 48, 49, 50, 51, 52, 168, 170, 15, 171, 130, 854 17, 83, 76, 20, 0, 21, 22, 23, 24, 25, 855 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 856 36, 37, 38, 39, 40, 75, 41, 42, 43, 44, 857 45, 46, 47, 48, 49, 50, 51, 52, 0, 0, 858 15, 0, 0, 17, 0, 82, 20, 0, 21, 22, 859 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 860 33, 34, 35, 36, 37, 38, 39, 40, 75, 41, 861 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 862 52, 0, 0, 15, 0, 0, 17, 0, 123, 20, 863 0, 21, 22, 23, 24, 25, 26, 27, 28, 29, 864 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 865 40, 75, 41, 42, 43, 44, 45, 46, 47, 48, 866 49, 50, 51, 52, 0, 0, 15, 0, 0, 17, 867 0, 127, 20, 0, 21, 22, 23, 24, 25, 26, 868 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 869 37, 38, 39, 40, 0, 41, 42, 43, 44, 45, 870 46, 47, 48, 49, 50, 51, 52, 15, 0, 0, 871 17, 0, 91, 20, 0, 21, 22, 23, 24, 25, 872 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 873 36, 37, 38, 39, 40, 0, 41, 42, 43, 44, 874 45, 46, 47, 48, 49, 50, 51, 52, 15, 0, 875 0, 17, 0, 117, 20, 0, 21, 22, 23, 24, 876 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 877 35, 36, 37, 38, 39, 40, 0, 41, 42, 43, 878 44, 45, 46, 47, 48, 49, 50, 51, 52, 15, 879 0, 0, 17, 0, 131, 20, 0, 21, 22, 23, 880 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 881 34, 35, 36, 37, 38, 39, 40, 0, 41, 42, 882 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 883 15, 0, 0, 17, 0, 0, 20, 0, 21, 22, 884 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 885 33, 34, 35, 36, 37, 38, 39, 40, 0, 41, 886 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 887 52, 60, 0, 61, 62, 0, 99, 100, 101, 102, 888 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 889 113, 114, 115, 116, 63, 64, 137, 0, 0, 98, 890 65, 0, 66, 67, 99, 100, 101, 102, 103, 104, 891 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 892 115, 116, 134, 0, 0, 0, 0, 99, 100, 101, 893 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 894 112, 113, 114, 115, 116, 100, 101, 102, 103, 104, 895 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 896 115, 116, 101, 102, 103, 104, 105, 106, 107, 108, 897 109, 110, 111, 112, 113, 114, 115, 116, 102, 103, 898 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 899 114, 115, 116, 103, 104, 105, 106, 107, 108, 109, 900 110, 111, 112, 113, 114, 115, 116, 104, 105, 106, 901 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 902 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 903 116 904 }; 905 906 #define yypact_value_is_default(yystate) \ 907 ((yystate) == (-149)) 908 909 #define yytable_value_is_error(yytable_value) \ 910 YYID (0) 911 912 static const yytype_int16 yycheck[] = 913 { 914 6, 1, 14, 9, 4, 16, 18, 24, 49, 157, 915 19, 52, 12, 22, 19, 24, 25, 165, 27, 28, 916 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 917 39, 40, 41, 42, 43, 44, 45, 46, 19, 48, 918 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 919 59, 57, 63, 64, 65, 66, 67, 19, 40, 41, 920 42, 43, 44, 45, 46, 78, 72, 19, 49, 19, 921 83, 48, 78, 21, 22, 24, 24, 83, 90, 24, 922 86, 44, 45, 46, 84, 85, 48, 24, 99, 100, 923 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 924 111, 112, 113, 114, 115, 116, 42, 43, 44, 45, 925 46, 8, 9, 24, 120, 0, 21, 22, 19, 49, 926 5, 6, 7, 129, 24, 10, 11, 12, 13, 14, 927 15, 16, 17, 18, 19, 20, 24, 22, 23, 24, 928 25, 24, 27, 28, 29, 30, 31, 32, 33, 34, 929 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 930 45, 46, 4, 48, 49, 50, 51, 52, 53, 54, 931 55, 56, 57, 58, 59, 24, 19, 19, 24, 85, 932 22, 9, 24, 25, -1, 27, 28, 29, 30, 31, 933 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 934 42, 43, 44, 45, 46, 4, 48, 49, 50, 51, 935 52, 53, 54, 55, 56, 57, 58, 59, -1, -1, 936 19, -1, -1, 22, -1, 24, 25, -1, 27, 28, 937 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 938 39, 40, 41, 42, 43, 44, 45, 46, 4, 48, 939 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 940 59, -1, -1, 19, -1, -1, 22, -1, 24, 25, 941 -1, 27, 28, 29, 30, 31, 32, 33, 34, 35, 942 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 943 46, 4, 48, 49, 50, 51, 52, 53, 54, 55, 944 56, 57, 58, 59, -1, -1, 19, -1, -1, 22, 945 -1, 24, 25, -1, 27, 28, 29, 30, 31, 32, 946 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 947 43, 44, 45, 46, -1, 48, 49, 50, 51, 52, 948 53, 54, 55, 56, 57, 58, 59, 19, -1, -1, 949 22, -1, 24, 25, -1, 27, 28, 29, 30, 31, 950 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 951 42, 43, 44, 45, 46, -1, 48, 49, 50, 51, 952 52, 53, 54, 55, 56, 57, 58, 59, 19, -1, 953 -1, 22, -1, 24, 25, -1, 27, 28, 29, 30, 954 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 955 41, 42, 43, 44, 45, 46, -1, 48, 49, 50, 956 51, 52, 53, 54, 55, 56, 57, 58, 59, 19, 957 -1, -1, 22, -1, 24, 25, -1, 27, 28, 29, 958 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 959 40, 41, 42, 43, 44, 45, 46, -1, 48, 49, 960 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 961 19, -1, -1, 22, -1, -1, 25, -1, 27, 28, 962 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 963 39, 40, 41, 42, 43, 44, 45, 46, -1, 48, 964 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 965 59, 19, -1, 21, 22, -1, 29, 30, 31, 32, 966 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 967 43, 44, 45, 46, 42, 43, 49, -1, -1, 24, 968 48, -1, 50, 51, 29, 30, 31, 32, 33, 34, 969 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 970 45, 46, 24, -1, -1, -1, -1, 29, 30, 31, 971 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 972 42, 43, 44, 45, 46, 30, 31, 32, 33, 34, 973 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 974 45, 46, 31, 32, 33, 34, 35, 36, 37, 38, 975 39, 40, 41, 42, 43, 44, 45, 46, 32, 33, 976 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 977 44, 45, 46, 33, 34, 35, 36, 37, 38, 39, 978 40, 41, 42, 43, 44, 45, 46, 34, 35, 36, 979 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 980 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 981 46 982 }; 983 984 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 985 symbol of state STATE-NUM. */ 986 static const yytype_uint8 yystos[] = 987 { 988 0, 61, 0, 5, 6, 7, 10, 11, 12, 13, 989 14, 15, 16, 17, 18, 19, 20, 22, 23, 24, 990 25, 27, 28, 29, 30, 31, 32, 33, 34, 35, 991 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 992 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 993 57, 58, 59, 62, 63, 64, 70, 76, 77, 78, 994 19, 21, 22, 42, 43, 48, 50, 51, 67, 68, 995 24, 71, 76, 8, 9, 4, 24, 74, 75, 77, 996 65, 66, 24, 75, 19, 19, 76, 19, 67, 68, 997 67, 24, 77, 68, 68, 68, 68, 68, 24, 29, 998 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 999 40, 41, 42, 43, 44, 45, 46, 24, 48, 72, 1000 76, 19, 48, 24, 74, 24, 24, 24, 73, 76, 1001 73, 24, 24, 24, 24, 24, 67, 49, 68, 68, 1002 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 1003 68, 68, 68, 68, 68, 68, 19, 49, 69, 24, 1004 19, 24, 24, 24, 72, 49, 52, 49, 24, 72, 1005 19, 24 1006 }; 1007 1008 #define yyerrok (yyerrstatus = 0) 1009 #define yyclearin (yychar = YYEMPTY) 1010 #define YYEMPTY (-2) 1011 #define YYEOF 0 1012 1013 #define YYACCEPT goto yyacceptlab 1014 #define YYABORT goto yyabortlab 1015 #define YYERROR goto yyerrorlab 1016 1017 1018 /* Like YYERROR except do call yyerror. This remains here temporarily 1019 to ease the transition to the new meaning of YYERROR, for GCC. 1020 Once GCC version 2 has supplanted version 1, this can go. However, 1021 YYFAIL appears to be in use. Nevertheless, it is formally deprecated 1022 in Bison 2.4.2's NEWS entry, where a plan to phase it out is 1023 discussed. */ 1024 1025 #define YYFAIL goto yyerrlab 1026 #if defined YYFAIL 1027 /* This is here to suppress warnings from the GCC cpp's 1028 -Wunused-macros. Normally we don't worry about that warning, but 1029 some users do, and we want to make it easy for users to remove 1030 YYFAIL uses, which will produce warnings from Bison 2.5. */ 1031 #endif 1032 1033 #define YYRECOVERING() (!!yyerrstatus) 1034 1035 #define YYBACKUP(Token, Value) \ 1036 do \ 1037 if (yychar == YYEMPTY && yylen == 1) \ 1038 { \ 1039 yychar = (Token); \ 1040 yylval = (Value); \ 1041 YYPOPSTACK (1); \ 1042 goto yybackup; \ 1043 } \ 1044 else \ 1045 { \ 1046 yyerror (&yylloc, parser, YY_("syntax error: cannot back up")); \ 1047 YYERROR; \ 1048 } \ 1049 while (YYID (0)) 1050 1051 1052 #define YYTERROR 1 1053 #define YYERRCODE 256 1054 1055 1056 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 1057 If N is 0, then set CURRENT to the empty location which ends 1058 the previous symbol: RHS[0] (always defined). */ 1059 1060 #define YYRHSLOC(Rhs, K) ((Rhs)[K]) 1061 #ifndef YYLLOC_DEFAULT 1062 # define YYLLOC_DEFAULT(Current, Rhs, N) \ 1063 do \ 1064 if (YYID (N)) \ 1065 { \ 1066 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 1067 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 1068 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 1069 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 1070 } \ 1071 else \ 1072 { \ 1073 (Current).first_line = (Current).last_line = \ 1074 YYRHSLOC (Rhs, 0).last_line; \ 1075 (Current).first_column = (Current).last_column = \ 1076 YYRHSLOC (Rhs, 0).last_column; \ 1077 } \ 1078 while (YYID (0)) 1079 #endif 1080 1081 1082 /* YY_LOCATION_PRINT -- Print the location on the stream. 1083 This macro was not mandated originally: define only if we know 1084 we won't break user code: when these are the locations we know. */ 1085 1086 #ifndef YY_LOCATION_PRINT 1087 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL 1088 # define YY_LOCATION_PRINT(File, Loc) \ 1089 fprintf (File, "%d.%d-%d.%d", \ 1090 (Loc).first_line, (Loc).first_column, \ 1091 (Loc).last_line, (Loc).last_column) 1092 # else 1093 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 1094 # endif 1095 #endif 1096 1097 1098 /* YYLEX -- calling `yylex' with the right arguments. */ 1099 1100 #ifdef YYLEX_PARAM 1101 # define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM) 1102 #else 1103 # define YYLEX yylex (&yylval, &yylloc, parser) 1104 #endif 1105 1106 /* Enable debugging if requested. */ 1107 #if YYDEBUG 1108 1109 # ifndef YYFPRINTF 1110 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 1111 # define YYFPRINTF fprintf 1112 # endif 1113 1114 # define YYDPRINTF(Args) \ 1115 do { \ 1116 if (yydebug) \ 1117 YYFPRINTF Args; \ 1118 } while (YYID (0)) 1119 1120 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 1121 do { \ 1122 if (yydebug) \ 1123 { \ 1124 YYFPRINTF (stderr, "%s ", Title); \ 1125 yy_symbol_print (stderr, \ 1126 Type, Value, Location, parser); \ 1127 YYFPRINTF (stderr, "\n"); \ 1128 } \ 1129 } while (YYID (0)) 1130 1131 1132 /*--------------------------------. 1133 | Print this symbol on YYOUTPUT. | 1134 `--------------------------------*/ 1135 1136 /*ARGSUSED*/ 1137 #if (defined __STDC__ || defined __C99__FUNC__ \ 1138 || defined __cplusplus || defined _MSC_VER) 1139 static void 1140 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, glcpp_parser_t *parser) 1141 #else 1142 static void 1143 yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, parser) 1144 FILE *yyoutput; 1145 int yytype; 1146 YYSTYPE const * const yyvaluep; 1147 YYLTYPE const * const yylocationp; 1148 glcpp_parser_t *parser; 1149 #endif 1150 { 1151 if (!yyvaluep) 1152 return; 1153 YYUSE (yylocationp); 1154 YYUSE (parser); 1155 # ifdef YYPRINT 1156 if (yytype < YYNTOKENS) 1157 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 1158 # else 1159 YYUSE (yyoutput); 1160 # endif 1161 switch (yytype) 1162 { 1163 default: 1164 break; 1165 } 1166 } 1167 1168 1169 /*--------------------------------. 1170 | Print this symbol on YYOUTPUT. | 1171 `--------------------------------*/ 1172 1173 #if (defined __STDC__ || defined __C99__FUNC__ \ 1174 || defined __cplusplus || defined _MSC_VER) 1175 static void 1176 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, glcpp_parser_t *parser) 1177 #else 1178 static void 1179 yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp, parser) 1180 FILE *yyoutput; 1181 int yytype; 1182 YYSTYPE const * const yyvaluep; 1183 YYLTYPE const * const yylocationp; 1184 glcpp_parser_t *parser; 1185 #endif 1186 { 1187 if (yytype < YYNTOKENS) 1188 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 1189 else 1190 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 1191 1192 YY_LOCATION_PRINT (yyoutput, *yylocationp); 1193 YYFPRINTF (yyoutput, ": "); 1194 yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, parser); 1195 YYFPRINTF (yyoutput, ")"); 1196 } 1197 1198 /*------------------------------------------------------------------. 1199 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 1200 | TOP (included). | 1201 `------------------------------------------------------------------*/ 1202 1203 #if (defined __STDC__ || defined __C99__FUNC__ \ 1204 || defined __cplusplus || defined _MSC_VER) 1205 static void 1206 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 1207 #else 1208 static void 1209 yy_stack_print (yybottom, yytop) 1210 yytype_int16 *yybottom; 1211 yytype_int16 *yytop; 1212 #endif 1213 { 1214 YYFPRINTF (stderr, "Stack now"); 1215 for (; yybottom <= yytop; yybottom++) 1216 { 1217 int yybot = *yybottom; 1218 YYFPRINTF (stderr, " %d", yybot); 1219 } 1220 YYFPRINTF (stderr, "\n"); 1221 } 1222 1223 # define YY_STACK_PRINT(Bottom, Top) \ 1224 do { \ 1225 if (yydebug) \ 1226 yy_stack_print ((Bottom), (Top)); \ 1227 } while (YYID (0)) 1228 1229 1230 /*------------------------------------------------. 1231 | Report that the YYRULE is going to be reduced. | 1232 `------------------------------------------------*/ 1233 1234 #if (defined __STDC__ || defined __C99__FUNC__ \ 1235 || defined __cplusplus || defined _MSC_VER) 1236 static void 1237 yy_reduce_print (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, glcpp_parser_t *parser) 1238 #else 1239 static void 1240 yy_reduce_print (yyvsp, yylsp, yyrule, parser) 1241 YYSTYPE *yyvsp; 1242 YYLTYPE *yylsp; 1243 int yyrule; 1244 glcpp_parser_t *parser; 1245 #endif 1246 { 1247 int yynrhs = yyr2[yyrule]; 1248 int yyi; 1249 unsigned long int yylno = yyrline[yyrule]; 1250 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 1251 yyrule - 1, yylno); 1252 /* The symbols being reduced. */ 1253 for (yyi = 0; yyi < yynrhs; yyi++) 1254 { 1255 YYFPRINTF (stderr, " $%d = ", yyi + 1); 1256 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 1257 &(yyvsp[(yyi + 1) - (yynrhs)]) 1258 , &(yylsp[(yyi + 1) - (yynrhs)]) , parser); 1259 YYFPRINTF (stderr, "\n"); 1260 } 1261 } 1262 1263 # define YY_REDUCE_PRINT(Rule) \ 1264 do { \ 1265 if (yydebug) \ 1266 yy_reduce_print (yyvsp, yylsp, Rule, parser); \ 1267 } while (YYID (0)) 1268 1269 /* Nonzero means print parse trace. It is left uninitialized so that 1270 multiple parsers can coexist. */ 1271 int yydebug; 1272 #else /* !YYDEBUG */ 1273 # define YYDPRINTF(Args) 1274 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 1275 # define YY_STACK_PRINT(Bottom, Top) 1276 # define YY_REDUCE_PRINT(Rule) 1277 #endif /* !YYDEBUG */ 1278 1279 1280 /* YYINITDEPTH -- initial size of the parser's stacks. */ 1281 #ifndef YYINITDEPTH 1282 # define YYINITDEPTH 200 1283 #endif 1284 1285 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 1286 if the built-in stack extension method is used). 1287 1288 Do not make this value too large; the results are undefined if 1289 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 1290 evaluated with infinite-precision integer arithmetic. */ 1291 1292 #ifndef YYMAXDEPTH 1293 # define YYMAXDEPTH 10000 1294 #endif 1295 1296 1297 #if YYERROR_VERBOSE 1298 1299 # ifndef yystrlen 1300 # if defined __GLIBC__ && defined _STRING_H 1301 # define yystrlen strlen 1302 # else 1303 /* Return the length of YYSTR. */ 1304 #if (defined __STDC__ || defined __C99__FUNC__ \ 1305 || defined __cplusplus || defined _MSC_VER) 1306 static YYSIZE_T 1307 yystrlen (const char *yystr) 1308 #else 1309 static YYSIZE_T 1310 yystrlen (yystr) 1311 const char *yystr; 1312 #endif 1313 { 1314 YYSIZE_T yylen; 1315 for (yylen = 0; yystr[yylen]; yylen++) 1316 continue; 1317 return yylen; 1318 } 1319 # endif 1320 # endif 1321 1322 # ifndef yystpcpy 1323 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 1324 # define yystpcpy stpcpy 1325 # else 1326 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 1327 YYDEST. */ 1328 #if (defined __STDC__ || defined __C99__FUNC__ \ 1329 || defined __cplusplus || defined _MSC_VER) 1330 static char * 1331 yystpcpy (char *yydest, const char *yysrc) 1332 #else 1333 static char * 1334 yystpcpy (yydest, yysrc) 1335 char *yydest; 1336 const char *yysrc; 1337 #endif 1338 { 1339 char *yyd = yydest; 1340 const char *yys = yysrc; 1341 1342 while ((*yyd++ = *yys++) != '\0') 1343 continue; 1344 1345 return yyd - 1; 1346 } 1347 # endif 1348 # endif 1349 1350 # ifndef yytnamerr 1351 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 1352 quotes and backslashes, so that it's suitable for yyerror. The 1353 heuristic is that double-quoting is unnecessary unless the string 1354 contains an apostrophe, a comma, or backslash (other than 1355 backslash-backslash). YYSTR is taken from yytname. If YYRES is 1356 null, do not copy; instead, return the length of what the result 1357 would have been. */ 1358 static YYSIZE_T 1359 yytnamerr (char *yyres, const char *yystr) 1360 { 1361 if (*yystr == '"') 1362 { 1363 YYSIZE_T yyn = 0; 1364 char const *yyp = yystr; 1365 1366 for (;;) 1367 switch (*++yyp) 1368 { 1369 case '\'': 1370 case ',': 1371 goto do_not_strip_quotes; 1372 1373 case '\\': 1374 if (*++yyp != '\\') 1375 goto do_not_strip_quotes; 1376 /* Fall through. */ 1377 default: 1378 if (yyres) 1379 yyres[yyn] = *yyp; 1380 yyn++; 1381 break; 1382 1383 case '"': 1384 if (yyres) 1385 yyres[yyn] = '\0'; 1386 return yyn; 1387 } 1388 do_not_strip_quotes: ; 1389 } 1390 1391 if (! yyres) 1392 return yystrlen (yystr); 1393 1394 return yystpcpy (yyres, yystr) - yyres; 1395 } 1396 # endif 1397 1398 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message 1399 about the unexpected token YYTOKEN for the state stack whose top is 1400 YYSSP. 1401 1402 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is 1403 not large enough to hold the message. In that case, also set 1404 *YYMSG_ALLOC to the required number of bytes. Return 2 if the 1405 required number of bytes is too large to store. */ 1406 static int 1407 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, 1408 yytype_int16 *yyssp, int yytoken) 1409 { 1410 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]); 1411 YYSIZE_T yysize = yysize0; 1412 YYSIZE_T yysize1; 1413 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1414 /* Internationalized format string. */ 1415 const char *yyformat = 0; 1416 /* Arguments of yyformat. */ 1417 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1418 /* Number of reported tokens (one for the "unexpected", one per 1419 "expected"). */ 1420 int yycount = 0; 1421 1422 /* There are many possibilities here to consider: 1423 - Assume YYFAIL is not used. It's too flawed to consider. See 1424 <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html> 1425 for details. YYERROR is fine as it does not invoke this 1426 function. 1427 - If this state is a consistent state with a default action, then 1428 the only way this function was invoked is if the default action 1429 is an error action. In that case, don't check for expected 1430 tokens because there are none. 1431 - The only way there can be no lookahead present (in yychar) is if 1432 this state is a consistent state with a default action. Thus, 1433 detecting the absence of a lookahead is sufficient to determine 1434 that there is no unexpected or expected token to report. In that 1435 case, just report a simple "syntax error". 1436 - Don't assume there isn't a lookahead just because this state is a 1437 consistent state with a default action. There might have been a 1438 previous inconsistent state, consistent state with a non-default 1439 action, or user semantic action that manipulated yychar. 1440 - Of course, the expected token list depends on states to have 1441 correct lookahead information, and it depends on the parser not 1442 to perform extra reductions after fetching a lookahead from the 1443 scanner and before detecting a syntax error. Thus, state merging 1444 (from LALR or IELR) and default reductions corrupt the expected 1445 token list. However, the list is correct for canonical LR with 1446 one exception: it will still contain any token that will not be 1447 accepted due to an error action in a later state. 1448 */ 1449 if (yytoken != YYEMPTY) 1450 { 1451 int yyn = yypact[*yyssp]; 1452 yyarg[yycount++] = yytname[yytoken]; 1453 if (!yypact_value_is_default (yyn)) 1454 { 1455 /* Start YYX at -YYN if negative to avoid negative indexes in 1456 YYCHECK. In other words, skip the first -YYN actions for 1457 this state because they are default actions. */ 1458 int yyxbegin = yyn < 0 ? -yyn : 0; 1459 /* Stay within bounds of both yycheck and yytname. */ 1460 int yychecklim = YYLAST - yyn + 1; 1461 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 1462 int yyx; 1463 1464 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 1465 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR 1466 && !yytable_value_is_error (yytable[yyx + yyn])) 1467 { 1468 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 1469 { 1470 yycount = 1; 1471 yysize = yysize0; 1472 break; 1473 } 1474 yyarg[yycount++] = yytname[yyx]; 1475 yysize1 = yysize + yytnamerr (0, yytname[yyx]); 1476 if (! (yysize <= yysize1 1477 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 1478 return 2; 1479 yysize = yysize1; 1480 } 1481 } 1482 } 1483 1484 switch (yycount) 1485 { 1486 # define YYCASE_(N, S) \ 1487 case N: \ 1488 yyformat = S; \ 1489 break 1490 YYCASE_(0, YY_("syntax error")); 1491 YYCASE_(1, YY_("syntax error, unexpected %s")); 1492 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); 1493 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); 1494 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); 1495 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); 1496 # undef YYCASE_ 1497 } 1498 1499 yysize1 = yysize + yystrlen (yyformat); 1500 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 1501 return 2; 1502 yysize = yysize1; 1503 1504 if (*yymsg_alloc < yysize) 1505 { 1506 *yymsg_alloc = 2 * yysize; 1507 if (! (yysize <= *yymsg_alloc 1508 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) 1509 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; 1510 return 1; 1511 } 1512 1513 /* Avoid sprintf, as that infringes on the user's name space. 1514 Don't have undefined behavior even if the translation 1515 produced a string with the wrong number of "%s"s. */ 1516 { 1517 char *yyp = *yymsg; 1518 int yyi = 0; 1519 while ((*yyp = *yyformat) != '\0') 1520 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) 1521 { 1522 yyp += yytnamerr (yyp, yyarg[yyi++]); 1523 yyformat += 2; 1524 } 1525 else 1526 { 1527 yyp++; 1528 yyformat++; 1529 } 1530 } 1531 return 0; 1532 } 1533 #endif /* YYERROR_VERBOSE */ 1534 1535 /*-----------------------------------------------. 1536 | Release the memory associated to this symbol. | 1537 `-----------------------------------------------*/ 1538 1539 /*ARGSUSED*/ 1540 #if (defined __STDC__ || defined __C99__FUNC__ \ 1541 || defined __cplusplus || defined _MSC_VER) 1542 static void 1543 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, glcpp_parser_t *parser) 1544 #else 1545 static void 1546 yydestruct (yymsg, yytype, yyvaluep, yylocationp, parser) 1547 const char *yymsg; 1548 int yytype; 1549 YYSTYPE *yyvaluep; 1550 YYLTYPE *yylocationp; 1551 glcpp_parser_t *parser; 1552 #endif 1553 { 1554 YYUSE (yyvaluep); 1555 YYUSE (yylocationp); 1556 YYUSE (parser); 1557 1558 if (!yymsg) 1559 yymsg = "Deleting"; 1560 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1561 1562 switch (yytype) 1563 { 1564 1565 default: 1566 break; 1567 } 1568 } 1569 1570 1571 /* Prevent warnings from -Wmissing-prototypes. */ 1572 #ifdef YYPARSE_PARAM 1573 #if defined __STDC__ || defined __cplusplus 1574 int yyparse (void *YYPARSE_PARAM); 1575 #else 1576 int yyparse (); 1577 #endif 1578 #else /* ! YYPARSE_PARAM */ 1579 #if defined __STDC__ || defined __cplusplus 1580 int yyparse (glcpp_parser_t *parser); 1581 #else 1582 int yyparse (); 1583 #endif 1584 #endif /* ! YYPARSE_PARAM */ 1585 1586 1587 /*----------. 1588 | yyparse. | 1589 `----------*/ 1590 1591 #ifdef YYPARSE_PARAM 1592 #if (defined __STDC__ || defined __C99__FUNC__ \ 1593 || defined __cplusplus || defined _MSC_VER) 1594 int 1595 yyparse (void *YYPARSE_PARAM) 1596 #else 1597 int 1598 yyparse (YYPARSE_PARAM) 1599 void *YYPARSE_PARAM; 1600 #endif 1601 #else /* ! YYPARSE_PARAM */ 1602 #if (defined __STDC__ || defined __C99__FUNC__ \ 1603 || defined __cplusplus || defined _MSC_VER) 1604 int 1605 yyparse (glcpp_parser_t *parser) 1606 #else 1607 int 1608 yyparse (parser) 1609 glcpp_parser_t *parser; 1610 #endif 1611 #endif 1612 { 1613 /* The lookahead symbol. */ 1614 int yychar; 1615 1616 /* The semantic value of the lookahead symbol. */ 1617 YYSTYPE yylval; 1618 1619 /* Location data for the lookahead symbol. */ 1620 YYLTYPE yylloc; 1621 1622 /* Number of syntax errors so far. */ 1623 int yynerrs; 1624 1625 int yystate; 1626 /* Number of tokens to shift before error messages enabled. */ 1627 int yyerrstatus; 1628 1629 /* The stacks and their tools: 1630 `yyss': related to states. 1631 `yyvs': related to semantic values. 1632 `yyls': related to locations. 1633 1634 Refer to the stacks thru separate pointers, to allow yyoverflow 1635 to reallocate them elsewhere. */ 1636 1637 /* The state stack. */ 1638 yytype_int16 yyssa[YYINITDEPTH]; 1639 yytype_int16 *yyss; 1640 yytype_int16 *yyssp; 1641 1642 /* The semantic value stack. */ 1643 YYSTYPE yyvsa[YYINITDEPTH]; 1644 YYSTYPE *yyvs; 1645 YYSTYPE *yyvsp; 1646 1647 /* The location stack. */ 1648 YYLTYPE yylsa[YYINITDEPTH]; 1649 YYLTYPE *yyls; 1650 YYLTYPE *yylsp; 1651 1652 /* The locations where the error started and ended. */ 1653 YYLTYPE yyerror_range[3]; 1654 1655 YYSIZE_T yystacksize; 1656 1657 int yyn; 1658 int yyresult; 1659 /* Lookahead token as an internal (translated) token number. */ 1660 int yytoken; 1661 /* The variables used to return semantic value and location from the 1662 action routines. */ 1663 YYSTYPE yyval; 1664 YYLTYPE yyloc; 1665 1666 #if YYERROR_VERBOSE 1667 /* Buffer for error messages, and its allocated size. */ 1668 char yymsgbuf[128]; 1669 char *yymsg = yymsgbuf; 1670 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 1671 #endif 1672 1673 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) 1674 1675 /* The number of symbols on the RHS of the reduced rule. 1676 Keep to zero when no symbol should be popped. */ 1677 int yylen = 0; 1678 1679 yytoken = 0; 1680 yyss = yyssa; 1681 yyvs = yyvsa; 1682 yyls = yylsa; 1683 yystacksize = YYINITDEPTH; 1684 1685 YYDPRINTF ((stderr, "Starting parse\n")); 1686 1687 yystate = 0; 1688 yyerrstatus = 0; 1689 yynerrs = 0; 1690 yychar = YYEMPTY; /* Cause a token to be read. */ 1691 1692 /* Initialize stack pointers. 1693 Waste one element of value and location stack 1694 so that they stay on the same level as the state stack. 1695 The wasted elements are never initialized. */ 1696 yyssp = yyss; 1697 yyvsp = yyvs; 1698 yylsp = yyls; 1699 1700 #if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL 1701 /* Initialize the default location before parsing starts. */ 1702 yylloc.first_line = yylloc.last_line = 1; 1703 yylloc.first_column = yylloc.last_column = 1; 1704 #endif 1705 1706 /* User initialization code. */ 1707 1708 /* Line 1590 of yacc.c */ 1709 #line 151 "src/src/glsl/glcpp/glcpp-parse.y" 1710 { 1711 yylloc.first_line = 1; 1712 yylloc.first_column = 1; 1713 yylloc.last_line = 1; 1714 yylloc.last_column = 1; 1715 yylloc.source = 0; 1716 } 1717 1718 /* Line 1590 of yacc.c */ 1719 #line 1720 "src/chromium_gensrc/mesa/glcpp-parse.c" 1720 yylsp[0] = yylloc; 1721 1722 goto yysetstate; 1723 1724 /*------------------------------------------------------------. 1725 | yynewstate -- Push a new state, which is found in yystate. | 1726 `------------------------------------------------------------*/ 1727 yynewstate: 1728 /* In all cases, when you get here, the value and location stacks 1729 have just been pushed. So pushing a state here evens the stacks. */ 1730 yyssp++; 1731 1732 yysetstate: 1733 *yyssp = yystate; 1734 1735 if (yyss + yystacksize - 1 <= yyssp) 1736 { 1737 /* Get the current used size of the three stacks, in elements. */ 1738 YYSIZE_T yysize = yyssp - yyss + 1; 1739 1740 #ifdef yyoverflow 1741 { 1742 /* Give user a chance to reallocate the stack. Use copies of 1743 these so that the &'s don't force the real ones into 1744 memory. */ 1745 YYSTYPE *yyvs1 = yyvs; 1746 yytype_int16 *yyss1 = yyss; 1747 YYLTYPE *yyls1 = yyls; 1748 1749 /* Each stack pointer address is followed by the size of the 1750 data in use in that stack, in bytes. This used to be a 1751 conditional around just the two extra args, but that might 1752 be undefined if yyoverflow is a macro. */ 1753 yyoverflow (YY_("memory exhausted"), 1754 &yyss1, yysize * sizeof (*yyssp), 1755 &yyvs1, yysize * sizeof (*yyvsp), 1756 &yyls1, yysize * sizeof (*yylsp), 1757 &yystacksize); 1758 1759 yyls = yyls1; 1760 yyss = yyss1; 1761 yyvs = yyvs1; 1762 } 1763 #else /* no yyoverflow */ 1764 # ifndef YYSTACK_RELOCATE 1765 goto yyexhaustedlab; 1766 # else 1767 /* Extend the stack our own way. */ 1768 if (YYMAXDEPTH <= yystacksize) 1769 goto yyexhaustedlab; 1770 yystacksize *= 2; 1771 if (YYMAXDEPTH < yystacksize) 1772 yystacksize = YYMAXDEPTH; 1773 1774 { 1775 yytype_int16 *yyss1 = yyss; 1776 union yyalloc *yyptr = 1777 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 1778 if (! yyptr) 1779 goto yyexhaustedlab; 1780 YYSTACK_RELOCATE (yyss_alloc, yyss); 1781 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 1782 YYSTACK_RELOCATE (yyls_alloc, yyls); 1783 # undef YYSTACK_RELOCATE 1784 if (yyss1 != yyssa) 1785 YYSTACK_FREE (yyss1); 1786 } 1787 # endif 1788 #endif /* no yyoverflow */ 1789 1790 yyssp = yyss + yysize - 1; 1791 yyvsp = yyvs + yysize - 1; 1792 yylsp = yyls + yysize - 1; 1793 1794 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 1795 (unsigned long int) yystacksize)); 1796 1797 if (yyss + yystacksize - 1 <= yyssp) 1798 YYABORT; 1799 } 1800 1801 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1802 1803 if (yystate == YYFINAL) 1804 YYACCEPT; 1805 1806 goto yybackup; 1807 1808 /*-----------. 1809 | yybackup. | 1810 `-----------*/ 1811 yybackup: 1812 1813 /* Do appropriate processing given the current state. Read a 1814 lookahead token if we need one and don't already have one. */ 1815 1816 /* First try to decide what to do without reference to lookahead token. */ 1817 yyn = yypact[yystate]; 1818 if (yypact_value_is_default (yyn)) 1819 goto yydefault; 1820 1821 /* Not known => get a lookahead token if don't already have one. */ 1822 1823 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 1824 if (yychar == YYEMPTY) 1825 { 1826 YYDPRINTF ((stderr, "Reading a token: ")); 1827 yychar = YYLEX; 1828 } 1829 1830 if (yychar <= YYEOF) 1831 { 1832 yychar = yytoken = YYEOF; 1833 YYDPRINTF ((stderr, "Now at end of input.\n")); 1834 } 1835 else 1836 { 1837 yytoken = YYTRANSLATE (yychar); 1838 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1839 } 1840 1841 /* If the proper action on seeing token YYTOKEN is to reduce or to 1842 detect an error, take that action. */ 1843 yyn += yytoken; 1844 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1845 goto yydefault; 1846 yyn = yytable[yyn]; 1847 if (yyn <= 0) 1848 { 1849 if (yytable_value_is_error (yyn)) 1850 goto yyerrlab; 1851 yyn = -yyn; 1852 goto yyreduce; 1853 } 1854 1855 /* Count tokens shifted since error; after three, turn off error 1856 status. */ 1857 if (yyerrstatus) 1858 yyerrstatus--; 1859 1860 /* Shift the lookahead token. */ 1861 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1862 1863 /* Discard the shifted token. */ 1864 yychar = YYEMPTY; 1865 1866 yystate = yyn; 1867 *++yyvsp = yylval; 1868 *++yylsp = yylloc; 1869 goto yynewstate; 1870 1871 1872 /*-----------------------------------------------------------. 1873 | yydefault -- do the default action for the current state. | 1874 `-----------------------------------------------------------*/ 1875 yydefault: 1876 yyn = yydefact[yystate]; 1877 if (yyn == 0) 1878 goto yyerrlab; 1879 goto yyreduce; 1880 1881 1882 /*-----------------------------. 1883 | yyreduce -- Do a reduction. | 1884 `-----------------------------*/ 1885 yyreduce: 1886 /* yyn is the number of a rule to reduce with. */ 1887 yylen = yyr2[yyn]; 1888 1889 /* If YYLEN is nonzero, implement the default value of the action: 1890 `$$ = $1'. 1891 1892 Otherwise, the following line sets YYVAL to garbage. 1893 This behavior is undocumented and Bison 1894 users should not rely upon it. Assigning to YYVAL 1895 unconditionally makes the parser a bit smaller, and it avoids a 1896 GCC warning that YYVAL may be used uninitialized. */ 1897 yyval = yyvsp[1-yylen]; 1898 1899 /* Default location. */ 1900 YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); 1901 YY_REDUCE_PRINT (yyn); 1902 switch (yyn) 1903 { 1904 case 4: 1905 1906 /* Line 1806 of yacc.c */ 1907 #line 190 "src/src/glsl/glcpp/glcpp-parse.y" 1908 { 1909 ralloc_asprintf_rewrite_tail (&parser->output, &parser->output_length, "\n"); 1910 } 1911 break; 1912 1913 case 5: 1914 1915 /* Line 1806 of yacc.c */ 1916 #line 193 "src/src/glsl/glcpp/glcpp-parse.y" 1917 { 1918 _glcpp_parser_print_expanded_token_list (parser, (yyvsp[(1) - (1)].token_list)); 1919 ralloc_asprintf_rewrite_tail (&parser->output, &parser->output_length, "\n"); 1920 ralloc_free ((yyvsp[(1) - (1)].token_list)); 1921 } 1922 break; 1923 1924 case 8: 1925 1926 /* Line 1806 of yacc.c */ 1927 #line 203 "src/src/glsl/glcpp/glcpp-parse.y" 1928 { 1929 _glcpp_parser_skip_stack_push_if (parser, & (yylsp[(1) - (3)]), (yyvsp[(2) - (3)].ival)); 1930 } 1931 break; 1932 1933 case 9: 1934 1935 /* Line 1806 of yacc.c */ 1936 #line 206 "src/src/glsl/glcpp/glcpp-parse.y" 1937 { 1938 _glcpp_parser_skip_stack_change_if (parser, & (yylsp[(1) - (3)]), "elif", (yyvsp[(2) - (3)].ival)); 1939 } 1940 break; 1941 1942 case 10: 1943 1944 /* Line 1806 of yacc.c */ 1945 #line 209 "src/src/glsl/glcpp/glcpp-parse.y" 1946 { 1947 parser->has_new_line_number = 1; 1948 parser->new_line_number = (yyvsp[(2) - (3)].ival); 1949 ralloc_asprintf_rewrite_tail (&parser->output, 1950 &parser->output_length, 1951 "#line %" PRIiMAX "\n", 1952 (yyvsp[(2) - (3)].ival)); 1953 } 1954 break; 1955 1956 case 11: 1957 1958 /* Line 1806 of yacc.c */ 1959 #line 217 "src/src/glsl/glcpp/glcpp-parse.y" 1960 { 1961 parser->has_new_line_number = 1; 1962 parser->new_line_number = (yyvsp[(2) - (4)].ival); 1963 parser->has_new_source_number = 1; 1964 parser->new_source_number = (yyvsp[(3) - (4)].ival); 1965 ralloc_asprintf_rewrite_tail (&parser->output, 1966 &parser->output_length, 1967 "#line %" PRIiMAX " %" PRIiMAX "\n", 1968 (yyvsp[(2) - (4)].ival), (yyvsp[(3) - (4)].ival)); 1969 } 1970 break; 1971 1972 case 12: 1973 1974 /* Line 1806 of yacc.c */ 1975 #line 230 "src/src/glsl/glcpp/glcpp-parse.y" 1976 { 1977 _define_object_macro (parser, & (yylsp[(2) - (4)]), (yyvsp[(2) - (4)].str), (yyvsp[(3) - (4)].token_list)); 1978 } 1979 break; 1980 1981 case 13: 1982 1983 /* Line 1806 of yacc.c */ 1984 #line 233 "src/src/glsl/glcpp/glcpp-parse.y" 1985 { 1986 _define_function_macro (parser, & (yylsp[(2) - (6)]), (yyvsp[(2) - (6)].str), NULL, (yyvsp[(5) - (6)].token_list)); 1987 } 1988 break; 1989 1990 case 14: 1991 1992 /* Line 1806 of yacc.c */ 1993 #line 236 "src/src/glsl/glcpp/glcpp-parse.y" 1994 { 1995 _define_function_macro (parser, & (yylsp[(2) - (7)]), (yyvsp[(2) - (7)].str), (yyvsp[(4) - (7)].string_list), (yyvsp[(6) - (7)].token_list)); 1996 } 1997 break; 1998 1999 case 15: 2000 2001 /* Line 1806 of yacc.c */ 2002 #line 239 "src/src/glsl/glcpp/glcpp-parse.y" 2003 { 2004 macro_t *macro = hash_table_find (parser->defines, (yyvsp[(2) - (3)].str)); 2005 if (macro) { 2006 hash_table_remove (parser->defines, (yyvsp[(2) - (3)].str)); 2007 ralloc_free (macro); 2008 } 2009 ralloc_free ((yyvsp[(2) - (3)].str)); 2010 } 2011 break; 2012 2013 case 16: 2014 2015 /* Line 1806 of yacc.c */ 2016 #line 247 "src/src/glsl/glcpp/glcpp-parse.y" 2017 { 2018 if (parser->skip_stack == NULL || 2019 parser->skip_stack->type == SKIP_NO_SKIP) 2020 { 2021 _glcpp_parser_expand_and_lex_from (parser, 2022 LINE_EXPANDED, (yyvsp[(2) - (3)].token_list)); 2023 } 2024 } 2025 break; 2026 2027 case 17: 2028 2029 /* Line 1806 of yacc.c */ 2030 #line 255 "src/src/glsl/glcpp/glcpp-parse.y" 2031 { 2032 /* Be careful to only evaluate the 'if' expression if 2033 * we are not skipping. When we are skipping, we 2034 * simply push a new 0-valued 'if' onto the skip 2035 * stack. 2036 * 2037 * This avoids generating diagnostics for invalid 2038 * expressions that are being skipped. */ 2039 if (parser->skip_stack == NULL || 2040 parser->skip_stack->type == SKIP_NO_SKIP) 2041 { 2042 _glcpp_parser_expand_and_lex_from (parser, 2043 IF_EXPANDED, (yyvsp[(2) - (3)].token_list)); 2044 } 2045 else 2046 { 2047 _glcpp_parser_skip_stack_push_if (parser, & (yylsp[(1) - (3)]), 0); 2048 parser->skip_stack->type = SKIP_TO_ENDIF; 2049 } 2050 } 2051 break; 2052 2053 case 18: 2054 2055 /* Line 1806 of yacc.c */ 2056 #line 275 "src/src/glsl/glcpp/glcpp-parse.y" 2057 { 2058 /* #if without an expression is only an error if we 2059 * are not skipping */ 2060 if (parser->skip_stack == NULL || 2061 parser->skip_stack->type == SKIP_NO_SKIP) 2062 { 2063 glcpp_error(& (yylsp[(1) - (2)]), parser, "#if with no expression"); 2064 } 2065 _glcpp_parser_skip_stack_push_if (parser, & (yylsp[(1) - (2)]), 0); 2066 } 2067 break; 2068 2069 case 19: 2070 2071 /* Line 1806 of yacc.c */ 2072 #line 285 "src/src/glsl/glcpp/glcpp-parse.y" 2073 { 2074 macro_t *macro = hash_table_find (parser->defines, (yyvsp[(2) - (4)].str)); 2075 ralloc_free ((yyvsp[(2) - (4)].str)); 2076 _glcpp_parser_skip_stack_push_if (parser, & (yylsp[(1) - (4)]), macro != NULL); 2077 } 2078 break; 2079 2080 case 20: 2081 2082 /* Line 1806 of yacc.c */ 2083 #line 290 "src/src/glsl/glcpp/glcpp-parse.y" 2084 { 2085 macro_t *macro = hash_table_find (parser->defines, (yyvsp[(2) - (4)].str)); 2086 ralloc_free ((yyvsp[(2) - (4)].str)); 2087 _glcpp_parser_skip_stack_push_if (parser, & (yylsp[(1) - (4)]), macro == NULL); 2088 } 2089 break; 2090 2091 case 21: 2092 2093 /* Line 1806 of yacc.c */ 2094 #line 295 "src/src/glsl/glcpp/glcpp-parse.y" 2095 { 2096 /* Be careful to only evaluate the 'elif' expression 2097 * if we are not skipping. When we are skipping, we 2098 * simply change to a 0-valued 'elif' on the skip 2099 * stack. 2100 * 2101 * This avoids generating diagnostics for invalid 2102 * expressions that are being skipped. */ 2103 if (parser->skip_stack && 2104 parser->skip_stack->type == SKIP_TO_ELSE) 2105 { 2106 _glcpp_parser_expand_and_lex_from (parser, 2107 ELIF_EXPANDED, (yyvsp[(2) - (3)].token_list)); 2108 } 2109 else 2110 { 2111 _glcpp_parser_skip_stack_change_if (parser, & (yylsp[(1) - (3)]), 2112 "elif", 0); 2113 } 2114 } 2115 break; 2116 2117 case 22: 2118 2119 /* Line 1806 of yacc.c */ 2120 #line 315 "src/src/glsl/glcpp/glcpp-parse.y" 2121 { 2122 /* #elif without an expression is an error unless we 2123 * are skipping. */ 2124 if (parser->skip_stack && 2125 parser->skip_stack->type == SKIP_TO_ELSE) 2126 { 2127 glcpp_error(& (yylsp[(1) - (2)]), parser, "#elif with no expression"); 2128 } 2129 else 2130 { 2131 _glcpp_parser_skip_stack_change_if (parser, & (yylsp[(1) - (2)]), 2132 "elif", 0); 2133 glcpp_warning(& (yylsp[(1) - (2)]), parser, "ignoring illegal #elif without expression"); 2134 } 2135 } 2136 break; 2137 2138 case 23: 2139 2140 /* Line 1806 of yacc.c */ 2141 #line 330 "src/src/glsl/glcpp/glcpp-parse.y" 2142 { 2143 _glcpp_parser_skip_stack_change_if (parser, & (yylsp[(1) - (1)]), "else", 1); 2144 } 2145 break; 2146 2147 case 25: 2148 2149 /* Line 1806 of yacc.c */ 2150 #line 333 "src/src/glsl/glcpp/glcpp-parse.y" 2151 { 2152 _glcpp_parser_skip_stack_pop (parser, & (yylsp[(1) - (1)])); 2153 } 2154 break; 2155 2156 case 27: 2157 2158 /* Line 1806 of yacc.c */ 2159 #line 336 "src/src/glsl/glcpp/glcpp-parse.y" 2160 { 2161 macro_t *macro = hash_table_find (parser->defines, "__VERSION__"); 2162 if (macro) { 2163 hash_table_remove (parser->defines, "__VERSION__"); 2164 ralloc_free (macro); 2165 } 2166 add_builtin_define (parser, "__VERSION__", (yyvsp[(2) - (3)].ival)); 2167 2168 if ((yyvsp[(2) - (3)].ival) == 100) 2169 add_builtin_define (parser, "GL_ES", 1); 2170 2171 /* Currently, all ES2 implementations support highp in the 2172 * fragment shader, so we always define this macro in ES2. 2173 * If we ever get a driver that doesn't support highp, we'll 2174 * need to add a flag to the gl_context and check that here. 2175 */ 2176 if ((yyvsp[(2) - (3)].ival) >= 130 || (yyvsp[(2) - (3)].ival) == 100) 2177 add_builtin_define (parser, "GL_FRAGMENT_PRECISION_HIGH", 1); 2178 2179 ralloc_asprintf_rewrite_tail (&parser->output, &parser->output_length, "#version %" PRIiMAX, (yyvsp[(2) - (3)].ival)); 2180 } 2181 break; 2182 2183 case 29: 2184 2185 /* Line 1806 of yacc.c */ 2186 #line 361 "src/src/glsl/glcpp/glcpp-parse.y" 2187 { 2188 if (strlen ((yyvsp[(1) - (1)].str)) >= 3 && strncmp ((yyvsp[(1) - (1)].str), "0x", 2) == 0) { 2189 (yyval.ival) = strtoll ((yyvsp[(1) - (1)].str) + 2, NULL, 16); 2190 } else if ((yyvsp[(1) - (1)].str)[0] == '0') { 2191 (yyval.ival) = strtoll ((yyvsp[(1) - (1)].str), NULL, 8); 2192 } else { 2193 (yyval.ival) = strtoll ((yyvsp[(1) - (1)].str), NULL, 10); 2194 } 2195 } 2196 break; 2197 2198 case 30: 2199 2200 /* Line 1806 of yacc.c */ 2201 #line 370 "src/src/glsl/glcpp/glcpp-parse.y" 2202 { 2203 (yyval.ival) = (yyvsp[(1) - (1)].ival); 2204 } 2205 break; 2206 2207 case 32: 2208 2209 /* Line 1806 of yacc.c */ 2210 #line 376 "src/src/glsl/glcpp/glcpp-parse.y" 2211 { 2212 (yyval.ival) = 0; 2213 } 2214 break; 2215 2216 case 33: 2217 2218 /* Line 1806 of yacc.c */ 2219 #line 379 "src/src/glsl/glcpp/glcpp-parse.y" 2220 { 2221 (yyval.ival) = (yyvsp[(1) - (3)].ival) || (yyvsp[(3) - (3)].ival); 2222 } 2223 break; 2224 2225 case 34: 2226 2227 /* Line 1806 of yacc.c */ 2228 #line 382 "src/src/glsl/glcpp/glcpp-parse.y" 2229 { 2230 (yyval.ival) = (yyvsp[(1) - (3)].ival) && (yyvsp[(3) - (3)].ival); 2231 } 2232 break; 2233 2234 case 35: 2235 2236 /* Line 1806 of yacc.c */ 2237 #line 385 "src/src/glsl/glcpp/glcpp-parse.y" 2238 { 2239 (yyval.ival) = (yyvsp[(1) - (3)].ival) | (yyvsp[(3) - (3)].ival); 2240 } 2241 break; 2242 2243 case 36: 2244 2245 /* Line 1806 of yacc.c */ 2246 #line 388 "src/src/glsl/glcpp/glcpp-parse.y" 2247 { 2248 (yyval.ival) = (yyvsp[(1) - (3)].ival) ^ (yyvsp[(3) - (3)].ival); 2249 } 2250 break; 2251 2252 case 37: 2253 2254 /* Line 1806 of yacc.c */ 2255 #line 391 "src/src/glsl/glcpp/glcpp-parse.y" 2256 { 2257 (yyval.ival) = (yyvsp[(1) - (3)].ival) & (yyvsp[(3) - (3)].ival); 2258 } 2259 break; 2260 2261 case 38: 2262 2263 /* Line 1806 of yacc.c */ 2264 #line 394 "src/src/glsl/glcpp/glcpp-parse.y" 2265 { 2266 (yyval.ival) = (yyvsp[(1) - (3)].ival) != (yyvsp[(3) - (3)].ival); 2267 } 2268 break; 2269 2270 case 39: 2271 2272 /* Line 1806 of yacc.c */ 2273 #line 397 "src/src/glsl/glcpp/glcpp-parse.y" 2274 { 2275 (yyval.ival) = (yyvsp[(1) - (3)].ival) == (yyvsp[(3) - (3)].ival); 2276 } 2277 break; 2278 2279 case 40: 2280 2281 /* Line 1806 of yacc.c */ 2282 #line 400 "src/src/glsl/glcpp/glcpp-parse.y" 2283 { 2284 (yyval.ival) = (yyvsp[(1) - (3)].ival) >= (yyvsp[(3) - (3)].ival); 2285 } 2286 break; 2287 2288 case 41: 2289 2290 /* Line 1806 of yacc.c */ 2291 #line 403 "src/src/glsl/glcpp/glcpp-parse.y" 2292 { 2293 (yyval.ival) = (yyvsp[(1) - (3)].ival) <= (yyvsp[(3) - (3)].ival); 2294 } 2295 break; 2296 2297 case 42: 2298 2299 /* Line 1806 of yacc.c */ 2300 #line 406 "src/src/glsl/glcpp/glcpp-parse.y" 2301 { 2302 (yyval.ival) = (yyvsp[(1) - (3)].ival) > (yyvsp[(3) - (3)].ival); 2303 } 2304 break; 2305 2306 case 43: 2307 2308 /* Line 1806 of yacc.c */ 2309 #line 409 "src/src/glsl/glcpp/glcpp-parse.y" 2310 { 2311 (yyval.ival) = (yyvsp[(1) - (3)].ival) < (yyvsp[(3) - (3)].ival); 2312 } 2313 break; 2314 2315 case 44: 2316 2317 /* Line 1806 of yacc.c */ 2318 #line 412 "src/src/glsl/glcpp/glcpp-parse.y" 2319 { 2320 (yyval.ival) = (yyvsp[(1) - (3)].ival) >> (yyvsp[(3) - (3)].ival); 2321 } 2322 break; 2323 2324 case 45: 2325 2326 /* Line 1806 of yacc.c */ 2327 #line 415 "src/src/glsl/glcpp/glcpp-parse.y" 2328 { 2329 (yyval.ival) = (yyvsp[(1) - (3)].ival) << (yyvsp[(3) - (3)].ival); 2330 } 2331 break; 2332 2333 case 46: 2334 2335 /* Line 1806 of yacc.c */ 2336 #line 418 "src/src/glsl/glcpp/glcpp-parse.y" 2337 { 2338 (yyval.ival) = (yyvsp[(1) - (3)].ival) - (yyvsp[(3) - (3)].ival); 2339 } 2340 break; 2341 2342 case 47: 2343 2344 /* Line 1806 of yacc.c */ 2345 #line 421 "src/src/glsl/glcpp/glcpp-parse.y" 2346 { 2347 (yyval.ival) = (yyvsp[(1) - (3)].ival) + (yyvsp[(3) - (3)].ival); 2348 } 2349 break; 2350 2351 case 48: 2352 2353 /* Line 1806 of yacc.c */ 2354 #line 424 "src/src/glsl/glcpp/glcpp-parse.y" 2355 { 2356 if ((yyvsp[(3) - (3)].ival) == 0) { 2357 yyerror (& (yylsp[(1) - (3)]), parser, 2358 "zero modulus in preprocessor directive"); 2359 } else { 2360 (yyval.ival) = (yyvsp[(1) - (3)].ival) % (yyvsp[(3) - (3)].ival); 2361 } 2362 } 2363 break; 2364 2365 case 49: 2366 2367 /* Line 1806 of yacc.c */ 2368 #line 432 "src/src/glsl/glcpp/glcpp-parse.y" 2369 { 2370 if ((yyvsp[(3) - (3)].ival) == 0) { 2371 yyerror (& (yylsp[(1) - (3)]), parser, 2372 "division by 0 in preprocessor directive"); 2373 } else { 2374 (yyval.ival) = (yyvsp[(1) - (3)].ival) / (yyvsp[(3) - (3)].ival); 2375 } 2376 } 2377 break; 2378 2379 case 50: 2380 2381 /* Line 1806 of yacc.c */ 2382 #line 440 "src/src/glsl/glcpp/glcpp-parse.y" 2383 { 2384 (yyval.ival) = (yyvsp[(1) - (3)].ival) * (yyvsp[(3) - (3)].ival); 2385 } 2386 break; 2387 2388 case 51: 2389 2390 /* Line 1806 of yacc.c */ 2391 #line 443 "src/src/glsl/glcpp/glcpp-parse.y" 2392 { 2393 (yyval.ival) = ! (yyvsp[(2) - (2)].ival); 2394 } 2395 break; 2396 2397 case 52: 2398 2399 /* Line 1806 of yacc.c */ 2400 #line 446 "src/src/glsl/glcpp/glcpp-parse.y" 2401 { 2402 (yyval.ival) = ~ (yyvsp[(2) - (2)].ival); 2403 } 2404 break; 2405 2406 case 53: 2407 2408 /* Line 1806 of yacc.c */ 2409 #line 449 "src/src/glsl/glcpp/glcpp-parse.y" 2410 { 2411 (yyval.ival) = - (yyvsp[(2) - (2)].ival); 2412 } 2413 break; 2414 2415 case 54: 2416 2417 /* Line 1806 of yacc.c */ 2418 #line 452 "src/src/glsl/glcpp/glcpp-parse.y" 2419 { 2420 (yyval.ival) = + (yyvsp[(2) - (2)].ival); 2421 } 2422 break; 2423 2424 case 55: 2425 2426 /* Line 1806 of yacc.c */ 2427 #line 455 "src/src/glsl/glcpp/glcpp-parse.y" 2428 { 2429 (yyval.ival) = (yyvsp[(2) - (3)].ival); 2430 } 2431 break; 2432 2433 case 56: 2434 2435 /* Line 1806 of yacc.c */ 2436 #line 461 "src/src/glsl/glcpp/glcpp-parse.y" 2437 { 2438 (yyval.string_list) = _string_list_create (parser); 2439 _string_list_append_item ((yyval.string_list), (yyvsp[(1) - (1)].str)); 2440 ralloc_steal ((yyval.string_list), (yyvsp[(1) - (1)].str)); 2441 } 2442 break; 2443 2444 case 57: 2445 2446 /* Line 1806 of yacc.c */ 2447 #line 466 "src/src/glsl/glcpp/glcpp-parse.y" 2448 { 2449 (yyval.string_list) = (yyvsp[(1) - (3)].string_list); 2450 _string_list_append_item ((yyval.string_list), (yyvsp[(3) - (3)].str)); 2451 ralloc_steal ((yyval.string_list), (yyvsp[(3) - (3)].str)); 2452 } 2453 break; 2454 2455 case 58: 2456 2457 /* Line 1806 of yacc.c */ 2458 #line 474 "src/src/glsl/glcpp/glcpp-parse.y" 2459 { (yyval.token_list) = NULL; } 2460 break; 2461 2462 case 60: 2463 2464 /* Line 1806 of yacc.c */ 2465 #line 479 "src/src/glsl/glcpp/glcpp-parse.y" 2466 { 2467 yyerror (& (yylsp[(1) - (2)]), parser, "Invalid tokens after #"); 2468 } 2469 break; 2470 2471 case 61: 2472 2473 /* Line 1806 of yacc.c */ 2474 #line 485 "src/src/glsl/glcpp/glcpp-parse.y" 2475 { (yyval.token_list) = NULL; } 2476 break; 2477 2478 case 64: 2479 2480 /* Line 1806 of yacc.c */ 2481 #line 491 "src/src/glsl/glcpp/glcpp-parse.y" 2482 { 2483 glcpp_warning(&(yylsp[(1) - (1)]), parser, "extra tokens at end of directive"); 2484 } 2485 break; 2486 2487 case 65: 2488 2489 /* Line 1806 of yacc.c */ 2490 #line 498 "src/src/glsl/glcpp/glcpp-parse.y" 2491 { 2492 int v = hash_table_find (parser->defines, (yyvsp[(2) - (2)].str)) ? 1 : 0; 2493 (yyval.token) = _token_create_ival (parser, INTEGER, v); 2494 } 2495 break; 2496 2497 case 66: 2498 2499 /* Line 1806 of yacc.c */ 2500 #line 502 "src/src/glsl/glcpp/glcpp-parse.y" 2501 { 2502 int v = hash_table_find (parser->defines, (yyvsp[(3) - (4)].str)) ? 1 : 0; 2503 (yyval.token) = _token_create_ival (parser, INTEGER, v); 2504 } 2505 break; 2506 2507 case 68: 2508 2509 /* Line 1806 of yacc.c */ 2510 #line 511 "src/src/glsl/glcpp/glcpp-parse.y" 2511 { 2512 (yyval.token_list) = _token_list_create (parser); 2513 _token_list_append ((yyval.token_list), (yyvsp[(1) - (1)].token)); 2514 } 2515 break; 2516 2517 case 69: 2518 2519 /* Line 1806 of yacc.c */ 2520 #line 515 "src/src/glsl/glcpp/glcpp-parse.y" 2521 { 2522 (yyval.token_list) = (yyvsp[(1) - (2)].token_list); 2523 _token_list_append ((yyval.token_list), (yyvsp[(2) - (2)].token)); 2524 } 2525 break; 2526 2527 case 70: 2528 2529 /* Line 1806 of yacc.c */ 2530 #line 522 "src/src/glsl/glcpp/glcpp-parse.y" 2531 { 2532 parser->space_tokens = 1; 2533 (yyval.token_list) = _token_list_create (parser); 2534 _token_list_append ((yyval.token_list), (yyvsp[(1) - (1)].token)); 2535 } 2536 break; 2537 2538 case 71: 2539 2540 /* Line 1806 of yacc.c */ 2541 #line 527 "src/src/glsl/glcpp/glcpp-parse.y" 2542 { 2543 (yyval.token_list) = (yyvsp[(1) - (2)].token_list); 2544 _token_list_append ((yyval.token_list), (yyvsp[(2) - (2)].token)); 2545 } 2546 break; 2547 2548 case 72: 2549 2550 /* Line 1806 of yacc.c */ 2551 #line 534 "src/src/glsl/glcpp/glcpp-parse.y" 2552 { 2553 (yyval.token) = _token_create_str (parser, IDENTIFIER, (yyvsp[(1) - (1)].str)); 2554 (yyval.token)->location = yylloc; 2555 } 2556 break; 2557 2558 case 73: 2559 2560 /* Line 1806 of yacc.c */ 2561 #line 538 "src/src/glsl/glcpp/glcpp-parse.y" 2562 { 2563 (yyval.token) = _token_create_str (parser, INTEGER_STRING, (yyvsp[(1) - (1)].str)); 2564 (yyval.token)->location = yylloc; 2565 } 2566 break; 2567 2568 case 74: 2569 2570 /* Line 1806 of yacc.c */ 2571 #line 542 "src/src/glsl/glcpp/glcpp-parse.y" 2572 { 2573 (yyval.token) = _token_create_ival (parser, (yyvsp[(1) - (1)].ival), (yyvsp[(1) - (1)].ival)); 2574 (yyval.token)->location = yylloc; 2575 } 2576 break; 2577 2578 case 75: 2579 2580 /* Line 1806 of yacc.c */ 2581 #line 546 "src/src/glsl/glcpp/glcpp-parse.y" 2582 { 2583 (yyval.token) = _token_create_str (parser, OTHER, (yyvsp[(1) - (1)].str)); 2584 (yyval.token)->location = yylloc; 2585 } 2586 break; 2587 2588 case 76: 2589 2590 /* Line 1806 of yacc.c */ 2591 #line 550 "src/src/glsl/glcpp/glcpp-parse.y" 2592 { 2593 (yyval.token) = _token_create_ival (parser, SPACE, SPACE); 2594 (yyval.token)->location = yylloc; 2595 } 2596 break; 2597 2598 case 77: 2599 2600 /* Line 1806 of yacc.c */ 2601 #line 557 "src/src/glsl/glcpp/glcpp-parse.y" 2602 { (yyval.ival) = '['; } 2603 break; 2604 2605 case 78: 2606 2607 /* Line 1806 of yacc.c */ 2608 #line 558 "src/src/glsl/glcpp/glcpp-parse.y" 2609 { (yyval.ival) = ']'; } 2610 break; 2611 2612 case 79: 2613 2614 /* Line 1806 of yacc.c */ 2615 #line 559 "src/src/glsl/glcpp/glcpp-parse.y" 2616 { (yyval.ival) = '('; } 2617 break; 2618 2619 case 80: 2620 2621 /* Line 1806 of yacc.c */ 2622 #line 560 "src/src/glsl/glcpp/glcpp-parse.y" 2623 { (yyval.ival) = ')'; } 2624 break; 2625 2626 case 81: 2627 2628 /* Line 1806 of yacc.c */ 2629 #line 561 "src/src/glsl/glcpp/glcpp-parse.y" 2630 { (yyval.ival) = '{'; } 2631 break; 2632 2633 case 82: 2634 2635 /* Line 1806 of yacc.c */ 2636 #line 562 "src/src/glsl/glcpp/glcpp-parse.y" 2637 { (yyval.ival) = '}'; } 2638 break; 2639 2640 case 83: 2641 2642 /* Line 1806 of yacc.c */ 2643 #line 563 "src/src/glsl/glcpp/glcpp-parse.y" 2644 { (yyval.ival) = '.'; } 2645 break; 2646 2647 case 84: 2648 2649 /* Line 1806 of yacc.c */ 2650 #line 564 "src/src/glsl/glcpp/glcpp-parse.y" 2651 { (yyval.ival) = '&'; } 2652 break; 2653 2654 case 85: 2655 2656 /* Line 1806 of yacc.c */ 2657 #line 565 "src/src/glsl/glcpp/glcpp-parse.y" 2658 { (yyval.ival) = '*'; } 2659 break; 2660 2661 case 86: 2662 2663 /* Line 1806 of yacc.c */ 2664 #line 566 "src/src/glsl/glcpp/glcpp-parse.y" 2665 { (yyval.ival) = '+'; } 2666 break; 2667 2668 case 87: 2669 2670 /* Line 1806 of yacc.c */ 2671 #line 567 "src/src/glsl/glcpp/glcpp-parse.y" 2672 { (yyval.ival) = '-'; } 2673 break; 2674 2675 case 88: 2676 2677 /* Line 1806 of yacc.c */ 2678 #line 568 "src/src/glsl/glcpp/glcpp-parse.y" 2679 { (yyval.ival) = '~'; } 2680 break; 2681 2682 case 89: 2683 2684 /* Line 1806 of yacc.c */ 2685 #line 569 "src/src/glsl/glcpp/glcpp-parse.y" 2686 { (yyval.ival) = '!'; } 2687 break; 2688 2689 case 90: 2690 2691 /* Line 1806 of yacc.c */ 2692 #line 570 "src/src/glsl/glcpp/glcpp-parse.y" 2693 { (yyval.ival) = '/'; } 2694 break; 2695 2696 case 91: 2697 2698 /* Line 1806 of yacc.c */ 2699 #line 571 "src/src/glsl/glcpp/glcpp-parse.y" 2700 { (yyval.ival) = '%'; } 2701 break; 2702 2703 case 92: 2704 2705 /* Line 1806 of yacc.c */ 2706 #line 572 "src/src/glsl/glcpp/glcpp-parse.y" 2707 { (yyval.ival) = LEFT_SHIFT; } 2708 break; 2709 2710 case 93: 2711 2712 /* Line 1806 of yacc.c */ 2713 #line 573 "src/src/glsl/glcpp/glcpp-parse.y" 2714 { (yyval.ival) = RIGHT_SHIFT; } 2715 break; 2716 2717 case 94: 2718 2719 /* Line 1806 of yacc.c */ 2720 #line 574 "src/src/glsl/glcpp/glcpp-parse.y" 2721 { (yyval.ival) = '<'; } 2722 break; 2723 2724 case 95: 2725 2726 /* Line 1806 of yacc.c */ 2727 #line 575 "src/src/glsl/glcpp/glcpp-parse.y" 2728 { (yyval.ival) = '>'; } 2729 break; 2730 2731 case 96: 2732 2733 /* Line 1806 of yacc.c */ 2734 #line 576 "src/src/glsl/glcpp/glcpp-parse.y" 2735 { (yyval.ival) = LESS_OR_EQUAL; } 2736 break; 2737 2738 case 97: 2739 2740 /* Line 1806 of yacc.c */ 2741 #line 577 "src/src/glsl/glcpp/glcpp-parse.y" 2742 { (yyval.ival) = GREATER_OR_EQUAL; } 2743 break; 2744 2745 case 98: 2746 2747 /* Line 1806 of yacc.c */ 2748 #line 578 "src/src/glsl/glcpp/glcpp-parse.y" 2749 { (yyval.ival) = EQUAL; } 2750 break; 2751 2752 case 99: 2753 2754 /* Line 1806 of yacc.c */ 2755 #line 579 "src/src/glsl/glcpp/glcpp-parse.y" 2756 { (yyval.ival) = NOT_EQUAL; } 2757 break; 2758 2759 case 100: 2760 2761 /* Line 1806 of yacc.c */ 2762 #line 580 "src/src/glsl/glcpp/glcpp-parse.y" 2763 { (yyval.ival) = '^'; } 2764 break; 2765 2766 case 101: 2767 2768 /* Line 1806 of yacc.c */ 2769 #line 581 "src/src/glsl/glcpp/glcpp-parse.y" 2770 { (yyval.ival) = '|'; } 2771 break; 2772 2773 case 102: 2774 2775 /* Line 1806 of yacc.c */ 2776 #line 582 "src/src/glsl/glcpp/glcpp-parse.y" 2777 { (yyval.ival) = AND; } 2778 break; 2779 2780 case 103: 2781 2782 /* Line 1806 of yacc.c */ 2783 #line 583 "src/src/glsl/glcpp/glcpp-parse.y" 2784 { (yyval.ival) = OR; } 2785 break; 2786 2787 case 104: 2788 2789 /* Line 1806 of yacc.c */ 2790 #line 584 "src/src/glsl/glcpp/glcpp-parse.y" 2791 { (yyval.ival) = ';'; } 2792 break; 2793 2794 case 105: 2795 2796 /* Line 1806 of yacc.c */ 2797 #line 585 "src/src/glsl/glcpp/glcpp-parse.y" 2798 { (yyval.ival) = ','; } 2799 break; 2800 2801 case 106: 2802 2803 /* Line 1806 of yacc.c */ 2804 #line 586 "src/src/glsl/glcpp/glcpp-parse.y" 2805 { (yyval.ival) = '='; } 2806 break; 2807 2808 case 107: 2809 2810 /* Line 1806 of yacc.c */ 2811 #line 587 "src/src/glsl/glcpp/glcpp-parse.y" 2812 { (yyval.ival) = PASTE; } 2813 break; 2814 2815 2816 2817 /* Line 1806 of yacc.c */ 2818 #line 2819 "src/chromium_gensrc/mesa/glcpp-parse.c" 2819 default: break; 2820 } 2821 /* User semantic actions sometimes alter yychar, and that requires 2822 that yytoken be updated with the new translation. We take the 2823 approach of translating immediately before every use of yytoken. 2824 One alternative is translating here after every semantic action, 2825 but that translation would be missed if the semantic action invokes 2826 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 2827 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 2828 incorrect destructor might then be invoked immediately. In the 2829 case of YYERROR or YYBACKUP, subsequent parser actions might lead 2830 to an incorrect destructor call or verbose syntax error message 2831 before the lookahead is translated. */ 2832 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 2833 2834 YYPOPSTACK (yylen); 2835 yylen = 0; 2836 YY_STACK_PRINT (yyss, yyssp); 2837 2838 *++yyvsp = yyval; 2839 *++yylsp = yyloc; 2840 2841 /* Now `shift' the result of the reduction. Determine what state 2842 that goes to, based on the state we popped back to and the rule 2843 number reduced by. */ 2844 2845 yyn = yyr1[yyn]; 2846 2847 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 2848 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 2849 yystate = yytable[yystate]; 2850 else 2851 yystate = yydefgoto[yyn - YYNTOKENS]; 2852 2853 goto yynewstate; 2854 2855 2856 /*------------------------------------. 2857 | yyerrlab -- here on detecting error | 2858 `------------------------------------*/ 2859 yyerrlab: 2860 /* Make sure we have latest lookahead translation. See comments at 2861 user semantic actions for why this is necessary. */ 2862 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); 2863 2864 /* If not already recovering from an error, report this error. */ 2865 if (!yyerrstatus) 2866 { 2867 ++yynerrs; 2868 #if ! YYERROR_VERBOSE 2869 yyerror (&yylloc, parser, YY_("syntax error")); 2870 #else 2871 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 2872 yyssp, yytoken) 2873 { 2874 char const *yymsgp = YY_("syntax error"); 2875 int yysyntax_error_status; 2876 yysyntax_error_status = YYSYNTAX_ERROR; 2877 if (yysyntax_error_status == 0) 2878 yymsgp = yymsg; 2879 else if (yysyntax_error_status == 1) 2880 { 2881 if (yymsg != yymsgbuf) 2882 YYSTACK_FREE (yymsg); 2883 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); 2884 if (!yymsg) 2885 { 2886 yymsg = yymsgbuf; 2887 yymsg_alloc = sizeof yymsgbuf; 2888 yysyntax_error_status = 2; 2889 } 2890 else 2891 { 2892 yysyntax_error_status = YYSYNTAX_ERROR; 2893 yymsgp = yymsg; 2894 } 2895 } 2896 yyerror (&yylloc, parser, yymsgp); 2897 if (yysyntax_error_status == 2) 2898 goto yyexhaustedlab; 2899 } 2900 # undef YYSYNTAX_ERROR 2901 #endif 2902 } 2903 2904 yyerror_range[1] = yylloc; 2905 2906 if (yyerrstatus == 3) 2907 { 2908 /* If just tried and failed to reuse lookahead token after an 2909 error, discard it. */ 2910 2911 if (yychar <= YYEOF) 2912 { 2913 /* Return failure if at end of input. */ 2914 if (yychar == YYEOF) 2915 YYABORT; 2916 } 2917 else 2918 { 2919 yydestruct ("Error: discarding", 2920 yytoken, &yylval, &yylloc, parser); 2921 yychar = YYEMPTY; 2922 } 2923 } 2924 2925 /* Else will try to reuse lookahead token after shifting the error 2926 token. */ 2927 goto yyerrlab1; 2928 2929 2930 /*---------------------------------------------------. 2931 | yyerrorlab -- error raised explicitly by YYERROR. | 2932 `---------------------------------------------------*/ 2933 yyerrorlab: 2934 2935 /* Pacify compilers like GCC when the user code never invokes 2936 YYERROR and the label yyerrorlab therefore never appears in user 2937 code. */ 2938 if (/*CONSTCOND*/ 0) 2939 goto yyerrorlab; 2940 2941 yyerror_range[1] = yylsp[1-yylen]; 2942 /* Do not reclaim the symbols of the rule which action triggered 2943 this YYERROR. */ 2944 YYPOPSTACK (yylen); 2945 yylen = 0; 2946 YY_STACK_PRINT (yyss, yyssp); 2947 yystate = *yyssp; 2948 goto yyerrlab1; 2949 2950 2951 /*-------------------------------------------------------------. 2952 | yyerrlab1 -- common code for both syntax error and YYERROR. | 2953 `-------------------------------------------------------------*/ 2954 yyerrlab1: 2955 yyerrstatus = 3; /* Each real token shifted decrements this. */ 2956 2957 for (;;) 2958 { 2959 yyn = yypact[yystate]; 2960 if (!yypact_value_is_default (yyn)) 2961 { 2962 yyn += YYTERROR; 2963 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 2964 { 2965 yyn = yytable[yyn]; 2966 if (0 < yyn) 2967 break; 2968 } 2969 } 2970 2971 /* Pop the current state because it cannot handle the error token. */ 2972 if (yyssp == yyss) 2973 YYABORT; 2974 2975 yyerror_range[1] = *yylsp; 2976 yydestruct ("Error: popping", 2977 yystos[yystate], yyvsp, yylsp, parser); 2978 YYPOPSTACK (1); 2979 yystate = *yyssp; 2980 YY_STACK_PRINT (yyss, yyssp); 2981 } 2982 2983 *++yyvsp = yylval; 2984 2985 yyerror_range[2] = yylloc; 2986 /* Using YYLLOC is tempting, but would change the location of 2987 the lookahead. YYLOC is available though. */ 2988 YYLLOC_DEFAULT (yyloc, yyerror_range, 2); 2989 *++yylsp = yyloc; 2990 2991 /* Shift the error token. */ 2992 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 2993 2994 yystate = yyn; 2995 goto yynewstate; 2996 2997 2998 /*-------------------------------------. 2999 | yyacceptlab -- YYACCEPT comes here. | 3000 `-------------------------------------*/ 3001 yyacceptlab: 3002 yyresult = 0; 3003 goto yyreturn; 3004 3005 /*-----------------------------------. 3006 | yyabortlab -- YYABORT comes here. | 3007 `-----------------------------------*/ 3008 yyabortlab: 3009 yyresult = 1; 3010 goto yyreturn; 3011 3012 #if !defined(yyoverflow) || YYERROR_VERBOSE 3013 /*-------------------------------------------------. 3014 | yyexhaustedlab -- memory exhaustion comes here. | 3015 `-------------------------------------------------*/ 3016 yyexhaustedlab: 3017 yyerror (&yylloc, parser, YY_("memory exhausted")); 3018 yyresult = 2; 3019 /* Fall through. */ 3020 #endif 3021 3022 yyreturn: 3023 if (yychar != YYEMPTY) 3024 { 3025 /* Make sure we have latest lookahead translation. See comments at 3026 user semantic actions for why this is necessary. */ 3027 yytoken = YYTRANSLATE (yychar); 3028 yydestruct ("Cleanup: discarding lookahead", 3029 yytoken, &yylval, &yylloc, parser); 3030 } 3031 /* Do not reclaim the symbols of the rule which action triggered 3032 this YYABORT or YYACCEPT. */ 3033 YYPOPSTACK (yylen); 3034 YY_STACK_PRINT (yyss, yyssp); 3035 while (yyssp != yyss) 3036 { 3037 yydestruct ("Cleanup: popping", 3038 yystos[*yyssp], yyvsp, yylsp, parser); 3039 YYPOPSTACK (1); 3040 } 3041 #ifndef yyoverflow 3042 if (yyss != yyssa) 3043 YYSTACK_FREE (yyss); 3044 #endif 3045 #if YYERROR_VERBOSE 3046 if (yymsg != yymsgbuf) 3047 YYSTACK_FREE (yymsg); 3048 #endif 3049 /* Make sure YYID is used. */ 3050 return YYID (yyresult); 3051 } 3052 3053 3054 3055 /* Line 2067 of yacc.c */ 3056 #line 590 "src/src/glsl/glcpp/glcpp-parse.y" 3057 3058 3059 string_list_t * 3060 _string_list_create (void *ctx) 3061 { 3062 string_list_t *list; 3063 3064 list = ralloc (ctx, string_list_t); 3065 list->head = NULL; 3066 list->tail = NULL; 3067 3068 return list; 3069 } 3070 3071 void 3072 _string_list_append_item (string_list_t *list, const char *str) 3073 { 3074 string_node_t *node; 3075 3076 node = ralloc (list, string_node_t); 3077 node->str = ralloc_strdup (node, str); 3078 3079 node->next = NULL; 3080 3081 if (list->head == NULL) { 3082 list->head = node; 3083 } else { 3084 list->tail->next = node; 3085 } 3086 3087 list->tail = node; 3088 } 3089 3090 int 3091 _string_list_contains (string_list_t *list, const char *member, int *index) 3092 { 3093 string_node_t *node; 3094 int i; 3095 3096 if (list == NULL) 3097 return 0; 3098 3099 for (i = 0, node = list->head; node; i++, node = node->next) { 3100 if (strcmp (node->str, member) == 0) { 3101 if (index) 3102 *index = i; 3103 return 1; 3104 } 3105 } 3106 3107 return 0; 3108 } 3109 3110 int 3111 _string_list_length (string_list_t *list) 3112 { 3113 int length = 0; 3114 string_node_t *node; 3115 3116 if (list == NULL) 3117 return 0; 3118 3119 for (node = list->head; node; node = node->next) 3120 length++; 3121 3122 return length; 3123 } 3124 3125 int 3126 _string_list_equal (string_list_t *a, string_list_t *b) 3127 { 3128 string_node_t *node_a, *node_b; 3129 3130 if (a == NULL && b == NULL) 3131 return 1; 3132 3133 if (a == NULL || b == NULL) 3134 return 0; 3135 3136 for (node_a = a->head, node_b = b->head; 3137 node_a && node_b; 3138 node_a = node_a->next, node_b = node_b->next) 3139 { 3140 if (strcmp (node_a->str, node_b->str)) 3141 return 0; 3142 } 3143 3144 /* Catch the case of lists being different lengths, (which 3145 * would cause the loop above to terminate after the shorter 3146 * list). */ 3147 return node_a == node_b; 3148 } 3149 3150 argument_list_t * 3151 _argument_list_create (void *ctx) 3152 { 3153 argument_list_t *list; 3154 3155 list = ralloc (ctx, argument_list_t); 3156 list->head = NULL; 3157 list->tail = NULL; 3158 3159 return list; 3160 } 3161 3162 void 3163 _argument_list_append (argument_list_t *list, token_list_t *argument) 3164 { 3165 argument_node_t *node; 3166 3167 node = ralloc (list, argument_node_t); 3168 node->argument = argument; 3169 3170 node->next = NULL; 3171 3172 if (list->head == NULL) { 3173 list->head = node; 3174 } else { 3175 list->tail->next = node; 3176 } 3177 3178 list->tail = node; 3179 } 3180 3181 int 3182 _argument_list_length (argument_list_t *list) 3183 { 3184 int length = 0; 3185 argument_node_t *node; 3186 3187 if (list == NULL) 3188 return 0; 3189 3190 for (node = list->head; node; node = node->next) 3191 length++; 3192 3193 return length; 3194 } 3195 3196 token_list_t * 3197 _argument_list_member_at (argument_list_t *list, int index) 3198 { 3199 argument_node_t *node; 3200 int i; 3201 3202 if (list == NULL) 3203 return NULL; 3204 3205 node = list->head; 3206 for (i = 0; i < index; i++) { 3207 node = node->next; 3208 if (node == NULL) 3209 break; 3210 } 3211 3212 if (node) 3213 return node->argument; 3214 3215 return NULL; 3216 } 3217 3218 /* Note: This function ralloc_steal()s the str pointer. */ 3219 token_t * 3220 _token_create_str (void *ctx, int type, char *str) 3221 { 3222 token_t *token; 3223 3224 token = ralloc (ctx, token_t); 3225 token->type = type; 3226 token->value.str = str; 3227 3228 ralloc_steal (token, str); 3229 3230 return token; 3231 } 3232 3233 token_t * 3234 _token_create_ival (void *ctx, int type, int ival) 3235 { 3236 token_t *token; 3237 3238 token = ralloc (ctx, token_t); 3239 token->type = type; 3240 token->value.ival = ival; 3241 3242 return token; 3243 } 3244 3245 token_list_t * 3246 _token_list_create (void *ctx) 3247 { 3248 token_list_t *list; 3249 3250 list = ralloc (ctx, token_list_t); 3251 list->head = NULL; 3252 list->tail = NULL; 3253 list->non_space_tail = NULL; 3254 3255 return list; 3256 } 3257 3258 void 3259 _token_list_append (token_list_t *list, token_t *token) 3260 { 3261 token_node_t *node; 3262 3263 node = ralloc (list, token_node_t); 3264 node->token = token; 3265 node->next = NULL; 3266 3267 if (list->head == NULL) { 3268 list->head = node; 3269 } else { 3270 list->tail->next = node; 3271 } 3272 3273 list->tail = node; 3274 if (token->type != SPACE) 3275 list->non_space_tail = node; 3276 } 3277 3278 void 3279 _token_list_append_list (token_list_t *list, token_list_t *tail) 3280 { 3281 if (tail == NULL || tail->head == NULL) 3282 return; 3283 3284 if (list->head == NULL) { 3285 list->head = tail->head; 3286 } else { 3287 list->tail->next = tail->head; 3288 } 3289 3290 list->tail = tail->tail; 3291 list->non_space_tail = tail->non_space_tail; 3292 } 3293 3294 static token_list_t * 3295 _token_list_copy (void *ctx, token_list_t *other) 3296 { 3297 token_list_t *copy; 3298 token_node_t *node; 3299 3300 if (other == NULL) 3301 return NULL; 3302 3303 copy = _token_list_create (ctx); 3304 for (node = other->head; node; node = node->next) { 3305 token_t *new_token = ralloc (copy, token_t); 3306 *new_token = *node->token; 3307 _token_list_append (copy, new_token); 3308 } 3309 3310 return copy; 3311 } 3312 3313 static void 3314 _token_list_trim_trailing_space (token_list_t *list) 3315 { 3316 token_node_t *tail, *next; 3317 3318 if (list->non_space_tail) { 3319 tail = list->non_space_tail->next; 3320 list->non_space_tail->next = NULL; 3321 list->tail = list->non_space_tail; 3322 3323 while (tail) { 3324 next = tail->next; 3325 ralloc_free (tail); 3326 tail = next; 3327 } 3328 } 3329 } 3330 3331 static int 3332 _token_list_is_empty_ignoring_space (token_list_t *l) 3333 { 3334 token_node_t *n; 3335 3336 if (l == NULL) 3337 return 1; 3338 3339 n = l->head; 3340 while (n != NULL && n->token->type == SPACE) 3341 n = n->next; 3342 3343 return n == NULL; 3344 } 3345 3346 int 3347 _token_list_equal_ignoring_space (token_list_t *a, token_list_t *b) 3348 { 3349 token_node_t *node_a, *node_b; 3350 3351 if (a == NULL || b == NULL) { 3352 int a_empty = _token_list_is_empty_ignoring_space(a); 3353 int b_empty = _token_list_is_empty_ignoring_space(b); 3354 return a_empty == b_empty; 3355 } 3356 3357 node_a = a->head; 3358 node_b = b->head; 3359 3360 while (1) 3361 { 3362 if (node_a == NULL && node_b == NULL) 3363 break; 3364 3365 if (node_a == NULL || node_b == NULL) 3366 return 0; 3367 3368 if (node_a->token->type == SPACE) { 3369 node_a = node_a->next; 3370 continue; 3371 } 3372 3373 if (node_b->token->type == SPACE) { 3374 node_b = node_b->next; 3375 continue; 3376 } 3377 3378 if (node_a->token->type != node_b->token->type) 3379 return 0; 3380 3381 switch (node_a->token->type) { 3382 case INTEGER: 3383 if (node_a->token->value.ival != 3384 node_b->token->value.ival) 3385 { 3386 return 0; 3387 } 3388 break; 3389 case IDENTIFIER: 3390 case INTEGER_STRING: 3391 case OTHER: 3392 if (strcmp (node_a->token->value.str, 3393 node_b->token->value.str)) 3394 { 3395 return 0; 3396 } 3397 break; 3398 } 3399 3400 node_a = node_a->next; 3401 node_b = node_b->next; 3402 } 3403 3404 return 1; 3405 } 3406 3407 static void 3408 _token_print (char **out, size_t *len, token_t *token) 3409 { 3410 if (token->type < 256) { 3411 ralloc_asprintf_rewrite_tail (out, len, "%c", token->type); 3412 return; 3413 } 3414 3415 switch (token->type) { 3416 case INTEGER: 3417 ralloc_asprintf_rewrite_tail (out, len, "%" PRIiMAX, token->value.ival); 3418 break; 3419 case IDENTIFIER: 3420 case INTEGER_STRING: 3421 case OTHER: 3422 ralloc_asprintf_rewrite_tail (out, len, "%s", token->value.str); 3423 break; 3424 case SPACE: 3425 ralloc_asprintf_rewrite_tail (out, len, " "); 3426 break; 3427 case LEFT_SHIFT: 3428 ralloc_asprintf_rewrite_tail (out, len, "<<"); 3429 break; 3430 case RIGHT_SHIFT: 3431 ralloc_asprintf_rewrite_tail (out, len, ">>"); 3432 break; 3433 case LESS_OR_EQUAL: 3434 ralloc_asprintf_rewrite_tail (out, len, "<="); 3435 break; 3436 case GREATER_OR_EQUAL: 3437 ralloc_asprintf_rewrite_tail (out, len, ">="); 3438 break; 3439 case EQUAL: 3440 ralloc_asprintf_rewrite_tail (out, len, "=="); 3441 break; 3442 case NOT_EQUAL: 3443 ralloc_asprintf_rewrite_tail (out, len, "!="); 3444 break; 3445 case AND: 3446 ralloc_asprintf_rewrite_tail (out, len, "&&"); 3447 break; 3448 case OR: 3449 ralloc_asprintf_rewrite_tail (out, len, "||"); 3450 break; 3451 case PASTE: 3452 ralloc_asprintf_rewrite_tail (out, len, "##"); 3453 break; 3454 case COMMA_FINAL: 3455 ralloc_asprintf_rewrite_tail (out, len, ","); 3456 break; 3457 case PLACEHOLDER: 3458 /* Nothing to print. */ 3459 break; 3460 default: 3461 assert(!"Error: Don't know how to print token."); 3462 break; 3463 } 3464 } 3465 3466 /* Return a new token (ralloc()ed off of 'token') formed by pasting 3467 * 'token' and 'other'. Note that this function may return 'token' or 3468 * 'other' directly rather than allocating anything new. 3469 * 3470 * Caution: Only very cursory error-checking is performed to see if 3471 * the final result is a valid single token. */ 3472 static token_t * 3473 _token_paste (glcpp_parser_t *parser, token_t *token, token_t *other) 3474 { 3475 token_t *combined = NULL; 3476 3477 /* Pasting a placeholder onto anything makes no change. */ 3478 if (other->type == PLACEHOLDER) 3479 return token; 3480 3481 /* When 'token' is a placeholder, just return 'other'. */ 3482 if (token->type == PLACEHOLDER) 3483 return other; 3484 3485 /* A very few single-character punctuators can be combined 3486 * with another to form a multi-character punctuator. */ 3487 switch (token->type) { 3488 case '<': 3489 if (other->type == '<') 3490 combined = _token_create_ival (token, LEFT_SHIFT, LEFT_SHIFT); 3491 else if (other->type == '=') 3492 combined = _token_create_ival (token, LESS_OR_EQUAL, LESS_OR_EQUAL); 3493 break; 3494 case '>': 3495 if (other->type == '>') 3496 combined = _token_create_ival (token, RIGHT_SHIFT, RIGHT_SHIFT); 3497 else if (other->type == '=') 3498 combined = _token_create_ival (token, GREATER_OR_EQUAL, GREATER_OR_EQUAL); 3499 break; 3500 case '=': 3501 if (other->type == '=') 3502 combined = _token_create_ival (token, EQUAL, EQUAL); 3503 break; 3504 case '!': 3505 if (other->type == '=') 3506 combined = _token_create_ival (token, NOT_EQUAL, NOT_EQUAL); 3507 break; 3508 case '&': 3509 if (other->type == '&') 3510 combined = _token_create_ival (token, AND, AND); 3511 break; 3512 case '|': 3513 if (other->type == '|') 3514 combined = _token_create_ival (token, OR, OR); 3515 break; 3516 } 3517 3518 if (combined != NULL) { 3519 /* Inherit the location from the first token */ 3520 combined->location = token->location; 3521 return combined; 3522 } 3523 3524 /* Two string-valued tokens can usually just be mashed 3525 * together. 3526 * 3527 * XXX: This isn't actually legitimate. Several things here 3528 * should result in a diagnostic since the result cannot be a 3529 * valid, single pre-processing token. For example, pasting 3530 * "123" and "abc" is not legal, but we don't catch that 3531 * here. */ 3532 if ((token->type == IDENTIFIER || token->type == OTHER || token->type == INTEGER_STRING) && 3533 (other->type == IDENTIFIER || other->type == OTHER || other->type == INTEGER_STRING)) 3534 { 3535 char *str; 3536 3537 str = ralloc_asprintf (token, "%s%s", token->value.str, 3538 other->value.str); 3539 combined = _token_create_str (token, token->type, str); 3540 combined->location = token->location; 3541 return combined; 3542 } 3543 3544 glcpp_error (&token->location, parser, ""); 3545 ralloc_asprintf_rewrite_tail (&parser->info_log, &parser->info_log_length, "Pasting \""); 3546 _token_print (&parser->info_log, &parser->info_log_length, token); 3547 ralloc_asprintf_rewrite_tail (&parser->info_log, &parser->info_log_length, "\" and \""); 3548 _token_print (&parser->info_log, &parser->info_log_length, other); 3549 ralloc_asprintf_rewrite_tail (&parser->info_log, &parser->info_log_length, "\" does not give a valid preprocessing token.\n"); 3550 3551 return token; 3552 } 3553 3554 static void 3555 _token_list_print (glcpp_parser_t *parser, token_list_t *list) 3556 { 3557 token_node_t *node; 3558 3559 if (list == NULL) 3560 return; 3561 3562 for (node = list->head; node; node = node->next) 3563 _token_print (&parser->output, &parser->output_length, node->token); 3564 } 3565 3566 void 3567 yyerror (YYLTYPE *locp, glcpp_parser_t *parser, const char *error) 3568 { 3569 glcpp_error(locp, parser, "%s", error); 3570 } 3571 3572 static void add_builtin_define(glcpp_parser_t *parser, 3573 const char *name, int value) 3574 { 3575 token_t *tok; 3576 token_list_t *list; 3577 3578 tok = _token_create_ival (parser, INTEGER, value); 3579 3580 list = _token_list_create(parser); 3581 _token_list_append(list, tok); 3582 _define_object_macro(parser, NULL, name, list); 3583 } 3584 3585 glcpp_parser_t * 3586 glcpp_parser_create (const struct gl_extensions *extensions, int api) 3587 { 3588 glcpp_parser_t *parser; 3589 int language_version; 3590 3591 parser = ralloc (NULL, glcpp_parser_t); 3592 3593 glcpp_lex_init_extra (parser, &parser->scanner); 3594 parser->defines = hash_table_ctor (32, hash_table_string_hash, 3595 hash_table_string_compare); 3596 parser->active = NULL; 3597 parser->lexing_if = 0; 3598 parser->space_tokens = 1; 3599 parser->newline_as_space = 0; 3600 parser->in_control_line = 0; 3601 parser->paren_count = 0; 3602 3603 parser->skip_stack = NULL; 3604 3605 parser->lex_from_list = NULL; 3606 parser->lex_from_node = NULL; 3607 3608 parser->output = ralloc_strdup(parser, ""); 3609 parser->output_length = 0; 3610 parser->info_log = ralloc_strdup(parser, ""); 3611 parser->info_log_length = 0; 3612 parser->error = 0; 3613 3614 parser->has_new_line_number = 0; 3615 parser->new_line_number = 1; 3616 parser->has_new_source_number = 0; 3617 parser->new_source_number = 0; 3618 3619 /* Add pre-defined macros. */ 3620 add_builtin_define(parser, "GL_ARB_draw_buffers", 1); 3621 add_builtin_define(parser, "GL_ARB_texture_rectangle", 1); 3622 3623 if (api == API_OPENGLES2) 3624 add_builtin_define(parser, "GL_ES", 1); 3625 3626 if (extensions != NULL) { 3627 if (extensions->EXT_texture_array) { 3628 add_builtin_define(parser, "GL_EXT_texture_array", 1); 3629 } 3630 3631 if (extensions->ARB_fragment_coord_conventions) 3632 add_builtin_define(parser, "GL_ARB_fragment_coord_conventions", 3633 1); 3634 3635 if (extensions->ARB_explicit_attrib_location) 3636 add_builtin_define(parser, "GL_ARB_explicit_attrib_location", 1); 3637 3638 if (extensions->ARB_shader_texture_lod) 3639 add_builtin_define(parser, "GL_ARB_shader_texture_lod", 1); 3640 3641 if (extensions->ARB_draw_instanced) 3642 add_builtin_define(parser, "GL_ARB_draw_instanced", 1); 3643 3644 if (extensions->ARB_conservative_depth) { 3645 add_builtin_define(parser, "GL_AMD_conservative_depth", 1); 3646 add_builtin_define(parser, "GL_ARB_conservative_depth", 1); 3647 } 3648 3649 if (extensions->OES_EGL_image_external) 3650 add_builtin_define(parser, "GL_OES_EGL_image_external", 1); 3651 3652 if (extensions->ARB_shader_bit_encoding) 3653 add_builtin_define(parser, "GL_ARB_shader_bit_encoding", 1); 3654 3655 if (extensions->ARB_uniform_buffer_object) 3656 add_builtin_define(parser, "GL_ARB_uniform_buffer_object", 1); 3657 } 3658 3659 language_version = 110; 3660 add_builtin_define(parser, "__VERSION__", language_version); 3661 3662 return parser; 3663 } 3664 3665 void 3666 glcpp_parser_destroy (glcpp_parser_t *parser) 3667 { 3668 glcpp_lex_destroy (parser->scanner); 3669 hash_table_dtor (parser->defines); 3670 ralloc_free (parser); 3671 } 3672 3673 typedef enum function_status 3674 { 3675 FUNCTION_STATUS_SUCCESS, 3676 FUNCTION_NOT_A_FUNCTION, 3677 FUNCTION_UNBALANCED_PARENTHESES 3678 } function_status_t; 3679 3680 /* Find a set of function-like macro arguments by looking for a 3681 * balanced set of parentheses. 3682 * 3683 * When called, 'node' should be the opening-parenthesis token, (or 3684 * perhaps preceeding SPACE tokens). Upon successful return *last will 3685 * be the last consumed node, (corresponding to the closing right 3686 * parenthesis). 3687 * 3688 * Return values: 3689 * 3690 * FUNCTION_STATUS_SUCCESS: 3691 * 3692 * Successfully parsed a set of function arguments. 3693 * 3694 * FUNCTION_NOT_A_FUNCTION: 3695 * 3696 * Macro name not followed by a '('. This is not an error, but 3697 * simply that the macro name should be treated as a non-macro. 3698 * 3699 * FUNCTION_UNBALANCED_PARENTHESES 3700 * 3701 * Macro name is not followed by a balanced set of parentheses. 3702 */ 3703 static function_status_t 3704 _arguments_parse (argument_list_t *arguments, 3705 token_node_t *node, 3706 token_node_t **last) 3707 { 3708 token_list_t *argument; 3709 int paren_count; 3710 3711 node = node->next; 3712 3713 /* Ignore whitespace before first parenthesis. */ 3714 while (node && node->token->type == SPACE) 3715 node = node->next; 3716 3717 if (node == NULL || node->token->type != '(') 3718 return FUNCTION_NOT_A_FUNCTION; 3719 3720 node = node->next; 3721 3722 argument = _token_list_create (arguments); 3723 _argument_list_append (arguments, argument); 3724 3725 for (paren_count = 1; node; node = node->next) { 3726 if (node->token->type == '(') 3727 { 3728 paren_count++; 3729 } 3730 else if (node->token->type == ')') 3731 { 3732 paren_count--; 3733 if (paren_count == 0) 3734 break; 3735 } 3736 3737 if (node->token->type == ',' && 3738 paren_count == 1) 3739 { 3740 _token_list_trim_trailing_space (argument); 3741 argument = _token_list_create (arguments); 3742 _argument_list_append (arguments, argument); 3743 } 3744 else { 3745 if (argument->head == NULL) { 3746 /* Don't treat initial whitespace as 3747 * part of the arguement. */ 3748 if (node->token->type == SPACE) 3749 continue; 3750 } 3751 _token_list_append (argument, node->token); 3752 } 3753 } 3754 3755 if (paren_count) 3756 return FUNCTION_UNBALANCED_PARENTHESES; 3757 3758 *last = node; 3759 3760 return FUNCTION_STATUS_SUCCESS; 3761 } 3762 3763 static token_list_t * 3764 _token_list_create_with_one_space (void *ctx) 3765 { 3766 token_list_t *list; 3767 token_t *space; 3768 3769 list = _token_list_create (ctx); 3770 space = _token_create_ival (list, SPACE, SPACE); 3771 _token_list_append (list, space); 3772 3773 return list; 3774 } 3775 3776 /* Perform macro expansion on 'list', placing the resulting tokens 3777 * into a new list which is initialized with a first token of type 3778 * 'head_token_type'. Then begin lexing from the resulting list, 3779 * (return to the current lexing source when this list is exhausted). 3780 */ 3781 static void 3782 _glcpp_parser_expand_and_lex_from (glcpp_parser_t *parser, 3783 int head_token_type, 3784 token_list_t *list) 3785 { 3786 token_list_t *expanded; 3787 token_t *token; 3788 3789 expanded = _token_list_create (parser); 3790 token = _token_create_ival (parser, head_token_type, head_token_type); 3791 _token_list_append (expanded, token); 3792 _glcpp_parser_expand_token_list (parser, list); 3793 _token_list_append_list (expanded, list); 3794 glcpp_parser_lex_from (parser, expanded); 3795 } 3796 3797 static void 3798 _glcpp_parser_apply_pastes (glcpp_parser_t *parser, token_list_t *list) 3799 { 3800 token_node_t *node; 3801 3802 node = list->head; 3803 while (node) 3804 { 3805 token_node_t *next_non_space; 3806 3807 /* Look ahead for a PASTE token, skipping space. */ 3808 next_non_space = node->next; 3809 while (next_non_space && next_non_space->token->type == SPACE) 3810 next_non_space = next_non_space->next; 3811 3812 if (next_non_space == NULL) 3813 break; 3814 3815 if (next_non_space->token->type != PASTE) { 3816 node = next_non_space; 3817 continue; 3818 } 3819 3820 /* Now find the next non-space token after the PASTE. */ 3821 next_non_space = next_non_space->next; 3822 while (next_non_space && next_non_space->token->type == SPACE) 3823 next_non_space = next_non_space->next; 3824 3825 if (next_non_space == NULL) { 3826 yyerror (&node->token->location, parser, "'##' cannot appear at either end of a macro expansion\n"); 3827 return; 3828 } 3829 3830 node->token = _token_paste (parser, node->token, next_non_space->token); 3831 node->next = next_non_space->next; 3832 if (next_non_space == list->tail) 3833 list->tail = node; 3834 } 3835 3836 list->non_space_tail = list->tail; 3837 } 3838 3839 /* This is a helper function that's essentially part of the 3840 * implementation of _glcpp_parser_expand_node. It shouldn't be called 3841 * except for by that function. 3842 * 3843 * Returns NULL if node is a simple token with no expansion, (that is, 3844 * although 'node' corresponds to an identifier defined as a 3845 * function-like macro, it is not followed with a parenthesized 3846 * argument list). 3847 * 3848 * Compute the complete expansion of node (which is a function-like 3849 * macro) and subsequent nodes which are arguments. 3850 * 3851 * Returns the token list that results from the expansion and sets 3852 * *last to the last node in the list that was consumed by the 3853 * expansion. Specifically, *last will be set as follows: as the 3854 * token of the closing right parenthesis. 3855 */ 3856 static token_list_t * 3857 _glcpp_parser_expand_function (glcpp_parser_t *parser, 3858 token_node_t *node, 3859 token_node_t **last) 3860 3861 { 3862 macro_t *macro; 3863 const char *identifier; 3864 argument_list_t *arguments; 3865 function_status_t status; 3866 token_list_t *substituted; 3867 int parameter_index; 3868 3869 identifier = node->token->value.str; 3870 3871 macro = hash_table_find (parser->defines, identifier); 3872 3873 assert (macro->is_function); 3874 3875 arguments = _argument_list_create (parser); 3876 status = _arguments_parse (arguments, node, last); 3877 3878 switch (status) { 3879 case FUNCTION_STATUS_SUCCESS: 3880 break; 3881 case FUNCTION_NOT_A_FUNCTION: 3882 return NULL; 3883 case FUNCTION_UNBALANCED_PARENTHESES: 3884 glcpp_error (&node->token->location, parser, "Macro %s call has unbalanced parentheses\n", identifier); 3885 return NULL; 3886 } 3887 3888 /* Replace a macro defined as empty with a SPACE token. */ 3889 if (macro->replacements == NULL) { 3890 ralloc_free (arguments); 3891 return _token_list_create_with_one_space (parser); 3892 } 3893 3894 if (! ((_argument_list_length (arguments) == 3895 _string_list_length (macro->parameters)) || 3896 (_string_list_length (macro->parameters) == 0 && 3897 _argument_list_length (arguments) == 1 && 3898 arguments->head->argument->head == NULL))) 3899 { 3900 glcpp_error (&node->token->location, parser, 3901 "Error: macro %s invoked with %d arguments (expected %d)\n", 3902 identifier, 3903 _argument_list_length (arguments), 3904 _string_list_length (macro->parameters)); 3905 return NULL; 3906 } 3907 3908 /* Perform argument substitution on the replacement list. */ 3909 substituted = _token_list_create (arguments); 3910 3911 for (node = macro->replacements->head; node; node = node->next) 3912 { 3913 if (node->token->type == IDENTIFIER && 3914 _string_list_contains (macro->parameters, 3915 node->token->value.str, 3916 ¶meter_index)) 3917 { 3918 token_list_t *argument; 3919 argument = _argument_list_member_at (arguments, 3920 parameter_index); 3921 /* Before substituting, we expand the argument 3922 * tokens, or append a placeholder token for 3923 * an empty argument. */ 3924 if (argument->head) { 3925 token_list_t *expanded_argument; 3926 expanded_argument = _token_list_copy (parser, 3927 argument); 3928 _glcpp_parser_expand_token_list (parser, 3929 expanded_argument); 3930 _token_list_append_list (substituted, 3931 expanded_argument); 3932 } else { 3933 token_t *new_token; 3934 3935 new_token = _token_create_ival (substituted, 3936 PLACEHOLDER, 3937 PLACEHOLDER); 3938 _token_list_append (substituted, new_token); 3939 } 3940 } else { 3941 _token_list_append (substituted, node->token); 3942 } 3943 } 3944 3945 /* After argument substitution, and before further expansion 3946 * below, implement token pasting. */ 3947 3948 _token_list_trim_trailing_space (substituted); 3949 3950 _glcpp_parser_apply_pastes (parser, substituted); 3951 3952 return substituted; 3953 } 3954 3955 /* Compute the complete expansion of node, (and subsequent nodes after 3956 * 'node' in the case that 'node' is a function-like macro and 3957 * subsequent nodes are arguments). 3958 * 3959 * Returns NULL if node is a simple token with no expansion. 3960 * 3961 * Otherwise, returns the token list that results from the expansion 3962 * and sets *last to the last node in the list that was consumed by 3963 * the expansion. Specifically, *last will be set as follows: 3964 * 3965 * As 'node' in the case of object-like macro expansion. 3966 * 3967 * As the token of the closing right parenthesis in the case of 3968 * function-like macro expansion. 3969 */ 3970 static token_list_t * 3971 _glcpp_parser_expand_node (glcpp_parser_t *parser, 3972 token_node_t *node, 3973 token_node_t **last) 3974 { 3975 token_t *token = node->token; 3976 const char *identifier; 3977 macro_t *macro; 3978 3979 /* We only expand identifiers */ 3980 if (token->type != IDENTIFIER) { 3981 /* We change any COMMA into a COMMA_FINAL to prevent 3982 * it being mistaken for an argument separator 3983 * later. */ 3984 if (token->type == ',') { 3985 token->type = COMMA_FINAL; 3986 token->value.ival = COMMA_FINAL; 3987 } 3988 3989 return NULL; 3990 } 3991 3992 /* Look up this identifier in the hash table. */ 3993 identifier = token->value.str; 3994 macro = hash_table_find (parser->defines, identifier); 3995 3996 /* Not a macro, so no expansion needed. */ 3997 if (macro == NULL) 3998 return NULL; 3999 4000 /* Finally, don't expand this macro if we're already actively 4001 * expanding it, (to avoid infinite recursion). */ 4002 if (_parser_active_list_contains (parser, identifier)) { 4003 /* We change the token type here from IDENTIFIER to 4004 * OTHER to prevent any future expansion of this 4005 * unexpanded token. */ 4006 char *str; 4007 token_list_t *expansion; 4008 token_t *final; 4009 4010 str = ralloc_strdup (parser, token->value.str); 4011 final = _token_create_str (parser, OTHER, str); 4012 expansion = _token_list_create (parser); 4013 _token_list_append (expansion, final); 4014 *last = node; 4015 return expansion; 4016 } 4017 4018 if (! macro->is_function) 4019 { 4020 token_list_t *replacement; 4021 *last = node; 4022 4023 /* Replace a macro defined as empty with a SPACE token. */ 4024 if (macro->replacements == NULL) 4025 return _token_list_create_with_one_space (parser); 4026 4027 replacement = _token_list_copy (parser, macro->replacements); 4028 _glcpp_parser_apply_pastes (parser, replacement); 4029 return replacement; 4030 } 4031 4032 return _glcpp_parser_expand_function (parser, node, last); 4033 } 4034 4035 /* Push a new identifier onto the parser's active list. 4036 * 4037 * Here, 'marker' is the token node that appears in the list after the 4038 * expansion of 'identifier'. That is, when the list iterator begins 4039 * examining 'marker', then it is time to pop this node from the 4040 * active stack. 4041 */ 4042 static void 4043 _parser_active_list_push (glcpp_parser_t *parser, 4044 const char *identifier, 4045 token_node_t *marker) 4046 { 4047 active_list_t *node; 4048 4049 node = ralloc (parser->active, active_list_t); 4050 node->identifier = ralloc_strdup (node, identifier); 4051 node->marker = marker; 4052 node->next = parser->active; 4053 4054 parser->active = node; 4055 } 4056 4057 static void 4058 _parser_active_list_pop (glcpp_parser_t *parser) 4059 { 4060 active_list_t *node = parser->active; 4061 4062 if (node == NULL) { 4063 parser->active = NULL; 4064 return; 4065 } 4066 4067 node = parser->active->next; 4068 ralloc_free (parser->active); 4069 4070 parser->active = node; 4071 } 4072 4073 static int 4074 _parser_active_list_contains (glcpp_parser_t *parser, const char *identifier) 4075 { 4076 active_list_t *node; 4077 4078 if (parser->active == NULL) 4079 return 0; 4080 4081 for (node = parser->active; node; node = node->next) 4082 if (strcmp (node->identifier, identifier) == 0) 4083 return 1; 4084 4085 return 0; 4086 } 4087 4088 /* Walk over the token list replacing nodes with their expansion. 4089 * Whenever nodes are expanded the walking will walk over the new 4090 * nodes, continuing to expand as necessary. The results are placed in 4091 * 'list' itself; 4092 */ 4093 static void 4094 _glcpp_parser_expand_token_list (glcpp_parser_t *parser, 4095 token_list_t *list) 4096 { 4097 token_node_t *node_prev; 4098 token_node_t *node, *last = NULL; 4099 token_list_t *expansion; 4100 active_list_t *active_initial = parser->active; 4101 4102 if (list == NULL) 4103 return; 4104 4105 _token_list_trim_trailing_space (list); 4106 4107 node_prev = NULL; 4108 node = list->head; 4109 4110 while (node) { 4111 4112 while (parser->active && parser->active->marker == node) 4113 _parser_active_list_pop (parser); 4114 4115 expansion = _glcpp_parser_expand_node (parser, node, &last); 4116 if (expansion) { 4117 token_node_t *n; 4118 4119 for (n = node; n != last->next; n = n->next) 4120 while (parser->active && 4121 parser->active->marker == n) 4122 { 4123 _parser_active_list_pop (parser); 4124 } 4125 4126 _parser_active_list_push (parser, 4127 node->token->value.str, 4128 last->next); 4129 4130 /* Splice expansion into list, supporting a 4131 * simple deletion if the expansion is 4132 * empty. */ 4133 if (expansion->head) { 4134 if (node_prev) 4135 node_prev->next = expansion->head; 4136 else 4137 list->head = expansion->head; 4138 expansion->tail->next = last->next; 4139 if (last == list->tail) 4140 list->tail = expansion->tail; 4141 } else { 4142 if (node_prev) 4143 node_prev->next = last->next; 4144 else 4145 list->head = last->next; 4146 if (last == list->tail) 4147 list->tail = NULL; 4148 } 4149 } else { 4150 node_prev = node; 4151 } 4152 node = node_prev ? node_prev->next : list->head; 4153 } 4154 4155 /* Remove any lingering effects of this invocation on the 4156 * active list. That is, pop until the list looks like it did 4157 * at the beginning of this function. */ 4158 while (parser->active && parser->active != active_initial) 4159 _parser_active_list_pop (parser); 4160 4161 list->non_space_tail = list->tail; 4162 } 4163 4164 void 4165 _glcpp_parser_print_expanded_token_list (glcpp_parser_t *parser, 4166 token_list_t *list) 4167 { 4168 if (list == NULL) 4169 return; 4170 4171 _glcpp_parser_expand_token_list (parser, list); 4172 4173 _token_list_trim_trailing_space (list); 4174 4175 _token_list_print (parser, list); 4176 } 4177 4178 static void 4179 _check_for_reserved_macro_name (glcpp_parser_t *parser, YYLTYPE *loc, 4180 const char *identifier) 4181 { 4182 /* According to the GLSL specification, macro names starting with "__" 4183 * or "GL_" are reserved for future use. So, don't allow them. 4184 */ 4185 if (strstr(identifier, "__")) { 4186 glcpp_error (loc, parser, "Macro names containing \"__\" are reserved.\n"); 4187 } 4188 if (strncmp(identifier, "GL_", 3) == 0) { 4189 glcpp_error (loc, parser, "Macro names starting with \"GL_\" are reserved.\n"); 4190 } 4191 } 4192 4193 static int 4194 _macro_equal (macro_t *a, macro_t *b) 4195 { 4196 if (a->is_function != b->is_function) 4197 return 0; 4198 4199 if (a->is_function) { 4200 if (! _string_list_equal (a->parameters, b->parameters)) 4201 return 0; 4202 } 4203 4204 return _token_list_equal_ignoring_space (a->replacements, 4205 b->replacements); 4206 } 4207 4208 void 4209 _define_object_macro (glcpp_parser_t *parser, 4210 YYLTYPE *loc, 4211 const char *identifier, 4212 token_list_t *replacements) 4213 { 4214 macro_t *macro, *previous; 4215 4216 if (loc != NULL) 4217 _check_for_reserved_macro_name(parser, loc, identifier); 4218 4219 macro = ralloc (parser, macro_t); 4220 4221 macro->is_function = 0; 4222 macro->parameters = NULL; 4223 macro->identifier = ralloc_strdup (macro, identifier); 4224 macro->replacements = replacements; 4225 ralloc_steal (macro, replacements); 4226 4227 previous = hash_table_find (parser->defines, identifier); 4228 if (previous) { 4229 if (_macro_equal (macro, previous)) { 4230 ralloc_free (macro); 4231 return; 4232 } 4233 glcpp_error (loc, parser, "Redefinition of macro %s\n", 4234 identifier); 4235 } 4236 4237 hash_table_insert (parser->defines, macro, identifier); 4238 } 4239 4240 void 4241 _define_function_macro (glcpp_parser_t *parser, 4242 YYLTYPE *loc, 4243 const char *identifier, 4244 string_list_t *parameters, 4245 token_list_t *replacements) 4246 { 4247 macro_t *macro, *previous; 4248 4249 _check_for_reserved_macro_name(parser, loc, identifier); 4250 4251 macro = ralloc (parser, macro_t); 4252 ralloc_steal (macro, parameters); 4253 ralloc_steal (macro, replacements); 4254 4255 macro->is_function = 1; 4256 macro->parameters = parameters; 4257 macro->identifier = ralloc_strdup (macro, identifier); 4258 macro->replacements = replacements; 4259 previous = hash_table_find (parser->defines, identifier); 4260 if (previous) { 4261 if (_macro_equal (macro, previous)) { 4262 ralloc_free (macro); 4263 return; 4264 } 4265 glcpp_error (loc, parser, "Redefinition of macro %s\n", 4266 identifier); 4267 } 4268 4269 hash_table_insert (parser->defines, macro, identifier); 4270 } 4271 4272 static int 4273 glcpp_parser_lex (YYSTYPE *yylval, YYLTYPE *yylloc, glcpp_parser_t *parser) 4274 { 4275 token_node_t *node; 4276 int ret; 4277 4278 if (parser->lex_from_list == NULL) { 4279 ret = glcpp_lex (yylval, yylloc, parser->scanner); 4280 4281 /* XXX: This ugly block of code exists for the sole 4282 * purpose of converting a NEWLINE token into a SPACE 4283 * token, but only in the case where we have seen a 4284 * function-like macro name, but have not yet seen its 4285 * closing parenthesis. 4286 * 4287 * There's perhaps a more compact way to do this with 4288 * mid-rule actions in the grammar. 4289 * 4290 * I'm definitely not pleased with the complexity of 4291 * this code here. 4292 */ 4293 if (parser->newline_as_space) 4294 { 4295 if (ret == '(') { 4296 parser->paren_count++; 4297 } else if (ret == ')') { 4298 parser->paren_count--; 4299 if (parser->paren_count == 0) 4300 parser->newline_as_space = 0; 4301 } else if (ret == NEWLINE) { 4302 ret = SPACE; 4303 } else if (ret != SPACE) { 4304 if (parser->paren_count == 0) 4305 parser->newline_as_space = 0; 4306 } 4307 } 4308 else if (parser->in_control_line) 4309 { 4310 if (ret == NEWLINE) 4311 parser->in_control_line = 0; 4312 } 4313 else if (ret == HASH_DEFINE || 4314 ret == HASH_UNDEF || ret == HASH_IF || 4315 ret == HASH_IFDEF || ret == HASH_IFNDEF || 4316 ret == HASH_ELIF || ret == HASH_ELSE || 4317 ret == HASH_ENDIF || ret == HASH) 4318 { 4319 parser->in_control_line = 1; 4320 } 4321 else if (ret == IDENTIFIER) 4322 { 4323 macro_t *macro; 4324 macro = hash_table_find (parser->defines, 4325 yylval->str); 4326 if (macro && macro->is_function) { 4327 parser->newline_as_space = 1; 4328 parser->paren_count = 0; 4329 } 4330 } 4331 4332 return ret; 4333 } 4334 4335 node = parser->lex_from_node; 4336 4337 if (node == NULL) { 4338 ralloc_free (parser->lex_from_list); 4339 parser->lex_from_list = NULL; 4340 return NEWLINE; 4341 } 4342 4343 *yylval = node->token->value; 4344 ret = node->token->type; 4345 4346 parser->lex_from_node = node->next; 4347 4348 return ret; 4349 } 4350 4351 static void 4352 glcpp_parser_lex_from (glcpp_parser_t *parser, token_list_t *list) 4353 { 4354 token_node_t *node; 4355 4356 assert (parser->lex_from_list == NULL); 4357 4358 /* Copy list, eliminating any space tokens. */ 4359 parser->lex_from_list = _token_list_create (parser); 4360 4361 for (node = list->head; node; node = node->next) { 4362 if (node->token->type == SPACE) 4363 continue; 4364 _token_list_append (parser->lex_from_list, node->token); 4365 } 4366 4367 ralloc_free (list); 4368 4369 parser->lex_from_node = parser->lex_from_list->head; 4370 4371 /* It's possible the list consisted of nothing but whitespace. */ 4372 if (parser->lex_from_node == NULL) { 4373 ralloc_free (parser->lex_from_list); 4374 parser->lex_from_list = NULL; 4375 } 4376 } 4377 4378 static void 4379 _glcpp_parser_skip_stack_push_if (glcpp_parser_t *parser, YYLTYPE *loc, 4380 int condition) 4381 { 4382 skip_type_t current = SKIP_NO_SKIP; 4383 skip_node_t *node; 4384 4385 if (parser->skip_stack) 4386 current = parser->skip_stack->type; 4387 4388 node = ralloc (parser, skip_node_t); 4389 node->loc = *loc; 4390 4391 if (current == SKIP_NO_SKIP) { 4392 if (condition) 4393 node->type = SKIP_NO_SKIP; 4394 else 4395 node->type = SKIP_TO_ELSE; 4396 } else { 4397 node->type = SKIP_TO_ENDIF; 4398 } 4399 4400 node->next = parser->skip_stack; 4401 parser->skip_stack = node; 4402 } 4403 4404 static void 4405 _glcpp_parser_skip_stack_change_if (glcpp_parser_t *parser, YYLTYPE *loc, 4406 const char *type, int condition) 4407 { 4408 if (parser->skip_stack == NULL) { 4409 glcpp_error (loc, parser, "%s without #if\n", type); 4410 return; 4411 } 4412 4413 if (parser->skip_stack->type == SKIP_TO_ELSE) { 4414 if (condition) 4415 parser->skip_stack->type = SKIP_NO_SKIP; 4416 } else { 4417 parser->skip_stack->type = SKIP_TO_ENDIF; 4418 } 4419 } 4420 4421 static void 4422 _glcpp_parser_skip_stack_pop (glcpp_parser_t *parser, YYLTYPE *loc) 4423 { 4424 skip_node_t *node; 4425 4426 if (parser->skip_stack == NULL) { 4427 glcpp_error (loc, parser, "#endif without #if\n"); 4428 return; 4429 } 4430 4431 node = parser->skip_stack; 4432 parser->skip_stack = node->next; 4433 ralloc_free (node); 4434 } 4435 4436
