GDB (xrefs)
Loading...
Searching...
No Matches
/tmp/gdb-13.1/gdb/p-exp.c
Go to the documentation of this file.
1/* A Bison parser, made by GNU Bison 3.8.2. */
2
3/* Bison implementation for Yacc-like parsers in C
4
5 Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation,
6 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 <https://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/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
38 especially those whose name start with YY_ or yy_. They are
39 private implementation details that can be changed or removed. */
40
41/* All symbols defined below should begin with yy or YY, to avoid
42 infringing on user name space. This should be done even for local
43 variables, as they might otherwise be expanded by user macros.
44 There are some unavoidable exceptions within include files to
45 define necessary library symbols; they are noted "INFRINGES ON
46 USER NAME SPACE" below. */
47
48/* Identify Bison output, and Bison version. */
49#define YYBISON 30802
50
51/* Bison version string. */
52#define YYBISON_VERSION "3.8.2"
53
54/* Skeleton name. */
55#define YYSKELETON_NAME "yacc.c"
56
57/* Pure parsers. */
58#define YYPURE 0
59
60/* Push parsers. */
61#define YYPUSH 0
62
63/* Pull parsers. */
64#define YYPULL 1
65
66
67
68
69/* First part of user prologue. */
70#line 44 "p-exp.y"
71
72
73#include "defs.h"
74#include <ctype.h>
75#include "expression.h"
76#include "value.h"
77#include "parser-defs.h"
78#include "language.h"
79#include "p-lang.h"
80#include "bfd.h" /* Required by objfiles.h. */
81#include "symfile.h" /* Required by objfiles.h. */
82#include "objfiles.h" /* For have_full_symbols and have_partial_symbols. */
83#include "block.h"
84#include "completer.h"
85#include "expop.h"
86
87#define parse_type(ps) builtin_type (ps->gdbarch ())
88
89/* Remap normal yacc parser interface names (yyparse, yylex, yyerror,
90 etc). */
91#define GDB_YY_REMAP_PREFIX pascal_
92#include "yy-remap.h"
93
94/* The state of the parser, used internally when we are parsing the
95 expression. */
96
97static struct parser_state *pstate = NULL;
98
99/* Depth of parentheses. */
100static int paren_depth;
101
102int yyparse (void);
103
104static int yylex (void);
105
106static void yyerror (const char *);
107
108static char *uptok (const char *, int);
109
110using namespace expr;
111
112#line 113 "p-exp.c.tmp"
113
114# ifndef YY_CAST
115# ifdef __cplusplus
116# define YY_CAST(Type, Val) static_cast<Type> (Val)
117# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
118# else
119# define YY_CAST(Type, Val) ((Type) (Val))
120# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
121# endif
122# endif
123# ifndef YY_NULLPTRPTR
124# if defined __cplusplus
125# if 201103L <= __cplusplus
126# define YY_NULLPTRPTR nullptr
127# else
128# define YY_NULLPTRPTR 0
129# endif
130# else
131# define YY_NULLPTRPTR ((void*)0)
132# endif
133# endif
134
135
136/* Debug traces. */
137#ifndef YYDEBUG
138# define YYDEBUG 0
139#endif
140#if YYDEBUG
141extern int yydebug;
142#endif
143
144/* Token kinds. */
145#ifndef YYTOKENTYPE
146# define YYTOKENTYPE
148 {
150 YYEOF = 0, /* "end of file" */
151 YYerror = 256, /* error */
152 YYUNDEF = 257, /* "invalid token" */
153 INT = 258, /* INT */
154 FLOAT = 259, /* FLOAT */
155 STRING = 260, /* STRING */
156 FIELDNAME = 261, /* FIELDNAME */
157 COMPLETE = 262, /* COMPLETE */
158 NAME = 263, /* NAME */
159 TYPENAME = 264, /* TYPENAME */
160 NAME_OR_INT = 265, /* NAME_OR_INT */
161 STRUCT = 266, /* STRUCT */
162 CLASS = 267, /* CLASS */
163 SIZEOF = 268, /* SIZEOF */
164 COLONCOLON = 269, /* COLONCOLON */
165 ERROR = 270, /* ERROR */
166 DOLLAR_VARIABLE = 271, /* DOLLAR_VARIABLE */
167 THIS = 272, /* THIS */
168 TRUEKEYWORD = 273, /* TRUEKEYWORD */
169 FALSEKEYWORD = 274, /* FALSEKEYWORD */
170 ABOVE_COMMA = 275, /* ABOVE_COMMA */
171 ASSIGN = 276, /* ASSIGN */
172 NOT = 277, /* NOT */
173 OR = 278, /* OR */
174 XOR = 279, /* XOR */
175 ANDAND = 280, /* ANDAND */
176 NOTEQUAL = 281, /* NOTEQUAL */
177 LEQ = 282, /* LEQ */
178 GEQ = 283, /* GEQ */
179 LSH = 284, /* LSH */
180 RSH = 285, /* RSH */
181 DIV = 286, /* DIV */
182 MOD = 287, /* MOD */
183 UNARY = 288, /* UNARY */
184 INCREMENT = 289, /* INCREMENT */
185 DECREMENT = 290, /* DECREMENT */
186 ARROW = 291, /* ARROW */
187 BLOCKNAME = 292 /* BLOCKNAME */
188 };
190#endif
191/* Token kinds. */
192#define YYEMPTY -2
193#define YYEOF 0
194#define YYerror 256
195#define YYUNDEF 257
196#define INT 258
197#define FLOAT 259
198#define STRING 260
199#define FIELDNAME 261
200#define COMPLETE 262
201#define NAME 263
202#define TYPENAME 264
203#define NAME_OR_INT 265
204#define STRUCT 266
205#define CLASS 267
206#define SIZEOF 268
207#define COLONCOLON 269
208#define ERROR 270
209#define DOLLAR_VARIABLE 271
210#define THIS 272
211#define TRUEKEYWORD 273
212#define FALSEKEYWORD 274
213#define ABOVE_COMMA 275
214#define ASSIGN 276
215#define NOT 277
216#define OR 278
217#define XOR 279
218#define ANDAND 280
219#define NOTEQUAL 281
220#define LEQ 282
221#define GEQ 283
222#define LSH 284
223#define RSH 285
224#define DIV 286
225#define MOD 287
226#define UNARY 288
227#define INCREMENT 289
228#define DECREMENT 290
229#define ARROW 291
230#define BLOCKNAME 292
231
232/* Value type. */
233#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
234union YYSTYPE
235{
236#line 91 "p-exp.y"
237
238 LONGEST lval;
239 struct {
240 LONGEST val;
241 struct type *type;
243 struct {
244 gdb_byte val[16];
245 struct type *type;
247 struct symbol *sym;
248 struct type *tval;
249 struct stoken sval;
250 struct ttype tsym;
251 struct symtoken ssym;
252 int voidval;
253 const struct block *bval;
254 enum exp_opcode opcode;
255 struct internalvar *ivar;
256
257 struct type **tvec;
258 int *ivec;
259
260
261#line 262 "p-exp.c.tmp"
262
263};
264typedef union YYSTYPE YYSTYPE;
265# define YYSTYPE_IS_TRIVIAL 1
266# define YYSTYPE_IS_DECLARED 1
267#endif
268
269
270extern YYSTYPE yylval;
271
272
273int yyparse (void);
274
275
276
277/* Symbol kind. */
279{
281 YYSYMBOL_YYEOF = 0, /* "end of file" */
282 YYSYMBOL_YYerror = 1, /* error */
283 YYSYMBOL_YYUNDEF = 2, /* "invalid token" */
284 YYSYMBOL_INT = 3, /* INT */
285 YYSYMBOL_FLOAT = 4, /* FLOAT */
286 YYSYMBOL_STRING = 5, /* STRING */
287 YYSYMBOL_FIELDNAME = 6, /* FIELDNAME */
288 YYSYMBOL_COMPLETE = 7, /* COMPLETE */
289 YYSYMBOL_NAME = 8, /* NAME */
290 YYSYMBOL_TYPENAME = 9, /* TYPENAME */
291 YYSYMBOL_NAME_OR_INT = 10, /* NAME_OR_INT */
292 YYSYMBOL_STRUCT = 11, /* STRUCT */
293 YYSYMBOL_CLASS = 12, /* CLASS */
294 YYSYMBOL_SIZEOF = 13, /* SIZEOF */
295 YYSYMBOL_COLONCOLON = 14, /* COLONCOLON */
296 YYSYMBOL_ERROR = 15, /* ERROR */
297 YYSYMBOL_DOLLAR_VARIABLE = 16, /* DOLLAR_VARIABLE */
298 YYSYMBOL_THIS = 17, /* THIS */
299 YYSYMBOL_TRUEKEYWORD = 18, /* TRUEKEYWORD */
300 YYSYMBOL_FALSEKEYWORD = 19, /* FALSEKEYWORD */
301 YYSYMBOL_20_ = 20, /* ',' */
302 YYSYMBOL_ABOVE_COMMA = 21, /* ABOVE_COMMA */
303 YYSYMBOL_ASSIGN = 22, /* ASSIGN */
304 YYSYMBOL_NOT = 23, /* NOT */
305 YYSYMBOL_OR = 24, /* OR */
306 YYSYMBOL_XOR = 25, /* XOR */
307 YYSYMBOL_ANDAND = 26, /* ANDAND */
308 YYSYMBOL_27_ = 27, /* '=' */
309 YYSYMBOL_NOTEQUAL = 28, /* NOTEQUAL */
310 YYSYMBOL_29_ = 29, /* '<' */
311 YYSYMBOL_30_ = 30, /* '>' */
312 YYSYMBOL_LEQ = 31, /* LEQ */
313 YYSYMBOL_GEQ = 32, /* GEQ */
314 YYSYMBOL_LSH = 33, /* LSH */
315 YYSYMBOL_RSH = 34, /* RSH */
316 YYSYMBOL_DIV = 35, /* DIV */
317 YYSYMBOL_MOD = 36, /* MOD */
318 YYSYMBOL_37_ = 37, /* '@' */
319 YYSYMBOL_38_ = 38, /* '+' */
320 YYSYMBOL_39_ = 39, /* '-' */
321 YYSYMBOL_40_ = 40, /* '*' */
322 YYSYMBOL_41_ = 41, /* '/' */
323 YYSYMBOL_UNARY = 42, /* UNARY */
324 YYSYMBOL_INCREMENT = 43, /* INCREMENT */
325 YYSYMBOL_DECREMENT = 44, /* DECREMENT */
326 YYSYMBOL_ARROW = 45, /* ARROW */
327 YYSYMBOL_46_ = 46, /* '.' */
328 YYSYMBOL_47_ = 47, /* '[' */
329 YYSYMBOL_48_ = 48, /* '(' */
330 YYSYMBOL_49_ = 49, /* '^' */
331 YYSYMBOL_BLOCKNAME = 50, /* BLOCKNAME */
332 YYSYMBOL_51_ = 51, /* ')' */
333 YYSYMBOL_52_ = 52, /* ']' */
334 YYSYMBOL_YYACCEPT = 53, /* $accept */
335 YYSYMBOL_start = 54, /* start */
336 YYSYMBOL_55_1 = 55, /* $@1 */
337 YYSYMBOL_normal_start = 56, /* normal_start */
338 YYSYMBOL_type_exp = 57, /* type_exp */
339 YYSYMBOL_exp1 = 58, /* exp1 */
340 YYSYMBOL_exp = 59, /* exp */
341 YYSYMBOL_field_exp = 60, /* field_exp */
342 YYSYMBOL_61_2 = 61, /* $@2 */
343 YYSYMBOL_62_3 = 62, /* $@3 */
344 YYSYMBOL_arglist = 63, /* arglist */
345 YYSYMBOL_64_4 = 64, /* $@4 */
346 YYSYMBOL_block = 65, /* block */
347 YYSYMBOL_variable = 66, /* variable */
348 YYSYMBOL_qualified_name = 67, /* qualified_name */
349 YYSYMBOL_ptype = 68, /* ptype */
350 YYSYMBOL_type = 69, /* type */
351 YYSYMBOL_typebase = 70, /* typebase */
352 YYSYMBOL_name = 71, /* name */
353 YYSYMBOL_name_not_typename = 72 /* name_not_typename */
356
357
358/* Second part of user prologue. */
359#line 115 "p-exp.y"
360
361/* YYSTYPE gets defined by %union */
362static int parse_number (struct parser_state *,
363 const char *, int, int, YYSTYPE *);
364
365static struct type *current_type;
367static void push_current_type (void);
368static void pop_current_type (void);
369static int search_field;
370
371#line 372 "p-exp.c.tmp"
372
373
374#ifdef short
375# undef short
376#endif
377
378/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
379 <limits.h> and (if available) <stdint.h> are included
380 so that the code can choose integer types of a good width. */
381
382#ifndef __PTRDIFF_MAX__
383# include <limits.h> /* INFRINGES ON USER NAME SPACE */
384# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
385# include <stdint.h> /* INFRINGES ON USER NAME SPACE */
386# define YY_STDINT_H
387# endif
388#endif
389
390/* Narrow types that promote to a signed type and that can represent a
391 signed or unsigned integer of at least N bits. In tables they can
392 save space and decrease cache pressure. Promoting to a signed type
393 helps avoid bugs in integer arithmetic. */
394
395#ifdef __INT_LEAST8_MAX__
396typedef __INT_LEAST8_TYPE__ yytype_int8;
397#elif defined YY_STDINT_H
398typedef int_least8_t yytype_int8;
399#else
400typedef signed char yytype_int8;
401#endif
402
403#ifdef __INT_LEAST16_MAX__
404typedef __INT_LEAST16_TYPE__ yytype_int16;
405#elif defined YY_STDINT_H
406typedef int_least16_t yytype_int16;
407#else
408typedef short yytype_int16;
409#endif
410
411/* Work around bug in HP-UX 11.23, which defines these macros
412 incorrectly for preprocessor constants. This workaround can likely
413 be removed in 2023, as HPE has promised support for HP-UX 11.23
414 (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of
415 <https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>. */
416#ifdef __hpux
417# undef UINT_LEAST8_MAX
418# undef UINT_LEAST16_MAX
419# define UINT_LEAST8_MAX 255
420# define UINT_LEAST16_MAX 65535
421#endif
422
423#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
424typedef __UINT_LEAST8_TYPE__ yytype_uint8;
425#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
426 && UINT_LEAST8_MAX <= INT_MAX)
427typedef uint_least8_t yytype_uint8;
428#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
429typedef unsigned char yytype_uint8;
430#else
431typedef short yytype_uint8;
432#endif
433
434#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
435typedef __UINT_LEAST16_TYPE__ yytype_uint16;
436#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
437 && UINT_LEAST16_MAX <= INT_MAX)
438typedef uint_least16_t yytype_uint16;
439#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
440typedef unsigned short yytype_uint16;
441#else
442typedef int yytype_uint16;
443#endif
444
445#ifndef YYPTRDIFF_T
446# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
447# define YYPTRDIFF_T __PTRDIFF_TYPE__
448# define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
449# elif defined PTRDIFF_MAX
450# ifndef ptrdiff_t
451# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
452# endif
453# define YYPTRDIFF_T ptrdiff_t
454# define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
455# else
456# define YYPTRDIFF_T long
457# define YYPTRDIFF_MAXIMUM LONG_MAX
458# endif
459#endif
460
461#ifndef YYSIZE_T
462# ifdef __SIZE_TYPE__
463# define YYSIZE_T __SIZE_TYPE__
464# elif defined size_t
465# define YYSIZE_T size_t
466# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
467# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
468# define YYSIZE_T size_t
469# else
470# define YYSIZE_T unsigned
471# endif
472#endif
473
474#define YYSIZE_MAXIMUM \
475 YY_CAST (YYPTRDIFF_T, \
476 (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
477 ? YYPTRDIFF_MAXIMUM \
478 : YY_CAST (YYSIZE_T, -1)))
479
480#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
481
482
483/* Stored state numbers (used for stacks). */
485
486/* State numbers in computations. */
487typedef int yy_state_fast_t;
488
489#ifndef YY_
490# if defined YYENABLE_NLS && YYENABLE_NLS
491# if ENABLE_NLS
492# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
493# define YY_(Msgid) dgettext ("bison-runtime", Msgid)
494# endif
495# endif
496# ifndef YY_
497# define YY_(Msgid) Msgid
498# endif
499#endif
500
501
502#ifndef YY_ATTRIBUTE_PURE
503# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
504# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
505# else
506# define YY_ATTRIBUTE_PURE
507# endif
508#endif
509
510#ifndef YY_ATTRIBUTE_UNUSED
511# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
512# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
513# else
514# define YY_ATTRIBUTE_UNUSED
515# endif
516#endif
517
518/* Suppress unused-variable warnings by "using" E. */
519#if ! defined lint || defined __GNUC__
520# define YY_USE(E) ((void) (E))
521#else
522# define YY_USE(E) /* empty */
523#endif
524
525/* Suppress an incorrect diagnostic about yylval being uninitialized. */
526#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__
527# if __GNUC__ * 100 + __GNUC_MINOR__ < 407
528# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
529 _Pragma ("GCC diagnostic push") \
530 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")
531# else
532# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
533 _Pragma ("GCC diagnostic push") \
534 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
535 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
536# endif
537# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
538 _Pragma ("GCC diagnostic pop")
539#else
540# define YY_INITIAL_VALUE(Value) Value
541#endif
542#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
543# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
544# define YY_IGNORE_MAYBE_UNINITIALIZED_END
545#endif
546#ifndef YY_INITIAL_VALUE
547# define YY_INITIAL_VALUE(Value) /* Nothing. */
548#endif
549
550#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
551# define YY_IGNORE_USELESS_CAST_BEGIN \
552 _Pragma ("GCC diagnostic push") \
553 _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
554# define YY_IGNORE_USELESS_CAST_END \
555 _Pragma ("GCC diagnostic pop")
556#endif
557#ifndef YY_IGNORE_USELESS_CAST_BEGIN
558# define YY_IGNORE_USELESS_CAST_BEGIN
559# define YY_IGNORE_USELESS_CAST_END
560#endif
561
562
563#define YY_ASSERT(E) ((void) (0 && (E)))
564
565#if !defined yyoverflow
566
567/* The parser invokes alloca or xmalloc; define the necessary symbols. */
568
569# ifdef YYSTACK_USE_ALLOCA
570# if YYSTACK_USE_ALLOCA
571# ifdef __GNUC__
572# define YYSTACK_ALLOC __builtin_alloca
573# elif defined __BUILTIN_VA_ARG_INCR
574# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
575# elif defined _AIX
576# define YYSTACK_ALLOC __alloca
577# elif defined _MSC_VER
578# define alloca _alloca
579# else
580# define YYSTACK_ALLOC alloca
581# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
582# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
583 /* Use EXIT_SUCCESS as a witness for stdlib.h. */
584# ifndef EXIT_SUCCESS
585# define EXIT_SUCCESS 0
586# endif
587# endif
588# endif
589# endif
590# endif
591
592# ifdef YYSTACK_ALLOC
593 /* Pacify GCC's 'empty if-body' warning. */
594# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
595# ifndef YYSTACK_ALLOC_MAXIMUM
596 /* The OS might guarantee only one guard page at the bottom of the stack,
597 and a page size can be as small as 4096 bytes. So we cannot safely
598 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
599 to allow for a few compiler-allocated temporary stack slots. */
600# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
601# endif
602# else
603# define YYSTACK_ALLOC YYMALLOC
604# define YYSTACK_FREE YYFREE
605# ifndef YYSTACK_ALLOC_MAXIMUM
606# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
607# endif
608# if (defined __cplusplus && ! defined EXIT_SUCCESS \
609 && ! ((defined YYMALLOC || defined xmalloc) \
610 && (defined YYFREE || defined xfree)))
611# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
612# ifndef EXIT_SUCCESS
613# define EXIT_SUCCESS 0
614# endif
615# endif
616# ifndef YYMALLOC
617# define YYMALLOC xmalloc
618# if ! defined xmalloc && ! defined EXIT_SUCCESS
619void *xmalloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
620# endif
621# endif
622# ifndef YYFREE
623# define YYFREE xfree
624# if ! defined xfree && ! defined EXIT_SUCCESS
625void xfree (void *); /* INFRINGES ON USER NAME SPACE */
626# endif
627# endif
628# endif
629#endif /* !defined yyoverflow */
630
631#if (! defined yyoverflow \
632 && (! defined __cplusplus \
633 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
634
635/* A type that is properly aligned for any stack member. */
636union yyalloc
637{
640};
641
642/* The size of the maximum gap between one aligned stack and the next. */
643# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
644
645/* The size of an array large to enough to hold all stacks, each with
646 N elements. */
647# define YYSTACK_BYTES(N) \
648 ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
649 + YYSTACK_GAP_MAXIMUM)
650
651# define YYCOPY_NEEDED 1
652
653/* Relocate STACK from its old location to the new one. The
654 local variables YYSIZE and YYSTACKSIZE give the old and new number of
655 elements in the stack, and YYPTR gives the new location of the
656 stack. Advance YYPTR to a properly aligned location for the next
657 stack. */
658# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
659 do \
660 { \
661 YYPTRDIFF_T yynewbytes; \
662 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
663 Stack = &yyptr->Stack_alloc; \
664 yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
665 yyptr += yynewbytes / YYSIZEOF (*yyptr); \
666 } \
667 while (0)
668
669#endif
670
671#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
672/* Copy COUNT objects from SRC to DST. The source and destination do
673 not overlap. */
674# ifndef YYCOPY
675# if defined __GNUC__ && 1 < __GNUC__
676# define YYCOPY(Dst, Src, Count) \
677 __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
678# else
679# define YYCOPY(Dst, Src, Count) \
680 do \
681 { \
682 YYPTRDIFF_T yyi; \
683 for (yyi = 0; yyi < (Count); yyi++) \
684 (Dst)[yyi] = (Src)[yyi]; \
685 } \
686 while (0)
687# endif
688# endif
689#endif /* !YYCOPY_NEEDED */
690
691/* YYFINAL -- State number of the termination state. */
692#define YYFINAL 3
693/* YYLAST -- Last index in YYTABLE. */
694#define YYLAST 377
695
696/* YYNTOKENS -- Number of terminals. */
697#define YYNTOKENS 53
698/* YYNNTS -- Number of nonterminals. */
699#define YYNNTS 20
700/* YYNRULES -- Number of rules. */
701#define YYNRULES 77
702/* YYNSTATES -- Number of states. */
703#define YYNSTATES 126
704
705/* YYMAXUTOK -- Last valid token kind. */
706#define YYMAXUTOK 292
707
708
709/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
710 as returned by yylex, with out-of-bounds checking. */
711#define YYTRANSLATE(YYX) \
712 (0 <= (YYX) && (YYX) <= YYMAXUTOK \
713 ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \
714 : YYSYMBOL_YYUNDEF)
715
716/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
717 as returned by yylex. */
718static const yytype_int8 yytranslate[] =
719{
720 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
721 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
722 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
723 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
724 48, 51, 40, 38, 20, 39, 46, 41, 2, 2,
725 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
726 29, 27, 30, 2, 37, 2, 2, 2, 2, 2,
727 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
728 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
729 2, 47, 2, 52, 49, 2, 2, 2, 2, 2,
730 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
731 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
732 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
733 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
734 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
735 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
736 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
737 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
738 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
739 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
740 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
741 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
742 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
743 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
744 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
745 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
746 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
747 15, 16, 17, 18, 19, 21, 22, 23, 24, 25,
748 26, 28, 31, 32, 33, 34, 35, 36, 42, 43,
749 44, 45, 50
750};
751
752#if YYDEBUG
753/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
754static const yytype_int16 yyrline[] =
755{
756 0, 196, 196, 196, 204, 205, 208, 214, 215, 220,
757 226, 232, 236, 240, 244, 249, 253, 271, 287, 296,
758 307, 305, 330, 327, 344, 345, 347, 351, 365, 371,
759 375, 375, 396, 400, 404, 408, 412, 416, 420, 427,
760 434, 441, 448, 455, 462, 466, 470, 474, 478, 485,
761 492, 500, 512, 521, 524, 550, 559, 563, 585, 612,
762 631, 644, 658, 672, 673, 684, 742, 753, 757, 759,
763 761, 766, 776, 777, 778, 779, 782, 783
764};
765#endif
766
768#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
769
770#if YYDEBUG || 0
771/* The user-facing name of the symbol whose (internal) number is
772 YYSYMBOL. No bounds checking. */
773static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED;
774
775/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
776 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
777static const char *const yytname[] =
778{
779 "\"end of file\"", "error", "\"invalid token\"", "INT", "FLOAT",
780 "STRING", "FIELDNAME", "COMPLETE", "NAME", "TYPENAME", "NAME_OR_INT",
781 "STRUCT", "CLASS", "SIZEOF", "COLONCOLON", "ERROR", "DOLLAR_VARIABLE",
782 "THIS", "TRUEKEYWORD", "FALSEKEYWORD", "','", "ABOVE_COMMA", "ASSIGN",
783 "NOT", "OR", "XOR", "ANDAND", "'='", "NOTEQUAL", "'<'", "'>'", "LEQ",
784 "GEQ", "LSH", "RSH", "DIV", "MOD", "'@'", "'+'", "'-'", "'*'", "'/'",
785 "UNARY", "INCREMENT", "DECREMENT", "ARROW", "'.'", "'['", "'('", "'^'",
786 "BLOCKNAME", "')'", "']'", "$accept", "start", "$@1", "normal_start",
787 "type_exp", "exp1", "exp", "field_exp", "$@2", "$@3", "arglist", "$@4",
788 "block", "variable", "qualified_name", "ptype", "type", "typebase",
789 "name", "name_not_typename", YY_NULLPTRPTR
790};
791
792static const char *
794{
795 return yytname[yysymbol];
796}
797#endif
798
799#define YYPACT_NINF (-44)
800
801#define yypact_value_is_default(Yyn) \
802 ((Yyn) == YYPACT_NINF)
803
804#define YYTABLE_NINF (-61)
805
806#define yytable_value_is_error(Yyn) \
807 0
808
809/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
810 STATE-NUM. */
811static const yytype_int16 yypact[] =
812{
813 -44, 20, 90, -44, -44, -44, -44, -44, -44, -44,
814 7, 7, -41, 7, -44, -44, -44, -44, 90, 90,
815 90, -39, -24, 90, 10, 13, -44, -44, 8, 231,
816 4, 21, -44, -44, -44, -14, 41, -44, -44, -44,
817 -44, -44, -44, -44, 90, -44, 35, -14, 35, 35,
818 90, 90, 5, -44, 90, 90, 90, 90, 90, 90,
819 90, 90, 90, 90, 90, 90, 90, 90, 90, 90,
820 90, 90, -44, -44, -44, -44, -44, -44, -44, 23,
821 7, 90, 7, 119, -43, 147, 175, -44, 231, 231,
822 256, 280, 303, 324, 324, 31, 31, 31, 31, 76,
823 76, 76, 76, 328, 328, 35, 90, 90, 90, -44,
824 44, 203, -44, -44, -44, -44, -44, 35, 9, 231,
825 11, -44, -44, 90, -44, 231
826};
827
828/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
829 Performed when YYTABLE does not specify something else to do. Zero
830 means the default is an error. */
831static const yytype_int8 yydefact[] =
832{
833 2, 0, 0, 1, 50, 52, 57, 76, 69, 51,
834 0, 0, 0, 0, 54, 58, 48, 49, 0, 0,
835 0, 0, 0, 0, 0, 77, 3, 5, 4, 7,
836 0, 0, 53, 63, 67, 6, 66, 65, 72, 74,
837 75, 73, 70, 71, 0, 64, 12, 0, 10, 11,
838 0, 0, 0, 68, 0, 0, 0, 0, 0, 0,
839 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
840 0, 0, 30, 15, 20, 22, 9, 16, 19, 17,
841 0, 0, 0, 0, 0, 0, 0, 28, 8, 47,
842 46, 45, 44, 38, 39, 42, 43, 40, 41, 36,
843 37, 32, 33, 34, 35, 29, 0, 0, 24, 18,
844 61, 0, 62, 56, 55, 13, 14, 31, 0, 25,
845 0, 27, 21, 0, 23, 26
846};
847
848/* YYPGOTO[NTERM-NUM]. */
849static const yytype_int8 yypgoto[] =
850{
851 -44, -44, -44, -44, -44, -20, -18, -44, -44, -44,
852 -44, -44, -44, -44, -44, -44, 16, 50, -7, -44
853};
854
855/* YYDEFGOTO[NTERM-NUM]. */
856static const yytype_int8 yydefgoto[] =
857{
858 0, 1, 2, 26, 27, 28, 29, 30, 107, 108,
859 120, 106, 31, 32, 33, 34, 47, 36, 42, 37
860};
861
862/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
863 positive, shift that token. If negative, reduce the rule whose
864 number is the opposite. If YYTABLE_NINF, syntax error. */
865static const yytype_int8 yytable[] =
866{
867 46, 48, 49, 52, 43, 81, 45, 44, 114, 50,
868 77, 78, 38, 39, 40, 38, 39, 40, 35, 8,
869 3, 10, 11, 79, 51, 54, 83, -59, 54, 54,
870 109, 123, 85, 86, 81, 80, 88, 89, 90, 91,
871 92, 93, 94, 95, 96, 97, 98, 99, 100, 101,
872 102, 103, 104, 105, 41, 82, 87, 41, -60, 24,
873 84, 122, 124, 111, 65, 66, 67, 68, 0, 69,
874 70, 71, 72, 110, 53, 112, 0, 73, 74, 75,
875 76, 73, 74, 75, 76, 0, 0, 118, 117, 0,
876 119, 0, 0, 4, 5, 6, 0, 0, 7, 8,
877 9, 10, 11, 12, 13, 125, 14, 15, 16, 17,
878 0, 0, 0, 18, 69, 70, 71, 72, 0, 0,
879 0, 0, 73, 74, 75, 76, 0, 19, 0, 20,
880 0, 0, 0, 21, 22, 0, 0, 0, 23, 24,
881 25, 55, 0, 56, 57, 58, 59, 60, 61, 62,
882 63, 64, 65, 66, 67, 68, 0, 69, 70, 71,
883 72, 0, 0, 0, 0, 73, 74, 75, 76, 55,
884 113, 56, 57, 58, 59, 60, 61, 62, 63, 64,
885 65, 66, 67, 68, 0, 69, 70, 71, 72, 0,
886 0, 0, 0, 73, 74, 75, 76, 55, 115, 56,
887 57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
888 67, 68, 0, 69, 70, 71, 72, 0, 0, 0,
889 0, 73, 74, 75, 76, 55, 116, 56, 57, 58,
890 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
891 0, 69, 70, 71, 72, 0, 0, 0, 0, 73,
892 74, 75, 76, 55, 121, 56, 57, 58, 59, 60,
893 61, 62, 63, 64, 65, 66, 67, 68, 0, 69,
894 70, 71, 72, 0, 0, 0, 0, 73, 74, 75,
895 76, 57, 58, 59, 60, 61, 62, 63, 64, 65,
896 66, 67, 68, 0, 69, 70, 71, 72, 0, 0,
897 0, 0, 73, 74, 75, 76, 58, 59, 60, 61,
898 62, 63, 64, 65, 66, 67, 68, 0, 69, 70,
899 71, 72, 0, 0, 0, 0, 73, 74, 75, 76,
900 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
901 0, 69, 70, 71, 72, 0, 0, 0, 0, 73,
902 74, 75, 76, 61, 62, 63, 64, 65, 66, 67,
903 68, 0, 69, 70, 71, 72, 0, 0, 71, 72,
904 73, 74, 75, 76, 73, 74, 75, 76
905};
906
907static const yytype_int8 yycheck[] =
908{
909 18, 19, 20, 23, 11, 48, 13, 48, 51, 48,
910 6, 7, 8, 9, 10, 8, 9, 10, 2, 9,
911 0, 11, 12, 30, 48, 20, 44, 14, 20, 20,
912 7, 20, 50, 51, 48, 14, 54, 55, 56, 57,
913 58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
914 68, 69, 70, 71, 50, 14, 51, 50, 14, 49,
915 44, 52, 51, 81, 33, 34, 35, 36, -1, 38,
916 39, 40, 41, 80, 24, 82, -1, 46, 47, 48,
917 49, 46, 47, 48, 49, -1, -1, 107, 106, -1,
918 108, -1, -1, 3, 4, 5, -1, -1, 8, 9,
919 10, 11, 12, 13, 14, 123, 16, 17, 18, 19,
920 -1, -1, -1, 23, 38, 39, 40, 41, -1, -1,
921 -1, -1, 46, 47, 48, 49, -1, 37, -1, 39,
922 -1, -1, -1, 43, 44, -1, -1, -1, 48, 49,
923 50, 22, -1, 24, 25, 26, 27, 28, 29, 30,
924 31, 32, 33, 34, 35, 36, -1, 38, 39, 40,
925 41, -1, -1, -1, -1, 46, 47, 48, 49, 22,
926 51, 24, 25, 26, 27, 28, 29, 30, 31, 32,
927 33, 34, 35, 36, -1, 38, 39, 40, 41, -1,
928 -1, -1, -1, 46, 47, 48, 49, 22, 51, 24,
929 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
930 35, 36, -1, 38, 39, 40, 41, -1, -1, -1,
931 -1, 46, 47, 48, 49, 22, 51, 24, 25, 26,
932 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
933 -1, 38, 39, 40, 41, -1, -1, -1, -1, 46,
934 47, 48, 49, 22, 51, 24, 25, 26, 27, 28,
935 29, 30, 31, 32, 33, 34, 35, 36, -1, 38,
936 39, 40, 41, -1, -1, -1, -1, 46, 47, 48,
937 49, 25, 26, 27, 28, 29, 30, 31, 32, 33,
938 34, 35, 36, -1, 38, 39, 40, 41, -1, -1,
939 -1, -1, 46, 47, 48, 49, 26, 27, 28, 29,
940 30, 31, 32, 33, 34, 35, 36, -1, 38, 39,
941 40, 41, -1, -1, -1, -1, 46, 47, 48, 49,
942 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
943 -1, 38, 39, 40, 41, -1, -1, -1, -1, 46,
944 47, 48, 49, 29, 30, 31, 32, 33, 34, 35,
945 36, -1, 38, 39, 40, 41, -1, -1, 40, 41,
946 46, 47, 48, 49, 46, 47, 48, 49
947};
948
949/* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of
950 state STATE-NUM. */
951static const yytype_int8 yystos[] =
952{
953 0, 54, 55, 0, 3, 4, 5, 8, 9, 10,
954 11, 12, 13, 14, 16, 17, 18, 19, 23, 37,
955 39, 43, 44, 48, 49, 50, 56, 57, 58, 59,
956 60, 65, 66, 67, 68, 69, 70, 72, 8, 9,
957 10, 50, 71, 71, 48, 71, 59, 69, 59, 59,
958 48, 48, 58, 70, 20, 22, 24, 25, 26, 27,
959 28, 29, 30, 31, 32, 33, 34, 35, 36, 38,
960 39, 40, 41, 46, 47, 48, 49, 6, 7, 71,
961 14, 48, 14, 59, 69, 59, 59, 51, 59, 59,
962 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
963 59, 59, 59, 59, 59, 59, 64, 61, 62, 7,
964 71, 59, 71, 51, 51, 51, 51, 59, 58, 59,
965 63, 51, 52, 20, 51, 59
966};
967
968/* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */
969static const yytype_int8 yyr1[] =
970{
971 0, 53, 55, 54, 56, 56, 57, 58, 58, 59,
972 59, 59, 59, 59, 59, 60, 59, 59, 59, 59,
973 61, 59, 62, 59, 63, 63, 63, 59, 59, 59,
974 64, 59, 59, 59, 59, 59, 59, 59, 59, 59,
975 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
976 59, 59, 59, 59, 59, 59, 59, 59, 59, 65,
977 65, 66, 67, 66, 66, 66, 68, 69, 70, 70,
978 70, 70, 71, 71, 71, 71, 72, 72
979};
980
981/* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */
982static const yytype_int8 yyr2[] =
983{
984 0, 2, 0, 2, 1, 1, 1, 1, 3, 2,
985 2, 2, 2, 4, 4, 2, 2, 2, 3, 2,
986 0, 5, 0, 5, 0, 1, 3, 4, 3, 3,
987 0, 4, 3, 3, 3, 3, 3, 3, 3, 3,
988 3, 3, 3, 3, 3, 3, 3, 3, 1, 1,
989 1, 1, 1, 1, 1, 4, 4, 1, 1, 1,
990 3, 3, 3, 1, 2, 1, 1, 1, 2, 1,
991 2, 2, 1, 1, 1, 1, 1, 1
992};
993
994
995enum { YYENOMEM = -2 };
996
997#define yyerrok (yyerrstatus = 0)
998#define yyclearin (yychar = YYEMPTY)
999
1000#define YYACCEPT goto yyacceptlab
1001#define YYABORT goto yyabortlab
1002#define YYERROR goto yyerrorlab
1003#define YYNOMEM goto yyexhaustedlab
1004
1005
1006#define YYRECOVERING() (!!yyerrstatus)
1007
1008#define YYBACKUP(Token, Value) \
1009 do \
1010 if (yychar == YYEMPTY) \
1011 { \
1012 yychar = (Token); \
1013 yylval = (Value); \
1014 YYPOPSTACK (yylen); \
1015 yystate = *yyssp; \
1016 goto yybackup; \
1017 } \
1018 else \
1019 { \
1020 yyerror (YY_("syntax error: cannot back up")); \
1021 YYERROR; \
1022 } \
1023 while (0)
1024
1025/* Backward compatibility with an undocumented macro.
1026 Use YYerror or YYUNDEF. */
1027#define YYERRCODE YYUNDEF
1028
1029
1030/* Enable debugging if requested. */
1031#if YYDEBUG
1032
1033# ifndef YYFPRINTF
1034# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1035# define YYFPRINTF fprintf
1036# endif
1037
1038# define YYDPRINTF(Args) \
1039do { \
1040 if (yydebug) \
1041 YYFPRINTF Args; \
1042} while (0)
1043
1044
1045
1046
1047# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \
1048do { \
1049 if (yydebug) \
1050 { \
1051 YYFPRINTF (stderr, "%s ", Title); \
1052 yy_symbol_print (stderr, \
1053 Kind, Value); \
1054 YYFPRINTF (stderr, "\n"); \
1055 } \
1056} while (0)
1057
1058
1059/*-----------------------------------.
1060| Print this symbol's value on YYO. |
1061`-----------------------------------*/
1062
1063static void
1065 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
1066{
1067 FILE *yyoutput = yyo;
1068 YY_USE (yyoutput);
1069 if (!yyvaluep)
1070 return;
1072 YY_USE (yykind);
1074}
1075
1076
1077/*---------------------------.
1078| Print this symbol on YYO. |
1079`---------------------------*/
1080
1081static void
1083 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
1084{
1085 YYFPRINTF (yyo, "%s %s (",
1086 yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));
1087
1088 yy_symbol_value_print (yyo, yykind, yyvaluep);
1089 YYFPRINTF (yyo, ")");
1090}
1091
1092/*------------------------------------------------------------------.
1093| yy_stack_print -- Print the state stack from its BOTTOM up to its |
1094| TOP (included). |
1095`------------------------------------------------------------------*/
1096
1097static void
1099{
1100 YYFPRINTF (stderr, "Stack now");
1101 for (; yybottom <= yytop; yybottom++)
1102 {
1103 int yybot = *yybottom;
1104 YYFPRINTF (stderr, " %d", yybot);
1105 }
1106 YYFPRINTF (stderr, "\n");
1107}
1108
1109# define YY_STACK_PRINT(Bottom, Top) \
1110do { \
1111 if (yydebug) \
1112 yy_stack_print ((Bottom), (Top)); \
1113} while (0)
1114
1115
1116/*------------------------------------------------.
1117| Report that the YYRULE is going to be reduced. |
1118`------------------------------------------------*/
1119
1120static void
1122 int yyrule)
1123{
1124 int yylno = yyrline[yyrule];
1125 int yynrhs = yyr2[yyrule];
1126 int yyi;
1127 YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
1128 yyrule - 1, yylno);
1129 /* The symbols being reduced. */
1130 for (yyi = 0; yyi < yynrhs; yyi++)
1131 {
1132 YYFPRINTF (stderr, " $%d = ", yyi + 1);
1133 yy_symbol_print (stderr,
1134 YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
1135 &yyvsp[(yyi + 1) - (yynrhs)]);
1136 YYFPRINTF (stderr, "\n");
1137 }
1138}
1139
1140# define YY_REDUCE_PRINT(Rule) \
1141do { \
1142 if (yydebug) \
1143 yy_reduce_print (yyssp, yyvsp, Rule); \
1144} while (0)
1145
1146/* Nonzero means print parse trace. It is left uninitialized so that
1147 multiple parsers can coexist. */
1149#else /* !YYDEBUG */
1150# define YYDPRINTF(Args) ((void) 0)
1151# define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
1152# define YY_STACK_PRINT(Bottom, Top)
1153# define YY_REDUCE_PRINT(Rule)
1154#endif /* !YYDEBUG */
1155
1156
1157/* YYINITDEPTH -- initial size of the parser's stacks. */
1158#ifndef YYINITDEPTH
1159# define YYINITDEPTH 200
1160#endif
1161
1162/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1163 if the built-in stack extension method is used).
1164
1165 Do not make this value too large; the results are undefined if
1166 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1167 evaluated with infinite-precision integer arithmetic. */
1168
1169#ifndef YYMAXDEPTH
1170# define YYMAXDEPTH 10000
1171#endif
1172
1173
1174
1175
1176
1177
1178/*-----------------------------------------------.
1179| Release the memory associated to this symbol. |
1180`-----------------------------------------------*/
1181
1182static void
1183yydestruct (const char *yymsg,
1184 yysymbol_kind_t yykind, YYSTYPE *yyvaluep)
1185{
1186 YY_USE (yyvaluep);
1187 if (!yymsg)
1188 yymsg = "Deleting";
1189 YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
1190
1192 YY_USE (yykind);
1194}
1195
1196
1197/* Lookahead token kind. */
1199
1200/* The semantic value of the lookahead symbol. */
1202/* Number of syntax errors so far. */
1204
1205
1206
1207
1208/*----------.
1209| yyparse. |
1210`----------*/
1211
1212int
1214{
1216 /* Number of tokens to shift before error messages enabled. */
1217 int yyerrstatus = 0;
1218
1219 /* Refer to the stacks through separate pointers, to allow yyoverflow
1220 to xreallocate them elsewhere. */
1221
1222 /* Their size. */
1224
1225 /* The state stack: array, bottom, top. */
1226 yy_state_t yyssa[YYINITDEPTH];
1227 yy_state_t *yyss = yyssa;
1229
1230 /* The semantic value stack: array, bottom, top. */
1231 YYSTYPE yyvsa[YYINITDEPTH];
1232 YYSTYPE *yyvs = yyvsa;
1233 YYSTYPE *yyvsp = yyvs;
1234
1235 int yyn;
1236 /* The return value of yyparse. */
1237 int yyresult;
1238 /* Lookahead symbol kind. */
1240 /* The variables used to return semantic value and location from the
1241 action routines. */
1242 YYSTYPE yyval;
1243
1244
1245
1246#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1247
1248 /* The number of symbols on the RHS of the reduced rule.
1249 Keep to zero when no symbol should be popped. */
1250 int yylen = 0;
1251
1252 YYDPRINTF ((stderr, "Starting parse\n"));
1253
1254 yychar = YYEMPTY; /* Cause a token to be read. */
1255
1256 goto yysetstate;
1257
1258
1259/*------------------------------------------------------------.
1260| yynewstate -- push a new state, which is found in yystate. |
1261`------------------------------------------------------------*/
1262yynewstate:
1263 /* In all cases, when you get here, the value and location stacks
1264 have just been pushed. So pushing a state here evens the stacks. */
1265 yyssp++;
1266
1267
1268/*--------------------------------------------------------------------.
1269| yysetstate -- set current state (the top of the stack) to yystate. |
1270`--------------------------------------------------------------------*/
1271yysetstate:
1272 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1273 YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
1278
1279 if (yyss + yystacksize - 1 <= yyssp)
1280#if !defined yyoverflow && !defined YYSTACK_RELOCATE
1281 YYNOMEM;
1282#else
1283 {
1284 /* Get the current used size of the three stacks, in elements. */
1285 YYPTRDIFF_T yysize = yyssp - yyss + 1;
1286
1287# if defined yyoverflow
1288 {
1289 /* Give user a chance to xreallocate the stack. Use copies of
1290 these so that the &'s don't force the real ones into
1291 memory. */
1292 yy_state_t *yyss1 = yyss;
1293 YYSTYPE *yyvs1 = yyvs;
1294
1295 /* Each stack pointer address is followed by the size of the
1296 data in use in that stack, in bytes. This used to be a
1297 conditional around just the two extra args, but that might
1298 be undefined if yyoverflow is a macro. */
1299 yyoverflow (YY_("memory exhausted"),
1300 &yyss1, yysize * YYSIZEOF (*yyssp),
1301 &yyvs1, yysize * YYSIZEOF (*yyvsp),
1302 &yystacksize);
1303 yyss = yyss1;
1304 yyvs = yyvs1;
1305 }
1306# else /* defined YYSTACK_RELOCATE */
1307 /* Extend the stack our own way. */
1308 if (YYMAXDEPTH <= yystacksize)
1309 YYNOMEM;
1310 yystacksize *= 2;
1311 if (YYMAXDEPTH < yystacksize)
1313
1314 {
1315 yy_state_t *yyss1 = yyss;
1316 union yyalloc *yyptr =
1317 YY_CAST (union yyalloc *,
1319 if (! yyptr)
1320 YYNOMEM;
1323# undef YYSTACK_RELOCATE
1324 if (yyss1 != yyssa)
1325 YYSTACK_FREE (yyss1);
1326 }
1327# endif
1328
1329 yyssp = yyss + yysize - 1;
1330 yyvsp = yyvs + yysize - 1;
1331
1333 YYDPRINTF ((stderr, "Stack size increased to %ld\n",
1334 YY_CAST (long, yystacksize)));
1336
1337 if (yyss + yystacksize - 1 <= yyssp)
1338 YYABORT;
1339 }
1340#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
1341
1342
1343 if (yystate == YYFINAL)
1344 YYACCEPT;
1345
1346 goto yybackup;
1347
1348
1349/*-----------.
1350| yybackup. |
1351`-----------*/
1352yybackup:
1353 /* Do appropriate processing given the current state. Read a
1354 lookahead token if we need one and don't already have one. */
1355
1356 /* First try to decide what to do without reference to lookahead token. */
1357 yyn = yypact[yystate];
1358 if (yypact_value_is_default (yyn))
1359 goto yydefault;
1360
1361 /* Not known => get a lookahead token if don't already have one. */
1362
1363 /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */
1364 if (yychar == YYEMPTY)
1365 {
1366 YYDPRINTF ((stderr, "Reading a token\n"));
1367 yychar = yylex ();
1368 }
1369
1370 if (yychar <= YYEOF)
1371 {
1372 yychar = YYEOF;
1373 yytoken = YYSYMBOL_YYEOF;
1374 YYDPRINTF ((stderr, "Now at end of input.\n"));
1375 }
1376 else if (yychar == YYerror)
1377 {
1378 /* The scanner already issued an error message, process directly
1379 to error recovery. But do not keep the error token as
1380 lookahead, it is too special and may lead us to an endless
1381 loop in error recovery. */
1382 yychar = YYUNDEF;
1383 yytoken = YYSYMBOL_YYerror;
1384 goto yyerrlab1;
1385 }
1386 else
1387 {
1388 yytoken = YYTRANSLATE (yychar);
1389 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1390 }
1391
1392 /* If the proper action on seeing token YYTOKEN is to reduce or to
1393 detect an error, take that action. */
1394 yyn += yytoken;
1395 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1396 goto yydefault;
1397 yyn = yytable[yyn];
1398 if (yyn <= 0)
1399 {
1400 if (yytable_value_is_error (yyn))
1401 goto yyerrlab;
1402 yyn = -yyn;
1403 goto yyreduce;
1404 }
1405
1406 /* Count tokens shifted since error; after three, turn off error
1407 status. */
1408 if (yyerrstatus)
1409 yyerrstatus--;
1410
1411 /* Shift the lookahead token. */
1412 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1413 yystate = yyn;
1415 *++yyvsp = yylval;
1417
1418 /* Discard the shifted token. */
1419 yychar = YYEMPTY;
1420 goto yynewstate;
1421
1422
1423/*-----------------------------------------------------------.
1424| yydefault -- do the default action for the current state. |
1425`-----------------------------------------------------------*/
1426yydefault:
1427 yyn = yydefact[yystate];
1428 if (yyn == 0)
1429 goto yyerrlab;
1430 goto yyreduce;
1431
1432
1433/*-----------------------------.
1434| yyreduce -- do a reduction. |
1435`-----------------------------*/
1436yyreduce:
1437 /* yyn is the number of a rule to reduce with. */
1438 yylen = yyr2[yyn];
1439
1440 /* If YYLEN is nonzero, implement the default value of the action:
1441 '$$ = $1'.
1442
1443 Otherwise, the following line sets YYVAL to garbage.
1444 This behavior is undocumented and Bison
1445 users should not rely upon it. Assigning to YYVAL
1446 unconditionally makes the parser a bit smaller, and it avoids a
1447 GCC warning that YYVAL may be used uninitialized. */
1448 yyval = yyvsp[1-yylen];
1449
1450
1451 YY_REDUCE_PRINT (yyn);
1452 switch (yyn)
1453 {
1454 case 2: /* $@1: %empty */
1455#line 196 "p-exp.y"
1456 { current_type = NULL;
1457 search_field = 0;
1459 }
1460#line 1462 "p-exp.c.tmp"
1461 break;
1462
1463 case 3: /* start: $@1 normal_start */
1464#line 200 "p-exp.y"
1465 {}
1466#line 1468 "p-exp.c.tmp"
1467 break;
1468
1469 case 6: /* type_exp: type */
1470#line 209 "p-exp.y"
1471 {
1472 pstate->push_new<type_operation> ((yyvsp[0].tval));
1473 current_type = (yyvsp[0].tval); }
1474#line 1476 "p-exp.c.tmp"
1475 break;
1476
1477 case 8: /* exp1: exp1 ',' exp */
1478#line 216 "p-exp.y"
1479 { pstate->wrap2<comma_operation> (); }
1480#line 1482 "p-exp.c.tmp"
1481 break;
1482
1483 case 9: /* exp: exp '^' */
1484#line 221 "p-exp.y"
1486 if (current_type)
1488#line 1490 "p-exp.c.tmp"
1489 break;
1490
1491 case 10: /* exp: '@' exp */
1492#line 227 "p-exp.y"
1494 if (current_type)
1496#line 1498 "p-exp.c.tmp"
1497 break;
1498
1499 case 11: /* exp: '-' exp */
1500#line 233 "p-exp.y"
1502#line 1504 "p-exp.c.tmp"
1503 break;
1504
1505 case 12: /* exp: NOT exp */
1506#line 237 "p-exp.y"
1508#line 1510 "p-exp.c.tmp"
1509 break;
1510
1511 case 13: /* exp: INCREMENT '(' exp ')' */
1512#line 241 "p-exp.y"
1513 { pstate->wrap<preinc_operation> (); }
1514#line 1516 "p-exp.c.tmp"
1515 break;
1516
1517 case 14: /* exp: DECREMENT '(' exp ')' */
1518#line 245 "p-exp.y"
1519 { pstate->wrap<predec_operation> (); }
1520#line 1522 "p-exp.c.tmp"
1521 break;
1522
1523 case 15: /* field_exp: exp '.' */
1524#line 250 "p-exp.y"
1525 { search_field = 1; }
1526#line 1528 "p-exp.c.tmp"
1527 break;
1528
1529 case 16: /* exp: field_exp FIELDNAME */
1530#line 254 "p-exp.y"
1531 {
1533 (pstate->pop (), copy_name ((yyvsp[0].sval)));
1534 search_field = 0;
1535 if (current_type)
1536 {
1537 while (current_type->code ()
1538 == TYPE_CODE_PTR)
1539 current_type =
1542 current_type, (yyvsp[0].sval).ptr, 0);
1543 }
1544 }
1545#line 1547 "p-exp.c.tmp"
1546 break;
1547
1548 case 17: /* exp: field_exp name */
1549#line 272 "p-exp.y"
1550 {
1552 (pstate->pop (), copy_name ((yyvsp[0].sval)));
1553 search_field = 0;
1554 if (current_type)
1555 {
1556 while (current_type->code ()
1557 == TYPE_CODE_PTR)
1558 current_type =
1561 current_type, (yyvsp[0].sval).ptr, 0);
1562 }
1563 }
1564#line 1566 "p-exp.c.tmp"
1565 break;
1566
1567 case 18: /* exp: field_exp name COMPLETE */
1568#line 288 "p-exp.y"
1569 {
1572 copy_name ((yyvsp[-1].sval)));
1574 pstate->push (operation_up (op));
1575 }
1576#line 1578 "p-exp.c.tmp"
1577 break;
1578
1579 case 19: /* exp: field_exp COMPLETE */
1580#line 297 "p-exp.y"
1581 {
1583 = new structop_ptr_operation (pstate->pop (), "");
1585 pstate->push (operation_up (op));
1586 }
1587#line 1589 "p-exp.c.tmp"
1588 break;
1589
1590 case 20: /* $@2: %empty */
1591#line 307 "p-exp.y"
1592 { const char *arrayname;
1593 int arrayfieldindex
1594 = pascal_is_string_type (current_type, NULL, NULL,
1595 NULL, NULL, &arrayname);
1596 if (arrayfieldindex)
1597 {
1599 = (current_type
1600 ->field (arrayfieldindex - 1).type ());
1602 (pstate->pop (), arrayname);
1603 }
1604 push_current_type (); }
1605#line 1607 "p-exp.c.tmp"
1606 break;
1607
1608 case 21: /* exp: exp '[' $@2 exp1 ']' */
1609#line 321 "p-exp.y"
1610 { pop_current_type ();
1612 if (current_type)
1614#line 1616 "p-exp.c.tmp"
1615 break;
1616
1617 case 22: /* $@3: %empty */
1618#line 330 "p-exp.y"
1619 { push_current_type ();
1620 pstate->start_arglist (); }
1621#line 1623 "p-exp.c.tmp"
1622 break;
1623
1624 case 23: /* exp: exp '(' $@3 arglist ')' */
1625#line 333 "p-exp.y"
1626 {
1627 std::vector<operation_up> args
1630 (pstate->pop (), std::move (args));
1632 if (current_type)
1634 }
1635#line 1637 "p-exp.c.tmp"
1636 break;
1637
1638 case 25: /* arglist: exp */
1639#line 346 "p-exp.y"
1640 { pstate->arglist_len = 1; }
1641#line 1643 "p-exp.c.tmp"
1642 break;
1643
1644 case 26: /* arglist: arglist ',' exp */
1645#line 348 "p-exp.y"
1646 { pstate->arglist_len++; }
1647#line 1649 "p-exp.c.tmp"
1648 break;
1649
1650 case 27: /* exp: type '(' exp ')' */
1651#line 352 "p-exp.y"
1652 { if (current_type)
1653 {
1654 /* Allow automatic dereference of classes. */
1655 if ((current_type->code () == TYPE_CODE_PTR)
1656 && (current_type->target_type ()->code () == TYPE_CODE_STRUCT)
1657 && (((yyvsp[-3].tval))->code () == TYPE_CODE_STRUCT))
1659 }
1661 (pstate->pop (), (yyvsp[-3].tval));
1662 current_type = (yyvsp[-3].tval); }
1663#line 1665 "p-exp.c.tmp"
1664 break;
1665
1666 case 28: /* exp: '(' exp1 ')' */
1667#line 366 "p-exp.y"
1668 { }
1669#line 1671 "p-exp.c.tmp"
1670 break;
1671
1672 case 29: /* exp: exp '*' exp */
1673#line 372 "p-exp.y"
1674 { pstate->wrap2<mul_operation> (); }
1675#line 1677 "p-exp.c.tmp"
1676 break;
1677
1678 case 30: /* $@4: %empty */
1679#line 375 "p-exp.y"
1680 {
1683 }
1684#line 1686 "p-exp.c.tmp"
1685 break;
1686
1687 case 31: /* exp: exp '/' $@4 exp */
1688#line 380 "p-exp.y"
1689 {
1692 {
1694 (pstate->pop (),
1695 parse_type (pstate)->builtin_long_double);
1697 = parse_type (pstate)->builtin_long_double;
1699 }
1700
1702 }
1703#line 1705 "p-exp.c.tmp"
1704 break;
1705
1706 case 32: /* exp: exp DIV exp */
1707#line 397 "p-exp.y"
1708 { pstate->wrap2<intdiv_operation> (); }
1709#line 1711 "p-exp.c.tmp"
1710 break;
1711
1712 case 33: /* exp: exp MOD exp */
1713#line 401 "p-exp.y"
1714 { pstate->wrap2<rem_operation> (); }
1715#line 1717 "p-exp.c.tmp"
1716 break;
1717
1718 case 34: /* exp: exp '+' exp */
1719#line 405 "p-exp.y"
1720 { pstate->wrap2<add_operation> (); }
1721#line 1723 "p-exp.c.tmp"
1722 break;
1723
1724 case 35: /* exp: exp '-' exp */
1725#line 409 "p-exp.y"
1726 { pstate->wrap2<sub_operation> (); }
1727#line 1729 "p-exp.c.tmp"
1728 break;
1729
1730 case 36: /* exp: exp LSH exp */
1731#line 413 "p-exp.y"
1732 { pstate->wrap2<lsh_operation> (); }
1733#line 1735 "p-exp.c.tmp"
1734 break;
1735
1736 case 37: /* exp: exp RSH exp */
1737#line 417 "p-exp.y"
1738 { pstate->wrap2<rsh_operation> (); }
1739#line 1741 "p-exp.c.tmp"
1740 break;
1741
1742 case 38: /* exp: exp '=' exp */
1743#line 421 "p-exp.y"
1744 {
1746 current_type = parse_type (pstate)->builtin_bool;
1747 }
1748#line 1750 "p-exp.c.tmp"
1749 break;
1750
1751 case 39: /* exp: exp NOTEQUAL exp */
1752#line 428 "p-exp.y"
1753 {
1755 current_type = parse_type (pstate)->builtin_bool;
1756 }
1757#line 1759 "p-exp.c.tmp"
1758 break;
1759
1760 case 40: /* exp: exp LEQ exp */
1761#line 435 "p-exp.y"
1762 {
1764 current_type = parse_type (pstate)->builtin_bool;
1765 }
1766#line 1768 "p-exp.c.tmp"
1767 break;
1768
1769 case 41: /* exp: exp GEQ exp */
1770#line 442 "p-exp.y"
1771 {
1773 current_type = parse_type (pstate)->builtin_bool;
1774 }
1775#line 1777 "p-exp.c.tmp"
1776 break;
1777
1778 case 42: /* exp: exp '<' exp */
1779#line 449 "p-exp.y"
1780 {
1782 current_type = parse_type (pstate)->builtin_bool;
1783 }
1784#line 1786 "p-exp.c.tmp"
1785 break;
1786
1787 case 43: /* exp: exp '>' exp */
1788#line 456 "p-exp.y"
1789 {
1791 current_type = parse_type (pstate)->builtin_bool;
1792 }
1793#line 1795 "p-exp.c.tmp"
1794 break;
1795
1796 case 44: /* exp: exp ANDAND exp */
1797#line 463 "p-exp.y"
1799#line 1801 "p-exp.c.tmp"
1800 break;
1801
1802 case 45: /* exp: exp XOR exp */
1803#line 467 "p-exp.y"
1805#line 1807 "p-exp.c.tmp"
1806 break;
1807
1808 case 46: /* exp: exp OR exp */
1809#line 471 "p-exp.y"
1811#line 1813 "p-exp.c.tmp"
1812 break;
1813
1814 case 47: /* exp: exp ASSIGN exp */
1815#line 475 "p-exp.y"
1816 { pstate->wrap2<assign_operation> (); }
1817#line 1819 "p-exp.c.tmp"
1818 break;
1819
1820 case 48: /* exp: TRUEKEYWORD */
1821#line 479 "p-exp.y"
1822 {
1823 pstate->push_new<bool_operation> ((yyvsp[0].lval));
1824 current_type = parse_type (pstate)->builtin_bool;
1825 }
1826#line 1828 "p-exp.c.tmp"
1827 break;
1828
1829 case 49: /* exp: FALSEKEYWORD */
1830#line 486 "p-exp.y"
1831 {
1832 pstate->push_new<bool_operation> ((yyvsp[0].lval));
1833 current_type = parse_type (pstate)->builtin_bool;
1834 }
1835#line 1837 "p-exp.c.tmp"
1836 break;
1837
1838 case 50: /* exp: INT */
1839#line 493 "p-exp.y"
1840 {
1842 ((yyvsp[0].typed_val_int).type, (yyvsp[0].typed_val_int).val);
1843 current_type = (yyvsp[0].typed_val_int).type;
1844 }
1845#line 1847 "p-exp.c.tmp"
1846 break;
1847
1848 case 51: /* exp: NAME_OR_INT */
1849#line 501 "p-exp.y"
1850 { YYSTYPE val;
1851 parse_number (pstate, (yyvsp[0].ssym).stoken.ptr,
1852 (yyvsp[0].ssym).stoken.length, 0, &val);
1854 (val.typed_val_int.type,
1855 val.typed_val_int.val);
1857 }
1858#line 1860 "p-exp.c.tmp"
1859 break;
1860
1861 case 52: /* exp: FLOAT */
1862#line 513 "p-exp.y"
1863 {
1864 float_data data;
1865 std::copy (std::begin ((yyvsp[0].typed_val_float).val), std::end ((yyvsp[0].typed_val_float).val),
1866 std::begin (data));
1867 pstate->push_new<float_const_operation> ((yyvsp[0].typed_val_float).type, data);
1868 }
1869#line 1871 "p-exp.c.tmp"
1870 break;
1871
1872 case 54: /* exp: DOLLAR_VARIABLE */
1873#line 525 "p-exp.y"
1874 {
1875 pstate->push_dollar ((yyvsp[0].sval));
1876
1877 /* $ is the normal prefix for pascal
1878 hexadecimal values but this conflicts
1879 with the GDB use for debugger variables
1880 so in expression to enter hexadecimal
1881 values we still need to use C syntax with
1882 0xff */
1883 std::string tmp ((yyvsp[0].sval).ptr, (yyvsp[0].sval).length);
1884 /* Handle current_type. */
1885 struct internalvar *intvar
1886 = lookup_only_internalvar (tmp.c_str () + 1);
1887 if (intvar != nullptr)
1888 {
1889 scoped_value_mark mark;
1890
1891 value *val
1893 intvar);
1894 current_type = value_type (val);
1895 }
1896 }
1897#line 1899 "p-exp.c.tmp"
1898 break;
1899
1900 case 55: /* exp: SIZEOF '(' type ')' */
1901#line 551 "p-exp.y"
1902 {
1903 current_type = parse_type (pstate)->builtin_int;
1904 (yyvsp[-1].tval) = check_typedef ((yyvsp[-1].tval));
1906 (parse_type (pstate)->builtin_int,
1907 (yyvsp[-1].tval)->length ()); }
1908#line 1910 "p-exp.c.tmp"
1909 break;
1910
1911 case 56: /* exp: SIZEOF '(' exp ')' */
1912#line 560 "p-exp.y"
1914 current_type = parse_type (pstate)->builtin_int; }
1915#line 1917 "p-exp.c.tmp"
1916 break;
1917
1918 case 57: /* exp: STRING */
1919#line 564 "p-exp.y"
1920 { /* C strings are converted into array constants with
1921 an explicit null byte added at the end. Thus
1922 the array upper bound is the string length.
1923 There is no such thing in C as a completely empty
1924 string. */
1925 const char *sp = (yyvsp[0].sval).ptr; int count = (yyvsp[0].sval).length;
1926
1927 std::vector<operation_up> args (count + 1);
1928 for (int i = 0; i < count; ++i)
1929 args[i] = (make_operation<long_const_operation>
1930 (parse_type (pstate)->builtin_char,
1931 *sp++));
1932 args[count] = (make_operation<long_const_operation>
1933 (parse_type (pstate)->builtin_char,
1934 '\0'));
1936 (0, (yyvsp[0].sval).length, std::move (args));
1937 }
1938#line 1940 "p-exp.c.tmp"
1939 break;
1940
1941 case 58: /* exp: THIS */
1942#line 586 "p-exp.y"
1943 {
1944 struct value * this_val;
1945 struct type * this_type;
1947 /* We need type of this. */
1948 this_val
1950 if (this_val)
1951 this_type = value_type (this_val);
1952 else
1953 this_type = NULL;
1954 if (this_type)
1955 {
1956 if (this_type->code () == TYPE_CODE_PTR)
1957 {
1958 this_type = this_type->target_type ();
1960 }
1961 }
1962
1963 current_type = this_type;
1964 }
1965#line 1967 "p-exp.c.tmp"
1966 break;
1967
1968 case 59: /* block: BLOCKNAME */
1969#line 613 "p-exp.y"
1970 {
1971 if ((yyvsp[0].ssym).sym.symbol != 0)
1972 (yyval.bval) = (yyvsp[0].ssym).sym.symbol->value_block ();
1973 else
1974 {
1975 std::string copy = copy_name ((yyvsp[0].ssym).stoken);
1976 struct symtab *tem =
1977 lookup_symtab (copy.c_str ());
1978 if (tem)
1979 (yyval.bval) = (tem->compunit ()->blockvector ()
1980 ->static_block ());
1981 else
1982 error (_("No file or function \"%s\"."),
1983 copy.c_str ());
1984 }
1985 }
1986#line 1988 "p-exp.c.tmp"
1987 break;
1988
1989 case 60: /* block: block COLONCOLON name */
1990#line 632 "p-exp.y"
1991 {
1992 std::string copy = copy_name ((yyvsp[0].sval));
1993 struct symbol *tem
1994 = lookup_symbol (copy.c_str (), (yyvsp[-2].bval),
1995 VAR_DOMAIN, NULL).symbol;
1996
1997 if (!tem || tem->aclass () != LOC_BLOCK)
1998 error (_("No function \"%s\" in specified context."),
1999 copy.c_str ());
2000 (yyval.bval) = tem->value_block (); }
2001#line 2003 "p-exp.c.tmp"
2002 break;
2003
2004 case 61: /* variable: block COLONCOLON name */
2005#line 645 "p-exp.y"
2006 { struct block_symbol sym;
2007
2008 std::string copy = copy_name ((yyvsp[0].sval));
2009 sym = lookup_symbol (copy.c_str (), (yyvsp[-2].bval),
2010 VAR_DOMAIN, NULL);
2011 if (sym.symbol == 0)
2012 error (_("No symbol \"%s\" in specified context."),
2013 copy.c_str ());
2014
2016 }
2017#line 2019 "p-exp.c.tmp"
2018 break;
2019
2020 case 62: /* qualified_name: typebase COLONCOLON name */
2021#line 659 "p-exp.y"
2022 {
2023 struct type *type = (yyvsp[-2].tval);
2024
2025 if (type->code () != TYPE_CODE_STRUCT
2026 && type->code () != TYPE_CODE_UNION)
2027 error (_("`%s' is not defined as an aggregate type."),
2028 type->name ());
2029
2031 (type, copy_name ((yyvsp[0].sval)));
2032 }
2033#line 2035 "p-exp.c.tmp"
2034 break;
2035
2036 case 64: /* variable: COLONCOLON name */
2037#line 674 "p-exp.y"
2038 {
2039 std::string name = copy_name ((yyvsp[0].sval));
2040
2041 struct block_symbol sym
2042 = lookup_symbol (name.c_str (), nullptr,
2043 VAR_DOMAIN, nullptr);
2044 pstate->push_symbol (name.c_str (), sym);
2045 }
2046#line 2048 "p-exp.c.tmp"
2047 break;
2048
2049 case 65: /* variable: name_not_typename */
2050#line 685 "p-exp.y"
2051 { struct block_symbol sym = (yyvsp[0].ssym).sym;
2052
2053 if (sym.symbol)
2054 {
2056 pstate->block_tracker->update (sym);
2057
2059 current_type = sym.symbol->type (); }
2060 else if ((yyvsp[0].ssym).is_a_field_of_this)
2061 {
2062 struct value * this_val;
2063 struct type * this_type;
2064 /* Object pascal: it hangs off of `this'. Must
2065 not inadvertently convert from a method call
2066 to data ref. */
2067 pstate->block_tracker->update (sym);
2068 operation_up thisop
2069 = make_operation<op_this_operation> ();
2071 (std::move (thisop), copy_name ((yyvsp[0].ssym).stoken));
2072 /* We need type of this. */
2073 this_val
2075 if (this_val)
2076 this_type = value_type (this_val);
2077 else
2078 this_type = NULL;
2079 if (this_type)
2081 this_type,
2082 copy_name ((yyvsp[0].ssym).stoken).c_str (), 0);
2083 else
2084 current_type = NULL;
2085 }
2086 else
2087 {
2088 struct bound_minimal_symbol msymbol;
2089 std::string arg = copy_name ((yyvsp[0].ssym).stoken);
2090
2091 msymbol =
2092 lookup_bound_minimal_symbol (arg.c_str ());
2093 if (msymbol.minsym != NULL)
2095 (msymbol);
2096 else if (!have_full_symbols ()
2097 && !have_partial_symbols ())
2098 error (_("No symbol table is loaded. "
2099 "Use the \"file\" command."));
2100 else
2101 error (_("No symbol \"%s\" in current context."),
2102 arg.c_str ());
2103 }
2104 }
2105#line 2107 "p-exp.c.tmp"
2106 break;
2107
2108 case 68: /* typebase: '^' typebase */
2109#line 758 "p-exp.y"
2110 { (yyval.tval) = lookup_pointer_type ((yyvsp[0].tval)); }
2111#line 2113 "p-exp.c.tmp"
2112 break;
2113
2114 case 69: /* typebase: TYPENAME */
2115#line 760 "p-exp.y"
2116 { (yyval.tval) = (yyvsp[0].tsym).type; }
2117#line 2119 "p-exp.c.tmp"
2118 break;
2119
2120 case 70: /* typebase: STRUCT name */
2121#line 762 "p-exp.y"
2122 { (yyval.tval)
2123 = lookup_struct (copy_name ((yyvsp[0].sval)).c_str (),
2125 }
2126#line 2128 "p-exp.c.tmp"
2127 break;
2128
2129 case 71: /* typebase: CLASS name */
2130#line 767 "p-exp.y"
2131 { (yyval.tval)
2132 = lookup_struct (copy_name ((yyvsp[0].sval)).c_str (),
2134 }
2135#line 2137 "p-exp.c.tmp"
2136 break;
2137
2138 case 72: /* name: NAME */
2139#line 776 "p-exp.y"
2140 { (yyval.sval) = (yyvsp[0].ssym).stoken; }
2141#line 2143 "p-exp.c.tmp"
2142 break;
2143
2144 case 73: /* name: BLOCKNAME */
2145#line 777 "p-exp.y"
2146 { (yyval.sval) = (yyvsp[0].ssym).stoken; }
2147#line 2149 "p-exp.c.tmp"
2148 break;
2149
2150 case 74: /* name: TYPENAME */
2151#line 778 "p-exp.y"
2152 { (yyval.sval) = (yyvsp[0].tsym).stoken; }
2153#line 2155 "p-exp.c.tmp"
2154 break;
2155
2156 case 75: /* name: NAME_OR_INT */
2157#line 779 "p-exp.y"
2158 { (yyval.sval) = (yyvsp[0].ssym).stoken; }
2159#line 2161 "p-exp.c.tmp"
2160 break;
2161
2162
2163#line 2165 "p-exp.c.tmp"
2164
2165 default: break;
2166 }
2167 /* User semantic actions sometimes alter yychar, and that requires
2168 that yytoken be updated with the new translation. We take the
2169 approach of translating immediately before every use of yytoken.
2170 One alternative is translating here after every semantic action,
2171 but that translation would be missed if the semantic action invokes
2172 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
2173 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
2174 incorrect destructor might then be invoked immediately. In the
2175 case of YYERROR or YYBACKUP, subsequent parser actions might lead
2176 to an incorrect destructor call or verbose syntax error message
2177 before the lookahead is translated. */
2178 YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc);
2179
2180 YYPOPSTACK (yylen);
2181 yylen = 0;
2182
2183 *++yyvsp = yyval;
2184
2185 /* Now 'shift' the result of the reduction. Determine what state
2186 that goes to, based on the state we popped back to and the rule
2187 number reduced by. */
2188 {
2189 const int yylhs = yyr1[yyn] - YYNTOKENS;
2190 const int yyi = yypgoto[yylhs] + *yyssp;
2191 yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
2192 ? yytable[yyi]
2193 : yydefgoto[yylhs]);
2194 }
2195
2196 goto yynewstate;
2197
2198
2199/*--------------------------------------.
2200| yyerrlab -- here on detecting error. |
2201`--------------------------------------*/
2202yyerrlab:
2203 /* Make sure we have latest lookahead translation. See comments at
2204 user semantic actions for why this is necessary. */
2206 /* If not already recovering from an error, report this error. */
2207 if (!yyerrstatus)
2208 {
2209 ++yynerrs;
2210 yyerror (YY_("syntax error"));
2211 }
2212
2213 if (yyerrstatus == 3)
2214 {
2215 /* If just tried and failed to reuse lookahead token after an
2216 error, discard it. */
2217
2218 if (yychar <= YYEOF)
2219 {
2220 /* Return failure if at end of input. */
2221 if (yychar == YYEOF)
2222 YYABORT;
2223 }
2224 else
2225 {
2226 yydestruct ("Error: discarding",
2227 yytoken, &yylval);
2228 yychar = YYEMPTY;
2229 }
2230 }
2231
2232 /* Else will try to reuse lookahead token after shifting the error
2233 token. */
2234 goto yyerrlab1;
2235
2236
2237/*---------------------------------------------------.
2238| yyerrorlab -- error raised explicitly by YYERROR. |
2239`---------------------------------------------------*/
2240yyerrorlab:
2241 /* Pacify compilers when the user code never invokes YYERROR and the
2242 label yyerrorlab therefore never appears in user code. */
2243 if (0)
2244 YYERROR;
2245 ++yynerrs;
2246
2247 /* Do not reclaim the symbols of the rule whose action triggered
2248 this YYERROR. */
2249 YYPOPSTACK (yylen);
2250 yylen = 0;
2252 yystate = *yyssp;
2253 goto yyerrlab1;
2254
2255
2256/*-------------------------------------------------------------.
2257| yyerrlab1 -- common code for both syntax error and YYERROR. |
2258`-------------------------------------------------------------*/
2259yyerrlab1:
2260 yyerrstatus = 3; /* Each real token shifted decrements this. */
2261
2262 /* Pop stack until we find a state that shifts the error token. */
2263 for (;;)
2264 {
2265 yyn = yypact[yystate];
2266 if (!yypact_value_is_default (yyn))
2267 {
2268 yyn += YYSYMBOL_YYerror;
2269 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
2270 {
2271 yyn = yytable[yyn];
2272 if (0 < yyn)
2273 break;
2274 }
2275 }
2276
2277 /* Pop the current state because it cannot handle the error token. */
2278 if (yyssp == yyss)
2279 YYABORT;
2280
2281
2282 yydestruct ("Error: popping",
2284 YYPOPSTACK (1);
2285 yystate = *yyssp;
2287 }
2288
2290 *++yyvsp = yylval;
2292
2293
2294 /* Shift the error token. */
2295 YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp);
2296
2297 yystate = yyn;
2298 goto yynewstate;
2299
2300
2301/*-------------------------------------.
2302| yyacceptlab -- YYACCEPT comes here. |
2303`-------------------------------------*/
2304yyacceptlab:
2305 yyresult = 0;
2306 goto yyreturnlab;
2307
2308
2309/*-----------------------------------.
2310| yyabortlab -- YYABORT comes here. |
2311`-----------------------------------*/
2312yyabortlab:
2313 yyresult = 1;
2314 goto yyreturnlab;
2315
2316
2317/*-----------------------------------------------------------.
2318| yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. |
2319`-----------------------------------------------------------*/
2320yyexhaustedlab:
2321 yyerror (YY_("memory exhausted"));
2322 yyresult = 2;
2323 goto yyreturnlab;
2324
2325
2326/*----------------------------------------------------------.
2327| yyreturnlab -- parsing is finished, clean up and return. |
2328`----------------------------------------------------------*/
2329yyreturnlab:
2330 if (yychar != YYEMPTY)
2331 {
2332 /* Make sure we have latest lookahead translation. See comments at
2333 user semantic actions for why this is necessary. */
2334 yytoken = YYTRANSLATE (yychar);
2335 yydestruct ("Cleanup: discarding lookahead",
2336 yytoken, &yylval);
2337 }
2338 /* Do not reclaim the symbols of the rule whose action triggered
2339 this YYABORT or YYACCEPT. */
2340 YYPOPSTACK (yylen);
2342 while (yyssp != yyss)
2343 {
2344 yydestruct ("Cleanup: popping",
2346 YYPOPSTACK (1);
2347 }
2348#ifndef yyoverflow
2349 if (yyss != yyssa)
2351#endif
2352
2353 return yyresult;
2354}
2355
2356#line 793 "p-exp.y"
2357
2358
2359/* Take care of parsing a number (anything that starts with a digit).
2360 Set yylval and return the token type; update lexptr.
2361 LEN is the number of characters in it. */
2362
2363/*** Needs some error checking for the float case ***/
2364
2365static int
2366parse_number (struct parser_state *par_state,
2367 const char *p, int len, int parsed_float, YYSTYPE *putithere)
2368{
2369 ULONGEST n = 0;
2370 ULONGEST prevn = 0;
2371
2372 int i = 0;
2373 int c;
2374 int base = input_radix;
2375 int unsigned_p = 0;
2376
2377 /* Number of "L" suffixes encountered. */
2378 int long_p = 0;
2379
2380 /* We have found a "L" or "U" suffix. */
2381 int found_suffix = 0;
2382
2383 if (parsed_float)
2384 {
2385 /* Handle suffixes: 'f' for float, 'l' for long double.
2386 FIXME: This appears to be an extension -- do we want this? */
2387 if (len >= 1 && tolower (p[len - 1]) == 'f')
2388 {
2389 putithere->typed_val_float.type
2390 = parse_type (par_state)->builtin_float;
2391 len--;
2392 }
2393 else if (len >= 1 && tolower (p[len - 1]) == 'l')
2394 {
2395 putithere->typed_val_float.type
2396 = parse_type (par_state)->builtin_long_double;
2397 len--;
2398 }
2399 /* Default type for floating-point literals is double. */
2400 else
2401 {
2402 putithere->typed_val_float.type
2403 = parse_type (par_state)->builtin_double;
2404 }
2405
2406 if (!parse_float (p, len,
2407 putithere->typed_val_float.type,
2408 putithere->typed_val_float.val))
2409 return ERROR;
2410 return FLOAT;
2411 }
2412
2413 /* Handle base-switching prefixes 0x, 0t, 0d, 0. */
2414 if (p[0] == '0' && len > 1)
2415 switch (p[1])
2416 {
2417 case 'x':
2418 case 'X':
2419 if (len >= 3)
2420 {
2421 p += 2;
2422 base = 16;
2423 len -= 2;
2424 }
2425 break;
2426
2427 case 't':
2428 case 'T':
2429 case 'd':
2430 case 'D':
2431 if (len >= 3)
2432 {
2433 p += 2;
2434 base = 10;
2435 len -= 2;
2436 }
2437 break;
2438
2439 default:
2440 base = 8;
2441 break;
2442 }
2443
2444 while (len-- > 0)
2445 {
2446 c = *p++;
2447 if (c >= 'A' && c <= 'Z')
2448 c += 'a' - 'A';
2449 if (c != 'l' && c != 'u')
2450 n *= base;
2451 if (c >= '0' && c <= '9')
2452 {
2453 if (found_suffix)
2454 return ERROR;
2455 n += i = c - '0';
2456 }
2457 else
2458 {
2459 if (base > 10 && c >= 'a' && c <= 'f')
2460 {
2461 if (found_suffix)
2462 return ERROR;
2463 n += i = c - 'a' + 10;
2464 }
2465 else if (c == 'l')
2466 {
2467 ++long_p;
2468 found_suffix = 1;
2469 }
2470 else if (c == 'u')
2471 {
2472 unsigned_p = 1;
2473 found_suffix = 1;
2474 }
2475 else
2476 return ERROR; /* Char not a digit */
2477 }
2478 if (i >= base)
2479 return ERROR; /* Invalid digit in this base. */
2480
2481 if (c != 'l' && c != 'u')
2482 {
2483 /* Test for overflow. */
2484 if (prevn == 0 && n == 0)
2485 ;
2486 else if (prevn >= n)
2487 error (_("Numeric constant too large."));
2488 }
2489 prevn = n;
2490 }
2491
2492 /* An integer constant is an int, a long, or a long long. An L
2493 suffix forces it to be long; an LL suffix forces it to be long
2494 long. If not forced to a larger size, it gets the first type of
2495 the above that it fits in. To figure out whether it fits, we
2496 shift it right and see whether anything remains. Note that we
2497 can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
2498 operation, because many compilers will warn about such a shift
2499 (which always produces a zero result). Sometimes gdbarch_int_bit
2500 or gdbarch_long_bit will be that big, sometimes not. To deal with
2501 the case where it is we just always shift the value more than
2502 once, with fewer bits each time. */
2503
2504 int int_bits = gdbarch_int_bit (par_state->gdbarch ());
2505 int long_bits = gdbarch_long_bit (par_state->gdbarch ());
2506 int long_long_bits = gdbarch_long_long_bit (par_state->gdbarch ());
2507 bool have_signed = !unsigned_p;
2508 bool have_int = long_p == 0;
2509 bool have_long = long_p <= 1;
2510 if (have_int && have_signed && fits_in_type (1, n, int_bits, true))
2511 putithere->typed_val_int.type = parse_type (par_state)->builtin_int;
2512 else if (have_int && fits_in_type (1, n, int_bits, false))
2513 putithere->typed_val_int.type
2514 = parse_type (par_state)->builtin_unsigned_int;
2515 else if (have_long && have_signed && fits_in_type (1, n, long_bits, true))
2516 putithere->typed_val_int.type = parse_type (par_state)->builtin_long;
2517 else if (have_long && fits_in_type (1, n, long_bits, false))
2518 putithere->typed_val_int.type
2519 = parse_type (par_state)->builtin_unsigned_long;
2520 else if (have_signed && fits_in_type (1, n, long_long_bits, true))
2521 putithere->typed_val_int.type
2522 = parse_type (par_state)->builtin_long_long;
2523 else if (fits_in_type (1, n, long_long_bits, false))
2524 putithere->typed_val_int.type
2525 = parse_type (par_state)->builtin_unsigned_long_long;
2526 else
2527 error (_("Numeric constant too large."));
2528 putithere->typed_val_int.val = n;
2529
2530 return INT;
2531}
2532
2533
2535{
2536 struct type *stored;
2538};
2539
2540static struct type_push *tp_top = NULL;
2541
2542static void
2544{
2545 struct type_push *tpnew;
2546 tpnew = (struct type_push *) xmalloc (sizeof (struct type_push));
2547 tpnew->next = tp_top;
2548 tpnew->stored = current_type;
2549 current_type = NULL;
2550 tp_top = tpnew;
2551}
2552
2553static void
2555{
2556 struct type_push *tp = tp_top;
2557 if (tp)
2558 {
2559 current_type = tp->stored;
2560 tp_top = tp->next;
2561 xfree (tp);
2562 }
2563}
2564
2565struct token
2566{
2567 const char *oper;
2568 int token;
2569 enum exp_opcode opcode;
2570};
2571
2572static const struct token tokentab3[] =
2573 {
2574 {"shr", RSH, OP_NULL},
2575 {"shl", LSH, OP_NULL},
2576 {"and", ANDAND, OP_NULL},
2577 {"div", DIV, OP_NULL},
2578 {"not", NOT, OP_NULL},
2579 {"mod", MOD, OP_NULL},
2580 {"inc", INCREMENT, OP_NULL},
2581 {"dec", DECREMENT, OP_NULL},
2582 {"xor", XOR, OP_NULL}
2583 };
2584
2585static const struct token tokentab2[] =
2586 {
2587 {"or", OR, OP_NULL},
2588 {"<>", NOTEQUAL, OP_NULL},
2589 {"<=", LEQ, OP_NULL},
2590 {">=", GEQ, OP_NULL},
2591 {":=", ASSIGN, OP_NULL},
2592 {"::", COLONCOLON, OP_NULL} };
2593
2594/* Allocate uppercased var: */
2595/* make an uppercased copy of tokstart. */
2596static char *
2597uptok (const char *tokstart, int namelen)
2598{
2599 int i;
2600 char *uptokstart = (char *)xmalloc(namelen+1);
2601 for (i = 0;i <= namelen;i++)
2602 {
2603 if ((tokstart[i]>='a' && tokstart[i]<='z'))
2604 uptokstart[i] = tokstart[i]-('a'-'A');
2605 else
2606 uptokstart[i] = tokstart[i];
2607 }
2608 uptokstart[namelen]='\0';
2609 return uptokstart;
2610}
2611
2612/* Read one token, getting characters through lexptr. */
2613
2614static int
2615yylex (void)
2616{
2617 int c;
2618 int namelen;
2619 const char *tokstart;
2620 char *uptokstart;
2621 const char *tokptr;
2622 int explen, tempbufindex;
2623 static char *tempbuf;
2624 static int tempbufsize;
2625
2626 retry:
2627
2629
2630 tokstart = pstate->lexptr;
2631 explen = strlen (pstate->lexptr);
2632
2633 /* See if it is a special token of length 3. */
2634 if (explen > 2)
2635 for (const auto &token : tokentab3)
2636 if (strncasecmp (tokstart, token.oper, 3) == 0
2637 && (!isalpha (token.oper[0]) || explen == 3
2638 || (!isalpha (tokstart[3])
2639 && !isdigit (tokstart[3]) && tokstart[3] != '_')))
2640 {
2641 pstate->lexptr += 3;
2643 return token.token;
2644 }
2645
2646 /* See if it is a special token of length 2. */
2647 if (explen > 1)
2648 for (const auto &token : tokentab2)
2649 if (strncasecmp (tokstart, token.oper, 2) == 0
2650 && (!isalpha (token.oper[0]) || explen == 2
2651 || (!isalpha (tokstart[2])
2652 && !isdigit (tokstart[2]) && tokstart[2] != '_')))
2653 {
2654 pstate->lexptr += 2;
2656 return token.token;
2657 }
2658
2659 switch (c = *tokstart)
2660 {
2661 case 0:
2663 return COMPLETE;
2664 else
2665 return 0;
2666
2667 case ' ':
2668 case '\t':
2669 case '\n':
2670 pstate->lexptr++;
2671 goto retry;
2672
2673 case '\'':
2674 /* We either have a character constant ('0' or '\177' for example)
2675 or we have a quoted symbol reference ('foo(int,int)' in object pascal
2676 for example). */
2677 pstate->lexptr++;
2678 c = *pstate->lexptr++;
2679 if (c == '\\')
2681 else if (c == '\'')
2682 error (_("Empty character constant."));
2683
2685 yylval.typed_val_int.type = parse_type (pstate)->builtin_char;
2686
2687 c = *pstate->lexptr++;
2688 if (c != '\'')
2689 {
2690 namelen = skip_quoted (tokstart) - tokstart;
2691 if (namelen > 2)
2692 {
2693 pstate->lexptr = tokstart + namelen;
2694 if (pstate->lexptr[-1] != '\'')
2695 error (_("Unmatched single quote."));
2696 namelen -= 2;
2697 tokstart++;
2698 uptokstart = uptok(tokstart,namelen);
2699 goto tryname;
2700 }
2701 error (_("Invalid character constant."));
2702 }
2703 return INT;
2704
2705 case '(':
2706 paren_depth++;
2707 pstate->lexptr++;
2708 return c;
2709
2710 case ')':
2711 if (paren_depth == 0)
2712 return 0;
2713 paren_depth--;
2714 pstate->lexptr++;
2715 return c;
2716
2717 case ',':
2718 if (pstate->comma_terminates && paren_depth == 0)
2719 return 0;
2720 pstate->lexptr++;
2721 return c;
2722
2723 case '.':
2724 /* Might be a floating point number. */
2725 if (pstate->lexptr[1] < '0' || pstate->lexptr[1] > '9')
2726 {
2727 goto symbol; /* Nope, must be a symbol. */
2728 }
2729
2730 /* FALL THRU. */
2731
2732 case '0':
2733 case '1':
2734 case '2':
2735 case '3':
2736 case '4':
2737 case '5':
2738 case '6':
2739 case '7':
2740 case '8':
2741 case '9':
2742 {
2743 /* It's a number. */
2744 int got_dot = 0, got_e = 0, toktype;
2745 const char *p = tokstart;
2746 int hex = input_radix > 10;
2747
2748 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
2749 {
2750 p += 2;
2751 hex = 1;
2752 }
2753 else if (c == '0' && (p[1]=='t' || p[1]=='T'
2754 || p[1]=='d' || p[1]=='D'))
2755 {
2756 p += 2;
2757 hex = 0;
2758 }
2759
2760 for (;; ++p)
2761 {
2762 /* This test includes !hex because 'e' is a valid hex digit
2763 and thus does not indicate a floating point number when
2764 the radix is hex. */
2765 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
2766 got_dot = got_e = 1;
2767 /* This test does not include !hex, because a '.' always indicates
2768 a decimal floating point number regardless of the radix. */
2769 else if (!got_dot && *p == '.')
2770 got_dot = 1;
2771 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
2772 && (*p == '-' || *p == '+'))
2773 /* This is the sign of the exponent, not the end of the
2774 number. */
2775 continue;
2776 /* We will take any letters or digits. parse_number will
2777 complain if past the radix, or if L or U are not final. */
2778 else if ((*p < '0' || *p > '9')
2779 && ((*p < 'a' || *p > 'z')
2780 && (*p < 'A' || *p > 'Z')))
2781 break;
2782 }
2783 toktype = parse_number (pstate, tokstart,
2784 p - tokstart, got_dot | got_e, &yylval);
2785 if (toktype == ERROR)
2786 {
2787 char *err_copy = (char *) alloca (p - tokstart + 1);
2788
2789 memcpy (err_copy, tokstart, p - tokstart);
2790 err_copy[p - tokstart] = 0;
2791 error (_("Invalid number \"%s\"."), err_copy);
2792 }
2793 pstate->lexptr = p;
2794 return toktype;
2795 }
2796
2797 case '+':
2798 case '-':
2799 case '*':
2800 case '/':
2801 case '|':
2802 case '&':
2803 case '^':
2804 case '~':
2805 case '!':
2806 case '@':
2807 case '<':
2808 case '>':
2809 case '[':
2810 case ']':
2811 case '?':
2812 case ':':
2813 case '=':
2814 case '{':
2815 case '}':
2816 symbol:
2817 pstate->lexptr++;
2818 return c;
2819
2820 case '"':
2821
2822 /* Build the gdb internal form of the input string in tempbuf,
2823 translating any standard C escape forms seen. Note that the
2824 buffer is null byte terminated *only* for the convenience of
2825 debugging gdb itself and printing the buffer contents when
2826 the buffer contains no embedded nulls. Gdb does not depend
2827 upon the buffer being null byte terminated, it uses the length
2828 string instead. This allows gdb to handle C strings (as well
2829 as strings in other languages) with embedded null bytes. */
2830
2831 tokptr = ++tokstart;
2832 tempbufindex = 0;
2833
2834 do {
2835 /* Grow the static temp buffer if necessary, including allocating
2836 the first one on demand. */
2837 if (tempbufindex + 1 >= tempbufsize)
2838 {
2839 tempbuf = (char *) xrealloc (tempbuf, tempbufsize += 64);
2840 }
2841
2842 switch (*tokptr)
2843 {
2844 case '\0':
2845 case '"':
2846 /* Do nothing, loop will terminate. */
2847 break;
2848 case '\\':
2849 ++tokptr;
2850 c = parse_escape (pstate->gdbarch (), &tokptr);
2851 if (c == -1)
2852 {
2853 continue;
2854 }
2855 tempbuf[tempbufindex++] = c;
2856 break;
2857 default:
2858 tempbuf[tempbufindex++] = *tokptr++;
2859 break;
2860 }
2861 } while ((*tokptr != '"') && (*tokptr != '\0'));
2862 if (*tokptr++ != '"')
2863 {
2864 error (_("Unterminated string in expression."));
2865 }
2866 tempbuf[tempbufindex] = '\0'; /* See note above. */
2869 pstate->lexptr = tokptr;
2870 return (STRING);
2871 }
2872
2873 if (!(c == '_' || c == '$'
2874 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
2875 /* We must have come across a bad character (e.g. ';'). */
2876 error (_("Invalid character '%c' in expression."), c);
2877
2878 /* It's a name. See how long it is. */
2879 namelen = 0;
2880 for (c = tokstart[namelen];
2881 (c == '_' || c == '$' || (c >= '0' && c <= '9')
2882 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
2883 {
2884 /* Template parameter lists are part of the name.
2885 FIXME: This mishandles `print $a<4&&$a>3'. */
2886 if (c == '<')
2887 {
2888 int i = namelen;
2889 int nesting_level = 1;
2890 while (tokstart[++i])
2891 {
2892 if (tokstart[i] == '<')
2893 nesting_level++;
2894 else if (tokstart[i] == '>')
2895 {
2896 if (--nesting_level == 0)
2897 break;
2898 }
2899 }
2900 if (tokstart[i] == '>')
2901 namelen = i;
2902 else
2903 break;
2904 }
2905
2906 /* do NOT uppercase internals because of registers !!! */
2907 c = tokstart[++namelen];
2908 }
2909
2910 uptokstart = uptok(tokstart,namelen);
2911
2912 /* The token "if" terminates the expression and is NOT
2913 removed from the input stream. */
2914 if (namelen == 2 && uptokstart[0] == 'I' && uptokstart[1] == 'F')
2915 {
2916 xfree (uptokstart);
2917 return 0;
2918 }
2919
2920 pstate->lexptr += namelen;
2921
2922 tryname:
2923
2924 /* Catch specific keywords. Should be done with a data structure. */
2925 switch (namelen)
2926 {
2927 case 6:
2928 if (strcmp (uptokstart, "OBJECT") == 0)
2929 {
2930 xfree (uptokstart);
2931 return CLASS;
2932 }
2933 if (strcmp (uptokstart, "RECORD") == 0)
2934 {
2935 xfree (uptokstart);
2936 return STRUCT;
2937 }
2938 if (strcmp (uptokstart, "SIZEOF") == 0)
2939 {
2940 xfree (uptokstart);
2941 return SIZEOF;
2942 }
2943 break;
2944 case 5:
2945 if (strcmp (uptokstart, "CLASS") == 0)
2946 {
2947 xfree (uptokstart);
2948 return CLASS;
2949 }
2950 if (strcmp (uptokstart, "FALSE") == 0)
2951 {
2952 yylval.lval = 0;
2953 xfree (uptokstart);
2954 return FALSEKEYWORD;
2955 }
2956 break;
2957 case 4:
2958 if (strcmp (uptokstart, "TRUE") == 0)
2959 {
2960 yylval.lval = 1;
2961 xfree (uptokstart);
2962 return TRUEKEYWORD;
2963 }
2964 if (strcmp (uptokstart, "SELF") == 0)
2965 {
2966 /* Here we search for 'this' like
2967 inserted in FPC stabs debug info. */
2968 static const char this_name[] = "this";
2969
2971 VAR_DOMAIN, NULL).symbol)
2972 {
2973 xfree (uptokstart);
2974 return THIS;
2975 }
2976 }
2977 break;
2978 default:
2979 break;
2980 }
2981
2982 yylval.sval.ptr = tokstart;
2983 yylval.sval.length = namelen;
2984
2985 if (*tokstart == '$')
2986 {
2987 xfree (uptokstart);
2988 return DOLLAR_VARIABLE;
2989 }
2990
2991 /* Use token-type BLOCKNAME for symbols that happen to be defined as
2992 functions or symtabs. If this is not so, then ...
2993 Use token-type TYPENAME for symbols that happen to be defined
2994 currently as names of types; NAME for other symbols.
2995 The caller is not constrained to care about the distinction. */
2996 {
2997 std::string tmp = copy_name (yylval.sval);
2998 struct symbol *sym;
2999 struct field_of_this_result is_a_field_of_this;
3000 int is_a_field = 0;
3001 int hextype;
3002
3003 is_a_field_of_this.type = NULL;
3005 is_a_field = (lookup_struct_elt_type (current_type,
3006 tmp.c_str (), 1) != NULL);
3007 if (is_a_field)
3008 sym = NULL;
3009 else
3010 sym = lookup_symbol (tmp.c_str (), pstate->expression_context_block,
3011 VAR_DOMAIN, &is_a_field_of_this).symbol;
3012 /* second chance uppercased (as Free Pascal does). */
3013 if (!sym && is_a_field_of_this.type == NULL && !is_a_field)
3014 {
3015 for (int i = 0; i <= namelen; i++)
3016 {
3017 if ((tmp[i] >= 'a' && tmp[i] <= 'z'))
3018 tmp[i] -= ('a'-'A');
3019 }
3021 is_a_field = (lookup_struct_elt_type (current_type,
3022 tmp.c_str (), 1) != NULL);
3023 if (is_a_field)
3024 sym = NULL;
3025 else
3026 sym = lookup_symbol (tmp.c_str (), pstate->expression_context_block,
3027 VAR_DOMAIN, &is_a_field_of_this).symbol;
3028 }
3029 /* Third chance Capitalized (as GPC does). */
3030 if (!sym && is_a_field_of_this.type == NULL && !is_a_field)
3031 {
3032 for (int i = 0; i <= namelen; i++)
3033 {
3034 if (i == 0)
3035 {
3036 if ((tmp[i] >= 'a' && tmp[i] <= 'z'))
3037 tmp[i] -= ('a'-'A');
3038 }
3039 else
3040 if ((tmp[i] >= 'A' && tmp[i] <= 'Z'))
3041 tmp[i] -= ('A'-'a');
3042 }
3044 is_a_field = (lookup_struct_elt_type (current_type,
3045 tmp.c_str (), 1) != NULL);
3046 if (is_a_field)
3047 sym = NULL;
3048 else
3049 sym = lookup_symbol (tmp.c_str (), pstate->expression_context_block,
3050 VAR_DOMAIN, &is_a_field_of_this).symbol;
3051 }
3052
3053 if (is_a_field || (is_a_field_of_this.type != NULL))
3054 {
3055 tempbuf = (char *) xrealloc (tempbuf, namelen + 1);
3056 strncpy (tempbuf, tmp.c_str (), namelen);
3057 tempbuf [namelen] = 0;
3059 yylval.sval.length = namelen;
3060 yylval.ssym.sym.symbol = NULL;
3061 yylval.ssym.sym.block = NULL;
3062 xfree (uptokstart);
3063 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
3064 if (is_a_field)
3065 return FIELDNAME;
3066 else
3067 return NAME;
3068 }
3069 /* Call lookup_symtab, not lookup_partial_symtab, in case there are
3070 no psymtabs (coff, xcoff, or some future change to blow away the
3071 psymtabs once once symbols are read). */
3072 if ((sym && sym->aclass () == LOC_BLOCK)
3073 || lookup_symtab (tmp.c_str ()))
3074 {
3075 yylval.ssym.sym.symbol = sym;
3076 yylval.ssym.sym.block = NULL;
3077 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
3078 xfree (uptokstart);
3079 return BLOCKNAME;
3080 }
3081 if (sym && sym->aclass () == LOC_TYPEDEF)
3082 {
3083#if 1
3084 /* Despite the following flaw, we need to keep this code enabled.
3085 Because we can get called from check_stub_method, if we don't
3086 handle nested types then it screws many operations in any
3087 program which uses nested types. */
3088 /* In "A::x", if x is a member function of A and there happens
3089 to be a type (nested or not, since the stabs don't make that
3090 distinction) named x, then this code incorrectly thinks we
3091 are dealing with nested types rather than a member function. */
3092
3093 const char *p;
3094 const char *namestart;
3095 struct symbol *best_sym;
3096
3097 /* Look ahead to detect nested types. This probably should be
3098 done in the grammar, but trying seemed to introduce a lot
3099 of shift/reduce and reduce/reduce conflicts. It's possible
3100 that it could be done, though. Or perhaps a non-grammar, but
3101 less ad hoc, approach would work well. */
3102
3103 /* Since we do not currently have any way of distinguishing
3104 a nested type from a non-nested one (the stabs don't tell
3105 us whether a type is nested), we just ignore the
3106 containing type. */
3107
3108 p = pstate->lexptr;
3109 best_sym = sym;
3110 while (1)
3111 {
3112 /* Skip whitespace. */
3113 while (*p == ' ' || *p == '\t' || *p == '\n')
3114 ++p;
3115 if (*p == ':' && p[1] == ':')
3116 {
3117 /* Skip the `::'. */
3118 p += 2;
3119 /* Skip whitespace. */
3120 while (*p == ' ' || *p == '\t' || *p == '\n')
3121 ++p;
3122 namestart = p;
3123 while (*p == '_' || *p == '$' || (*p >= '0' && *p <= '9')
3124 || (*p >= 'a' && *p <= 'z')
3125 || (*p >= 'A' && *p <= 'Z'))
3126 ++p;
3127 if (p != namestart)
3128 {
3129 struct symbol *cur_sym;
3130 /* As big as the whole rest of the expression, which is
3131 at least big enough. */
3132 char *ncopy
3133 = (char *) alloca (tmp.size () + strlen (namestart)
3134 + 3);
3135 char *tmp1;
3136
3137 tmp1 = ncopy;
3138 memcpy (tmp1, tmp.c_str (), tmp.size ());
3139 tmp1 += tmp.size ();
3140 memcpy (tmp1, "::", 2);
3141 tmp1 += 2;
3142 memcpy (tmp1, namestart, p - namestart);
3143 tmp1[p - namestart] = '\0';
3144 cur_sym
3145 = lookup_symbol (ncopy,
3147 VAR_DOMAIN, NULL).symbol;
3148 if (cur_sym)
3149 {
3150 if (cur_sym->aclass () == LOC_TYPEDEF)
3151 {
3152 best_sym = cur_sym;
3153 pstate->lexptr = p;
3154 }
3155 else
3156 break;
3157 }
3158 else
3159 break;
3160 }
3161 else
3162 break;
3163 }
3164 else
3165 break;
3166 }
3167
3168 yylval.tsym.type = best_sym->type ();
3169#else /* not 0 */
3170 yylval.tsym.type = sym->type ();
3171#endif /* not 0 */
3172 xfree (uptokstart);
3173 return TYPENAME;
3174 }
3177 pstate->gdbarch (), tmp.c_str ());
3178 if (yylval.tsym.type != NULL)
3179 {
3180 xfree (uptokstart);
3181 return TYPENAME;
3182 }
3183
3184 /* Input names that aren't symbols but ARE valid hex numbers,
3185 when the input radix permits them, can be names or numbers
3186 depending on the parse. Note we support radixes > 16 here. */
3187 if (!sym
3188 && ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10)
3189 || (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
3190 {
3191 YYSTYPE newlval; /* Its value is ignored. */
3192 hextype = parse_number (pstate, tokstart, namelen, 0, &newlval);
3193 if (hextype == INT)
3194 {
3195 yylval.ssym.sym.symbol = sym;
3196 yylval.ssym.sym.block = NULL;
3197 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
3198 xfree (uptokstart);
3199 return NAME_OR_INT;
3200 }
3201 }
3202
3203 xfree(uptokstart);
3204 /* Any other kind of symbol. */
3205 yylval.ssym.sym.symbol = sym;
3206 yylval.ssym.sym.block = NULL;
3207 return NAME;
3208 }
3209}
3210
3211/* See language.h. */
3212
3213int
3214pascal_language::parser (struct parser_state *par_state) const
3215{
3216 /* Setting up the parser state. */
3217 scoped_restore pstate_restore = make_scoped_restore (&pstate);
3218 gdb_assert (par_state != NULL);
3219 pstate = par_state;
3220 paren_depth = 0;
3221
3222 int result = yyparse ();
3223 if (!result)
3225 return result;
3226}
3227
3228static void
3229yyerror (const char *msg)
3230{
3231 if (pstate->prev_lexptr)
3233
3234 error (_("A %s in expression, near `%s'."), msg, pstate->lexptr);
3235}
const char *const name
Definition: aarch64-tdep.c:67
yytokentype
Definition: ada-exp.c:498
yysymbol_kind_t
Definition: ada-exp.c:647
short yytype_int16
Definition: ada-exp.c:785
yytype_uint8 yy_state_t
Definition: ada-exp.c:861
static struct parser_state * pstate
Definition: ada-exp.c:104
int yy_state_fast_t
Definition: ada-exp.c:864
signed char yytype_int8
Definition: ada-exp.c:777
static int paren_depth
Definition: ada-lex.c:914
void * xrealloc(void *ptr, size_t size)
Definition: alloc.c:65
static struct obstack tempbuf
Definition: c-exp.c:4842
void update(const struct block *b, innermost_block_tracker_types t)
Definition: parse.c:84
int parser(struct parser_state *ps) const override
Definition: p-exp.c:3214
const char * skip_quoted(const char *str)
Definition: completer.c:2406
unsigned input_radix
Definition: valprint.c:165
exp_opcode
Definition: expression.h:44
static int tempbufsize
Definition: f-exp.c:3220
static int tempbufindex
Definition: f-exp.c:3221
int symbol_read_needs_frame(struct symbol *sym)
Definition: findvar.c:389
int gdbarch_long_long_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1457
int gdbarch_int_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1423
int gdbarch_long_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1440
struct type * lookup_pointer_type(struct type *type)
Definition: gdbtypes.c:402
int is_integral_type(struct type *t)
Definition: gdbtypes.c:3772
struct type * lookup_struct_elt_type(struct type *type, const char *name, int noerr)
Definition: gdbtypes.c:1897
struct type * lookup_struct(const char *name, const struct block *block)
Definition: gdbtypes.c:1742
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:3010
#define TYPE_POINTER_TYPE(thistype)
Definition: gdbtypes.h:2028
struct type * language_lookup_primitive_type(const struct language_defn *la, struct gdbarch *gdbarch, const char *name)
Definition: language.c:1053
struct bound_minimal_symbol lookup_bound_minimal_symbol(const char *name)
Definition: minsyms.c:481
Definition: ada-exp.h:80
std::unique_ptr< operation > operation_up
Definition: expression.h:81
std::array< gdb_byte, 16 > float_data
Definition: expop.h:547
int have_partial_symbols(void)
Definition: objfiles.c:803
int have_full_symbols(void)
Definition: objfiles.c:818
static const char * yysymbol_name(yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED
Definition: p-exp.c:793
#define LEQ
Definition: p-exp.c:220
@ YYENOMEM
Definition: p-exp.c:995
#define DOLLAR_VARIABLE
Definition: p-exp.c:209
#define TRUEKEYWORD
Definition: p-exp.c:211
int yynerrs
Definition: p-exp.c:1203
#define STRING
Definition: p-exp.c:198
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
Definition: p-exp.c:543
#define YYMAXDEPTH
Definition: p-exp.c:1170
#define NOTEQUAL
Definition: p-exp.c:219
#define TYPENAME
Definition: p-exp.c:202
#define YYSTACK_FREE
Definition: p-exp.c:604
static const yytype_int8 yytranslate[]
Definition: p-exp.c:718
short yytype_uint8
Definition: p-exp.c:431
yysymbol_kind_t
Definition: p-exp.c:279
@ YYSYMBOL_type_exp
Definition: p-exp.c:338
@ YYSYMBOL_38_
Definition: p-exp.c:319
@ YYSYMBOL_46_
Definition: p-exp.c:327
@ YYSYMBOL_exp1
Definition: p-exp.c:339
@ YYSYMBOL_TYPENAME
Definition: p-exp.c:290
@ YYSYMBOL_41_
Definition: p-exp.c:322
@ YYSYMBOL_STRING
Definition: p-exp.c:286
@ YYSYMBOL_YYUNDEF
Definition: p-exp.c:283
@ YYSYMBOL_name_not_typename
Definition: p-exp.c:353
@ YYSYMBOL_52_
Definition: p-exp.c:333
@ YYSYMBOL_STRUCT
Definition: p-exp.c:292
@ YYSYMBOL_NAME_OR_INT
Definition: p-exp.c:291
@ YYSYMBOL_arglist
Definition: p-exp.c:344
@ YYSYMBOL_47_
Definition: p-exp.c:328
@ YYSYMBOL_INT
Definition: p-exp.c:284
@ YYSYMBOL_NOTEQUAL
Definition: p-exp.c:309
@ YYSYMBOL_FIELDNAME
Definition: p-exp.c:287
@ YYSYMBOL_SIZEOF
Definition: p-exp.c:294
@ YYSYMBOL_UNARY
Definition: p-exp.c:323
@ YYSYMBOL_LEQ
Definition: p-exp.c:312
@ YYSYMBOL_YYerror
Definition: p-exp.c:282
@ YYSYMBOL_GEQ
Definition: p-exp.c:313
@ YYSYMBOL_start
Definition: p-exp.c:335
@ YYSYMBOL_exp
Definition: p-exp.c:340
@ YYSYMBOL_type
Definition: p-exp.c:350
@ YYSYMBOL_49_
Definition: p-exp.c:330
@ YYSYMBOL_qualified_name
Definition: p-exp.c:348
@ YYSYMBOL_CLASS
Definition: p-exp.c:293
@ YYSYMBOL_29_
Definition: p-exp.c:310
@ YYSYMBOL_COMPLETE
Definition: p-exp.c:288
@ YYSYMBOL_typebase
Definition: p-exp.c:351
@ YYSYMBOL_DIV
Definition: p-exp.c:316
@ YYSYMBOL_51_
Definition: p-exp.c:332
@ YYSYMBOL_ARROW
Definition: p-exp.c:326
@ YYSYMBOL_39_
Definition: p-exp.c:320
@ YYSYMBOL_LSH
Definition: p-exp.c:314
@ YYSYMBOL_48_
Definition: p-exp.c:329
@ YYSYMBOL_MOD
Definition: p-exp.c:317
@ YYSYMBOL_DECREMENT
Definition: p-exp.c:325
@ YYSYMBOL_20_
Definition: p-exp.c:301
@ YYSYMBOL_ANDAND
Definition: p-exp.c:307
@ YYSYMBOL_field_exp
Definition: p-exp.c:341
@ YYSYMBOL_RSH
Definition: p-exp.c:315
@ YYSYMBOL_name
Definition: p-exp.c:352
@ YYSYMBOL_block
Definition: p-exp.c:346
@ YYSYMBOL_COLONCOLON
Definition: p-exp.c:295
@ YYSYMBOL_YYACCEPT
Definition: p-exp.c:334
@ YYSYMBOL_30_
Definition: p-exp.c:311
@ YYSYMBOL_OR
Definition: p-exp.c:305
@ YYSYMBOL_55_1
Definition: p-exp.c:336
@ YYSYMBOL_ERROR
Definition: p-exp.c:296
@ YYSYMBOL_TRUEKEYWORD
Definition: p-exp.c:299
@ YYSYMBOL_YYEOF
Definition: p-exp.c:281
@ YYSYMBOL_ABOVE_COMMA
Definition: p-exp.c:302
@ YYSYMBOL_DOLLAR_VARIABLE
Definition: p-exp.c:297
@ YYSYMBOL_27_
Definition: p-exp.c:308
@ YYSYMBOL_variable
Definition: p-exp.c:347
@ YYSYMBOL_BLOCKNAME
Definition: p-exp.c:331
@ YYSYMBOL_YYEMPTY
Definition: p-exp.c:280
@ YYSYMBOL_ptype
Definition: p-exp.c:349
@ YYSYMBOL_62_3
Definition: p-exp.c:343
@ YYSYMBOL_61_2
Definition: p-exp.c:342
@ YYSYMBOL_XOR
Definition: p-exp.c:306
@ YYSYMBOL_normal_start
Definition: p-exp.c:337
@ YYSYMBOL_INCREMENT
Definition: p-exp.c:324
@ YYSYMBOL_64_4
Definition: p-exp.c:345
@ YYSYMBOL_37_
Definition: p-exp.c:318
@ YYSYMBOL_FLOAT
Definition: p-exp.c:285
@ YYSYMBOL_FALSEKEYWORD
Definition: p-exp.c:300
@ YYSYMBOL_THIS
Definition: p-exp.c:298
@ YYSYMBOL_NAME
Definition: p-exp.c:289
@ YYSYMBOL_ASSIGN
Definition: p-exp.c:303
@ YYSYMBOL_NOT
Definition: p-exp.c:304
@ YYSYMBOL_40_
Definition: p-exp.c:321
static void yy_symbol_print(FILE *yyo, yysymbol_kind_t yykind, YYSTYPE const *const yyvaluep)
Definition: p-exp.c:1082
#define YY_ASSERT(E)
Definition: p-exp.c:563
#define YY_(Msgid)
Definition: p-exp.c:497
#define RSH
Definition: p-exp.c:223
#define YYNOMEM
Definition: p-exp.c:1003
#define SIZEOF
Definition: p-exp.c:206
#define YY_IGNORE_MAYBE_UNINITIALIZED_END
Definition: p-exp.c:544
static const yytype_int8 yydefact[]
Definition: p-exp.c:831
#define YYNSTATES
Definition: p-exp.c:703
#define YY_IGNORE_USELESS_CAST_END
Definition: p-exp.c:559
short yytype_int16
Definition: p-exp.c:408
#define OR
Definition: p-exp.c:216
#define FALSEKEYWORD
Definition: p-exp.c:212
void * xmalloc(YYSIZE_T)
#define YYEOF
Definition: p-exp.c:193
#define YYABORT
Definition: p-exp.c:1001
static const yytype_int16 yyrline[]
Definition: p-exp.c:754
#define YYSTACK_BYTES(N)
Definition: p-exp.c:647
static const yytype_int8 yycheck[]
Definition: p-exp.c:907
#define XOR
Definition: p-exp.c:217
#define NAME
Definition: p-exp.c:201
#define YY_REDUCE_PRINT(Rule)
Definition: p-exp.c:1140
#define COMPLETE
Definition: p-exp.c:200
#define YY_CAST(Type, Val)
Definition: p-exp.c:119
static void yydestruct(const char *yymsg, yysymbol_kind_t yykind, YYSTYPE *yyvaluep)
Definition: p-exp.c:1183
#define ABOVE_COMMA
Definition: p-exp.c:213
#define ASSIGN
Definition: p-exp.c:214
static struct parser_state * pstate
Definition: p-exp.c:97
static const yytype_int16 yypact[]
Definition: p-exp.c:811
YYSTYPE yylval
Definition: p-exp.c:1201
#define YYerror
Definition: p-exp.c:194
#define YYUNDEF
Definition: p-exp.c:195
#define ARROW
Definition: p-exp.c:229
#define YYFINAL
Definition: p-exp.c:692
#define LSH
Definition: p-exp.c:222
static int yylex(void)
Definition: p-exp.c:2615
#define YY_ACCESSING_SYMBOL(State)
Definition: p-exp.c:768
#define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
Definition: p-exp.c:1047
static void push_current_type(void)
Definition: p-exp.c:2543
static int parse_number(struct parser_state *, const char *, int, int, YYSTYPE *)
Definition: p-exp.c:2366
#define YYNTOKENS
Definition: p-exp.c:697
static const struct token tokentab3[]
Definition: p-exp.c:2572
#define YY_STACK_PRINT(Bottom, Top)
Definition: p-exp.c:1109
static void yy_symbol_value_print(FILE *yyo, yysymbol_kind_t yykind, YYSTYPE const *const yyvaluep)
Definition: p-exp.c:1064
#define YYSIZE_T
Definition: p-exp.c:470
#define YY_IGNORE_USELESS_CAST_BEGIN
Definition: p-exp.c:558
#define parse_type(ps)
Definition: p-exp.c:87
#define DIV
Definition: p-exp.c:224
int yyparse(void)
Definition: p-exp.c:1213
#define STRUCT
Definition: p-exp.c:204
static const yytype_int8 yyr2[]
Definition: p-exp.c:982
static const yytype_int8 yytable[]
Definition: p-exp.c:865
#define ERROR
Definition: p-exp.c:208
#define DECREMENT
Definition: p-exp.c:228
#define YYPTRDIFF_T
Definition: p-exp.c:456
static int paren_depth
Definition: p-exp.c:100
static void pop_current_type(void)
Definition: p-exp.c:2554
static void yy_reduce_print(yy_state_t *yyssp, YYSTYPE *yyvsp, int yyrule)
Definition: p-exp.c:1121
#define NAME_OR_INT
Definition: p-exp.c:203
int yychar
Definition: p-exp.c:1198
#define GEQ
Definition: p-exp.c:221
static int leftdiv_is_integer
Definition: p-exp.c:366
#define YY_NULLPTRPTR
Definition: p-exp.c:131
#define YYACCEPT
Definition: p-exp.c:1000
#define yytable_value_is_error(Yyn)
Definition: p-exp.c:806
int yytype_uint16
Definition: p-exp.c:442
#define COLONCOLON
Definition: p-exp.c:207
#define YYTRANSLATE(YYX)
Definition: p-exp.c:711
static const yytype_int8 yystos[]
Definition: p-exp.c:951
#define UNARY
Definition: p-exp.c:226
int yydebug
Definition: p-exp.c:1148
#define YY_ATTRIBUTE_UNUSED
Definition: p-exp.c:514
static int search_field
Definition: p-exp.c:369
static const struct token tokentab2[]
Definition: p-exp.c:2585
static const char *const yytname[]
Definition: p-exp.c:777
#define ANDAND
Definition: p-exp.c:218
static struct type * current_type
Definition: p-exp.c:365
static const yytype_int8 yypgoto[]
Definition: p-exp.c:849
#define THIS
Definition: p-exp.c:210
static const yytype_int8 yyr1[]
Definition: p-exp.c:969
#define MOD
Definition: p-exp.c:225
enum yytokentype yytoken_kind_t
Definition: p-exp.c:189
static struct type_push * tp_top
Definition: p-exp.c:2540
#define YYPOPSTACK(N)
#define NOT
Definition: p-exp.c:215
int yy_state_fast_t
Definition: p-exp.c:487
#define INCREMENT
Definition: p-exp.c:227
static const yytype_int8 yydefgoto[]
Definition: p-exp.c:856
static char * uptok(const char *, int)
Definition: p-exp.c:2597
#define YYEMPTY
Definition: p-exp.c:192
#define YYLAST
Definition: p-exp.c:694
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
Definition: p-exp.c:658
#define FLOAT
Definition: p-exp.c:197
#define yypact_value_is_default(Yyn)
Definition: p-exp.c:801
#define CLASS
Definition: p-exp.c:205
#define YYINITDEPTH
Definition: p-exp.c:1159
signed char yytype_int8
Definition: p-exp.c:400
#define BLOCKNAME
Definition: p-exp.c:230
#define YYERROR
Definition: p-exp.c:1002
static void yy_stack_print(yy_state_t *yybottom, yy_state_t *yytop)
Definition: p-exp.c:1098
#define YYSIZEOF(X)
Definition: p-exp.c:480
#define YYSTACK_ALLOC
Definition: p-exp.c:603
#define FIELDNAME
Definition: p-exp.c:199
yytype_int8 yy_state_t
Definition: p-exp.c:484
#define YYDPRINTF(Args)
Definition: p-exp.c:1038
void xfree(void *)
#define YY_USE(E)
Definition: p-exp.c:520
#define INT
Definition: p-exp.c:196
int pascal_is_string_type(struct type *type, int *length_pos, int *length_size, int *string_pos, struct type **char_type, const char **arrayname)
Definition: p-lang.c:90
bool parse_float(const char *p, int len, const struct type *type, gdb_byte *data)
Definition: parse.c:609
bool fits_in_type(int n_sign, ULONGEST n, int type_bits, bool type_signed_p)
Definition: parse.c:619
std::string copy_name(struct stoken token)
Definition: parse.c:407
const struct block * block
Definition: symtab.h:1498
struct symbol * symbol
Definition: symtab.h:1494
Definition: block.h:109
struct block * static_block()
Definition: block.h:302
struct minimal_symbol * minsym
Definition: minsyms.h:49
struct blockvector * blockvector()
Definition: symtab.h:1773
void set_operation(expr::operation_up &&op)
Definition: parser-defs.h:75
const struct language_defn * language()
Definition: parser-defs.h:68
struct gdbarch * gdbarch()
Definition: parser-defs.h:61
struct type * type
Definition: symtab.h:1979
struct type * type() const
Definition: gdbtypes.h:559
void push_new(Arg... args)
Definition: parser-defs.h:214
int end_arglist()
Definition: parser-defs.h:179
void wrap2()
Definition: parser-defs.h:260
const struct block *const expression_context_block
Definition: parser-defs.h:270
std::vector< expr::operation_up > pop_vector(int n)
Definition: parser-defs.h:239
bool parse_completion
Definition: parser-defs.h:297
void push_dollar(struct stoken str)
Definition: parse.c:248
const char * prev_lexptr
Definition: parser-defs.h:290
void push_symbol(const char *name, block_symbol sym)
Definition: parse.c:225
void start_arglist()
Definition: parser-defs.h:170
innermost_block_tracker * block_tracker
Definition: parser-defs.h:303
expr::operation_up pop()
Definition: parser-defs.h:231
void push(expr::operation_up &&op)
Definition: parser-defs.h:207
const char * lexptr
Definition: parser-defs.h:286
int comma_terminates
Definition: parser-defs.h:281
void mark_struct_expression(expr::structop_base_operation *op)
Definition: parse.c:187
int length
Definition: parser-defs.h:370
const char * ptr
Definition: parser-defs.h:368
const block * value_block() const
Definition: symtab.h:1348
address_class aclass() const
Definition: symtab.h:1235
struct type * type() const
Definition: symtab.h:1285
struct compunit_symtab * compunit() const
Definition: symtab.h:1603
int is_a_field_of_this
Definition: parser-defs.h:399
struct block_symbol sym
Definition: parser-defs.h:398
Definition: c-exp.c:5133
const char * oper
Definition: c-exp.c:5134
enum exp_opcode opcode
Definition: c-exp.c:5136
int token
Definition: c-exp.c:5135
struct type * type
Definition: parser-defs.h:392
struct type * stored
Definition: p-exp.c:2536
struct type_push * next
Definition: p-exp.c:2537
Definition: gdbtypes.h:922
struct type * target_type() const
Definition: gdbtypes.h:1000
type_code code() const
Definition: gdbtypes.h:927
struct field & field(int idx) const
Definition: gdbtypes.h:983
const char * name() const
Definition: gdbtypes.h:939
Definition: value.c:181
struct block_symbol lookup_symbol(const char *name, const struct block *block, domain_enum domain, struct field_of_this_result *is_a_field_of_this)
Definition: symtab.c:1967
struct symtab * lookup_symtab(const char *name)
Definition: symtab.c:643
@ LOC_BLOCK
Definition: symtab.h:999
@ LOC_TYPEDEF
Definition: symtab.h:989
@ VAR_DOMAIN
Definition: symtab.h:881
struct YYSTYPE::@23 typed_val_int
struct ttype tsym
Definition: c-exp.c:370
struct YYSTYPE::@3 typed_val_float
const struct block * bval
Definition: ada-exp.c:625
int voidval
Definition: c-exp.c:372
struct stoken sval
Definition: ada-exp.c:624
struct internalvar * ivar
Definition: ada-exp.c:626
struct symtoken ssym
Definition: c-exp.c:371
int * ivec
Definition: f-exp.c:316
std::vector< struct type * > * tvec
Definition: c-exp.c:377
LONGEST val
Definition: ada-exp.c:616
struct type * tval
Definition: ada-exp.c:623
struct symbol * sym
Definition: d-exp.c:274
LONGEST lval
Definition: ada-exp.c:614
enum exp_opcode opcode
Definition: c-exp.c:374
struct type * type
Definition: ada-exp.c:617
YYSTYPE yyvs_alloc
Definition: ada-exp.c:1016
yy_state_t yyss_alloc
Definition: ada-exp.c:1015
int parse_escape(struct gdbarch *gdbarch, const char **string_ptr)
Definition: utils.c:1063
struct value * value_of_this_silent(const struct language_defn *lang)
Definition: valops.c:4011
struct type * value_type(const struct value *value)
Definition: value.c:1109
struct value * value_of_internalvar(struct gdbarch *gdbarch, struct internalvar *var)
Definition: value.c:2250
struct internalvar * lookup_only_internalvar(const char *name)
Definition: value.c:2150
#define yylloc
Definition: yy-remap.h:68
#define yyss
Definition: yy-remap.h:82
#define yyval
Definition: yy-remap.h:67
#define yyrule
Definition: yy-remap.h:72
#define yylhs
Definition: yy-remap.h:73
#define yyvsp
Definition: yy-remap.h:87
#define yyparse
Definition: yy-remap.h:43
#define yylen
Definition: yy-remap.h:74
#define yyssp
Definition: yy-remap.h:84
#define yystacksize
Definition: yy-remap.h:85
#define yyvs
Definition: yy-remap.h:86
#define yystate
Definition: yy-remap.h:63
#define YYFPRINTF
Definition: yy-remap.h:96
#define yyerror
Definition: yy-remap.h:45