OLD | NEW |
(Empty) | |
| 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__ || de
fined __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__ || define
d __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 yyvalue
p, 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, YYL
TYPE 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 *par
ser) |
| 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 *yylocatio
np, 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_l
ength, "\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_l
ength, "\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)].st
r)); |
| 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 e
xpression"); |
| 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 il
legal #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)].iva
l)); |
| 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_l
ength, "#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, (yyvs
p[(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)].iv
al), (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->valu
e.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_S
HIFT); |
| 3491 else if (other->type == '=') |
| 3492 combined = _token_create_ival (token, LESS_OR_EQUAL, LES
S_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_EQU
AL); |
| 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_lengt
h, "Pasting \""); |
| 3546 _token_print (&parser->info_log, &parser->info_log_length, token); |
| 3547 ralloc_asprintf_rewrite_tail (&parser->info_log, &parser->info_log_lengt
h, "\" and \""); |
| 3548 _token_print (&parser->info_log, &parser->info_log_length, other); |
| 3549 ralloc_asprintf_rewrite_tail (&parser->info_log, &parser->info_log_lengt
h, "\" 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->tok
en); |
| 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 ap
pear 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 (expect
ed %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_argume
nt); |
| 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 res
erved.\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 |
OLD | NEW |