1 /* A Bison parser, made by GNU Bison 3.0.4. */
2
3 /* Bison implementation for Yacc-like parsers in C
4
5 Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
6
7 This program is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20 /* As a special exception, you may create a larger work that contains
21 part or all of the Bison parser skeleton and distribute that work
22 under terms of your choice, so long as that work isn't itself a
23 parser generator using the skeleton or a modified version thereof
24 as a parser skeleton. Alternatively, if you modify or redistribute
25 the parser skeleton itself, you may (at your option) remove this
26 special exception, which will cause the skeleton and the resulting
27 Bison output files to be licensed under the GNU General Public
28 License without this special exception.
29
30 This special exception was added by the Free Software Foundation in
31 version 2.2 of Bison. */
32
33 /* C LALR(1) parser skeleton written by Richard Stallman, by
34 simplifying the original so-called "semantic" parser. */
35
36 /* All symbols defined below should begin with yy or YY, to avoid
37 infringing on user name space. This should be done even for local
38 variables, as they might otherwise be expanded by user macros.
39 There are some unavoidable exceptions within include files to
40 define necessary library symbols; they are noted "INFRINGES ON
41 USER NAME SPACE" below. */
42
43 /* Identify Bison output. */
44 #define YYBISON 1
45
46 /* Bison version. */
47 #define YYBISON_VERSION "3.0.4"
48
49 /* Skeleton name. */
50 #define YYSKELETON_NAME "yacc.c"
51
52 /* Pure parsers. */
53 #define YYPURE 1
54
55 /* Push parsers. */
56 #define YYPUSH 0
57
58 /* Pull parsers. */
59 #define YYPULL 1
60
61
62 /* Substitute the variable and function names. */
63 #define yyparse ppparse
64 #define yylex pplex
65 #define yyerror pperror
66 #define yydebug ppdebug
67 #define yynerrs ppnerrs
68
69
70 /* Copy the first part of user declarations. */
71
72
73 // Copyright 2016 The SwiftShader Authors. All Rights Reserved.
74 //
75 // Licensed under the Apache License, Version 2.0 (the "License");
76 // you may not use this file except in compliance with the License.
77 // You may obtain a copy of the License at
78 //
79 // http://www.apache.org/licenses/LICENSE-2.0
80 //
81 // Unless required by applicable law or agreed to in writing, software
82 // distributed under the License is distributed on an "AS IS" BASIS,
83 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
84 // See the License for the specific language governing permissions and
85 // limitations under the License.
86
87 // This file is auto-generated by generate_parser.sh. DO NOT EDIT!
88
89 #if defined(__GNUC__)
90 // Triggered by the auto-generated pplval variable.
91 #if !defined(__clang__) && ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7))
92 #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
93 #else
94 #pragma GCC diagnostic ignored "-Wuninitialized"
95 #endif
96 #elif defined(_MSC_VER)
97 #pragma warning(disable: 4065 4244 4701 4702)
98 #endif
99
100 #include "ExpressionParser.h"
101
102 #if defined(_MSC_VER)
103 #include <malloc.h>
104 #else
105 #include <stdlib.h>
106 #endif
107
108 #include <limits>
109 #include <cassert>
110 #include <sstream>
111 #include <stdint.h>
112
113 #include "DiagnosticsBase.h"
114 #include "Lexer.h"
115 #include "Token.h"
116 #include "../../common/debug.h"
117
118 typedef int32_t YYSTYPE;
119 typedef uint32_t UNSIGNED_TYPE;
120
121 #define YYENABLE_NLS 0
122 #define YYLTYPE_IS_TRIVIAL 1
123 #define YYSTYPE_IS_TRIVIAL 1
124 #define YYSTYPE_IS_DECLARED 1
125
126 namespace {
127 struct Context
128 {
129 pp::Diagnostics* diagnostics;
130 pp::Lexer* lexer;
131 pp::Token* token;
132 int* result;
133 bool parsePresetToken;
134
135 pp::ExpressionParser::ErrorSettings errorSettings;
136 bool *valid;
137
startIgnoreErrors__anon0d8f87260111::Context138 void startIgnoreErrors() { ++ignoreErrors; }
endIgnoreErrors__anon0d8f87260111::Context139 void endIgnoreErrors() { --ignoreErrors; }
140
isIgnoringErrors__anon0d8f87260111::Context141 bool isIgnoringErrors() { return ignoreErrors > 0; }
142
143 int ignoreErrors;
144 };
145 } // namespace
146
147
148 static int yylex(YYSTYPE* lvalp, Context* context);
149 static void yyerror(Context* context, const char* reason);
150
151
152
153 # ifndef YY_NULLPTR
154 # if defined __cplusplus && 201103L <= __cplusplus
155 # define YY_NULLPTR nullptr
156 # else
157 # define YY_NULLPTR 0
158 # endif
159 # endif
160
161 /* Enabling verbose error messages. */
162 #ifdef YYERROR_VERBOSE
163 # undef YYERROR_VERBOSE
164 # define YYERROR_VERBOSE 1
165 #else
166 # define YYERROR_VERBOSE 0
167 #endif
168
169
170 /* Debug traces. */
171 #ifndef YYDEBUG
172 # define YYDEBUG 0
173 #endif
174 #if YYDEBUG
175 extern int ppdebug;
176 #endif
177
178 /* Token type. */
179 #ifndef YYTOKENTYPE
180 # define YYTOKENTYPE
181 enum yytokentype
182 {
183 TOK_CONST_INT = 258,
184 TOK_IDENTIFIER = 259,
185 TOK_OP_OR = 260,
186 TOK_OP_AND = 261,
187 TOK_OP_EQ = 262,
188 TOK_OP_NE = 263,
189 TOK_OP_LE = 264,
190 TOK_OP_GE = 265,
191 TOK_OP_LEFT = 266,
192 TOK_OP_RIGHT = 267,
193 TOK_UNARY = 268
194 };
195 #endif
196
197 /* Value type. */
198 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
199 typedef int YYSTYPE;
200 # define YYSTYPE_IS_TRIVIAL 1
201 # define YYSTYPE_IS_DECLARED 1
202 #endif
203
204
205
206 int ppparse (Context *context);
207
208
209
210 /* Copy the second part of user declarations. */
211
212
213
214 #ifdef short
215 # undef short
216 #endif
217
218 #ifdef YYTYPE_UINT8
219 typedef YYTYPE_UINT8 yytype_uint8;
220 #else
221 typedef unsigned char yytype_uint8;
222 #endif
223
224 #ifdef YYTYPE_INT8
225 typedef YYTYPE_INT8 yytype_int8;
226 #else
227 typedef signed char yytype_int8;
228 #endif
229
230 #ifdef YYTYPE_UINT16
231 typedef YYTYPE_UINT16 yytype_uint16;
232 #else
233 typedef unsigned short int yytype_uint16;
234 #endif
235
236 #ifdef YYTYPE_INT16
237 typedef YYTYPE_INT16 yytype_int16;
238 #else
239 typedef short int yytype_int16;
240 #endif
241
242 #ifndef YYSIZE_T
243 # ifdef __SIZE_TYPE__
244 # define YYSIZE_T __SIZE_TYPE__
245 # elif defined size_t
246 # define YYSIZE_T size_t
247 # elif ! defined YYSIZE_T
248 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
249 # define YYSIZE_T size_t
250 # else
251 # define YYSIZE_T unsigned int
252 # endif
253 #endif
254
255 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
256
257 #ifndef YY_
258 # if defined YYENABLE_NLS && YYENABLE_NLS
259 # if ENABLE_NLS
260 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
261 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
262 # endif
263 # endif
264 # ifndef YY_
265 # define YY_(Msgid) Msgid
266 # endif
267 #endif
268
269 #ifndef YY_ATTRIBUTE
270 # if (defined __GNUC__ \
271 && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
272 || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
273 # define YY_ATTRIBUTE(Spec) __attribute__(Spec)
274 # else
275 # define YY_ATTRIBUTE(Spec) /* empty */
276 # endif
277 #endif
278
279 #ifndef YY_ATTRIBUTE_PURE
280 # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
281 #endif
282
283 #ifndef YY_ATTRIBUTE_UNUSED
284 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
285 #endif
286
287 #if !defined _Noreturn \
288 && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
289 # if defined _MSC_VER && 1200 <= _MSC_VER
290 # define _Noreturn __declspec (noreturn)
291 # else
292 # define _Noreturn YY_ATTRIBUTE ((__noreturn__))
293 # endif
294 #endif
295
296 /* Suppress unused-variable warnings by "using" E. */
297 #if ! defined lint || defined __GNUC__
298 # define YYUSE(E) ((void) (E))
299 #else
300 # define YYUSE(E) /* empty */
301 #endif
302
303 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
304 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
305 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
306 _Pragma ("GCC diagnostic push") \
307 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
308 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
309 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
310 _Pragma ("GCC diagnostic pop")
311 #else
312 # define YY_INITIAL_VALUE(Value) Value
313 #endif
314 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
315 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
316 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
317 #endif
318 #ifndef YY_INITIAL_VALUE
319 # define YY_INITIAL_VALUE(Value) /* Nothing. */
320 #endif
321
322
323 #if ! defined yyoverflow || YYERROR_VERBOSE
324
325 /* The parser invokes alloca or malloc; define the necessary symbols. */
326
327 # ifdef YYSTACK_USE_ALLOCA
328 # if YYSTACK_USE_ALLOCA
329 # ifdef __GNUC__
330 # define YYSTACK_ALLOC __builtin_alloca
331 # elif defined __BUILTIN_VA_ARG_INCR
332 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
333 # elif defined _AIX
334 # define YYSTACK_ALLOC __alloca
335 # elif defined _MSC_VER
336 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
337 # define alloca _alloca
338 # else
339 # define YYSTACK_ALLOC alloca
340 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
341 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
342 /* Use EXIT_SUCCESS as a witness for stdlib.h. */
343 # ifndef EXIT_SUCCESS
344 # define EXIT_SUCCESS 0
345 # endif
346 # endif
347 # endif
348 # endif
349 # endif
350
351 # ifdef YYSTACK_ALLOC
352 /* Pacify GCC's 'empty if-body' warning. */
353 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
354 # ifndef YYSTACK_ALLOC_MAXIMUM
355 /* The OS might guarantee only one guard page at the bottom of the stack,
356 and a page size can be as small as 4096 bytes. So we cannot safely
357 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
358 to allow for a few compiler-allocated temporary stack slots. */
359 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
360 # endif
361 # else
362 # define YYSTACK_ALLOC YYMALLOC
363 # define YYSTACK_FREE YYFREE
364 # ifndef YYSTACK_ALLOC_MAXIMUM
365 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
366 # endif
367 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
368 && ! ((defined YYMALLOC || defined malloc) \
369 && (defined YYFREE || defined free)))
370 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
371 # ifndef EXIT_SUCCESS
372 # define EXIT_SUCCESS 0
373 # endif
374 # endif
375 # ifndef YYMALLOC
376 # define YYMALLOC malloc
377 # if ! defined malloc && ! defined EXIT_SUCCESS
378 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
379 # endif
380 # endif
381 # ifndef YYFREE
382 # define YYFREE free
383 # if ! defined free && ! defined EXIT_SUCCESS
384 void free (void *); /* INFRINGES ON USER NAME SPACE */
385 # endif
386 # endif
387 # endif
388 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
389
390
391 #if (! defined yyoverflow \
392 && (! defined __cplusplus \
393 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
394
395 /* A type that is properly aligned for any stack member. */
396 union yyalloc
397 {
398 yytype_int16 yyss_alloc;
399 YYSTYPE yyvs_alloc;
400 };
401
402 /* The size of the maximum gap between one aligned stack and the next. */
403 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
404
405 /* The size of an array large to enough to hold all stacks, each with
406 N elements. */
407 # define YYSTACK_BYTES(N) \
408 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
409 + YYSTACK_GAP_MAXIMUM)
410
411 # define YYCOPY_NEEDED 1
412
413 /* Relocate STACK from its old location to the new one. The
414 local variables YYSIZE and YYSTACKSIZE give the old and new number of
415 elements in the stack, and YYPTR gives the new location of the
416 stack. Advance YYPTR to a properly aligned location for the next
417 stack. */
418 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
419 do \
420 { \
421 YYSIZE_T yynewbytes; \
422 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
423 Stack = &yyptr->Stack_alloc; \
424 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
425 yyptr += yynewbytes / sizeof (*yyptr); \
426 } \
427 while (0)
428
429 #endif
430
431 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
432 /* Copy COUNT objects from SRC to DST. The source and destination do
433 not overlap. */
434 # ifndef YYCOPY
435 # if defined __GNUC__ && 1 < __GNUC__
436 # define YYCOPY(Dst, Src, Count) \
437 __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
438 # else
439 # define YYCOPY(Dst, Src, Count) \
440 do \
441 { \
442 YYSIZE_T yyi; \
443 for (yyi = 0; yyi < (Count); yyi++) \
444 (Dst)[yyi] = (Src)[yyi]; \
445 } \
446 while (0)
447 # endif
448 # endif
449 #endif /* !YYCOPY_NEEDED */
450
451 /* YYFINAL -- State number of the termination state. */
452 #define YYFINAL 15
453 /* YYLAST -- Last index in YYTABLE. */
454 #define YYLAST 176
455
456 /* YYNTOKENS -- Number of terminals. */
457 #define YYNTOKENS 28
458 /* YYNNTS -- Number of nonterminals. */
459 #define YYNNTS 5
460 /* YYNRULES -- Number of rules. */
461 #define YYNRULES 29
462 /* YYNSTATES -- Number of states. */
463 #define YYNSTATES 55
464
465 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
466 by yylex, with out-of-bounds checking. */
467 #define YYUNDEFTOK 2
468 #define YYMAXUTOK 268
469
470 #define YYTRANSLATE(YYX) \
471 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
472
473 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
474 as returned by yylex, without out-of-bounds checking. */
475 static const yytype_uint8 yytranslate[] =
476 {
477 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
478 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
479 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
480 2, 2, 2, 24, 2, 2, 2, 22, 9, 2,
481 26, 27, 20, 18, 2, 19, 2, 21, 2, 2,
482 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
483 12, 2, 13, 2, 2, 2, 2, 2, 2, 2,
484 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
485 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
486 2, 2, 2, 2, 8, 2, 2, 2, 2, 2,
487 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
488 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
489 2, 2, 2, 2, 7, 2, 25, 2, 2, 2,
490 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
491 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
492 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
493 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
494 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
495 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
496 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
497 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
498 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
499 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
500 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
501 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
502 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
503 5, 6, 10, 11, 14, 15, 16, 17, 23
504 };
505
506 #if YYDEBUG
507 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
508 static const yytype_uint16 yyrline[] =
509 {
510 0, 125, 125, 132, 133, 144, 144, 165, 165, 186,
511 189, 192, 195, 198, 201, 204, 207, 210, 213, 238,
512 260, 263, 266, 292, 319, 322, 325, 328, 340, 343
513 };
514 #endif
515
516 #if YYDEBUG || YYERROR_VERBOSE || 0
517 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
518 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
519 static const char *const yytname[] =
520 {
521 "$end", "error", "$undefined", "TOK_CONST_INT", "TOK_IDENTIFIER",
522 "TOK_OP_OR", "TOK_OP_AND", "'|'", "'^'", "'&'", "TOK_OP_EQ", "TOK_OP_NE",
523 "'<'", "'>'", "TOK_OP_LE", "TOK_OP_GE", "TOK_OP_LEFT", "TOK_OP_RIGHT",
524 "'+'", "'-'", "'*'", "'/'", "'%'", "TOK_UNARY", "'!'", "'~'", "'('",
525 "')'", "$accept", "input", "expression", "$@1", "$@2", YY_NULLPTR
526 };
527 #endif
528
529 # ifdef YYPRINT
530 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
531 (internal) symbol number NUM (which must be that of a token). */
532 static const yytype_uint16 yytoknum[] =
533 {
534 0, 256, 257, 258, 259, 260, 261, 124, 94, 38,
535 262, 263, 60, 62, 264, 265, 266, 267, 43, 45,
536 42, 47, 37, 268, 33, 126, 40, 41
537 };
538 # endif
539
540 #define YYPACT_NINF -12
541
542 #define yypact_value_is_default(Yystate) \
543 (!!((Yystate) == (-12)))
544
545 #define YYTABLE_NINF -1
546
547 #define yytable_value_is_error(Yytable_value) \
548 0
549
550 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
551 STATE-NUM. */
552 static const yytype_int16 yypact[] =
553 {
554 31, -12, -12, 31, 31, 31, 31, 31, 51, 76,
555 -12, -12, -12, -12, 53, -12, -12, -12, 31, 31,
556 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,
557 31, 31, 31, 31, -12, 31, 31, 124, 138, 26,
558 149, 149, -11, -11, -11, -11, 154, 154, -8, -8,
559 -12, -12, -12, 93, 109
560 };
561
562 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
563 Performed when YYTABLE does not specify something else to do. Zero
564 means the default is an error. */
565 static const yytype_uint8 yydefact[] =
566 {
567 0, 3, 4, 0, 0, 0, 0, 0, 0, 2,
568 28, 27, 25, 26, 0, 1, 5, 7, 0, 0,
569 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
570 0, 0, 0, 0, 29, 0, 0, 9, 10, 11,
571 13, 12, 17, 16, 15, 14, 19, 18, 21, 20,
572 24, 23, 22, 6, 8
573 };
574
575 /* YYPGOTO[NTERM-NUM]. */
576 static const yytype_int8 yypgoto[] =
577 {
578 -12, -12, -3, -12, -12
579 };
580
581 /* YYDEFGOTO[NTERM-NUM]. */
582 static const yytype_int8 yydefgoto[] =
583 {
584 -1, 8, 9, 35, 36
585 };
586
587 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
588 positive, shift that token. If negative, reduce the rule whose
589 number is the opposite. If YYTABLE_NINF, syntax error. */
590 static const yytype_uint8 yytable[] =
591 {
592 10, 11, 12, 13, 14, 27, 28, 29, 30, 31,
593 32, 33, 31, 32, 33, 37, 38, 39, 40, 41,
594 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
595 52, 0, 53, 54, 1, 2, 21, 22, 23, 24,
596 25, 26, 27, 28, 29, 30, 31, 32, 33, 3,
597 4, 15, 0, 0, 0, 5, 6, 7, 16, 17,
598 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
599 28, 29, 30, 31, 32, 33, 0, 0, 0, 0,
600 34, 16, 17, 18, 19, 20, 21, 22, 23, 24,
601 25, 26, 27, 28, 29, 30, 31, 32, 33, 17,
602 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
603 28, 29, 30, 31, 32, 33, 18, 19, 20, 21,
604 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
605 32, 33, 19, 20, 21, 22, 23, 24, 25, 26,
606 27, 28, 29, 30, 31, 32, 33, 20, 21, 22,
607 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
608 33, 23, 24, 25, 26, 27, 28, 29, 30, 31,
609 32, 33, 29, 30, 31, 32, 33
610 };
611
612 static const yytype_int8 yycheck[] =
613 {
614 3, 4, 5, 6, 7, 16, 17, 18, 19, 20,
615 21, 22, 20, 21, 22, 18, 19, 20, 21, 22,
616 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
617 33, -1, 35, 36, 3, 4, 10, 11, 12, 13,
618 14, 15, 16, 17, 18, 19, 20, 21, 22, 18,
619 19, 0, -1, -1, -1, 24, 25, 26, 5, 6,
620 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
621 17, 18, 19, 20, 21, 22, -1, -1, -1, -1,
622 27, 5, 6, 7, 8, 9, 10, 11, 12, 13,
623 14, 15, 16, 17, 18, 19, 20, 21, 22, 6,
624 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
625 17, 18, 19, 20, 21, 22, 7, 8, 9, 10,
626 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
627 21, 22, 8, 9, 10, 11, 12, 13, 14, 15,
628 16, 17, 18, 19, 20, 21, 22, 9, 10, 11,
629 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
630 22, 12, 13, 14, 15, 16, 17, 18, 19, 20,
631 21, 22, 18, 19, 20, 21, 22
632 };
633
634 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
635 symbol of state STATE-NUM. */
636 static const yytype_uint8 yystos[] =
637 {
638 0, 3, 4, 18, 19, 24, 25, 26, 29, 30,
639 30, 30, 30, 30, 30, 0, 5, 6, 7, 8,
640 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
641 19, 20, 21, 22, 27, 31, 32, 30, 30, 30,
642 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
643 30, 30, 30, 30, 30
644 };
645
646 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
647 static const yytype_uint8 yyr1[] =
648 {
649 0, 28, 29, 30, 30, 31, 30, 32, 30, 30,
650 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
651 30, 30, 30, 30, 30, 30, 30, 30, 30, 30
652 };
653
654 /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
655 static const yytype_uint8 yyr2[] =
656 {
657 0, 2, 1, 1, 1, 0, 4, 0, 4, 3,
658 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
659 3, 3, 3, 3, 3, 2, 2, 2, 2, 3
660 };
661
662
663 #define yyerrok (yyerrstatus = 0)
664 #define yyclearin (yychar = YYEMPTY)
665 #define YYEMPTY (-2)
666 #define YYEOF 0
667
668 #define YYACCEPT goto yyacceptlab
669 #define YYABORT goto yyabortlab
670 #define YYERROR goto yyerrorlab
671
672
673 #define YYRECOVERING() (!!yyerrstatus)
674
675 #define YYBACKUP(Token, Value) \
676 do \
677 if (yychar == YYEMPTY) \
678 { \
679 yychar = (Token); \
680 yylval = (Value); \
681 YYPOPSTACK (yylen); \
682 yystate = *yyssp; \
683 goto yybackup; \
684 } \
685 else \
686 { \
687 yyerror (context, YY_("syntax error: cannot back up")); \
688 YYERROR; \
689 } \
690 while (0)
691
692 /* Error token number */
693 #define YYTERROR 1
694 #define YYERRCODE 256
695
696
697
698 /* Enable debugging if requested. */
699 #if YYDEBUG
700
701 # ifndef YYFPRINTF
702 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
703 # define YYFPRINTF fprintf
704 # endif
705
706 # define YYDPRINTF(Args) \
707 do { \
708 if (yydebug) \
709 YYFPRINTF Args; \
710 } while (0)
711
712 /* This macro is provided for backward compatibility. */
713 #ifndef YY_LOCATION_PRINT
714 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
715 #endif
716
717
718 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
719 do { \
720 if (yydebug) \
721 { \
722 YYFPRINTF (stderr, "%s ", Title); \
723 yy_symbol_print (stderr, \
724 Type, Value, context); \
725 YYFPRINTF (stderr, "\n"); \
726 } \
727 } while (0)
728
729
730 /*----------------------------------------.
731 | Print this symbol's value on YYOUTPUT. |
732 `----------------------------------------*/
733
734 static void
yy_symbol_value_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep,Context * context)735 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, Context *context)
736 {
737 FILE *yyo = yyoutput;
738 YYUSE (yyo);
739 YYUSE (context);
740 if (!yyvaluep)
741 return;
742 # ifdef YYPRINT
743 if (yytype < YYNTOKENS)
744 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
745 # endif
746 YYUSE (yytype);
747 }
748
749
750 /*--------------------------------.
751 | Print this symbol on YYOUTPUT. |
752 `--------------------------------*/
753
754 static void
yy_symbol_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep,Context * context)755 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, Context *context)
756 {
757 YYFPRINTF (yyoutput, "%s %s (",
758 yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
759
760 yy_symbol_value_print (yyoutput, yytype, yyvaluep, context);
761 YYFPRINTF (yyoutput, ")");
762 }
763
764 /*------------------------------------------------------------------.
765 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
766 | TOP (included). |
767 `------------------------------------------------------------------*/
768
769 static void
yy_stack_print(yytype_int16 * yybottom,yytype_int16 * yytop)770 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
771 {
772 YYFPRINTF (stderr, "Stack now");
773 for (; yybottom <= yytop; yybottom++)
774 {
775 int yybot = *yybottom;
776 YYFPRINTF (stderr, " %d", yybot);
777 }
778 YYFPRINTF (stderr, "\n");
779 }
780
781 # define YY_STACK_PRINT(Bottom, Top) \
782 do { \
783 if (yydebug) \
784 yy_stack_print ((Bottom), (Top)); \
785 } while (0)
786
787
788 /*------------------------------------------------.
789 | Report that the YYRULE is going to be reduced. |
790 `------------------------------------------------*/
791
792 static void
yy_reduce_print(yytype_int16 * yyssp,YYSTYPE * yyvsp,int yyrule,Context * context)793 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, Context *context)
794 {
795 unsigned long int yylno = yyrline[yyrule];
796 int yynrhs = yyr2[yyrule];
797 int yyi;
798 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
799 yyrule - 1, yylno);
800 /* The symbols being reduced. */
801 for (yyi = 0; yyi < yynrhs; yyi++)
802 {
803 YYFPRINTF (stderr, " $%d = ", yyi + 1);
804 yy_symbol_print (stderr,
805 yystos[yyssp[yyi + 1 - yynrhs]],
806 &(yyvsp[(yyi + 1) - (yynrhs)])
807 , context);
808 YYFPRINTF (stderr, "\n");
809 }
810 }
811
812 # define YY_REDUCE_PRINT(Rule) \
813 do { \
814 if (yydebug) \
815 yy_reduce_print (yyssp, yyvsp, Rule, context); \
816 } while (0)
817
818 /* Nonzero means print parse trace. It is left uninitialized so that
819 multiple parsers can coexist. */
820 int yydebug;
821 #else /* !YYDEBUG */
822 # define YYDPRINTF(Args)
823 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
824 # define YY_STACK_PRINT(Bottom, Top)
825 # define YY_REDUCE_PRINT(Rule)
826 #endif /* !YYDEBUG */
827
828
829 /* YYINITDEPTH -- initial size of the parser's stacks. */
830 #ifndef YYINITDEPTH
831 # define YYINITDEPTH 200
832 #endif
833
834 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
835 if the built-in stack extension method is used).
836
837 Do not make this value too large; the results are undefined if
838 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
839 evaluated with infinite-precision integer arithmetic. */
840
841 #ifndef YYMAXDEPTH
842 # define YYMAXDEPTH 10000
843 #endif
844
845
846 #if YYERROR_VERBOSE
847
848 # ifndef yystrlen
849 # if defined __GLIBC__ && defined _STRING_H
850 # define yystrlen strlen
851 # else
852 /* Return the length of YYSTR. */
853 static YYSIZE_T
yystrlen(const char * yystr)854 yystrlen (const char *yystr)
855 {
856 YYSIZE_T yylen;
857 for (yylen = 0; yystr[yylen]; yylen++)
858 continue;
859 return yylen;
860 }
861 # endif
862 # endif
863
864 # ifndef yystpcpy
865 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
866 # define yystpcpy stpcpy
867 # else
868 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
869 YYDEST. */
870 static char *
yystpcpy(char * yydest,const char * yysrc)871 yystpcpy (char *yydest, const char *yysrc)
872 {
873 char *yyd = yydest;
874 const char *yys = yysrc;
875
876 while ((*yyd++ = *yys++) != '\0')
877 continue;
878
879 return yyd - 1;
880 }
881 # endif
882 # endif
883
884 # ifndef yytnamerr
885 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
886 quotes and backslashes, so that it's suitable for yyerror. The
887 heuristic is that double-quoting is unnecessary unless the string
888 contains an apostrophe, a comma, or backslash (other than
889 backslash-backslash). YYSTR is taken from yytname. If YYRES is
890 null, do not copy; instead, return the length of what the result
891 would have been. */
892 static YYSIZE_T
yytnamerr(char * yyres,const char * yystr)893 yytnamerr (char *yyres, const char *yystr)
894 {
895 if (*yystr == '"')
896 {
897 YYSIZE_T yyn = 0;
898 char const *yyp = yystr;
899
900 for (;;)
901 switch (*++yyp)
902 {
903 case '\'':
904 case ',':
905 goto do_not_strip_quotes;
906
907 case '\\':
908 if (*++yyp != '\\')
909 goto do_not_strip_quotes;
910 /* Fall through. */
911 default:
912 if (yyres)
913 yyres[yyn] = *yyp;
914 yyn++;
915 break;
916
917 case '"':
918 if (yyres)
919 yyres[yyn] = '\0';
920 return yyn;
921 }
922 do_not_strip_quotes: ;
923 }
924
925 if (! yyres)
926 return yystrlen (yystr);
927
928 return yystpcpy (yyres, yystr) - yyres;
929 }
930 # endif
931
932 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
933 about the unexpected token YYTOKEN for the state stack whose top is
934 YYSSP.
935
936 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
937 not large enough to hold the message. In that case, also set
938 *YYMSG_ALLOC to the required number of bytes. Return 2 if the
939 required number of bytes is too large to store. */
940 static int
yysyntax_error(YYSIZE_T * yymsg_alloc,char ** yymsg,yytype_int16 * yyssp,int yytoken)941 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
942 yytype_int16 *yyssp, int yytoken)
943 {
944 YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
945 YYSIZE_T yysize = yysize0;
946 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
947 /* Internationalized format string. */
948 const char *yyformat = YY_NULLPTR;
949 /* Arguments of yyformat. */
950 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
951 /* Number of reported tokens (one for the "unexpected", one per
952 "expected"). */
953 int yycount = 0;
954
955 /* There are many possibilities here to consider:
956 - If this state is a consistent state with a default action, then
957 the only way this function was invoked is if the default action
958 is an error action. In that case, don't check for expected
959 tokens because there are none.
960 - The only way there can be no lookahead present (in yychar) is if
961 this state is a consistent state with a default action. Thus,
962 detecting the absence of a lookahead is sufficient to determine
963 that there is no unexpected or expected token to report. In that
964 case, just report a simple "syntax error".
965 - Don't assume there isn't a lookahead just because this state is a
966 consistent state with a default action. There might have been a
967 previous inconsistent state, consistent state with a non-default
968 action, or user semantic action that manipulated yychar.
969 - Of course, the expected token list depends on states to have
970 correct lookahead information, and it depends on the parser not
971 to perform extra reductions after fetching a lookahead from the
972 scanner and before detecting a syntax error. Thus, state merging
973 (from LALR or IELR) and default reductions corrupt the expected
974 token list. However, the list is correct for canonical LR with
975 one exception: it will still contain any token that will not be
976 accepted due to an error action in a later state.
977 */
978 if (yytoken != YYEMPTY)
979 {
980 int yyn = yypact[*yyssp];
981 yyarg[yycount++] = yytname[yytoken];
982 if (!yypact_value_is_default (yyn))
983 {
984 /* Start YYX at -YYN if negative to avoid negative indexes in
985 YYCHECK. In other words, skip the first -YYN actions for
986 this state because they are default actions. */
987 int yyxbegin = yyn < 0 ? -yyn : 0;
988 /* Stay within bounds of both yycheck and yytname. */
989 int yychecklim = YYLAST - yyn + 1;
990 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
991 int yyx;
992
993 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
994 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
995 && !yytable_value_is_error (yytable[yyx + yyn]))
996 {
997 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
998 {
999 yycount = 1;
1000 yysize = yysize0;
1001 break;
1002 }
1003 yyarg[yycount++] = yytname[yyx];
1004 {
1005 YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
1006 if (! (yysize <= yysize1
1007 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1008 return 2;
1009 yysize = yysize1;
1010 }
1011 }
1012 }
1013 }
1014
1015 switch (yycount)
1016 {
1017 # define YYCASE_(N, S) \
1018 case N: \
1019 yyformat = S; \
1020 break
1021 YYCASE_(0, YY_("syntax error"));
1022 YYCASE_(1, YY_("syntax error, unexpected %s"));
1023 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1024 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1025 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1026 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1027 # undef YYCASE_
1028 }
1029
1030 {
1031 YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
1032 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1033 return 2;
1034 yysize = yysize1;
1035 }
1036
1037 if (*yymsg_alloc < yysize)
1038 {
1039 *yymsg_alloc = 2 * yysize;
1040 if (! (yysize <= *yymsg_alloc
1041 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1042 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1043 return 1;
1044 }
1045
1046 /* Avoid sprintf, as that infringes on the user's name space.
1047 Don't have undefined behavior even if the translation
1048 produced a string with the wrong number of "%s"s. */
1049 {
1050 char *yyp = *yymsg;
1051 int yyi = 0;
1052 while ((*yyp = *yyformat) != '\0')
1053 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1054 {
1055 yyp += yytnamerr (yyp, yyarg[yyi++]);
1056 yyformat += 2;
1057 }
1058 else
1059 {
1060 yyp++;
1061 yyformat++;
1062 }
1063 }
1064 return 0;
1065 }
1066 #endif /* YYERROR_VERBOSE */
1067
1068 /*-----------------------------------------------.
1069 | Release the memory associated to this symbol. |
1070 `-----------------------------------------------*/
1071
1072 static void
yydestruct(const char * yymsg,int yytype,YYSTYPE * yyvaluep,Context * context)1073 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, Context *context)
1074 {
1075 YYUSE (yyvaluep);
1076 YYUSE (context);
1077 if (!yymsg)
1078 yymsg = "Deleting";
1079 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1080
1081 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1082 YYUSE (yytype);
1083 YY_IGNORE_MAYBE_UNINITIALIZED_END
1084 }
1085
1086
1087
1088
1089 /*----------.
1090 | yyparse. |
1091 `----------*/
1092
1093 int
yyparse(Context * context)1094 yyparse (Context *context)
1095 {
1096 /* The lookahead symbol. */
1097 int yychar;
1098
1099
1100 /* The semantic value of the lookahead symbol. */
1101 /* Default value used for initialization, for pacifying older GCCs
1102 or non-GCC compilers. */
1103 YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
1104 YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
1105
1106 /* Number of syntax errors so far. */
1107 int yynerrs;
1108
1109 int yystate;
1110 /* Number of tokens to shift before error messages enabled. */
1111 int yyerrstatus;
1112
1113 /* The stacks and their tools:
1114 'yyss': related to states.
1115 'yyvs': related to semantic values.
1116
1117 Refer to the stacks through separate pointers, to allow yyoverflow
1118 to reallocate them elsewhere. */
1119
1120 /* The state stack. */
1121 yytype_int16 yyssa[YYINITDEPTH];
1122 yytype_int16 *yyss;
1123 yytype_int16 *yyssp;
1124
1125 /* The semantic value stack. */
1126 YYSTYPE yyvsa[YYINITDEPTH];
1127 YYSTYPE *yyvs;
1128 YYSTYPE *yyvsp;
1129
1130 YYSIZE_T yystacksize;
1131
1132 int yyn;
1133 int yyresult;
1134 /* Lookahead token as an internal (translated) token number. */
1135 int yytoken = 0;
1136 /* The variables used to return semantic value and location from the
1137 action routines. */
1138 YYSTYPE yyval;
1139
1140 #if YYERROR_VERBOSE
1141 /* Buffer for error messages, and its allocated size. */
1142 char yymsgbuf[128];
1143 char *yymsg = yymsgbuf;
1144 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1145 #endif
1146
1147 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1148
1149 /* The number of symbols on the RHS of the reduced rule.
1150 Keep to zero when no symbol should be popped. */
1151 int yylen = 0;
1152
1153 yyssp = yyss = yyssa;
1154 yyvsp = yyvs = yyvsa;
1155 yystacksize = YYINITDEPTH;
1156
1157 YYDPRINTF ((stderr, "Starting parse\n"));
1158
1159 yystate = 0;
1160 yyerrstatus = 0;
1161 yynerrs = 0;
1162 yychar = YYEMPTY; /* Cause a token to be read. */
1163 goto yysetstate;
1164
1165 /*------------------------------------------------------------.
1166 | yynewstate -- Push a new state, which is found in yystate. |
1167 `------------------------------------------------------------*/
1168 yynewstate:
1169 /* In all cases, when you get here, the value and location stacks
1170 have just been pushed. So pushing a state here evens the stacks. */
1171 yyssp++;
1172
1173 yysetstate:
1174 *yyssp = yystate;
1175
1176 if (yyss + yystacksize - 1 <= yyssp)
1177 {
1178 /* Get the current used size of the three stacks, in elements. */
1179 YYSIZE_T yysize = yyssp - yyss + 1;
1180
1181 #ifdef yyoverflow
1182 {
1183 /* Give user a chance to reallocate the stack. Use copies of
1184 these so that the &'s don't force the real ones into
1185 memory. */
1186 YYSTYPE *yyvs1 = yyvs;
1187 yytype_int16 *yyss1 = yyss;
1188
1189 /* Each stack pointer address is followed by the size of the
1190 data in use in that stack, in bytes. This used to be a
1191 conditional around just the two extra args, but that might
1192 be undefined if yyoverflow is a macro. */
1193 yyoverflow (YY_("memory exhausted"),
1194 &yyss1, yysize * sizeof (*yyssp),
1195 &yyvs1, yysize * sizeof (*yyvsp),
1196 &yystacksize);
1197
1198 yyss = yyss1;
1199 yyvs = yyvs1;
1200 }
1201 #else /* no yyoverflow */
1202 # ifndef YYSTACK_RELOCATE
1203 goto yyexhaustedlab;
1204 # else
1205 /* Extend the stack our own way. */
1206 if (YYMAXDEPTH <= yystacksize)
1207 goto yyexhaustedlab;
1208 yystacksize *= 2;
1209 if (YYMAXDEPTH < yystacksize)
1210 yystacksize = YYMAXDEPTH;
1211
1212 {
1213 yytype_int16 *yyss1 = yyss;
1214 union yyalloc *yyptr =
1215 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1216 if (! yyptr)
1217 goto yyexhaustedlab;
1218 YYSTACK_RELOCATE (yyss_alloc, yyss);
1219 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1220 # undef YYSTACK_RELOCATE
1221 if (yyss1 != yyssa)
1222 YYSTACK_FREE (yyss1);
1223 }
1224 # endif
1225 #endif /* no yyoverflow */
1226
1227 yyssp = yyss + yysize - 1;
1228 yyvsp = yyvs + yysize - 1;
1229
1230 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1231 (unsigned long int) yystacksize));
1232
1233 if (yyss + yystacksize - 1 <= yyssp)
1234 YYABORT;
1235 }
1236
1237 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1238
1239 if (yystate == YYFINAL)
1240 YYACCEPT;
1241
1242 goto yybackup;
1243
1244 /*-----------.
1245 | yybackup. |
1246 `-----------*/
1247 yybackup:
1248
1249 /* Do appropriate processing given the current state. Read a
1250 lookahead token if we need one and don't already have one. */
1251
1252 /* First try to decide what to do without reference to lookahead token. */
1253 yyn = yypact[yystate];
1254 if (yypact_value_is_default (yyn))
1255 goto yydefault;
1256
1257 /* Not known => get a lookahead token if don't already have one. */
1258
1259 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1260 if (yychar == YYEMPTY)
1261 {
1262 YYDPRINTF ((stderr, "Reading a token: "));
1263 yychar = yylex (&yylval, context);
1264 }
1265
1266 if (yychar <= YYEOF)
1267 {
1268 yychar = yytoken = YYEOF;
1269 YYDPRINTF ((stderr, "Now at end of input.\n"));
1270 }
1271 else
1272 {
1273 yytoken = YYTRANSLATE (yychar);
1274 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1275 }
1276
1277 /* If the proper action on seeing token YYTOKEN is to reduce or to
1278 detect an error, take that action. */
1279 yyn += yytoken;
1280 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1281 goto yydefault;
1282 yyn = yytable[yyn];
1283 if (yyn <= 0)
1284 {
1285 if (yytable_value_is_error (yyn))
1286 goto yyerrlab;
1287 yyn = -yyn;
1288 goto yyreduce;
1289 }
1290
1291 /* Count tokens shifted since error; after three, turn off error
1292 status. */
1293 if (yyerrstatus)
1294 yyerrstatus--;
1295
1296 /* Shift the lookahead token. */
1297 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1298
1299 /* Discard the shifted token. */
1300 yychar = YYEMPTY;
1301
1302 yystate = yyn;
1303 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1304 *++yyvsp = yylval;
1305 YY_IGNORE_MAYBE_UNINITIALIZED_END
1306
1307 goto yynewstate;
1308
1309
1310 /*-----------------------------------------------------------.
1311 | yydefault -- do the default action for the current state. |
1312 `-----------------------------------------------------------*/
1313 yydefault:
1314 yyn = yydefact[yystate];
1315 if (yyn == 0)
1316 goto yyerrlab;
1317 goto yyreduce;
1318
1319
1320 /*-----------------------------.
1321 | yyreduce -- Do a reduction. |
1322 `-----------------------------*/
1323 yyreduce:
1324 /* yyn is the number of a rule to reduce with. */
1325 yylen = yyr2[yyn];
1326
1327 /* If YYLEN is nonzero, implement the default value of the action:
1328 '$$ = $1'.
1329
1330 Otherwise, the following line sets YYVAL to garbage.
1331 This behavior is undocumented and Bison
1332 users should not rely upon it. Assigning to YYVAL
1333 unconditionally makes the parser a bit smaller, and it avoids a
1334 GCC warning that YYVAL may be used uninitialized. */
1335 yyval = yyvsp[1-yylen];
1336
1337
1338 YY_REDUCE_PRINT (yyn);
1339 switch (yyn)
1340 {
1341 case 2:
1342
1343 {
1344 *(context->result) = static_cast<int>((yyvsp[0]));
1345 YYACCEPT;
1346 }
1347
1348 break;
1349
1350 case 4:
1351
1352 {
1353 if (!context->isIgnoringErrors())
1354 {
1355 // This rule should be applied right after the token is lexed, so we can
1356 // refer to context->token in the error message.
1357 context->diagnostics->report(context->errorSettings.unexpectedIdentifier,
1358 context->token->location, context->token->text);
1359 *(context->valid) = false;
1360 }
1361 (yyval) = (yyvsp[0]);
1362 }
1363
1364 break;
1365
1366 case 5:
1367
1368 {
1369 if ((yyvsp[-1]) != 0)
1370 {
1371 // Ignore errors in the short-circuited part of the expression.
1372 // ESSL3.00 section 3.4:
1373 // If an operand is not evaluated, the presence of undefined identifiers
1374 // in the operand will not cause an error.
1375 // Unevaluated division by zero should not cause an error either.
1376 context->startIgnoreErrors();
1377 }
1378 }
1379
1380 break;
1381
1382 case 6:
1383
1384 {
1385 if ((yyvsp[-3]) != 0)
1386 {
1387 context->endIgnoreErrors();
1388 (yyval) = static_cast<YYSTYPE>(1);
1389 }
1390 else
1391 {
1392 (yyval) = (yyvsp[-3]) || (yyvsp[0]);
1393 }
1394 }
1395
1396 break;
1397
1398 case 7:
1399
1400 {
1401 if ((yyvsp[-1]) == 0)
1402 {
1403 // Ignore errors in the short-circuited part of the expression.
1404 // ESSL3.00 section 3.4:
1405 // If an operand is not evaluated, the presence of undefined identifiers
1406 // in the operand will not cause an error.
1407 // Unevaluated division by zero should not cause an error either.
1408 context->startIgnoreErrors();
1409 }
1410 }
1411
1412 break;
1413
1414 case 8:
1415
1416 {
1417 if ((yyvsp[-3]) == 0)
1418 {
1419 context->endIgnoreErrors();
1420 (yyval) = static_cast<YYSTYPE>(0);
1421 }
1422 else
1423 {
1424 (yyval) = (yyvsp[-3]) && (yyvsp[0]);
1425 }
1426 }
1427
1428 break;
1429
1430 case 9:
1431
1432 {
1433 (yyval) = (yyvsp[-2]) | (yyvsp[0]);
1434 }
1435
1436 break;
1437
1438 case 10:
1439
1440 {
1441 (yyval) = (yyvsp[-2]) ^ (yyvsp[0]);
1442 }
1443
1444 break;
1445
1446 case 11:
1447
1448 {
1449 (yyval) = (yyvsp[-2]) & (yyvsp[0]);
1450 }
1451
1452 break;
1453
1454 case 12:
1455
1456 {
1457 (yyval) = (yyvsp[-2]) != (yyvsp[0]);
1458 }
1459
1460 break;
1461
1462 case 13:
1463
1464 {
1465 (yyval) = (yyvsp[-2]) == (yyvsp[0]);
1466 }
1467
1468 break;
1469
1470 case 14:
1471
1472 {
1473 (yyval) = (yyvsp[-2]) >= (yyvsp[0]);
1474 }
1475
1476 break;
1477
1478 case 15:
1479
1480 {
1481 (yyval) = (yyvsp[-2]) <= (yyvsp[0]);
1482 }
1483
1484 break;
1485
1486 case 16:
1487
1488 {
1489 (yyval) = (yyvsp[-2]) > (yyvsp[0]);
1490 }
1491
1492 break;
1493
1494 case 17:
1495
1496 {
1497 (yyval) = (yyvsp[-2]) < (yyvsp[0]);
1498 }
1499
1500 break;
1501
1502 case 18:
1503
1504 {
1505 if ((yyvsp[0]) < 0 || (yyvsp[0]) > 31)
1506 {
1507 if (!context->isIgnoringErrors())
1508 {
1509 std::ostringstream stream;
1510 stream << (yyvsp[-2]) << " >> " << (yyvsp[0]);
1511 std::string text = stream.str();
1512 context->diagnostics->report(pp::Diagnostics::PP_UNDEFINED_SHIFT,
1513 context->token->location,
1514 text.c_str());
1515 *(context->valid) = false;
1516 }
1517 (yyval) = static_cast<YYSTYPE>(0);
1518 }
1519 else if ((yyvsp[-2]) < 0)
1520 {
1521 // Logical shift right.
1522 (yyval) = static_cast<YYSTYPE>(static_cast<UNSIGNED_TYPE>((yyvsp[-2])) >> (yyvsp[0]));
1523 }
1524 else
1525 {
1526 (yyval) = (yyvsp[-2]) >> (yyvsp[0]);
1527 }
1528 }
1529
1530 break;
1531
1532 case 19:
1533
1534 {
1535 if ((yyvsp[0]) < 0 || (yyvsp[0]) > 31)
1536 {
1537 if (!context->isIgnoringErrors())
1538 {
1539 std::ostringstream stream;
1540 stream << (yyvsp[-2]) << " << " << (yyvsp[0]);
1541 std::string text = stream.str();
1542 context->diagnostics->report(pp::Diagnostics::PP_UNDEFINED_SHIFT,
1543 context->token->location,
1544 text.c_str());
1545 *(context->valid) = false;
1546 }
1547 (yyval) = static_cast<YYSTYPE>(0);
1548 }
1549 else
1550 {
1551 // Logical shift left. Casting to unsigned is needed to ensure there's no signed integer
1552 // overflow, which some tools treat as an error.
1553 (yyval) = static_cast<YYSTYPE>(static_cast<UNSIGNED_TYPE>((yyvsp[-2])) << (yyvsp[0]));
1554 }
1555 }
1556
1557 break;
1558
1559 case 20:
1560
1561 {
1562 (yyval) = (yyvsp[-2]) - (yyvsp[0]);
1563 }
1564
1565 break;
1566
1567 case 21:
1568
1569 {
1570 (yyval) = (yyvsp[-2]) + (yyvsp[0]);
1571 }
1572
1573 break;
1574
1575 case 22:
1576
1577 {
1578 if ((yyvsp[0]) == 0)
1579 {
1580 if (!context->isIgnoringErrors())
1581 {
1582 std::ostringstream stream;
1583 stream << (yyvsp[-2]) << " % " << (yyvsp[0]);
1584 std::string text = stream.str();
1585 context->diagnostics->report(pp::Diagnostics::PP_DIVISION_BY_ZERO,
1586 context->token->location,
1587 text.c_str());
1588 *(context->valid) = false;
1589 }
1590 (yyval) = static_cast<YYSTYPE>(0);
1591 }
1592 else if (((yyvsp[-2]) == std::numeric_limits<YYSTYPE>::min()) && ((yyvsp[0]) == -1))
1593 {
1594 // Check for the special case where the minimum representable number is
1595 // divided by -1. If left alone this has undefined results.
1596 (yyval) = 0;
1597 }
1598 else
1599 {
1600 (yyval) = (yyvsp[-2]) % (yyvsp[0]);
1601 }
1602 }
1603
1604 break;
1605
1606 case 23:
1607
1608 {
1609 if ((yyvsp[0]) == 0)
1610 {
1611 if (!context->isIgnoringErrors())
1612 {
1613 std::ostringstream stream;
1614 stream << (yyvsp[-2]) << " / " << (yyvsp[0]);
1615 std::string text = stream.str();
1616 context->diagnostics->report(pp::Diagnostics::PP_DIVISION_BY_ZERO,
1617 context->token->location,
1618 text.c_str());
1619 *(context->valid) = false;
1620 }
1621 (yyval) = static_cast<YYSTYPE>(0);
1622 }
1623 else if (((yyvsp[-2]) == std::numeric_limits<YYSTYPE>::min()) && ((yyvsp[0]) == -1))
1624 {
1625 // Check for the special case where the minimum representable number is
1626 // divided by -1. If left alone this leads to integer overflow in C++, which
1627 // has undefined results.
1628 (yyval) = std::numeric_limits<YYSTYPE>::max();
1629 }
1630 else
1631 {
1632 (yyval) = (yyvsp[-2]) / (yyvsp[0]);
1633 }
1634 }
1635
1636 break;
1637
1638 case 24:
1639
1640 {
1641 (yyval) = (yyvsp[-2]) * (yyvsp[0]);
1642 }
1643
1644 break;
1645
1646 case 25:
1647
1648 {
1649 (yyval) = ! (yyvsp[0]);
1650 }
1651
1652 break;
1653
1654 case 26:
1655
1656 {
1657 (yyval) = ~ (yyvsp[0]);
1658 }
1659
1660 break;
1661
1662 case 27:
1663
1664 {
1665 // Check for negation of minimum representable integer to prevent undefined signed int
1666 // overflow.
1667 if ((yyvsp[0]) == std::numeric_limits<YYSTYPE>::min())
1668 {
1669 (yyval) = std::numeric_limits<YYSTYPE>::min();
1670 }
1671 else
1672 {
1673 (yyval) = -(yyvsp[0]);
1674 }
1675 }
1676
1677 break;
1678
1679 case 28:
1680
1681 {
1682 (yyval) = + (yyvsp[0]);
1683 }
1684
1685 break;
1686
1687 case 29:
1688
1689 {
1690 (yyval) = (yyvsp[-1]);
1691 }
1692
1693 break;
1694
1695
1696
1697 default: break;
1698 }
1699 /* User semantic actions sometimes alter yychar, and that requires
1700 that yytoken be updated with the new translation. We take the
1701 approach of translating immediately before every use of yytoken.
1702 One alternative is translating here after every semantic action,
1703 but that translation would be missed if the semantic action invokes
1704 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1705 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
1706 incorrect destructor might then be invoked immediately. In the
1707 case of YYERROR or YYBACKUP, subsequent parser actions might lead
1708 to an incorrect destructor call or verbose syntax error message
1709 before the lookahead is translated. */
1710 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1711
1712 YYPOPSTACK (yylen);
1713 yylen = 0;
1714 YY_STACK_PRINT (yyss, yyssp);
1715
1716 *++yyvsp = yyval;
1717
1718 /* Now 'shift' the result of the reduction. Determine what state
1719 that goes to, based on the state we popped back to and the rule
1720 number reduced by. */
1721
1722 yyn = yyr1[yyn];
1723
1724 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1725 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1726 yystate = yytable[yystate];
1727 else
1728 yystate = yydefgoto[yyn - YYNTOKENS];
1729
1730 goto yynewstate;
1731
1732
1733 /*--------------------------------------.
1734 | yyerrlab -- here on detecting error. |
1735 `--------------------------------------*/
1736 yyerrlab:
1737 /* Make sure we have latest lookahead translation. See comments at
1738 user semantic actions for why this is necessary. */
1739 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
1740
1741 /* If not already recovering from an error, report this error. */
1742 if (!yyerrstatus)
1743 {
1744 ++yynerrs;
1745 #if ! YYERROR_VERBOSE
1746 yyerror (context, YY_("syntax error"));
1747 #else
1748 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
1749 yyssp, yytoken)
1750 {
1751 char const *yymsgp = YY_("syntax error");
1752 int yysyntax_error_status;
1753 yysyntax_error_status = YYSYNTAX_ERROR;
1754 if (yysyntax_error_status == 0)
1755 yymsgp = yymsg;
1756 else if (yysyntax_error_status == 1)
1757 {
1758 if (yymsg != yymsgbuf)
1759 YYSTACK_FREE (yymsg);
1760 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
1761 if (!yymsg)
1762 {
1763 yymsg = yymsgbuf;
1764 yymsg_alloc = sizeof yymsgbuf;
1765 yysyntax_error_status = 2;
1766 }
1767 else
1768 {
1769 yysyntax_error_status = YYSYNTAX_ERROR;
1770 yymsgp = yymsg;
1771 }
1772 }
1773 yyerror (context, yymsgp);
1774 if (yysyntax_error_status == 2)
1775 goto yyexhaustedlab;
1776 }
1777 # undef YYSYNTAX_ERROR
1778 #endif
1779 }
1780
1781
1782
1783 if (yyerrstatus == 3)
1784 {
1785 /* If just tried and failed to reuse lookahead token after an
1786 error, discard it. */
1787
1788 if (yychar <= YYEOF)
1789 {
1790 /* Return failure if at end of input. */
1791 if (yychar == YYEOF)
1792 YYABORT;
1793 }
1794 else
1795 {
1796 yydestruct ("Error: discarding",
1797 yytoken, &yylval, context);
1798 yychar = YYEMPTY;
1799 }
1800 }
1801
1802 /* Else will try to reuse lookahead token after shifting the error
1803 token. */
1804 goto yyerrlab1;
1805
1806
1807 /*---------------------------------------------------.
1808 | yyerrorlab -- error raised explicitly by YYERROR. |
1809 `---------------------------------------------------*/
1810 yyerrorlab:
1811
1812 /* Pacify compilers like GCC when the user code never invokes
1813 YYERROR and the label yyerrorlab therefore never appears in user
1814 code. */
1815 if (/*CONSTCOND*/ 0)
1816 goto yyerrorlab;
1817
1818 /* Do not reclaim the symbols of the rule whose action triggered
1819 this YYERROR. */
1820 YYPOPSTACK (yylen);
1821 yylen = 0;
1822 YY_STACK_PRINT (yyss, yyssp);
1823 yystate = *yyssp;
1824 goto yyerrlab1;
1825
1826
1827 /*-------------------------------------------------------------.
1828 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1829 `-------------------------------------------------------------*/
1830 yyerrlab1:
1831 yyerrstatus = 3; /* Each real token shifted decrements this. */
1832
1833 for (;;)
1834 {
1835 yyn = yypact[yystate];
1836 if (!yypact_value_is_default (yyn))
1837 {
1838 yyn += YYTERROR;
1839 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1840 {
1841 yyn = yytable[yyn];
1842 if (0 < yyn)
1843 break;
1844 }
1845 }
1846
1847 /* Pop the current state because it cannot handle the error token. */
1848 if (yyssp == yyss)
1849 YYABORT;
1850
1851
1852 yydestruct ("Error: popping",
1853 yystos[yystate], yyvsp, context);
1854 YYPOPSTACK (1);
1855 yystate = *yyssp;
1856 YY_STACK_PRINT (yyss, yyssp);
1857 }
1858
1859 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1860 *++yyvsp = yylval;
1861 YY_IGNORE_MAYBE_UNINITIALIZED_END
1862
1863
1864 /* Shift the error token. */
1865 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1866
1867 yystate = yyn;
1868 goto yynewstate;
1869
1870
1871 /*-------------------------------------.
1872 | yyacceptlab -- YYACCEPT comes here. |
1873 `-------------------------------------*/
1874 yyacceptlab:
1875 yyresult = 0;
1876 goto yyreturn;
1877
1878 /*-----------------------------------.
1879 | yyabortlab -- YYABORT comes here. |
1880 `-----------------------------------*/
1881 yyabortlab:
1882 yyresult = 1;
1883 goto yyreturn;
1884
1885 #if !defined yyoverflow || YYERROR_VERBOSE
1886 /*-------------------------------------------------.
1887 | yyexhaustedlab -- memory exhaustion comes here. |
1888 `-------------------------------------------------*/
1889 yyexhaustedlab:
1890 yyerror (context, YY_("memory exhausted"));
1891 yyresult = 2;
1892 /* Fall through. */
1893 #endif
1894
1895 yyreturn:
1896 if (yychar != YYEMPTY)
1897 {
1898 /* Make sure we have latest lookahead translation. See comments at
1899 user semantic actions for why this is necessary. */
1900 yytoken = YYTRANSLATE (yychar);
1901 yydestruct ("Cleanup: discarding lookahead",
1902 yytoken, &yylval, context);
1903 }
1904 /* Do not reclaim the symbols of the rule whose action triggered
1905 this YYABORT or YYACCEPT. */
1906 YYPOPSTACK (yylen);
1907 YY_STACK_PRINT (yyss, yyssp);
1908 while (yyssp != yyss)
1909 {
1910 yydestruct ("Cleanup: popping",
1911 yystos[*yyssp], yyvsp, context);
1912 YYPOPSTACK (1);
1913 }
1914 #ifndef yyoverflow
1915 if (yyss != yyssa)
1916 YYSTACK_FREE (yyss);
1917 #endif
1918 #if YYERROR_VERBOSE
1919 if (yymsg != yymsgbuf)
1920 YYSTACK_FREE (yymsg);
1921 #endif
1922 return yyresult;
1923 }
1924
1925
1926
yylex(YYSTYPE * lvalp,Context * context)1927 int yylex(YYSTYPE *lvalp, Context *context)
1928 {
1929 pp::Token *token = context->token;
1930 if (!context->parsePresetToken)
1931 {
1932 context->lexer->lex(token);
1933 }
1934 context->parsePresetToken = false;
1935
1936 int type = 0;
1937
1938 switch (token->type)
1939 {
1940 case pp::Token::CONST_INT: {
1941 unsigned int val = 0;
1942 int testVal = 0;
1943 if (!token->uValue(&val) || (!token->iValue(&testVal) &&
1944 context->errorSettings.integerLiteralsMustFit32BitSignedRange))
1945 {
1946 context->diagnostics->report(pp::Diagnostics::PP_INTEGER_OVERFLOW,
1947 token->location, token->text);
1948 *(context->valid) = false;
1949 }
1950 *lvalp = static_cast<YYSTYPE>(val);
1951 type = TOK_CONST_INT;
1952 break;
1953 }
1954 case pp::Token::IDENTIFIER:
1955 *lvalp = static_cast<YYSTYPE>(-1);
1956 type = TOK_IDENTIFIER;
1957 break;
1958 case pp::Token::OP_OR:
1959 type = TOK_OP_OR;
1960 break;
1961 case pp::Token::OP_AND:
1962 type = TOK_OP_AND;
1963 break;
1964 case pp::Token::OP_NE:
1965 type = TOK_OP_NE;
1966 break;
1967 case pp::Token::OP_EQ:
1968 type = TOK_OP_EQ;
1969 break;
1970 case pp::Token::OP_GE:
1971 type = TOK_OP_GE;
1972 break;
1973 case pp::Token::OP_LE:
1974 type = TOK_OP_LE;
1975 break;
1976 case pp::Token::OP_RIGHT:
1977 type = TOK_OP_RIGHT;
1978 break;
1979 case pp::Token::OP_LEFT:
1980 type = TOK_OP_LEFT;
1981 break;
1982 case '|':
1983 case '^':
1984 case '&':
1985 case '>':
1986 case '<':
1987 case '-':
1988 case '+':
1989 case '%':
1990 case '/':
1991 case '*':
1992 case '!':
1993 case '~':
1994 case '(':
1995 case ')':
1996 type = token->type;
1997 break;
1998
1999 default:
2000 break;
2001 }
2002
2003 return type;
2004 }
2005
yyerror(Context * context,const char * reason)2006 void yyerror(Context *context, const char *reason)
2007 {
2008 context->diagnostics->report(pp::Diagnostics::PP_INVALID_EXPRESSION,
2009 context->token->location,
2010 reason);
2011 }
2012
2013 namespace pp {
2014
ExpressionParser(Lexer * lexer,Diagnostics * diagnostics)2015 ExpressionParser::ExpressionParser(Lexer *lexer, Diagnostics *diagnostics)
2016 : mLexer(lexer),
2017 mDiagnostics(diagnostics)
2018 {
2019 }
2020
parse(Token * token,int * result,bool parsePresetToken,const ErrorSettings & errorSettings,bool * valid)2021 bool ExpressionParser::parse(Token *token,
2022 int *result,
2023 bool parsePresetToken,
2024 const ErrorSettings &errorSettings,
2025 bool *valid)
2026 {
2027 Context context;
2028 context.diagnostics = mDiagnostics;
2029 context.lexer = mLexer;
2030 context.token = token;
2031 context.result = result;
2032 context.ignoreErrors = 0;
2033 context.parsePresetToken = parsePresetToken;
2034 context.errorSettings = errorSettings;
2035 context.valid = valid;
2036 int ret = yyparse(&context);
2037 switch (ret)
2038 {
2039 case 0:
2040 case 1:
2041 break;
2042
2043 case 2:
2044 mDiagnostics->report(Diagnostics::PP_OUT_OF_MEMORY, token->location, "");
2045 break;
2046
2047 default:
2048 assert(false);
2049 mDiagnostics->report(Diagnostics::PP_INTERNAL_ERROR, token->location, "");
2050 break;
2051 }
2052
2053 return ret == 0;
2054 }
2055
2056 } // namespace pp
2057