projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
glsl2: Refresh autogenerated bison parser.
[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 <stdint.h>
100
101 #include "glcpp.h"
102 #include "main/mtypes.h"
103
104 #define glcpp_print(stream, str) stream = talloc_strdup_append(stream, str)
105 #define glcpp_printf(stream, fmt, args, ...) \
106 stream = talloc_asprintf_append(stream, fmt, args)
107
108 static void
109 yyerror (YYLTYPE *locp, glcpp_parser_t *parser, const char *error);
110
111 static void
112 _define_object_macro (glcpp_parser_t *parser,
113 YYLTYPE *loc,
114 const char *macro,
115 token_list_t *replacements);
116
117 static void
118 _define_function_macro (glcpp_parser_t *parser,
119 YYLTYPE *loc,
120 const char *macro,
121 string_list_t *parameters,
122 token_list_t *replacements);
123
124 static string_list_t *
125 _string_list_create (void *ctx);
126
127 static void
128 _string_list_append_item (string_list_t *list, const char *str);
129
130 static int
131 _string_list_contains (string_list_t *list, const char *member, int *index);
132
133 static int
134 _string_list_length (string_list_t *list);
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 talloc_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 adds a talloc_reference() to token.
159 *
160 * You may want to talloc_unlink any current reference if you no
161 * longer need it. */
162 static void
163 _token_list_append (token_list_t *list, token_t *token);
164
165 static void
166 _token_list_append_list (token_list_t *list, token_list_t *tail);
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, 314, 318, 327, 332, 333, 336, 339,
631 342, 345, 348, 351, 354, 357, 360, 363, 366, 369,
632 372, 375, 378, 381, 384, 387, 390, 393, 396, 399,
633 405, 410, 418, 419, 423, 429, 430, 433, 435, 442,
634 446, 450, 455, 461, 469, 475, 483, 487, 491, 495,
635 499, 506, 507, 508, 509, 510, 511, 512, 513, 514,
636 515, 516, 517, 518, 519, 520, 521, 522, 523, 524,
637 525, 526, 527, 528, 529, 530, 531, 532, 533, 534,
638 535, 536
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 glcpp_print(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 glcpp_print(parser->output, "\n");
1818 talloc_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 talloc_free (macro);
1876 }
1877 talloc_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 talloc_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 talloc_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 talloc_free (macro);
2017 }
2018 add_builtin_define (parser, "__VERSION__", (yyvsp[(2) - (3)].ival));
2019 glcpp_printf(parser->output, "#version %" PRIiMAX "\n", (yyvsp[(2) - (3)].ival));
2020 ;}
2021 break;
2022
2023 case 24:
2024
2025 /* Line 1464 of yacc.c */
2026 #line 318 "glcpp/glcpp-parse.y"
2027 {
2028 if (strlen ((yyvsp[(1) - (1)].str)) >= 3 && strncmp ((yyvsp[(1) - (1)].str), "0x", 2) == 0) {
2029 (yyval.ival) = strtoll ((yyvsp[(1) - (1)].str) + 2, NULL, 16);
2030 } else if ((yyvsp[(1) - (1)].str)[0] == '0') {
2031 (yyval.ival) = strtoll ((yyvsp[(1) - (1)].str), NULL, 8);
2032 } else {
2033 (yyval.ival) = strtoll ((yyvsp[(1) - (1)].str), NULL, 10);
2034 }
2035 ;}
2036 break;
2037
2038 case 25:
2039
2040 /* Line 1464 of yacc.c */
2041 #line 327 "glcpp/glcpp-parse.y"
2042 {
2043 (yyval.ival) = (yyvsp[(1) - (1)].ival);
2044 ;}
2045 break;
2046
2047 case 27:
2048
2049 /* Line 1464 of yacc.c */
2050 #line 333 "glcpp/glcpp-parse.y"
2051 {
2052 (yyval.ival) = (yyvsp[(1) - (3)].ival) || (yyvsp[(3) - (3)].ival);
2053 ;}
2054 break;
2055
2056 case 28:
2057
2058 /* Line 1464 of yacc.c */
2059 #line 336 "glcpp/glcpp-parse.y"
2060 {
2061 (yyval.ival) = (yyvsp[(1) - (3)].ival) && (yyvsp[(3) - (3)].ival);
2062 ;}
2063 break;
2064
2065 case 29:
2066
2067 /* Line 1464 of yacc.c */
2068 #line 339 "glcpp/glcpp-parse.y"
2069 {
2070 (yyval.ival) = (yyvsp[(1) - (3)].ival) | (yyvsp[(3) - (3)].ival);
2071 ;}
2072 break;
2073
2074 case 30:
2075
2076 /* Line 1464 of yacc.c */
2077 #line 342 "glcpp/glcpp-parse.y"
2078 {
2079 (yyval.ival) = (yyvsp[(1) - (3)].ival) ^ (yyvsp[(3) - (3)].ival);
2080 ;}
2081 break;
2082
2083 case 31:
2084
2085 /* Line 1464 of yacc.c */
2086 #line 345 "glcpp/glcpp-parse.y"
2087 {
2088 (yyval.ival) = (yyvsp[(1) - (3)].ival) & (yyvsp[(3) - (3)].ival);
2089 ;}
2090 break;
2091
2092 case 32:
2093
2094 /* Line 1464 of yacc.c */
2095 #line 348 "glcpp/glcpp-parse.y"
2096 {
2097 (yyval.ival) = (yyvsp[(1) - (3)].ival) != (yyvsp[(3) - (3)].ival);
2098 ;}
2099 break;
2100
2101 case 33:
2102
2103 /* Line 1464 of yacc.c */
2104 #line 351 "glcpp/glcpp-parse.y"
2105 {
2106 (yyval.ival) = (yyvsp[(1) - (3)].ival) == (yyvsp[(3) - (3)].ival);
2107 ;}
2108 break;
2109
2110 case 34:
2111
2112 /* Line 1464 of yacc.c */
2113 #line 354 "glcpp/glcpp-parse.y"
2114 {
2115 (yyval.ival) = (yyvsp[(1) - (3)].ival) >= (yyvsp[(3) - (3)].ival);
2116 ;}
2117 break;
2118
2119 case 35:
2120
2121 /* Line 1464 of yacc.c */
2122 #line 357 "glcpp/glcpp-parse.y"
2123 {
2124 (yyval.ival) = (yyvsp[(1) - (3)].ival) <= (yyvsp[(3) - (3)].ival);
2125 ;}
2126 break;
2127
2128 case 36:
2129
2130 /* Line 1464 of yacc.c */
2131 #line 360 "glcpp/glcpp-parse.y"
2132 {
2133 (yyval.ival) = (yyvsp[(1) - (3)].ival) > (yyvsp[(3) - (3)].ival);
2134 ;}
2135 break;
2136
2137 case 37:
2138
2139 /* Line 1464 of yacc.c */
2140 #line 363 "glcpp/glcpp-parse.y"
2141 {
2142 (yyval.ival) = (yyvsp[(1) - (3)].ival) < (yyvsp[(3) - (3)].ival);
2143 ;}
2144 break;
2145
2146 case 38:
2147
2148 /* Line 1464 of yacc.c */
2149 #line 366 "glcpp/glcpp-parse.y"
2150 {
2151 (yyval.ival) = (yyvsp[(1) - (3)].ival) >> (yyvsp[(3) - (3)].ival);
2152 ;}
2153 break;
2154
2155 case 39:
2156
2157 /* Line 1464 of yacc.c */
2158 #line 369 "glcpp/glcpp-parse.y"
2159 {
2160 (yyval.ival) = (yyvsp[(1) - (3)].ival) << (yyvsp[(3) - (3)].ival);
2161 ;}
2162 break;
2163
2164 case 40:
2165
2166 /* Line 1464 of yacc.c */
2167 #line 372 "glcpp/glcpp-parse.y"
2168 {
2169 (yyval.ival) = (yyvsp[(1) - (3)].ival) - (yyvsp[(3) - (3)].ival);
2170 ;}
2171 break;
2172
2173 case 41:
2174
2175 /* Line 1464 of yacc.c */
2176 #line 375 "glcpp/glcpp-parse.y"
2177 {
2178 (yyval.ival) = (yyvsp[(1) - (3)].ival) + (yyvsp[(3) - (3)].ival);
2179 ;}
2180 break;
2181
2182 case 42:
2183
2184 /* Line 1464 of yacc.c */
2185 #line 378 "glcpp/glcpp-parse.y"
2186 {
2187 (yyval.ival) = (yyvsp[(1) - (3)].ival) % (yyvsp[(3) - (3)].ival);
2188 ;}
2189 break;
2190
2191 case 43:
2192
2193 /* Line 1464 of yacc.c */
2194 #line 381 "glcpp/glcpp-parse.y"
2195 {
2196 (yyval.ival) = (yyvsp[(1) - (3)].ival) / (yyvsp[(3) - (3)].ival);
2197 ;}
2198 break;
2199
2200 case 44:
2201
2202 /* Line 1464 of yacc.c */
2203 #line 384 "glcpp/glcpp-parse.y"
2204 {
2205 (yyval.ival) = (yyvsp[(1) - (3)].ival) * (yyvsp[(3) - (3)].ival);
2206 ;}
2207 break;
2208
2209 case 45:
2210
2211 /* Line 1464 of yacc.c */
2212 #line 387 "glcpp/glcpp-parse.y"
2213 {
2214 (yyval.ival) = ! (yyvsp[(2) - (2)].ival);
2215 ;}
2216 break;
2217
2218 case 46:
2219
2220 /* Line 1464 of yacc.c */
2221 #line 390 "glcpp/glcpp-parse.y"
2222 {
2223 (yyval.ival) = ~ (yyvsp[(2) - (2)].ival);
2224 ;}
2225 break;
2226
2227 case 47:
2228
2229 /* Line 1464 of yacc.c */
2230 #line 393 "glcpp/glcpp-parse.y"
2231 {
2232 (yyval.ival) = - (yyvsp[(2) - (2)].ival);
2233 ;}
2234 break;
2235
2236 case 48:
2237
2238 /* Line 1464 of yacc.c */
2239 #line 396 "glcpp/glcpp-parse.y"
2240 {
2241 (yyval.ival) = + (yyvsp[(2) - (2)].ival);
2242 ;}
2243 break;
2244
2245 case 49:
2246
2247 /* Line 1464 of yacc.c */
2248 #line 399 "glcpp/glcpp-parse.y"
2249 {
2250 (yyval.ival) = (yyvsp[(2) - (3)].ival);
2251 ;}
2252 break;
2253
2254 case 50:
2255
2256 /* Line 1464 of yacc.c */
2257 #line 405 "glcpp/glcpp-parse.y"
2258 {
2259 (yyval.string_list) = _string_list_create (parser);
2260 _string_list_append_item ((yyval.string_list), (yyvsp[(1) - (1)].str));
2261 talloc_steal ((yyval.string_list), (yyvsp[(1) - (1)].str));
2262 ;}
2263 break;
2264
2265 case 51:
2266
2267 /* Line 1464 of yacc.c */
2268 #line 410 "glcpp/glcpp-parse.y"
2269 {
2270 (yyval.string_list) = (yyvsp[(1) - (3)].string_list);
2271 _string_list_append_item ((yyval.string_list), (yyvsp[(3) - (3)].str));
2272 talloc_steal ((yyval.string_list), (yyvsp[(3) - (3)].str));
2273 ;}
2274 break;
2275
2276 case 52:
2277
2278 /* Line 1464 of yacc.c */
2279 #line 418 "glcpp/glcpp-parse.y"
2280 { (yyval.token_list) = NULL; ;}
2281 break;
2282
2283 case 54:
2284
2285 /* Line 1464 of yacc.c */
2286 #line 423 "glcpp/glcpp-parse.y"
2287 {
2288 yyerror (& (yylsp[(1) - (2)]), parser, "Invalid tokens after #");
2289 ;}
2290 break;
2291
2292 case 55:
2293
2294 /* Line 1464 of yacc.c */
2295 #line 429 "glcpp/glcpp-parse.y"
2296 { (yyval.token_list) = NULL; ;}
2297 break;
2298
2299 case 58:
2300
2301 /* Line 1464 of yacc.c */
2302 #line 435 "glcpp/glcpp-parse.y"
2303 {
2304 glcpp_warning(&(yylsp[(1) - (1)]), parser, "extra tokens at end of directive");
2305 ;}
2306 break;
2307
2308 case 59:
2309
2310 /* Line 1464 of yacc.c */
2311 #line 442 "glcpp/glcpp-parse.y"
2312 {
2313 int v = hash_table_find (parser->defines, (yyvsp[(2) - (2)].str)) ? 1 : 0;
2314 (yyval.token) = _token_create_ival (parser, INTEGER, v);
2315 ;}
2316 break;
2317
2318 case 60:
2319
2320 /* Line 1464 of yacc.c */
2321 #line 446 "glcpp/glcpp-parse.y"
2322 {
2323 int v = hash_table_find (parser->defines, (yyvsp[(3) - (4)].str)) ? 1 : 0;
2324 (yyval.token) = _token_create_ival (parser, INTEGER, v);
2325 ;}
2326 break;
2327
2328 case 62:
2329
2330 /* Line 1464 of yacc.c */
2331 #line 455 "glcpp/glcpp-parse.y"
2332 {
2333 parser->space_tokens = 1;
2334 (yyval.token_list) = _token_list_create (parser);
2335 _token_list_append ((yyval.token_list), (yyvsp[(1) - (1)].token));
2336 talloc_unlink (parser, (yyvsp[(1) - (1)].token));
2337 ;}
2338 break;
2339
2340 case 63:
2341
2342 /* Line 1464 of yacc.c */
2343 #line 461 "glcpp/glcpp-parse.y"
2344 {
2345 (yyval.token_list) = (yyvsp[(1) - (2)].token_list);
2346 _token_list_append ((yyval.token_list), (yyvsp[(2) - (2)].token));
2347 talloc_unlink (parser, (yyvsp[(2) - (2)].token));
2348 ;}
2349 break;
2350
2351 case 64:
2352
2353 /* Line 1464 of yacc.c */
2354 #line 469 "glcpp/glcpp-parse.y"
2355 {
2356 parser->space_tokens = 1;
2357 (yyval.token_list) = _token_list_create (parser);
2358 _token_list_append ((yyval.token_list), (yyvsp[(1) - (1)].token));
2359 talloc_unlink (parser, (yyvsp[(1) - (1)].token));
2360 ;}
2361 break;
2362
2363 case 65:
2364
2365 /* Line 1464 of yacc.c */
2366 #line 475 "glcpp/glcpp-parse.y"
2367 {
2368 (yyval.token_list) = (yyvsp[(1) - (2)].token_list);
2369 _token_list_append ((yyval.token_list), (yyvsp[(2) - (2)].token));
2370 talloc_unlink (parser, (yyvsp[(2) - (2)].token));
2371 ;}
2372 break;
2373
2374 case 66:
2375
2376 /* Line 1464 of yacc.c */
2377 #line 483 "glcpp/glcpp-parse.y"
2378 {
2379 (yyval.token) = _token_create_str (parser, IDENTIFIER, (yyvsp[(1) - (1)].str));
2380 (yyval.token)->location = yylloc;
2381 ;}
2382 break;
2383
2384 case 67:
2385
2386 /* Line 1464 of yacc.c */
2387 #line 487 "glcpp/glcpp-parse.y"
2388 {
2389 (yyval.token) = _token_create_str (parser, INTEGER_STRING, (yyvsp[(1) - (1)].str));
2390 (yyval.token)->location = yylloc;
2391 ;}
2392 break;
2393
2394 case 68:
2395
2396 /* Line 1464 of yacc.c */
2397 #line 491 "glcpp/glcpp-parse.y"
2398 {
2399 (yyval.token) = _token_create_ival (parser, (yyvsp[(1) - (1)].ival), (yyvsp[(1) - (1)].ival));
2400 (yyval.token)->location = yylloc;
2401 ;}
2402 break;
2403
2404 case 69:
2405
2406 /* Line 1464 of yacc.c */
2407 #line 495 "glcpp/glcpp-parse.y"
2408 {
2409 (yyval.token) = _token_create_str (parser, OTHER, (yyvsp[(1) - (1)].str));
2410 (yyval.token)->location = yylloc;
2411 ;}
2412 break;
2413
2414 case 70:
2415
2416 /* Line 1464 of yacc.c */
2417 #line 499 "glcpp/glcpp-parse.y"
2418 {
2419 (yyval.token) = _token_create_ival (parser, SPACE, SPACE);
2420 (yyval.token)->location = yylloc;
2421 ;}
2422 break;
2423
2424 case 71:
2425
2426 /* Line 1464 of yacc.c */
2427 #line 506 "glcpp/glcpp-parse.y"
2428 { (yyval.ival) = '['; ;}
2429 break;
2430
2431 case 72:
2432
2433 /* Line 1464 of yacc.c */
2434 #line 507 "glcpp/glcpp-parse.y"
2435 { (yyval.ival) = ']'; ;}
2436 break;
2437
2438 case 73:
2439
2440 /* Line 1464 of yacc.c */
2441 #line 508 "glcpp/glcpp-parse.y"
2442 { (yyval.ival) = '('; ;}
2443 break;
2444
2445 case 74:
2446
2447 /* Line 1464 of yacc.c */
2448 #line 509 "glcpp/glcpp-parse.y"
2449 { (yyval.ival) = ')'; ;}
2450 break;
2451
2452 case 75:
2453
2454 /* Line 1464 of yacc.c */
2455 #line 510 "glcpp/glcpp-parse.y"
2456 { (yyval.ival) = '{'; ;}
2457 break;
2458
2459 case 76:
2460
2461 /* Line 1464 of yacc.c */
2462 #line 511 "glcpp/glcpp-parse.y"
2463 { (yyval.ival) = '}'; ;}
2464 break;
2465
2466 case 77:
2467
2468 /* Line 1464 of yacc.c */
2469 #line 512 "glcpp/glcpp-parse.y"
2470 { (yyval.ival) = '.'; ;}
2471 break;
2472
2473 case 78:
2474
2475 /* Line 1464 of yacc.c */
2476 #line 513 "glcpp/glcpp-parse.y"
2477 { (yyval.ival) = '&'; ;}
2478 break;
2479
2480 case 79:
2481
2482 /* Line 1464 of yacc.c */
2483 #line 514 "glcpp/glcpp-parse.y"
2484 { (yyval.ival) = '*'; ;}
2485 break;
2486
2487 case 80:
2488
2489 /* Line 1464 of yacc.c */
2490 #line 515 "glcpp/glcpp-parse.y"
2491 { (yyval.ival) = '+'; ;}
2492 break;
2493
2494 case 81:
2495
2496 /* Line 1464 of yacc.c */
2497 #line 516 "glcpp/glcpp-parse.y"
2498 { (yyval.ival) = '-'; ;}
2499 break;
2500
2501 case 82:
2502
2503 /* Line 1464 of yacc.c */
2504 #line 517 "glcpp/glcpp-parse.y"
2505 { (yyval.ival) = '~'; ;}
2506 break;
2507
2508 case 83:
2509
2510 /* Line 1464 of yacc.c */
2511 #line 518 "glcpp/glcpp-parse.y"
2512 { (yyval.ival) = '!'; ;}
2513 break;
2514
2515 case 84:
2516
2517 /* Line 1464 of yacc.c */
2518 #line 519 "glcpp/glcpp-parse.y"
2519 { (yyval.ival) = '/'; ;}
2520 break;
2521
2522 case 85:
2523
2524 /* Line 1464 of yacc.c */
2525 #line 520 "glcpp/glcpp-parse.y"
2526 { (yyval.ival) = '%'; ;}
2527 break;
2528
2529 case 86:
2530
2531 /* Line 1464 of yacc.c */
2532 #line 521 "glcpp/glcpp-parse.y"
2533 { (yyval.ival) = LEFT_SHIFT; ;}
2534 break;
2535
2536 case 87:
2537
2538 /* Line 1464 of yacc.c */
2539 #line 522 "glcpp/glcpp-parse.y"
2540 { (yyval.ival) = RIGHT_SHIFT; ;}
2541 break;
2542
2543 case 88:
2544
2545 /* Line 1464 of yacc.c */
2546 #line 523 "glcpp/glcpp-parse.y"
2547 { (yyval.ival) = '<'; ;}
2548 break;
2549
2550 case 89:
2551
2552 /* Line 1464 of yacc.c */
2553 #line 524 "glcpp/glcpp-parse.y"
2554 { (yyval.ival) = '>'; ;}
2555 break;
2556
2557 case 90:
2558
2559 /* Line 1464 of yacc.c */
2560 #line 525 "glcpp/glcpp-parse.y"
2561 { (yyval.ival) = LESS_OR_EQUAL; ;}
2562 break;
2563
2564 case 91:
2565
2566 /* Line 1464 of yacc.c */
2567 #line 526 "glcpp/glcpp-parse.y"
2568 { (yyval.ival) = GREATER_OR_EQUAL; ;}
2569 break;
2570
2571 case 92:
2572
2573 /* Line 1464 of yacc.c */
2574 #line 527 "glcpp/glcpp-parse.y"
2575 { (yyval.ival) = EQUAL; ;}
2576 break;
2577
2578 case 93:
2579
2580 /* Line 1464 of yacc.c */
2581 #line 528 "glcpp/glcpp-parse.y"
2582 { (yyval.ival) = NOT_EQUAL; ;}
2583 break;
2584
2585 case 94:
2586
2587 /* Line 1464 of yacc.c */
2588 #line 529 "glcpp/glcpp-parse.y"
2589 { (yyval.ival) = '^'; ;}
2590 break;
2591
2592 case 95:
2593
2594 /* Line 1464 of yacc.c */
2595 #line 530 "glcpp/glcpp-parse.y"
2596 { (yyval.ival) = '|'; ;}
2597 break;
2598
2599 case 96:
2600
2601 /* Line 1464 of yacc.c */
2602 #line 531 "glcpp/glcpp-parse.y"
2603 { (yyval.ival) = AND; ;}
2604 break;
2605
2606 case 97:
2607
2608 /* Line 1464 of yacc.c */
2609 #line 532 "glcpp/glcpp-parse.y"
2610 { (yyval.ival) = OR; ;}
2611 break;
2612
2613 case 98:
2614
2615 /* Line 1464 of yacc.c */
2616 #line 533 "glcpp/glcpp-parse.y"
2617 { (yyval.ival) = ';'; ;}
2618 break;
2619
2620 case 99:
2621
2622 /* Line 1464 of yacc.c */
2623 #line 534 "glcpp/glcpp-parse.y"
2624 { (yyval.ival) = ','; ;}
2625 break;
2626
2627 case 100:
2628
2629 /* Line 1464 of yacc.c */
2630 #line 535 "glcpp/glcpp-parse.y"
2631 { (yyval.ival) = '='; ;}
2632 break;
2633
2634 case 101:
2635
2636 /* Line 1464 of yacc.c */
2637 #line 536 "glcpp/glcpp-parse.y"
2638 { (yyval.ival) = PASTE; ;}
2639 break;
2640
2641
2642
2643 /* Line 1464 of yacc.c */
2644 #line 2645 "glcpp/glcpp-parse.c"
2645 default: break;
2646 }
2647 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
2648
2649 YYPOPSTACK (yylen);
2650 yylen = 0;
2651 YY_STACK_PRINT (yyss, yyssp);
2652
2653 *++yyvsp = yyval;
2654 *++yylsp = yyloc;
2655
2656 /* Now `shift' the result of the reduction. Determine what state
2657 that goes to, based on the state we popped back to and the rule
2658 number reduced by. */
2659
2660 yyn = yyr1[yyn];
2661
2662 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
2663 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2664 yystate = yytable[yystate];
2665 else
2666 yystate = yydefgoto[yyn - YYNTOKENS];
2667
2668 goto yynewstate;
2669
2670
2671 /*------------------------------------.
2672 | yyerrlab -- here on detecting error |
2673 `------------------------------------*/
2674 yyerrlab:
2675 /* If not already recovering from an error, report this error. */
2676 if (!yyerrstatus)
2677 {
2678 ++yynerrs;
2679 #if ! YYERROR_VERBOSE
2680 yyerror (&yylloc, parser, YY_("syntax error"));
2681 #else
2682 {
2683 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
2684 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
2685 {
2686 YYSIZE_T yyalloc = 2 * yysize;
2687 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
2688 yyalloc = YYSTACK_ALLOC_MAXIMUM;
2689 if (yymsg != yymsgbuf)
2690 YYSTACK_FREE (yymsg);
2691 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
2692 if (yymsg)
2693 yymsg_alloc = yyalloc;
2694 else
2695 {
2696 yymsg = yymsgbuf;
2697 yymsg_alloc = sizeof yymsgbuf;
2698 }
2699 }
2700
2701 if (0 < yysize && yysize <= yymsg_alloc)
2702 {
2703 (void) yysyntax_error (yymsg, yystate, yychar);
2704 yyerror (&yylloc, parser, yymsg);
2705 }
2706 else
2707 {
2708 yyerror (&yylloc, parser, YY_("syntax error"));
2709 if (yysize != 0)
2710 goto yyexhaustedlab;
2711 }
2712 }
2713 #endif
2714 }
2715
2716 yyerror_range[1] = yylloc;
2717
2718 if (yyerrstatus == 3)
2719 {
2720 /* If just tried and failed to reuse lookahead token after an
2721 error, discard it. */
2722
2723 if (yychar <= YYEOF)
2724 {
2725 /* Return failure if at end of input. */
2726 if (yychar == YYEOF)
2727 YYABORT;
2728 }
2729 else
2730 {
2731 yydestruct ("Error: discarding",
2732 yytoken, &yylval, &yylloc, parser);
2733 yychar = YYEMPTY;
2734 }
2735 }
2736
2737 /* Else will try to reuse lookahead token after shifting the error
2738 token. */
2739 goto yyerrlab1;
2740
2741
2742 /*---------------------------------------------------.
2743 | yyerrorlab -- error raised explicitly by YYERROR. |
2744 `---------------------------------------------------*/
2745 yyerrorlab:
2746
2747 /* Pacify compilers like GCC when the user code never invokes
2748 YYERROR and the label yyerrorlab therefore never appears in user
2749 code. */
2750 if (/*CONSTCOND*/ 0)
2751 goto yyerrorlab;
2752
2753 yyerror_range[1] = yylsp[1-yylen];
2754 /* Do not reclaim the symbols of the rule which action triggered
2755 this YYERROR. */
2756 YYPOPSTACK (yylen);
2757 yylen = 0;
2758 YY_STACK_PRINT (yyss, yyssp);
2759 yystate = *yyssp;
2760 goto yyerrlab1;
2761
2762
2763 /*-------------------------------------------------------------.
2764 | yyerrlab1 -- common code for both syntax error and YYERROR. |
2765 `-------------------------------------------------------------*/
2766 yyerrlab1:
2767 yyerrstatus = 3; /* Each real token shifted decrements this. */
2768
2769 for (;;)
2770 {
2771 yyn = yypact[yystate];
2772 if (yyn != YYPACT_NINF)
2773 {
2774 yyn += YYTERROR;
2775 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
2776 {
2777 yyn = yytable[yyn];
2778 if (0 < yyn)
2779 break;
2780 }
2781 }
2782
2783 /* Pop the current state because it cannot handle the error token. */
2784 if (yyssp == yyss)
2785 YYABORT;
2786
2787 yyerror_range[1] = *yylsp;
2788 yydestruct ("Error: popping",
2789 yystos[yystate], yyvsp, yylsp, parser);
2790 YYPOPSTACK (1);
2791 yystate = *yyssp;
2792 YY_STACK_PRINT (yyss, yyssp);
2793 }
2794
2795 *++yyvsp = yylval;
2796
2797 yyerror_range[2] = yylloc;
2798 /* Using YYLLOC is tempting, but would change the location of
2799 the lookahead. YYLOC is available though. */
2800 YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
2801 *++yylsp = yyloc;
2802
2803 /* Shift the error token. */
2804 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
2805
2806 yystate = yyn;
2807 goto yynewstate;
2808
2809
2810 /*-------------------------------------.
2811 | yyacceptlab -- YYACCEPT comes here. |
2812 `-------------------------------------*/
2813 yyacceptlab:
2814 yyresult = 0;
2815 goto yyreturn;
2816
2817 /*-----------------------------------.
2818 | yyabortlab -- YYABORT comes here. |
2819 `-----------------------------------*/
2820 yyabortlab:
2821 yyresult = 1;
2822 goto yyreturn;
2823
2824 #if !defined(yyoverflow) || YYERROR_VERBOSE
2825 /*-------------------------------------------------.
2826 | yyexhaustedlab -- memory exhaustion comes here. |
2827 `-------------------------------------------------*/
2828 yyexhaustedlab:
2829 yyerror (&yylloc, parser, YY_("memory exhausted"));
2830 yyresult = 2;
2831 /* Fall through. */
2832 #endif
2833
2834 yyreturn:
2835 if (yychar != YYEMPTY)
2836 yydestruct ("Cleanup: discarding lookahead",
2837 yytoken, &yylval, &yylloc, parser);
2838 /* Do not reclaim the symbols of the rule which action triggered
2839 this YYABORT or YYACCEPT. */
2840 YYPOPSTACK (yylen);
2841 YY_STACK_PRINT (yyss, yyssp);
2842 while (yyssp != yyss)
2843 {
2844 yydestruct ("Cleanup: popping",
2845 yystos[*yyssp], yyvsp, yylsp, parser);
2846 YYPOPSTACK (1);
2847 }
2848 #ifndef yyoverflow
2849 if (yyss != yyssa)
2850 YYSTACK_FREE (yyss);
2851 #endif
2852 #if YYERROR_VERBOSE
2853 if (yymsg != yymsgbuf)
2854 YYSTACK_FREE (yymsg);
2855 #endif
2856 /* Make sure YYID is used. */
2857 return YYID (yyresult);
2858 }
2859
2860
2861
2862 /* Line 1684 of yacc.c */
2863 #line 539 "glcpp/glcpp-parse.y"
2864
2865
2866 string_list_t *
2867 _string_list_create (void *ctx)
2868 {
2869 string_list_t *list;
2870
2871 list = talloc (ctx, string_list_t);
2872 list->head = NULL;
2873 list->tail = NULL;
2874
2875 return list;
2876 }
2877
2878 void
2879 _string_list_append_item (string_list_t *list, const char *str)
2880 {
2881 string_node_t *node;
2882
2883 node = talloc (list, string_node_t);
2884 node->str = talloc_strdup (node, str);
2885
2886 node->next = NULL;
2887
2888 if (list->head == NULL) {
2889 list->head = node;
2890 } else {
2891 list->tail->next = node;
2892 }
2893
2894 list->tail = node;
2895 }
2896
2897 int
2898 _string_list_contains (string_list_t *list, const char *member, int *index)
2899 {
2900 string_node_t *node;
2901 int i;
2902
2903 if (list == NULL)
2904 return 0;
2905
2906 for (i = 0, node = list->head; node; i++, node = node->next) {
2907 if (strcmp (node->str, member) == 0) {
2908 if (index)
2909 *index = i;
2910 return 1;
2911 }
2912 }
2913
2914 return 0;
2915 }
2916
2917 int
2918 _string_list_length (string_list_t *list)
2919 {
2920 int length = 0;
2921 string_node_t *node;
2922
2923 if (list == NULL)
2924 return 0;
2925
2926 for (node = list->head; node; node = node->next)
2927 length++;
2928
2929 return length;
2930 }
2931
2932 argument_list_t *
2933 _argument_list_create (void *ctx)
2934 {
2935 argument_list_t *list;
2936
2937 list = talloc (ctx, argument_list_t);
2938 list->head = NULL;
2939 list->tail = NULL;
2940
2941 return list;
2942 }
2943
2944 void
2945 _argument_list_append (argument_list_t *list, token_list_t *argument)
2946 {
2947 argument_node_t *node;
2948
2949 node = talloc (list, argument_node_t);
2950 node->argument = argument;
2951
2952 node->next = NULL;
2953
2954 if (list->head == NULL) {
2955 list->head = node;
2956 } else {
2957 list->tail->next = node;
2958 }
2959
2960 list->tail = node;
2961 }
2962
2963 int
2964 _argument_list_length (argument_list_t *list)
2965 {
2966 int length = 0;
2967 argument_node_t *node;
2968
2969 if (list == NULL)
2970 return 0;
2971
2972 for (node = list->head; node; node = node->next)
2973 length++;
2974
2975 return length;
2976 }
2977
2978 token_list_t *
2979 _argument_list_member_at (argument_list_t *list, int index)
2980 {
2981 argument_node_t *node;
2982 int i;
2983
2984 if (list == NULL)
2985 return NULL;
2986
2987 node = list->head;
2988 for (i = 0; i < index; i++) {
2989 node = node->next;
2990 if (node == NULL)
2991 break;
2992 }
2993
2994 if (node)
2995 return node->argument;
2996
2997 return NULL;
2998 }
2999
3000 /* Note: This function talloc_steal()s the str pointer. */
3001 token_t *
3002 _token_create_str (void *ctx, int type, char *str)
3003 {
3004 token_t *token;
3005
3006 token = talloc (ctx, token_t);
3007 token->type = type;
3008 token->value.str = talloc_steal (token, str);
3009
3010 return token;
3011 }
3012
3013 token_t *
3014 _token_create_ival (void *ctx, int type, int ival)
3015 {
3016 token_t *token;
3017
3018 token = talloc (ctx, token_t);
3019 token->type = type;
3020 token->value.ival = ival;
3021
3022 return token;
3023 }
3024
3025 token_list_t *
3026 _token_list_create (void *ctx)
3027 {
3028 token_list_t *list;
3029
3030 list = talloc (ctx, token_list_t);
3031 list->head = NULL;
3032 list->tail = NULL;
3033 list->non_space_tail = NULL;
3034
3035 return list;
3036 }
3037
3038 void
3039 _token_list_append (token_list_t *list, token_t *token)
3040 {
3041 token_node_t *node;
3042
3043 node = talloc (list, token_node_t);
3044 node->token = talloc_reference (list, token);
3045
3046 node->next = NULL;
3047
3048 if (list->head == NULL) {
3049 list->head = node;
3050 } else {
3051 list->tail->next = node;
3052 }
3053
3054 list->tail = node;
3055 if (token->type != SPACE)
3056 list->non_space_tail = node;
3057 }
3058
3059 void
3060 _token_list_append_list (token_list_t *list, token_list_t *tail)
3061 {
3062 if (tail == NULL || tail->head == NULL)
3063 return;
3064
3065 if (list->head == NULL) {
3066 list->head = tail->head;
3067 } else {
3068 list->tail->next = tail->head;
3069 }
3070
3071 list->tail = tail->tail;
3072 list->non_space_tail = tail->non_space_tail;
3073 }
3074
3075 static token_list_t *
3076 _token_list_copy (void *ctx, token_list_t *other)
3077 {
3078 token_list_t *copy;
3079 token_node_t *node;
3080
3081 if (other == NULL)
3082 return NULL;
3083
3084 copy = _token_list_create (ctx);
3085 for (node = other->head; node; node = node->next)
3086 _token_list_append (copy, node->token);
3087
3088 return copy;
3089 }
3090
3091 static void
3092 _token_list_trim_trailing_space (token_list_t *list)
3093 {
3094 token_node_t *tail, *next;
3095
3096 if (list->non_space_tail) {
3097 tail = list->non_space_tail->next;
3098 list->non_space_tail->next = NULL;
3099 list->tail = list->non_space_tail;
3100
3101 while (tail) {
3102 next = tail->next;
3103 talloc_free (tail);
3104 tail = next;
3105 }
3106 }
3107 }
3108
3109 static void
3110 _token_print (char **out, token_t *token)
3111 {
3112 if (token->type < 256) {
3113 glcpp_printf (*out, "%c", token->type);
3114 return;
3115 }
3116
3117 switch (token->type) {
3118 case INTEGER:
3119 glcpp_printf (*out, "%" PRIiMAX, token->value.ival);
3120 break;
3121 case IDENTIFIER:
3122 case INTEGER_STRING:
3123 case OTHER:
3124 glcpp_print (*out, token->value.str);
3125 break;
3126 case SPACE:
3127 glcpp_print (*out, " ");
3128 break;
3129 case LEFT_SHIFT:
3130 glcpp_print (*out, "<<");
3131 break;
3132 case RIGHT_SHIFT:
3133 glcpp_print (*out, ">>");
3134 break;
3135 case LESS_OR_EQUAL:
3136 glcpp_print (*out, "<=");
3137 break;
3138 case GREATER_OR_EQUAL:
3139 glcpp_print (*out, ">=");
3140 break;
3141 case EQUAL:
3142 glcpp_print (*out, "==");
3143 break;
3144 case NOT_EQUAL:
3145 glcpp_print (*out, "!=");
3146 break;
3147 case AND:
3148 glcpp_print (*out, "&&");
3149 break;
3150 case OR:
3151 glcpp_print (*out, "||");
3152 break;
3153 case PASTE:
3154 glcpp_print (*out, "##");
3155 break;
3156 case COMMA_FINAL:
3157 glcpp_print (*out, ",");
3158 break;
3159 case PLACEHOLDER:
3160 /* Nothing to print. */
3161 break;
3162 default:
3163 assert(!"Error: Don't know how to print token.");
3164 break;
3165 }
3166 }
3167
3168 /* Return a new token (talloc()ed off of 'token') formed by pasting
3169 * 'token' and 'other'. Note that this function may return 'token' or
3170 * 'other' directly rather than allocating anything new.
3171 *
3172 * Caution: Only very cursory error-checking is performed to see if
3173 * the final result is a valid single token. */
3174 static token_t *
3175 _token_paste (glcpp_parser_t *parser, token_t *token, token_t *other)
3176 {
3177 token_t *combined = NULL;
3178
3179 /* Pasting a placeholder onto anything makes no change. */
3180 if (other->type == PLACEHOLDER)
3181 return token;
3182
3183 /* When 'token' is a placeholder, just return 'other'. */
3184 if (token->type == PLACEHOLDER)
3185 return other;
3186
3187 /* A very few single-character punctuators can be combined
3188 * with another to form a multi-character punctuator. */
3189 switch (token->type) {
3190 case '<':
3191 if (other->type == '<')
3192 combined = _token_create_ival (token, LEFT_SHIFT, LEFT_SHIFT);
3193 else if (other->type == '=')
3194 combined = _token_create_ival (token, LESS_OR_EQUAL, LESS_OR_EQUAL);
3195 break;
3196 case '>':
3197 if (other->type == '>')
3198 combined = _token_create_ival (token, RIGHT_SHIFT, RIGHT_SHIFT);
3199 else if (other->type == '=')
3200 combined = _token_create_ival (token, GREATER_OR_EQUAL, GREATER_OR_EQUAL);
3201 break;
3202 case '=':
3203 if (other->type == '=')
3204 combined = _token_create_ival (token, EQUAL, EQUAL);
3205 break;
3206 case '!':
3207 if (other->type == '=')
3208 combined = _token_create_ival (token, NOT_EQUAL, NOT_EQUAL);
3209 break;
3210 case '&':
3211 if (other->type == '&')
3212 combined = _token_create_ival (token, AND, AND);
3213 break;
3214 case '|':
3215 if (other->type == '|')
3216 combined = _token_create_ival (token, OR, OR);
3217 break;
3218 }
3219
3220 if (combined != NULL) {
3221 /* Inherit the location from the first token */
3222 combined->location = token->location;
3223 return combined;
3224 }
3225
3226 /* Two string-valued tokens can usually just be mashed
3227 * together.
3228 *
3229 * XXX: This isn't actually legitimate. Several things here
3230 * should result in a diagnostic since the result cannot be a
3231 * valid, single pre-processing token. For example, pasting
3232 * "123" and "abc" is not legal, but we don't catch that
3233 * here. */
3234 if ((token->type == IDENTIFIER || token->type == OTHER || token->type == INTEGER_STRING) &&
3235 (other->type == IDENTIFIER || other->type == OTHER || other->type == INTEGER_STRING))
3236 {
3237 char *str;
3238
3239 str = talloc_asprintf (token, "%s%s", token->value.str,
3240 other->value.str);
3241 combined = _token_create_str (token, token->type, str);
3242 combined->location = token->location;
3243 return combined;
3244 }
3245
3246 glcpp_error (&token->location, parser, "");
3247 glcpp_print (parser->info_log, "Pasting \"");
3248 _token_print (&parser->info_log, token);
3249 glcpp_print (parser->info_log, "\" and \"");
3250 _token_print (&parser->info_log, other);
3251 glcpp_print (parser->info_log, "\" does not give a valid preprocessing token.\n");
3252
3253 return token;
3254 }
3255
3256 static void
3257 _token_list_print (glcpp_parser_t *parser, token_list_t *list)
3258 {
3259 token_node_t *node;
3260
3261 if (list == NULL)
3262 return;
3263
3264 for (node = list->head; node; node = node->next)
3265 _token_print (&parser->output, node->token);
3266 }
3267
3268 void
3269 yyerror (YYLTYPE *locp, glcpp_parser_t *parser, const char *error)
3270 {
3271 glcpp_error(locp, parser, "%s", error);
3272 }
3273
3274 static void add_builtin_define(glcpp_parser_t *parser,
3275 const char *name, int value)
3276 {
3277 token_t *tok;
3278 token_list_t *list;
3279
3280 tok = _token_create_ival (parser, INTEGER, value);
3281
3282 list = _token_list_create(parser);
3283 _token_list_append(list, tok);
3284 _define_object_macro(parser, NULL, name, list);
3285
3286 talloc_unlink(parser, tok);
3287 }
3288
3289 glcpp_parser_t *
3290 glcpp_parser_create (const struct gl_extensions *extensions)
3291 {
3292 glcpp_parser_t *parser;
3293 int language_version;
3294
3295 parser = talloc (NULL, glcpp_parser_t);
3296
3297 glcpp_lex_init_extra (parser, &parser->scanner);
3298 parser->defines = hash_table_ctor (32, hash_table_string_hash,
3299 hash_table_string_compare);
3300 parser->active = NULL;
3301 parser->lexing_if = 0;
3302 parser->space_tokens = 1;
3303 parser->newline_as_space = 0;
3304 parser->in_control_line = 0;
3305 parser->paren_count = 0;
3306
3307 parser->skip_stack = NULL;
3308
3309 parser->lex_from_list = NULL;
3310 parser->lex_from_node = NULL;
3311
3312 parser->output = talloc_strdup(parser, "");
3313 parser->info_log = talloc_strdup(parser, "");
3314 parser->error = 0;
3315
3316 /* Add pre-defined macros. */
3317 add_builtin_define(parser, "GL_ARB_draw_buffers", 1);
3318 add_builtin_define(parser, "GL_ARB_texture_rectangle", 1);
3319
3320 if (extensions != NULL) {
3321 if (extensions->EXT_texture_array) {
3322 add_builtin_define(parser, "GL_EXT_texture_array", 1);
3323 }
3324
3325 if (extensions->ARB_fragment_coord_conventions)
3326 add_builtin_define(parser, "GL_ARB_fragment_coord_conventions",
3327 1);
3328 }
3329
3330 language_version = 110;
3331 add_builtin_define(parser, "__VERSION__", language_version);
3332
3333 return parser;
3334 }
3335
3336 int
3337 glcpp_parser_parse (glcpp_parser_t *parser)
3338 {
3339 return yyparse (parser);
3340 }
3341
3342 void
3343 glcpp_parser_destroy (glcpp_parser_t *parser)
3344 {
3345 glcpp_lex_destroy (parser->scanner);
3346 hash_table_dtor (parser->defines);
3347 talloc_free (parser);
3348 }
3349
3350 typedef enum function_status
3351 {
3352 FUNCTION_STATUS_SUCCESS,
3353 FUNCTION_NOT_A_FUNCTION,
3354 FUNCTION_UNBALANCED_PARENTHESES
3355 } function_status_t;
3356
3357 /* Find a set of function-like macro arguments by looking for a
3358 * balanced set of parentheses.
3359 *
3360 * When called, 'node' should be the opening-parenthesis token, (or
3361 * perhaps preceeding SPACE tokens). Upon successful return *last will
3362 * be the last consumed node, (corresponding to the closing right
3363 * parenthesis).
3364 *
3365 * Return values:
3366 *
3367 * FUNCTION_STATUS_SUCCESS:
3368 *
3369 * Successfully parsed a set of function arguments.
3370 *
3371 * FUNCTION_NOT_A_FUNCTION:
3372 *
3373 * Macro name not followed by a '('. This is not an error, but
3374 * simply that the macro name should be treated as a non-macro.
3375 *
3376 * FUNCTION_UNBALANCED_PARENTHESES
3377 *
3378 * Macro name is not followed by a balanced set of parentheses.
3379 */
3380 static function_status_t
3381 _arguments_parse (argument_list_t *arguments,
3382 token_node_t *node,
3383 token_node_t **last)
3384 {
3385 token_list_t *argument;
3386 int paren_count;
3387
3388 node = node->next;
3389
3390 /* Ignore whitespace before first parenthesis. */
3391 while (node && node->token->type == SPACE)
3392 node = node->next;
3393
3394 if (node == NULL || node->token->type != '(')
3395 return FUNCTION_NOT_A_FUNCTION;
3396
3397 node = node->next;
3398
3399 argument = _token_list_create (arguments);
3400 _argument_list_append (arguments, argument);
3401
3402 for (paren_count = 1; node; node = node->next) {
3403 if (node->token->type == '(')
3404 {
3405 paren_count++;
3406 }
3407 else if (node->token->type == ')')
3408 {
3409 paren_count--;
3410 if (paren_count == 0)
3411 break;
3412 }
3413
3414 if (node->token->type == ',' &&
3415 paren_count == 1)
3416 {
3417 _token_list_trim_trailing_space (argument);
3418 argument = _token_list_create (arguments);
3419 _argument_list_append (arguments, argument);
3420 }
3421 else {
3422 if (argument->head == NULL) {
3423 /* Don't treat initial whitespace as
3424 * part of the arguement. */
3425 if (node->token->type == SPACE)
3426 continue;
3427 }
3428 _token_list_append (argument, node->token);
3429 }
3430 }
3431
3432 if (paren_count)
3433 return FUNCTION_UNBALANCED_PARENTHESES;
3434
3435 *last = node;
3436
3437 return FUNCTION_STATUS_SUCCESS;
3438 }
3439
3440 static token_list_t *
3441 _token_list_create_with_one_space (void *ctx)
3442 {
3443 token_list_t *list;
3444 token_t *space;
3445
3446 list = _token_list_create (ctx);
3447 space = _token_create_ival (list, SPACE, SPACE);
3448 _token_list_append (list, space);
3449
3450 return list;
3451 }
3452
3453 static void
3454 _glcpp_parser_expand_if (glcpp_parser_t *parser, int type, token_list_t *list)
3455 {
3456 token_list_t *expanded;
3457 token_t *token;
3458
3459 expanded = _token_list_create (parser);
3460 token = _token_create_ival (parser, type, type);
3461 _token_list_append (expanded, token);
3462 _glcpp_parser_expand_token_list (parser, list);
3463 _token_list_append_list (expanded, list);
3464 glcpp_parser_lex_from (parser, expanded);
3465 }
3466
3467 /* This is a helper function that's essentially part of the
3468 * implementation of _glcpp_parser_expand_node. It shouldn't be called
3469 * except for by that function.
3470 *
3471 * Returns NULL if node is a simple token with no expansion, (that is,
3472 * although 'node' corresponds to an identifier defined as a
3473 * function-like macro, it is not followed with a parenthesized
3474 * argument list).
3475 *
3476 * Compute the complete expansion of node (which is a function-like
3477 * macro) and subsequent nodes which are arguments.
3478 *
3479 * Returns the token list that results from the expansion and sets
3480 * *last to the last node in the list that was consumed by the
3481 * expansion. Specifically, *last will be set as follows: as the
3482 * token of the closing right parenthesis.
3483 */
3484 static token_list_t *
3485 _glcpp_parser_expand_function (glcpp_parser_t *parser,
3486 token_node_t *node,
3487 token_node_t **last)
3488
3489 {
3490 macro_t *macro;
3491 const char *identifier;
3492 argument_list_t *arguments;
3493 function_status_t status;
3494 token_list_t *substituted;
3495 int parameter_index;
3496
3497 identifier = node->token->value.str;
3498
3499 macro = hash_table_find (parser->defines, identifier);
3500
3501 assert (macro->is_function);
3502
3503 arguments = _argument_list_create (parser);
3504 status = _arguments_parse (arguments, node, last);
3505
3506 switch (status) {
3507 case FUNCTION_STATUS_SUCCESS:
3508 break;
3509 case FUNCTION_NOT_A_FUNCTION:
3510 return NULL;
3511 case FUNCTION_UNBALANCED_PARENTHESES:
3512 glcpp_error (&node->token->location, parser, "Macro %s call has unbalanced parentheses\n", identifier);
3513 return NULL;
3514 }
3515
3516 /* Replace a macro defined as empty with a SPACE token. */
3517 if (macro->replacements == NULL) {
3518 talloc_free (arguments);
3519 return _token_list_create_with_one_space (parser);
3520 }
3521
3522 if (! ((_argument_list_length (arguments) ==
3523 _string_list_length (macro->parameters)) ||
3524 (_string_list_length (macro->parameters) == 0 &&
3525 _argument_list_length (arguments) == 1 &&
3526 arguments->head->argument->head == NULL)))
3527 {
3528 glcpp_error (&node->token->location, parser,
3529 "Error: macro %s invoked with %d arguments (expected %d)\n",
3530 identifier,
3531 _argument_list_length (arguments),
3532 _string_list_length (macro->parameters));
3533 return NULL;
3534 }
3535
3536 /* Perform argument substitution on the replacement list. */
3537 substituted = _token_list_create (arguments);
3538
3539 for (node = macro->replacements->head; node; node = node->next)
3540 {
3541 if (node->token->type == IDENTIFIER &&
3542 _string_list_contains (macro->parameters,
3543 node->token->value.str,
3544 &parameter_index))
3545 {
3546 token_list_t *argument;
3547 argument = _argument_list_member_at (arguments,
3548 parameter_index);
3549 /* Before substituting, we expand the argument
3550 * tokens, or append a placeholder token for
3551 * an empty argument. */
3552 if (argument->head) {
3553 token_list_t *expanded_argument;
3554 expanded_argument = _token_list_copy (parser,
3555 argument);
3556 _glcpp_parser_expand_token_list (parser,
3557 expanded_argument);
3558 _token_list_append_list (substituted,
3559 expanded_argument);
3560 } else {
3561 token_t *new_token;
3562
3563 new_token = _token_create_ival (substituted,
3564 PLACEHOLDER,
3565 PLACEHOLDER);
3566 _token_list_append (substituted, new_token);
3567 }
3568 } else {
3569 _token_list_append (substituted, node->token);
3570 }
3571 }
3572
3573 /* After argument substitution, and before further expansion
3574 * below, implement token pasting. */
3575
3576 _token_list_trim_trailing_space (substituted);
3577
3578 node = substituted->head;
3579 while (node)
3580 {
3581 token_node_t *next_non_space;
3582
3583 /* Look ahead for a PASTE token, skipping space. */
3584 next_non_space = node->next;
3585 while (next_non_space && next_non_space->token->type == SPACE)
3586 next_non_space = next_non_space->next;
3587
3588 if (next_non_space == NULL)
3589 break;
3590
3591 if (next_non_space->token->type != PASTE) {
3592 node = next_non_space;
3593 continue;
3594 }
3595
3596 /* Now find the next non-space token after the PASTE. */
3597 next_non_space = next_non_space->next;
3598 while (next_non_space && next_non_space->token->type == SPACE)
3599 next_non_space = next_non_space->next;
3600
3601 if (next_non_space == NULL) {
3602 yyerror (&node->token->location, parser, "'##' cannot appear at either end of a macro expansion\n");
3603 return NULL;
3604 }
3605
3606 node->token = _token_paste (parser, node->token, next_non_space->token);
3607 node->next = next_non_space->next;
3608 if (next_non_space == substituted->tail)
3609 substituted->tail = node;
3610
3611 node = node->next;
3612 }
3613
3614 substituted->non_space_tail = substituted->tail;
3615
3616 return substituted;
3617 }
3618
3619 /* Compute the complete expansion of node, (and subsequent nodes after
3620 * 'node' in the case that 'node' is a function-like macro and
3621 * subsequent nodes are arguments).
3622 *
3623 * Returns NULL if node is a simple token with no expansion.
3624 *
3625 * Otherwise, returns the token list that results from the expansion
3626 * and sets *last to the last node in the list that was consumed by
3627 * the expansion. Specifically, *last will be set as follows:
3628 *
3629 * As 'node' in the case of object-like macro expansion.
3630 *
3631 * As the token of the closing right parenthesis in the case of
3632 * function-like macro expansion.
3633 */
3634 static token_list_t *
3635 _glcpp_parser_expand_node (glcpp_parser_t *parser,
3636 token_node_t *node,
3637 token_node_t **last)
3638 {
3639 token_t *token = node->token;
3640 const char *identifier;
3641 macro_t *macro;
3642
3643 /* We only expand identifiers */
3644 if (token->type != IDENTIFIER) {
3645 /* We change any COMMA into a COMMA_FINAL to prevent
3646 * it being mistaken for an argument separator
3647 * later. */
3648 if (token->type == ',') {
3649 token->type = COMMA_FINAL;
3650 token->value.ival = COMMA_FINAL;
3651 }
3652
3653 return NULL;
3654 }
3655
3656 /* Look up this identifier in the hash table. */
3657 identifier = token->value.str;
3658 macro = hash_table_find (parser->defines, identifier);
3659
3660 /* Not a macro, so no expansion needed. */
3661 if (macro == NULL)
3662 return NULL;
3663
3664 /* Finally, don't expand this macro if we're already actively
3665 * expanding it, (to avoid infinite recursion). */
3666 if (_active_list_contains (parser->active, identifier)) {
3667 /* We change the token type here from IDENTIFIER to
3668 * OTHER to prevent any future expansion of this
3669 * unexpanded token. */
3670 char *str;
3671 token_list_t *expansion;
3672 token_t *final;
3673
3674 str = talloc_strdup (parser, token->value.str);
3675 final = _token_create_str (parser, OTHER, str);
3676 expansion = _token_list_create (parser);
3677 _token_list_append (expansion, final);
3678 *last = node;
3679 return expansion;
3680 }
3681
3682 if (! macro->is_function)
3683 {
3684 *last = node;
3685
3686 /* Replace a macro defined as empty with a SPACE token. */
3687 if (macro->replacements == NULL)
3688 return _token_list_create_with_one_space (parser);
3689
3690 return _token_list_copy (parser, macro->replacements);
3691 }
3692
3693 return _glcpp_parser_expand_function (parser, node, last);
3694 }
3695
3696 /* Push a new identifier onto the active list, returning the new list.
3697 *
3698 * Here, 'marker' is the token node that appears in the list after the
3699 * expansion of 'identifier'. That is, when the list iterator begins
3700 * examinging 'marker', then it is time to pop this node from the
3701 * active stack.
3702 */
3703 active_list_t *
3704 _active_list_push (active_list_t *list,
3705 const char *identifier,
3706 token_node_t *marker)
3707 {
3708 active_list_t *node;
3709
3710 node = talloc (list, active_list_t);
3711 node->identifier = talloc_strdup (node, identifier);
3712 node->marker = marker;
3713 node->next = list;
3714
3715 return node;
3716 }
3717
3718 active_list_t *
3719 _active_list_pop (active_list_t *list)
3720 {
3721 active_list_t *node = list;
3722
3723 if (node == NULL)
3724 return NULL;
3725
3726 node = list->next;
3727 talloc_free (list);
3728
3729 return node;
3730 }
3731
3732 int
3733 _active_list_contains (active_list_t *list, const char *identifier)
3734 {
3735 active_list_t *node;
3736
3737 if (list == NULL)
3738 return 0;
3739
3740 for (node = list; node; node = node->next)
3741 if (strcmp (node->identifier, identifier) == 0)
3742 return 1;
3743
3744 return 0;
3745 }
3746
3747 /* Walk over the token list replacing nodes with their expansion.
3748 * Whenever nodes are expanded the walking will walk over the new
3749 * nodes, continuing to expand as necessary. The results are placed in
3750 * 'list' itself;
3751 */
3752 static void
3753 _glcpp_parser_expand_token_list (glcpp_parser_t *parser,
3754 token_list_t *list)
3755 {
3756 token_node_t *node_prev;
3757 token_node_t *node, *last = NULL;
3758 token_list_t *expansion;
3759
3760 if (list == NULL)
3761 return;
3762
3763 _token_list_trim_trailing_space (list);
3764
3765 node_prev = NULL;
3766 node = list->head;
3767
3768 while (node) {
3769
3770 while (parser->active && parser->active->marker == node)
3771 parser->active = _active_list_pop (parser->active);
3772
3773 /* Find the expansion for node, which will replace all
3774 * nodes from node to last, inclusive. */
3775 expansion = _glcpp_parser_expand_node (parser, node, &last);
3776 if (expansion) {
3777 token_node_t *n;
3778
3779 for (n = node; n != last->next; n = n->next)
3780 while (parser->active &&
3781 parser->active->marker == n)
3782 {
3783 parser->active = _active_list_pop (parser->active);
3784 }
3785
3786 parser->active = _active_list_push (parser->active,
3787 node->token->value.str,
3788 last->next);
3789
3790 /* Splice expansion into list, supporting a
3791 * simple deletion if the expansion is
3792 * empty. */
3793 if (expansion->head) {
3794 if (node_prev)
3795 node_prev->next = expansion->head;
3796 else
3797 list->head = expansion->head;
3798 expansion->tail->next = last->next;
3799 if (last == list->tail)
3800 list->tail = expansion->tail;
3801 } else {
3802 if (node_prev)
3803 node_prev->next = last->next;
3804 else
3805 list->head = last->next;
3806 if (last == list->tail)
3807 list->tail = NULL;
3808 }
3809 } else {
3810 node_prev = node;
3811 }
3812 node = node_prev ? node_prev->next : list->head;
3813 }
3814
3815 while (parser->active)
3816 parser->active = _active_list_pop (parser->active);
3817
3818 list->non_space_tail = list->tail;
3819 }
3820
3821 void
3822 _glcpp_parser_print_expanded_token_list (glcpp_parser_t *parser,
3823 token_list_t *list)
3824 {
3825 if (list == NULL)
3826 return;
3827
3828 _glcpp_parser_expand_token_list (parser, list);
3829
3830 _token_list_trim_trailing_space (list);
3831
3832 _token_list_print (parser, list);
3833 }
3834
3835 static void
3836 _check_for_reserved_macro_name (glcpp_parser_t *parser, YYLTYPE *loc,
3837 const char *identifier)
3838 {
3839 /* According to the GLSL specification, macro names starting with "__"
3840 * or "GL_" are reserved for future use. So, don't allow them.
3841 */
3842 if (strncmp(identifier, "__", 2) == 0) {
3843 glcpp_error (loc, parser, "Macro names starting with \"__\" are reserved.\n");
3844 }
3845 if (strncmp(identifier, "GL_", 3) == 0) {
3846 glcpp_error (loc, parser, "Macro names starting with \"GL_\" are reserved.\n");
3847 }
3848 }
3849
3850 void
3851 _define_object_macro (glcpp_parser_t *parser,
3852 YYLTYPE *loc,
3853 const char *identifier,
3854 token_list_t *replacements)
3855 {
3856 macro_t *macro;
3857
3858 if (loc != NULL)
3859 _check_for_reserved_macro_name(parser, loc, identifier);
3860
3861 macro = talloc (parser, macro_t);
3862
3863 macro->is_function = 0;
3864 macro->parameters = NULL;
3865 macro->identifier = talloc_strdup (macro, identifier);
3866 macro->replacements = talloc_steal (macro, replacements);
3867
3868 hash_table_insert (parser->defines, macro, identifier);
3869 }
3870
3871 void
3872 _define_function_macro (glcpp_parser_t *parser,
3873 YYLTYPE *loc,
3874 const char *identifier,
3875 string_list_t *parameters,
3876 token_list_t *replacements)
3877 {
3878 macro_t *macro;
3879
3880 _check_for_reserved_macro_name(parser, loc, identifier);
3881
3882 macro = talloc (parser, macro_t);
3883
3884 macro->is_function = 1;
3885 macro->parameters = talloc_steal (macro, parameters);
3886 macro->identifier = talloc_strdup (macro, identifier);
3887 macro->replacements = talloc_steal (macro, replacements);
3888
3889 hash_table_insert (parser->defines, macro, identifier);
3890 }
3891
3892 static int
3893 glcpp_parser_lex (YYSTYPE *yylval, YYLTYPE *yylloc, glcpp_parser_t *parser)
3894 {
3895 token_node_t *node;
3896 int ret;
3897
3898 if (parser->lex_from_list == NULL) {
3899 ret = glcpp_lex (yylval, yylloc, parser->scanner);
3900
3901 /* XXX: This ugly block of code exists for the sole
3902 * purpose of converting a NEWLINE token into a SPACE
3903 * token, but only in the case where we have seen a
3904 * function-like macro name, but have not yet seen its
3905 * closing parenthesis.
3906 *
3907 * There's perhaps a more compact way to do this with
3908 * mid-rule actions in the grammar.
3909 *
3910 * I'm definitely not pleased with the complexity of
3911 * this code here.
3912 */
3913 if (parser->newline_as_space)
3914 {
3915 if (ret == '(') {
3916 parser->paren_count++;
3917 } else if (ret == ')') {
3918 parser->paren_count--;
3919 if (parser->paren_count == 0)
3920 parser->newline_as_space = 0;
3921 } else if (ret == NEWLINE) {
3922 ret = SPACE;
3923 } else if (ret != SPACE) {
3924 if (parser->paren_count == 0)
3925 parser->newline_as_space = 0;
3926 }
3927 }
3928 else if (parser->in_control_line)
3929 {
3930 if (ret == NEWLINE)
3931 parser->in_control_line = 0;
3932 }
3933 else if (ret == HASH_DEFINE_OBJ || ret == HASH_DEFINE_FUNC ||
3934 ret == HASH_UNDEF || ret == HASH_IF ||
3935 ret == HASH_IFDEF || ret == HASH_IFNDEF ||
3936 ret == HASH_ELIF || ret == HASH_ELSE ||
3937 ret == HASH_ENDIF || ret == HASH)
3938 {
3939 parser->in_control_line = 1;
3940 }
3941 else if (ret == IDENTIFIER)
3942 {
3943 macro_t *macro;
3944 macro = hash_table_find (parser->defines,
3945 yylval->str);
3946 if (macro && macro->is_function) {
3947 parser->newline_as_space = 1;
3948 parser->paren_count = 0;
3949 }
3950 }
3951
3952 return ret;
3953 }
3954
3955 node = parser->lex_from_node;
3956
3957 if (node == NULL) {
3958 talloc_free (parser->lex_from_list);
3959 parser->lex_from_list = NULL;
3960 return NEWLINE;
3961 }
3962
3963 *yylval = node->token->value;
3964 ret = node->token->type;
3965
3966 parser->lex_from_node = node->next;
3967
3968 return ret;
3969 }
3970
3971 static void
3972 glcpp_parser_lex_from (glcpp_parser_t *parser, token_list_t *list)
3973 {
3974 token_node_t *node;
3975
3976 assert (parser->lex_from_list == NULL);
3977
3978 /* Copy list, eliminating any space tokens. */
3979 parser->lex_from_list = _token_list_create (parser);
3980
3981 for (node = list->head; node; node = node->next) {
3982 if (node->token->type == SPACE)
3983 continue;
3984 _token_list_append (parser->lex_from_list, node->token);
3985 }
3986
3987 talloc_free (list);
3988
3989 parser->lex_from_node = parser->lex_from_list->head;
3990
3991 /* It's possible the list consisted of nothing but whitespace. */
3992 if (parser->lex_from_node == NULL) {
3993 talloc_free (parser->lex_from_list);
3994 parser->lex_from_list = NULL;
3995 }
3996 }
3997
3998 static void
3999 _glcpp_parser_skip_stack_push_if (glcpp_parser_t *parser, YYLTYPE *loc,
4000 int condition)
4001 {
4002 skip_type_t current = SKIP_NO_SKIP;
4003 skip_node_t *node;
4004
4005 if (parser->skip_stack)
4006 current = parser->skip_stack->type;
4007
4008 node = talloc (parser, skip_node_t);
4009 node->loc = *loc;
4010
4011 if (current == SKIP_NO_SKIP) {
4012 if (condition)
4013 node->type = SKIP_NO_SKIP;
4014 else
4015 node->type = SKIP_TO_ELSE;
4016 } else {
4017 node->type = SKIP_TO_ENDIF;
4018 }
4019
4020 node->next = parser->skip_stack;
4021 parser->skip_stack = node;
4022 }
4023
4024 static void
4025 _glcpp_parser_skip_stack_change_if (glcpp_parser_t *parser, YYLTYPE *loc,
4026 const char *type, int condition)
4027 {
4028 if (parser->skip_stack == NULL) {
4029 glcpp_error (loc, parser, "%s without #if\n", type);
4030 return;
4031 }
4032
4033 if (parser->skip_stack->type == SKIP_TO_ELSE) {
4034 if (condition)
4035 parser->skip_stack->type = SKIP_NO_SKIP;
4036 } else {
4037 parser->skip_stack->type = SKIP_TO_ENDIF;
4038 }
4039 }
4040
4041 static void
4042 _glcpp_parser_skip_stack_pop (glcpp_parser_t *parser, YYLTYPE *loc)
4043 {
4044 skip_node_t *node;
4045
4046 if (parser->skip_stack == NULL) {
4047 glcpp_error (loc, parser, "#endif without #if\n");
4048 return;
4049 }
4050
4051 node = parser->skip_stack;
4052 parser->skip_stack = node->next;
4053 talloc_free (node);
4054 }
4055