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