GDB (xrefs)

/tmp/gdb-8.1/gdb/c-exp.c
Go to the documentation of this file.
1 /* A Bison parser, made by GNU Bison 3.0.4. */
2
3 /* Bison implementation for Yacc-like parsers in C
4
5 Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
6
7 This program is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20 /* As a special exception, you may create a larger work that contains
21 part or all of the Bison parser skeleton and distribute that work
22 under terms of your choice, so long as that work isn't itself a
23 parser generator using the skeleton or a modified version thereof
24 as a parser skeleton. Alternatively, if you modify or redistribute
25 the parser skeleton itself, you may (at your option) remove this
26 special exception, which will cause the skeleton and the resulting
27 Bison output files to be licensed under the GNU General Public
28 License without this special exception.
29
30 This special exception was added by the Free Software Foundation in
31 version 2.2 of Bison. */
32
33 /* C LALR(1) parser skeleton written by Richard Stallman, by
34 simplifying the original so-called "semantic" parser. */
35
36 /* All symbols defined below should begin with yy or YY, to avoid
37 infringing on user name space. This should be done even for local
38 variables, as they might otherwise be expanded by user macros.
39 There are some unavoidable exceptions within include files to
40 define necessary library symbols; they are noted "INFRINGES ON
41 USER NAME SPACE" below. */
42
43 /* Identify Bison output. */
44 #define YYBISON 1
45
46 /* Bison version. */
47 #define YYBISON_VERSION "3.0.4"
48
49 /* Skeleton name. */
50 #define YYSKELETON_NAME "yacc.c"
51
52 /* Pure parsers. */
53 #define YYPURE 0
54
55 /* Push parsers. */
56 #define YYPUSH 0
57
58 /* Pull parsers. */
59 #define YYPULL 1
60
61
62
63
64 /* Copy the first part of user declarations. */
65 #line 36 "c-exp.y" /* yacc.c:339 */
66
67
68 #include "defs.h"
69 #include <ctype.h>
70 #include "expression.h"
71 #include "value.h"
72 #include "parser-defs.h"
73 #include "language.h"
74 #include "c-lang.h"
75 #include "bfd.h" /* Required by objfiles.h. */
76 #include "symfile.h" /* Required by objfiles.h. */
77 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
78 #include "charset.h"
79 #include "block.h"
80 #include "cp-support.h"
81 #include "macroscope.h"
82 #include "objc-lang.h"
83 #include "typeprint.h"
84 #include "cp-abi.h"
85
86 #define parse_type(ps) builtin_type (parse_gdbarch (ps))
87
88 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror,
89 etc). */
90 #define GDB_YY_REMAP_PREFIX c_
91 #include "yy-remap.h"
92
93 /* The state of the parser, used internally when we are parsing the
94 expression. */
95
96 static struct parser_state *pstate = NULL;
97
98 int yyparse (void);
99
100 static int yylex (void);
101
102 void yyerror (const char *);
103
104 static int type_aggregate_p (struct type *);
105
106
107 #line 108 "c-exp.c" /* yacc.c:339 */
108
109 # ifndef YY_NULLPTRPTR
110 # if defined __cplusplus && 201103L <= __cplusplus
111 # define YY_NULLPTRPTR nullptr
112 # else
113 # define YY_NULLPTRPTR 0
114 # endif
115 # endif
116
117 /* Enabling verbose error messages. */
118 #ifdef YYERROR_VERBOSE
119 # undef YYERROR_VERBOSE
120 # define YYERROR_VERBOSE 1
121 #else
122 # define YYERROR_VERBOSE 0
123 #endif
124
125
126 /* Debug traces. */
127 #ifndef YYDEBUG
128 # define YYDEBUG 0
129 #endif
130 #if YYDEBUG
131 extern int yydebug;
132 #endif
133
134 /* Token type. */
135 #ifndef YYTOKENTYPE
136 # define YYTOKENTYPE
137 enum yytokentype
138 {
139 INT = 258,
140 FLOAT = 259,
141 STRING = 260,
142 NSSTRING = 261,
143 SELECTOR = 262,
144 CHAR = 263,
145 NAME = 264,
146 UNKNOWN_CPP_NAME = 265,
147 COMPLETE = 266,
148 TYPENAME = 267,
149 CLASSNAME = 268,
150 OBJC_LBRAC = 269,
151 NAME_OR_INT = 270,
152 OPERATOR = 271,
153 STRUCT = 272,
154 CLASS = 273,
155 UNION = 274,
156 ENUM = 275,
157 SIZEOF = 276,
158 UNSIGNED = 277,
159 COLONCOLON = 278,
160 TEMPLATE = 279,
161 ERROR = 280,
162 NEW = 281,
163 DELETE = 282,
164 REINTERPRET_CAST = 283,
165 DYNAMIC_CAST = 284,
166 STATIC_CAST = 285,
167 CONST_CAST = 286,
168 ENTRY = 287,
169 TYPEOF = 288,
170 DECLTYPE = 289,
171 TYPEID = 290,
172 SIGNED_KEYWORD = 291,
173 LONG = 292,
174 SHORT = 293,
175 INT_KEYWORD = 294,
176 CONST_KEYWORD = 295,
177 VOLATILE_KEYWORD = 296,
178 DOUBLE_KEYWORD = 297,
179 VARIABLE = 298,
180 ASSIGN_MODIFY = 299,
181 TRUEKEYWORD = 300,
182 FALSEKEYWORD = 301,
183 ABOVE_COMMA = 302,
184 OROR = 303,
185 ANDAND = 304,
186 EQUAL = 305,
187 NOTEQUAL = 306,
188 LEQ = 307,
189 GEQ = 308,
190 LSH = 309,
191 RSH = 310,
192 UNARY = 311,
193 INCREMENT = 312,
194 DECREMENT = 313,
195 ARROW = 314,
196 ARROW_STAR = 315,
197 DOT_STAR = 316,
198 BLOCKNAME = 317,
199 FILENAME = 318,
200 DOTDOTDOT = 319
201 };
202 #endif
203 /* Tokens. */
204 #define INT 258
205 #define FLOAT 259
206 #define STRING 260
207 #define NSSTRING 261
208 #define SELECTOR 262
209 #define CHAR 263
210 #define NAME 264
211 #define UNKNOWN_CPP_NAME 265
212 #define COMPLETE 266
213 #define TYPENAME 267
214 #define CLASSNAME 268
215 #define OBJC_LBRAC 269
216 #define NAME_OR_INT 270
217 #define OPERATOR 271
218 #define STRUCT 272
219 #define CLASS 273
220 #define UNION 274
221 #define ENUM 275
222 #define SIZEOF 276
223 #define UNSIGNED 277
224 #define COLONCOLON 278
225 #define TEMPLATE 279
226 #define ERROR 280
227 #define NEW 281
228 #define DELETE 282
229 #define REINTERPRET_CAST 283
230 #define DYNAMIC_CAST 284
231 #define STATIC_CAST 285
232 #define CONST_CAST 286
233 #define ENTRY 287
234 #define TYPEOF 288
235 #define DECLTYPE 289
236 #define TYPEID 290
237 #define SIGNED_KEYWORD 291
238 #define LONG 292
239 #define SHORT 293
240 #define INT_KEYWORD 294
241 #define CONST_KEYWORD 295
242 #define VOLATILE_KEYWORD 296
243 #define DOUBLE_KEYWORD 297
244 #define VARIABLE 298
245 #define ASSIGN_MODIFY 299
246 #define TRUEKEYWORD 300
247 #define FALSEKEYWORD 301
248 #define ABOVE_COMMA 302
249 #define OROR 303
250 #define ANDAND 304
251 #define EQUAL 305
252 #define NOTEQUAL 306
253 #define LEQ 307
254 #define GEQ 308
255 #define LSH 309
256 #define RSH 310
257 #define UNARY 311
258 #define INCREMENT 312
259 #define DECREMENT 313
260 #define ARROW 314
261 #define ARROW_STAR 315
262 #define DOT_STAR 316
263 #define BLOCKNAME 317
264 #define FILENAME 318
265 #define DOTDOTDOT 319
266
267 /* Value type. */
268 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
269
270 union YYSTYPE
271 {
272 #line 83 "c-exp.y" /* yacc.c:355 */
273
274 LONGEST lval;
275 struct {
276 LONGEST val;
277 struct type *type;
278 } typed_val_int;
279 struct {
280 gdb_byte val[16];
281 struct type *type;
282 } typed_val_float;
283 struct type *tval;
284 struct stoken sval;
285 struct typed_stoken tsval;
286 struct ttype tsym;
287 struct symtoken ssym;
288 int voidval;
289 const struct block *bval;
290 enum exp_opcode opcode;
291
292 struct stoken_vector svec;
293 VEC (type_ptr) *tvec;
294
295 struct type_stack *type_stack;
296
297 struct objc_class_str theclass;
298
299
300 #line 301 "c-exp.c" /* yacc.c:355 */
301 };
302
303 typedef union YYSTYPE YYSTYPE;
304 # define YYSTYPE_IS_TRIVIAL 1
305 # define YYSTYPE_IS_DECLARED 1
306 #endif
307
308
309 extern YYSTYPE yylval;
310
311 int yyparse (void);
312
313
314
315 /* Copy the second part of user declarations. */
316 #line 110 "c-exp.y" /* yacc.c:358 */
317
318 /* YYSTYPE gets defined by %union */
319 static int parse_number (struct parser_state *par_state,
320 const char *, int, int, YYSTYPE *);
321 static struct stoken operator_stoken (const char *);
322 static void check_parameter_typelist (VEC (type_ptr) *);
323 static void write_destructor_name (struct parser_state *par_state,
324 struct stoken);
325
326 #ifdef YYBISON
327 static void c_print_token (FILE *file, int type, YYSTYPE value);
328 #define YYPRINT(FILE, TYPE, VALUE) c_print_token (FILE, TYPE, VALUE)
329 #endif
330
331 #line 332 "c-exp.c" /* yacc.c:358 */
332
333 #ifdef short
334 # undef short
335 #endif
336
337 #ifdef YYTYPE_UINT8
338 typedef YYTYPE_UINT8 yytype_uint8;
339 #else
340 typedef unsigned char yytype_uint8;
341 #endif
342
343 #ifdef YYTYPE_INT8
344 typedef YYTYPE_INT8 yytype_int8;
345 #else
346 typedef signed char yytype_int8;
347 #endif
348
349 #ifdef YYTYPE_UINT16
350 typedef YYTYPE_UINT16 yytype_uint16;
351 #else
352 typedef unsigned short int yytype_uint16;
353 #endif
354
355 #ifdef YYTYPE_INT16
356 typedef YYTYPE_INT16 yytype_int16;
357 #else
358 typedef short int yytype_int16;
359 #endif
360
361 #ifndef YYSIZE_T
362 # ifdef __SIZE_TYPE__
363 # define YYSIZE_T __SIZE_TYPE__
364 # elif defined size_t
365 # define YYSIZE_T size_t
366 # elif ! defined YYSIZE_T
367 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
368 # define YYSIZE_T size_t
369 # else
370 # define YYSIZE_T unsigned int
371 # endif
372 #endif
373
374 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
375
376 #ifndef YY_
377 # if defined YYENABLE_NLS && YYENABLE_NLS
378 # if ENABLE_NLS
379 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
380 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
381 # endif
382 # endif
383 # ifndef YY_
384 # define YY_(Msgid) Msgid
385 # endif
386 #endif
387
388 #ifndef YY_ATTRIBUTE
389 # if (defined __GNUC__ \
390 && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
391 || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
392 # define YY_ATTRIBUTE(Spec) __attribute__(Spec)
393 # else
394 # define YY_ATTRIBUTE(Spec) /* empty */
395 # endif
396 #endif
397
398 #ifndef YY_ATTRIBUTE_PURE
399 # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
400 #endif
401
402 #ifndef YY_ATTRIBUTE_UNUSED
403 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
404 #endif
405
406 #if !defined _Noreturn \
407 && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
408 # if defined _MSC_VER && 1200 <= _MSC_VER
409 # define _Noreturn __declspec (noreturn)
410 # else
411 # define _Noreturn YY_ATTRIBUTE ((__noreturn__))
412 # endif
413 #endif
414
415 /* Suppress unused-variable warnings by "using" E. */
416 #if ! defined lint || defined __GNUC__
417 # define YYUSE(E) ((void) (E))
418 #else
419 # define YYUSE(E) /* empty */
420 #endif
421
422 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
423 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
424 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
425 _Pragma ("GCC diagnostic push") \
426 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
427 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
428 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
429 _Pragma ("GCC diagnostic pop")
430 #else
431 # define YY_INITIAL_VALUE(Value) Value
432 #endif
433 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
434 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
435 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
436 #endif
437 #ifndef YY_INITIAL_VALUE
438 # define YY_INITIAL_VALUE(Value) /* Nothing. */
439 #endif
440
441
442 #if ! defined yyoverflow || YYERROR_VERBOSE
443
444 /* The parser invokes alloca or xmalloc; define the necessary symbols. */
445
446 # ifdef YYSTACK_USE_ALLOCA
447 # if YYSTACK_USE_ALLOCA
448 # ifdef __GNUC__
449 # define YYSTACK_ALLOC __builtin_alloca
450 # elif defined __BUILTIN_VA_ARG_INCR
451 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
452 # elif defined _AIX
453 # define YYSTACK_ALLOC __alloca
454 # elif defined _MSC_VER
455 # define alloca _alloca
456 # else
457 # define YYSTACK_ALLOC alloca
458 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
459 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
460 /* Use EXIT_SUCCESS as a witness for stdlib.h. */
461 # ifndef EXIT_SUCCESS
462 # define EXIT_SUCCESS 0
463 # endif
464 # endif
465 # endif
466 # endif
467 # endif
468
469 # ifdef YYSTACK_ALLOC
470 /* Pacify GCC's 'empty if-body' warning. */
471 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
472 # ifndef YYSTACK_ALLOC_MAXIMUM
473 /* The OS might guarantee only one guard page at the bottom of the stack,
474 and a page size can be as small as 4096 bytes. So we cannot safely
475 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
476 to allow for a few compiler-allocated temporary stack slots. */
477 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
478 # endif
479 # else
480 # define YYSTACK_ALLOC YYMALLOC
481 # define YYSTACK_FREE YYFREE
482 # ifndef YYSTACK_ALLOC_MAXIMUM
483 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
484 # endif
485 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
486 && ! ((defined YYMALLOC || defined xmalloc) \
487 && (defined YYFREE || defined xfree)))
488 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
489 # ifndef EXIT_SUCCESS
490 # define EXIT_SUCCESS 0
491 # endif
492 # endif
493 # ifndef YYMALLOC
494 # define YYMALLOC xmalloc
495 # if ! defined xmalloc && ! defined EXIT_SUCCESS
496 void *xmalloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
497 # endif
498 # endif
499 # ifndef YYFREE
500 # define YYFREE xfree
501 # if ! defined xfree && ! defined EXIT_SUCCESS
502 void xfree (void *); /* INFRINGES ON USER NAME SPACE */
503 # endif
504 # endif
505 # endif
506 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
507
508
509 #if (! defined yyoverflow \
510 && (! defined __cplusplus \
511 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
512
513 /* A type that is properly aligned for any stack member. */
514 union yyalloc
515 {
516 yytype_int16 yyss_alloc;
517 YYSTYPE yyvs_alloc;
518 };
519
520 /* The size of the maximum gap between one aligned stack and the next. */
521 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
522
523 /* The size of an array large to enough to hold all stacks, each with
524 N elements. */
525 # define YYSTACK_BYTES(N) \
526 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
527 + YYSTACK_GAP_MAXIMUM)
528
529 # define YYCOPY_NEEDED 1
530
531 /* Relocate STACK from its old location to the new one. The
532 local variables YYSIZE and YYSTACKSIZE give the old and new number of
533 elements in the stack, and YYPTR gives the new location of the
534 stack. Advance YYPTR to a properly aligned location for the next
535 stack. */
536 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
537 do \
538 { \
539 YYSIZE_T yynewbytes; \
540 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
541 Stack = &yyptr->Stack_alloc; \
542 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
543 yyptr += yynewbytes / sizeof (*yyptr); \
544 } \
545 while (0)
546
547 #endif
548
549 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
550 /* Copy COUNT objects from SRC to DST. The source and destination do
551 not overlap. */
552 # ifndef YYCOPY
553 # if defined __GNUC__ && 1 < __GNUC__
554 # define YYCOPY(Dst, Src, Count) \
555 __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
556 # else
557 # define YYCOPY(Dst, Src, Count) \
558 do \
559 { \
560 YYSIZE_T yyi; \
561 for (yyi = 0; yyi < (Count); yyi++) \
562 (Dst)[yyi] = (Src)[yyi]; \
563 } \
564 while (0)
565 # endif
566 # endif
567 #endif /* !YYCOPY_NEEDED */
568
569 /* YYFINAL -- State number of the termination state. */
570 #define YYFINAL 169
571 /* YYLAST -- Last index in YYTABLE. */
572 #define YYLAST 1705
573
574 /* YYNTOKENS -- Number of terminals. */
575 #define YYNTOKENS 89
576 /* YYNNTS -- Number of nonterminals. */
577 #define YYNNTS 49
578 /* YYNRULES -- Number of rules. */
579 #define YYNRULES 267
580 /* YYNSTATES -- Number of states. */
581 #define YYNSTATES 421
582
583 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
584 by yylex, with out-of-bounds checking. */
585 #define YYUNDEFTOK 2
586 #define YYMAXUTOK 319
587
588 #define YYTRANSLATE(YYX) \
589 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
590
591 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
592 as returned by yylex, without out-of-bounds checking. */
593 static const yytype_uint8 yytranslate[] =
594 {
595 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
596 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
597 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
598 2, 2, 2, 83, 2, 2, 2, 69, 55, 2,
599 78, 82, 67, 65, 47, 66, 75, 68, 2, 2,
600 2, 2, 2, 2, 2, 2, 2, 2, 86, 2,
601 58, 49, 59, 50, 64, 2, 2, 2, 2, 2,
602 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
603 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
604 2, 77, 2, 85, 54, 2, 2, 2, 2, 2,
605 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
606 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
607 2, 2, 2, 87, 53, 88, 84, 2, 2, 2,
608 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
609 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
610 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
611 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
612 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
613 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
614 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
615 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
616 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
617 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
618 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
619 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
620 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
621 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
622 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
623 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
624 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
625 45, 46, 48, 51, 52, 56, 57, 60, 61, 62,
626 63, 70, 71, 72, 73, 74, 76, 79, 80, 81
627 };
628
629 #if YYDEBUG
630 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
631 static const yytype_uint16 yyrline[] =
632 {
633 0, 227, 227, 228, 231, 235, 239, 245, 252, 253,
634 258, 262, 266, 270, 274, 278, 282, 286, 290, 294,
635 298, 302, 306, 310, 316, 323, 333, 339, 346, 354,
636 358, 364, 371, 381, 387, 394, 402, 406, 410, 420,
637 419, 443, 442, 459, 458, 467, 469, 472, 473, 476,
638 478, 480, 487, 484, 498, 508, 507, 533, 537, 540,
639 544, 548, 571, 582, 589, 590, 593, 601, 604, 611,
640 615, 619, 625, 629, 633, 637, 641, 645, 649, 653,
641 657, 661, 665, 669, 673, 677, 681, 685, 689, 693,
642 697, 701, 705, 709, 716, 723, 732, 745, 752, 755,
643 761, 768, 788, 793, 797, 801, 808, 825, 843, 876,
644 885, 893, 903, 911, 917, 928, 943, 965, 978, 1002,
645 1011, 1012, 1040, 1111, 1115, 1116, 1119, 1122, 1123, 1127,
646 1128, 1133, 1132, 1136, 1135, 1138, 1140, 1142, 1144, 1148,
647 1157, 1159, 1160, 1163, 1165, 1172, 1179, 1185, 1192, 1194,
648 1196, 1198, 1202, 1204, 1216, 1220, 1222, 1226, 1230, 1234,
649 1238, 1242, 1246, 1250, 1254, 1258, 1262, 1266, 1270, 1274,
650 1278, 1282, 1286, 1290, 1294, 1298, 1302, 1306, 1310, 1314,
651 1318, 1322, 1326, 1332, 1338, 1341, 1346, 1352, 1355, 1360,
652 1366, 1369, 1374, 1380, 1383, 1388, 1394, 1398, 1402, 1406,
653 1413, 1417, 1419, 1423, 1424, 1432, 1440, 1451, 1453, 1462,
654 1468, 1475, 1476, 1483, 1487, 1488, 1491, 1492, 1495, 1499,
655 1501, 1505, 1507, 1509, 1511, 1513, 1515, 1517, 1519, 1521,
656 1523, 1525, 1527, 1529, 1531, 1533, 1535, 1537, 1539, 1541,
657 1543, 1583, 1585, 1587, 1589, 1591, 1593, 1595, 1597, 1599,
658 1601, 1603, 1605, 1607, 1609, 1611, 1613, 1615, 1632, 1633,
659 1634, 1635, 1636, 1637, 1640, 1641, 1649, 1661
660 };
661 #endif
662
663 #if YYDEBUG || YYERROR_VERBOSE || 0
664 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
665 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
666 static const char *const yytname[] =
667 {
668 "$end", "error", "$undefined", "INT", "FLOAT", "STRING", "NSSTRING",
669 "SELECTOR", "CHAR", "NAME", "UNKNOWN_CPP_NAME", "COMPLETE", "TYPENAME",
670 "CLASSNAME", "OBJC_LBRAC", "NAME_OR_INT", "OPERATOR", "STRUCT", "CLASS",
671 "UNION", "ENUM", "SIZEOF", "UNSIGNED", "COLONCOLON", "TEMPLATE", "ERROR",
672 "NEW", "DELETE", "REINTERPRET_CAST", "DYNAMIC_CAST", "STATIC_CAST",
673 "CONST_CAST", "ENTRY", "TYPEOF", "DECLTYPE", "TYPEID", "SIGNED_KEYWORD",
674 "LONG", "SHORT", "INT_KEYWORD", "CONST_KEYWORD", "VOLATILE_KEYWORD",
675 "DOUBLE_KEYWORD", "VARIABLE", "ASSIGN_MODIFY", "TRUEKEYWORD",
676 "FALSEKEYWORD", "','", "ABOVE_COMMA", "'='", "'?'", "OROR", "ANDAND",
677 "'|'", "'^'", "'&'", "EQUAL", "NOTEQUAL", "'<'", "'>'", "LEQ", "GEQ",
678 "LSH", "RSH", "'@'", "'+'", "'-'", "'*'", "'/'", "'%'", "UNARY",
679 "INCREMENT", "DECREMENT", "ARROW", "ARROW_STAR", "'.'", "DOT_STAR",
680 "'['", "'('", "BLOCKNAME", "FILENAME", "DOTDOTDOT", "')'", "'!'", "'~'",
681 "']'", "':'", "'{'", "'}'", "$accept", "start", "type_exp", "exp1",
682 "exp", "$@1", "$@2", "$@3", "msglist", "msgarglist", "msgarg", "$@4",
683 "$@5", "lcurly", "arglist", "function_method", "function_method_void",
684 "function_method_void_or_typelist", "rcurly", "string_exp", "block",
685 "variable", "qualified_name", "space_identifier", "const_or_volatile",
686 "cv_with_space_id", "const_or_volatile_or_space_identifier_noopt",
687 "const_or_volatile_or_space_identifier", "ptr_operator", "$@6", "$@7",
688 "ptr_operator_ts", "abs_decl", "direct_abs_decl", "array_mod",
689 "func_mod", "type", "typebase", "type_name", "parameter_typelist",
690 "nonempty_typelist", "ptype", "conversion_type_id",
691 "conversion_declarator", "const_and_volatile", "const_or_volatile_noopt",
692 "oper", "name", "name_not_typename", YY_NULLPTRPTR
693 };
694 #endif
695
696 # ifdef YYPRINT
697 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
698 (internal) symbol number NUM (which must be that of a token). */
699 static const yytype_uint16 yytoknum[] =
700 {
701 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
702 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
703 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
704 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
705 295, 296, 297, 298, 299, 300, 301, 44, 302, 61,
706 63, 303, 304, 124, 94, 38, 305, 306, 60, 62,
707 307, 308, 309, 310, 64, 43, 45, 42, 47, 37,
708 311, 312, 313, 314, 315, 46, 316, 91, 40, 317,
709 318, 319, 41, 33, 126, 93, 58, 123, 125
710 };
711 # endif
712
713 #define YYPACT_NINF -218
714
715 #define yypact_value_is_default(Yystate) \
716 (!!((Yystate) == (-218)))
717
718 #define YYTABLE_NINF -126
719
720 #define yytable_value_is_error(Yytable_value) \
721 0
722
723 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
724 STATE-NUM. */
725 static const yytype_int16 yypact[] =
726 {
727 476, -218, -218, -218, -218, -26, -218, -218, -16, 32,
728 646, -218, 890, 222, 263, 278, 302, 731, 111, 31,
729 245, 10, 14, 37, 50, 39, 43, 61, 116, 325,
730 184, -218, 105, 118, -218, -218, -218, -218, 816, 816,
731 816, 816, 816, 816, 476, 138, -218, 816, 816, -218,
732 188, -218, 145, 1430, 391, 172, -218, 173, 192, 175,
733 -218, -218, 139, -218, 751, -218, 51, 311, -218, 140,
734 -218, 183, 245, -218, 202, 32, -218, 1430, -218, 120,
735 20, 36, -218, -218, -218, -218, -218, -218, -218, -218,
736 -218, -218, -218, -218, -218, -218, -218, -218, -218, -218,
737 -218, -218, -218, -218, -218, -218, -218, 122, 137, -218,
738 -218, 267, -218, -218, -218, -218, -218, -218, -218, -218,
739 210, -218, 217, -218, 218, -218, 224, 32, 476, 452,
740 -218, 70, 197, -218, -218, -218, -218, -218, 181, 666,
741 666, 666, 666, 561, 816, 476, 99, -218, -218, 204,
742 212, 205, -218, -218, 214, 223, -218, -218, -218, 452,
743 452, 452, 452, 452, 452, 167, 4, 452, 452, -218,
744 816, 816, 816, 816, 816, 816, 816, 816, 816, 816,
745 816, 816, 816, 816, 816, 816, 816, 816, 816, 816,
746 816, 816, 816, 816, -218, -218, 48, 816, 72, 816,
747 816, 996, 189, 1430, -23, 245, -218, 245, 254, 89,
748 51, -218, 11, -1, 209, -218, 19, 228, 215, 12,
749 -218, 47, -218, -218, -218, 203, 816, 245, 248, 33,
750 33, 33, -218, 199, 207, 213, 230, -218, -218, 85,
751 -218, -218, -218, -218, -218, 227, 261, -218, -218, 751,
752 257, 262, 268, 269, 1038, 238, 1094, 244, 1150, 293,
753 -218, -218, -218, 296, 297, -218, -218, -218, 816, -218,
754 1430, -12, 1430, 1430, 926, 1486, 1515, 1542, 1571, 1598,
755 1627, 1627, 1059, 1059, 1059, 1059, 1115, 1115, 1171, 1227,
756 1227, 452, 452, 452, -218, 32, 245, -218, 327, 25,
757 -218, 245, -218, 328, 25, -11, 30, 816, -218, 258,
758 301, -218, 816, 816, -218, -218, 320, -218, -218, -218,
759 259, -218, 215, 215, 51, 264, -218, -218, 273, 277,
760 -218, 47, 334, -218, -218, -218, 29, -218, 245, 816,
761 816, 265, 33, -218, 279, 283, 284, -218, -218, -218,
762 -218, -218, -218, -218, -218, 318, 304, 305, 306, 307,
763 -218, -218, -218, -218, -218, -218, -218, -218, 452, -218,
764 816, 368, -218, 369, -218, -218, -218, 38, 89, 1005,
765 452, 1430, -218, -218, -218, -218, -218, -218, 51, -218,
766 -218, 1430, 1430, -218, -218, 279, 816, -218, -218, -218,
767 816, 816, 816, 816, 1459, -218, -218, -218, -218, -218,
768 -218, -218, 1430, 1206, 1262, 1318, 1374, -218, -218, -218,
769 -218
770 };
771
772 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
773 Performed when YYTABLE does not specify something else to do. Zero
774 means the default is an error. */
775 static const yytype_uint16 yydefact[] =
776 {
777 125, 94, 97, 106, 109, 0, 95, 264, 267, 155,
778 0, 96, 125, 0, 0, 0, 0, 0, 197, 0,
779 0, 0, 0, 0, 0, 0, 0, 0, 199, 157,
780 158, 156, 219, 220, 182, 99, 110, 111, 0, 0,
781 0, 0, 0, 0, 125, 265, 113, 0, 0, 57,
782 0, 3, 2, 8, 58, 63, 65, 0, 108, 0,
783 98, 120, 0, 127, 125, 4, 211, 154, 218, 128,
784 266, 122, 0, 55, 0, 39, 41, 43, 155, 0,
785 221, 222, 240, 251, 237, 248, 247, 234, 232, 233,
786 243, 244, 238, 239, 245, 246, 241, 242, 227, 228,
787 229, 230, 231, 249, 250, 253, 252, 0, 0, 236,
788 235, 214, 257, 258, 262, 185, 260, 261, 259, 263,
789 184, 188, 187, 191, 190, 194, 193, 0, 125, 22,
790 203, 205, 206, 204, 196, 267, 265, 121, 0, 125,
791 125, 125, 125, 125, 0, 125, 205, 206, 198, 165,
792 161, 166, 159, 183, 180, 178, 176, 216, 217, 11,
793 13, 12, 10, 16, 17, 0, 0, 14, 15, 1,
794 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
795 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
796 0, 0, 0, 0, 18, 19, 0, 0, 0, 0,
797 0, 52, 0, 59, 0, 0, 107, 0, 0, 125,
798 201, 202, 0, 137, 135, 133, 0, 125, 139, 141,
799 212, 142, 145, 147, 115, 0, 58, 0, 117, 0,
800 0, 0, 256, 0, 0, 0, 0, 255, 254, 214,
801 213, 186, 189, 192, 195, 0, 172, 163, 179, 125,
802 0, 0, 0, 0, 0, 0, 0, 0, 0, 170,
803 162, 164, 160, 174, 169, 167, 181, 177, 0, 71,
804 9, 0, 93, 92, 0, 90, 89, 88, 87, 86,
805 80, 81, 84, 85, 82, 83, 78, 79, 72, 76,
806 77, 73, 74, 75, 25, 260, 0, 28, 23, 29,
807 32, 0, 35, 30, 36, 0, 54, 58, 209, 0,
808 207, 67, 0, 0, 68, 66, 116, 123, 126, 124,
809 0, 149, 138, 136, 130, 0, 148, 152, 0, 0,
810 131, 140, 125, 144, 146, 100, 0, 118, 0, 0,
811 0, 0, 46, 47, 45, 0, 0, 225, 223, 226,
812 224, 131, 215, 101, 173, 0, 0, 0, 0, 0,
813 5, 6, 7, 21, 20, 171, 175, 168, 70, 38,
814 0, 26, 24, 33, 31, 37, 62, 0, 125, 125,
815 69, 60, 151, 129, 134, 150, 143, 153, 130, 56,
816 119, 51, 50, 40, 48, 0, 0, 42, 44, 200,
817 0, 0, 0, 0, 91, 27, 34, 53, 61, 208,
818 210, 132, 49, 0, 0, 0, 0, 102, 104, 103,
819 105
820 };
821
822 /* YYPGOTO[NTERM-NUM]. */
823 static const yytype_int16 yypgoto[] =
824 {
825 -218, -218, 2, 13, -10, -218, -218, -218, -45, -218,
826 45, -218, -218, -218, -214, -218, -218, -218, 198, -218,
827 -218, -218, -39, -218, -188, -218, -65, 16, -108, -218,
828 -218, -218, 200, 216, -217, -215, -123, 15, 390, 237,
829 -218, -218, -218, 201, -218, -184, -5, 3, 404
830 };
831
832 /* YYDEFGOTO[NTERM-NUM]. */
833 static const yytype_int16 yydefgoto[] =
834 {
835 -1, 50, 165, 166, 53, 229, 230, 231, 341, 342,
836 343, 307, 226, 54, 204, 55, 56, 57, 312, 58,
837 59, 60, 61, 209, 62, 63, 64, 384, 218, 388,
838 324, 219, 220, 221, 222, 223, 65, 66, 134, 329,
839 310, 67, 112, 240, 68, 69, 70, 344, 71
840 };
841
842 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
843 positive, shift that token. If negative, reduce the rule whose
844 number is the opposite. If YYTABLE_NINF, syntax error. */
845 static const yytype_int16 yytable[] =
846 {
847 77, 211, 51, 239, 333, 245, 334, 129, 119, 119,
848 119, 119, 336, 52, 320, 119, 120, 122, 124, 126,
849 255, 318, 325, 138, 313, 319, 212, 111, 159, 160,
850 161, 162, 163, 164, 233, 170, 170, 167, 168, 171,
851 7, 135, 113, 114, 203, 116, 211, 12, 117, 12,
852 235, 170, 72, -125, 214, 74, 202, 113, 114, 294,
853 295, 212, 73, 117, 12, 311, 215, 119, 139, 119,
854 32, 33, 140, 369, 375, 225, 313, 228, 308, 210,
855 339, 113, 114, 300, 295, 313, 269, 117, 12, 216,
856 217, 32, 33, 377, 308, 141, 321, 234, 196, 197,
857 198, 199, 200, 201, 326, 322, 323, 246, 142, 247,
858 136, 389, 118, 236, 333, -125, 334, 143, 376, 340,
859 407, 144, 319, 130, 216, 332, 355, 118, 130, 32,
860 33, 239, 296, 254, 256, 258, 259, 213, 260, 145,
861 214, 250, 251, 252, 253, 211, 157, 257, 131, 132,
862 133, 118, 351, 146, 147, 133, 301, 297, 158, 302,
863 270, -112, 272, 273, 274, 275, 276, 277, 278, 279,
864 280, 281, 282, 283, 284, 285, 286, 287, 288, 289,
865 290, 291, 292, 293, 271, 345, 346, 299, 169, 304,
866 408, 119, 170, 119, 319, -64, 205, 206, 207, 298,
867 119, 303, 119, 208, -124, 232, 154, 237, 315, 308,
868 316, 113, 114, 305, 116, 224, 203, 117, 12, 238,
869 155, 241, 119, 156, 119, 119, 119, 263, 242, 243,
870 337, 113, 114, 115, 116, 244, 248, 117, 12, 249,
871 78, 264, 212, 261, 265, 13, 14, 15, 16, 268,
872 18, 262, 20, 266, 113, 114, 410, 116, 368, 383,
873 117, 12, 267, 317, 28, 29, 30, 31, 32, 33,
874 34, 338, 113, 114, 121, 116, 215, 311, 117, 12,
875 213, 118, 330, 214, 347, 335, 227, 113, 114, 123,
876 116, 119, 348, 117, 12, 215, 119, 203, 349, 371,
877 354, 118, 380, 381, 373, 216, 217, 32, 33, 353,
878 327, 113, 114, 125, 116, 350, 356, 117, 12, 213,
879 361, 357, 214, 383, 118, 212, 363, 358, 359, 391,
880 392, -125, 365, 119, 215, 366, 367, 119, 372, 374,
881 378, 390, 118, -114, 382, 395, 78, 149, 379, 385,
882 393, 13, 14, 15, 16, 386, 18, 118, 20, 387,
883 404, 150, 151, 213, 152, 396, 214, 153, 397, 398,
884 28, 29, 30, 31, 32, 33, 34, 399, 215, 405,
885 406, 118, 400, 401, 402, 403, 412, 394, 216, 217,
886 413, 414, 415, 416, 1, 2, 3, 4, 5, 6,
887 7, 8, 314, 9, 411, 10, 11, 12, 13, 14,
888 15, 16, 17, 18, 19, 20, 327, 328, 148, 21,
889 22, 23, 24, 137, 25, 26, 27, 28, 29, 30,
890 31, 32, 33, 34, 35, 331, 36, 37, 309, 0,
891 352, 0, 0, 0, 0, 0, 38, 0, 0, 0,
892 0, 0, 0, 0, 0, -125, 39, 40, 41, 0,
893 0, 0, 42, 43, 0, 0, 171, 0, 0, 44,
894 45, 46, 0, 0, 47, 48, 0, 0, 49, 1,
895 2, 3, 4, 5, 6, 7, 8, 0, 9, 0,
896 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
897 20, 0, 0, 0, 21, 22, 23, 24, 0, 25,
898 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
899 0, 36, 37, 194, 195, 196, 197, 198, 199, 200,
900 201, 38, 0, 0, 0, 0, 0, 0, 0, 0,
901 0, 39, 40, 41, 0, 0, 0, 42, 43, 0,
902 0, 0, 0, 0, 44, 45, 46, 0, 0, 47,
903 48, 0, 0, 49, 1, 2, 3, 4, 5, 6,
904 7, 8, 0, 9, 0, 10, 11, 12, 13, 14,
905 15, 16, 17, 18, 19, 20, 0, 0, 0, 21,
906 22, 23, 24, 0, 0, 0, 27, 28, 29, 30,
907 31, 32, 33, 34, 35, 0, 36, 37, 0, 0,
908 0, 0, 0, 0, 0, 0, 38, 0, 0, 0,
909 0, 0, 0, 0, 0, 0, 39, 40, 41, 0,
910 0, 0, 42, 43, 0, 0, 0, 0, 0, 44,
911 45, 46, 0, 0, 47, 48, 0, 0, 49, 1,
912 2, 3, 4, 5, 6, 7, 8, 0, 75, 76,
913 10, 11, 12, 0, 0, 0, 0, 17, 0, 19,
914 0, 0, 0, 0, 21, 22, 23, 24, 78, 0,
915 0, 27, 0, 13, 14, 15, 16, 0, 18, 35,
916 20, 36, 37, 0, 0, 0, 0, 0, 0, 25,
917 26, 38, 28, 29, 30, 31, 32, 33, 34, 0,
918 0, 39, 40, 41, 0, 0, 0, 42, 43, 0,
919 0, 0, 0, 0, 44, 45, 46, 0, 0, 47,
920 48, 0, 0, 49, 1, 2, 3, 4, 5, 6,
921 7, 8, 0, 127, 0, 10, 11, 12, 0, 0,
922 0, 0, 17, 0, 19, 0, 0, 0, 0, 21,
923 22, 23, 24, 78, 0, 0, 27, 0, 13, 14,
924 15, 16, 0, 18, 35, 20, 36, 37, 0, 0,
925 0, 0, 0, 0, 0, 0, 38, 28, 29, 30,
926 31, 32, 33, 34, 0, 0, 39, 40, 41, 0,
927 0, 0, 42, 43, 0, 0, 0, 0, 0, 128,
928 45, 46, 0, 0, 47, 48, 0, 0, 49, 1,
929 2, 3, 4, 5, 6, 7, 8, 0, 127, 0,
930 10, 11, 12, 0, 0, 0, 0, 17, 0, 19,
931 0, 0, 0, 0, 21, 22, 23, 24, 0, 0,
932 0, 27, 0, 0, 0, 0, 0, 0, 0, 35,
933 0, 36, 37, 0, 0, 0, 0, 0, 0, 0,
934 0, 38, 0, 0, 0, 0, 0, 0, 0, 0,
935 0, 39, 40, 41, 0, 0, 0, 42, 43, 0,
936 0, 0, 0, 0, 44, 45, 46, 0, 0, 47,
937 48, 0, 78, 49, 79, 0, 0, 13, 14, 15,
938 16, 0, 18, 0, 20, 0, 80, 81, 0, 0,
939 0, 0, 0, 0, 0, 0, 28, 29, 30, 31,
940 32, 33, 34, 0, 82, 0, 0, 83, 0, 84,
941 171, 85, 86, 87, 88, 89, 90, 91, 92, 93,
942 94, 95, 96, 97, 0, 98, 99, 100, 101, 102,
943 0, 103, 104, 105, 106, 0, 0, 107, 108, 0,
944 172, 0, 0, 109, 110, 173, 174, 175, 176, 177,
945 178, 179, 180, 181, 182, 183, 184, 185, 186, 187,
946 188, 189, 190, 191, 192, 193, 0, 194, 195, 196,
947 197, 198, 199, 200, 201, 0, 0, 0, 78, 0,
948 0, 0, 370, 13, 14, 15, 16, 78, 18, 0,
949 20, 0, 13, 14, 15, 16, 0, 18, 0, 20,
950 0, 0, 28, 29, 30, 31, 32, 33, 34, 0,
951 0, 28, 29, 30, 31, 32, 33, 34, 0, 0,
952 0, 0, 171, 0, 0, 0, 0, 0, 0, 0,
953 -125, 0, 0, 0, 0, 0, 0, 0, 0, 0,
954 0, 0, 0, 171, 0, 0, 0, 0, 306, 0,
955 0, 0, 172, 0, 0, 0, 409, 173, 174, 175,
956 176, 177, 178, 179, 180, 181, 182, 183, 184, 185,
957 186, 187, 188, 189, 190, 191, 192, 193, 171, 194,
958 195, 196, 197, 198, 199, 200, 201, 0, 0, 0,
959 360, 186, 187, 188, 189, 190, 191, 192, 193, 171,
960 194, 195, 196, 197, 198, 199, 200, 201, 172, 0,
961 0, 0, 0, 173, 174, 175, 176, 177, 178, 179,
962 180, 181, 182, 183, 184, 185, 186, 187, 188, 189,
963 190, 191, 192, 193, 171, 194, 195, 196, 197, 198,
964 199, 200, 201, 0, 0, 0, 362, 0, 0, 188,
965 189, 190, 191, 192, 193, 171, 194, 195, 196, 197,
966 198, 199, 200, 201, 172, 0, 0, 0, 0, 173,
967 174, 175, 176, 177, 178, 179, 180, 181, 182, 183,
968 184, 185, 186, 187, 188, 189, 190, 191, 192, 193,
969 171, 194, 195, 196, 197, 198, 199, 200, 201, 0,
970 0, 0, 364, 0, 0, 0, 189, 190, 191, 192,
971 193, 171, 194, 195, 196, 197, 198, 199, 200, 201,
972 172, 0, 0, 0, 0, 173, 174, 175, 176, 177,
973 178, 179, 180, 181, 182, 183, 184, 185, 186, 187,
974 188, 189, 190, 191, 192, 193, 171, 194, 195, 196,
975 197, 198, 199, 200, 201, 0, 0, 0, 417, 0,
976 0, 0, 0, 0, 191, 192, 193, 0, 194, 195,
977 196, 197, 198, 199, 200, 201, 172, 0, 0, 0,
978 0, 173, 174, 175, 176, 177, 178, 179, 180, 181,
979 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
980 192, 193, 171, 194, 195, 196, 197, 198, 199, 200,
981 201, 0, 0, 0, 418, 0, 0, 0, 0, 0,
982 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
983 0, 0, 172, 0, 0, 0, 0, 173, 174, 175,
984 176, 177, 178, 179, 180, 181, 182, 183, 184, 185,
985 186, 187, 188, 189, 190, 191, 192, 193, 171, 194,
986 195, 196, 197, 198, 199, 200, 201, 0, 0, 0,
987 419, 0, 0, 0, 0, 0, 0, 0, 0, 0,
988 0, 0, 0, 0, 0, 0, 0, 0, 172, 0,
989 0, 0, 0, 173, 174, 175, 176, 177, 178, 179,
990 180, 181, 182, 183, 184, 185, 186, 187, 188, 189,
991 190, 191, 192, 193, 171, 194, 195, 196, 197, 198,
992 199, 200, 201, 0, 0, 0, 420, 0, 0, 0,
993 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
994 0, 0, 0, 171, 172, 0, 0, 0, 0, 173,
995 174, 175, 176, 177, 178, 179, 180, 181, 182, 183,
996 184, 185, 186, 187, 188, 189, 190, 191, 192, 193,
997 171, 194, 195, 196, 197, 198, 199, 200, 201, 174,
998 175, 176, 177, 178, 179, 180, 181, 182, 183, 184,
999 185, 186, 187, 188, 189, 190, 191, 192, 193, 171,
1000 194, 195, 196, 197, 198, 199, 200, 201, 176, 177,
1001 178, 179, 180, 181, 182, 183, 184, 185, 186, 187,
1002 188, 189, 190, 191, 192, 193, 171, 194, 195, 196,
1003 197, 198, 199, 200, 201, 0, 0, 0, 177, 178,
1004 179, 180, 181, 182, 183, 184, 185, 186, 187, 188,
1005 189, 190, 191, 192, 193, 171, 194, 195, 196, 197,
1006 198, 199, 200, 201, 0, 0, 178, 179, 180, 181,
1007 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
1008 192, 193, 171, 194, 195, 196, 197, 198, 199, 200,
1009 201, 0, 0, 0, 0, 0, 179, 180, 181, 182,
1010 183, 184, 185, 186, 187, 188, 189, 190, 191, 192,
1011 193, 171, 194, 195, 196, 197, 198, 199, 200, 201,
1012 0, 0, 0, 0, 180, 181, 182, 183, 184, 185,
1013 186, 187, 188, 189, 190, 191, 192, 193, 0, 194,
1014 195, 196, 197, 198, 199, 200, 201, 0, 0, 0,
1015 0, 0, 0, 0, 0, 182, 183, 184, 185, 186,
1016 187, 188, 189, 190, 191, 192, 193, 0, 194, 195,
1017 196, 197, 198, 199, 200, 201
1018 };
1019
1020 static const yytype_int16 yycheck[] =
1021 {
1022 10, 66, 0, 111, 221, 128, 221, 17, 13, 14,
1023 15, 16, 226, 0, 3, 20, 13, 14, 15, 16,
1024 143, 209, 3, 20, 47, 209, 14, 12, 38, 39,
1025 40, 41, 42, 43, 14, 47, 47, 47, 48, 14,
1026 9, 10, 9, 10, 54, 12, 111, 16, 15, 16,
1027 14, 47, 78, 23, 55, 23, 54, 9, 10, 11,
1028 12, 14, 78, 15, 16, 88, 67, 72, 58, 74,
1029 40, 41, 58, 85, 85, 72, 47, 74, 201, 64,
1030 47, 9, 10, 11, 12, 47, 82, 15, 16, 77,
1031 78, 40, 41, 307, 217, 58, 85, 77, 73, 74,
1032 75, 76, 77, 78, 85, 213, 214, 37, 58, 39,
1033 79, 82, 79, 77, 331, 64, 331, 78, 306, 86,
1034 82, 78, 306, 12, 77, 78, 249, 79, 12, 40,
1035 41, 239, 84, 143, 144, 145, 37, 52, 39, 78,
1036 55, 139, 140, 141, 142, 210, 41, 145, 37, 38,
1037 39, 79, 67, 37, 38, 39, 84, 196, 40, 198,
1038 170, 23, 172, 173, 174, 175, 176, 177, 178, 179,
1039 180, 181, 182, 183, 184, 185, 186, 187, 188, 189,
1040 190, 191, 192, 193, 171, 230, 231, 197, 0, 199,
1041 378, 196, 47, 198, 378, 23, 23, 5, 23, 196,
1042 205, 198, 207, 64, 64, 85, 22, 85, 205, 332,
1043 207, 9, 10, 200, 12, 32, 226, 15, 16, 82,
1044 36, 11, 227, 39, 229, 230, 231, 22, 11, 11,
1045 227, 9, 10, 11, 12, 11, 39, 15, 16, 58,
1046 12, 36, 14, 39, 39, 17, 18, 19, 20, 82,
1047 22, 39, 24, 39, 9, 10, 379, 12, 268, 324,
1048 15, 16, 39, 9, 36, 37, 38, 39, 40, 41,
1049 42, 23, 9, 10, 11, 12, 67, 88, 15, 16,
1050 52, 79, 67, 55, 85, 82, 84, 9, 10, 11,
1051 12, 296, 85, 15, 16, 67, 301, 307, 85, 296,
1052 39, 79, 312, 313, 301, 77, 78, 40, 41, 82,
1053 82, 9, 10, 11, 12, 85, 59, 15, 16, 52,
1054 82, 59, 55, 388, 79, 14, 82, 59, 59, 339,
1055 340, 64, 39, 338, 67, 39, 39, 342, 11, 11,
1056 82, 338, 79, 23, 85, 342, 12, 22, 47, 85,
1057 85, 17, 18, 19, 20, 82, 22, 79, 24, 82,
1058 370, 36, 37, 52, 39, 86, 55, 42, 85, 85,
1059 36, 37, 38, 39, 40, 41, 42, 59, 67, 11,
1060 11, 79, 78, 78, 78, 78, 396, 342, 77, 78,
1061 400, 401, 402, 403, 3, 4, 5, 6, 7, 8,
1062 9, 10, 204, 12, 388, 14, 15, 16, 17, 18,
1063 19, 20, 21, 22, 23, 24, 82, 217, 28, 28,
1064 29, 30, 31, 19, 33, 34, 35, 36, 37, 38,
1065 39, 40, 41, 42, 43, 219, 45, 46, 201, -1,
1066 239, -1, -1, -1, -1, -1, 55, -1, -1, -1,
1067 -1, -1, -1, -1, -1, 64, 65, 66, 67, -1,
1068 -1, -1, 71, 72, -1, -1, 14, -1, -1, 78,
1069 79, 80, -1, -1, 83, 84, -1, -1, 87, 3,
1070 4, 5, 6, 7, 8, 9, 10, -1, 12, -1,
1071 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
1072 24, -1, -1, -1, 28, 29, 30, 31, -1, 33,
1073 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
1074 -1, 45, 46, 71, 72, 73, 74, 75, 76, 77,
1075 78, 55, -1, -1, -1, -1, -1, -1, -1, -1,
1076 -1, 65, 66, 67, -1, -1, -1, 71, 72, -1,
1077 -1, -1, -1, -1, 78, 79, 80, -1, -1, 83,
1078 84, -1, -1, 87, 3, 4, 5, 6, 7, 8,
1079 9, 10, -1, 12, -1, 14, 15, 16, 17, 18,
1080 19, 20, 21, 22, 23, 24, -1, -1, -1, 28,
1081 29, 30, 31, -1, -1, -1, 35, 36, 37, 38,
1082 39, 40, 41, 42, 43, -1, 45, 46, -1, -1,
1083 -1, -1, -1, -1, -1, -1, 55, -1, -1, -1,
1084 -1, -1, -1, -1, -1, -1, 65, 66, 67, -1,
1085 -1, -1, 71, 72, -1, -1, -1, -1, -1, 78,
1086 79, 80, -1, -1, 83, 84, -1, -1, 87, 3,
1087 4, 5, 6, 7, 8, 9, 10, -1, 12, 13,
1088 14, 15, 16, -1, -1, -1, -1, 21, -1, 23,
1089 -1, -1, -1, -1, 28, 29, 30, 31, 12, -1,
1090 -1, 35, -1, 17, 18, 19, 20, -1, 22, 43,
1091 24, 45, 46, -1, -1, -1, -1, -1, -1, 33,
1092 34, 55, 36, 37, 38, 39, 40, 41, 42, -1,
1093 -1, 65, 66, 67, -1, -1, -1, 71, 72, -1,
1094 -1, -1, -1, -1, 78, 79, 80, -1, -1, 83,
1095 84, -1, -1, 87, 3, 4, 5, 6, 7, 8,
1096 9, 10, -1, 12, -1, 14, 15, 16, -1, -1,
1097 -1, -1, 21, -1, 23, -1, -1, -1, -1, 28,
1098 29, 30, 31, 12, -1, -1, 35, -1, 17, 18,
1099 19, 20, -1, 22, 43, 24, 45, 46, -1, -1,
1100 -1, -1, -1, -1, -1, -1, 55, 36, 37, 38,
1101 39, 40, 41, 42, -1, -1, 65, 66, 67, -1,
1102 -1, -1, 71, 72, -1, -1, -1, -1, -1, 78,
1103 79, 80, -1, -1, 83, 84, -1, -1, 87, 3,
1104 4, 5, 6, 7, 8, 9, 10, -1, 12, -1,
1105 14, 15, 16, -1, -1, -1, -1, 21, -1, 23,
1106 -1, -1, -1, -1, 28, 29, 30, 31, -1, -1,
1107 -1, 35, -1, -1, -1, -1, -1, -1, -1, 43,
1108 -1, 45, 46, -1, -1, -1, -1, -1, -1, -1,
1109 -1, 55, -1, -1, -1, -1, -1, -1, -1, -1,
1110 -1, 65, 66, 67, -1, -1, -1, 71, 72, -1,
1111 -1, -1, -1, -1, 78, 79, 80, -1, -1, 83,
1112 84, -1, 12, 87, 14, -1, -1, 17, 18, 19,
1113 20, -1, 22, -1, 24, -1, 26, 27, -1, -1,
1114 -1, -1, -1, -1, -1, -1, 36, 37, 38, 39,
1115 40, 41, 42, -1, 44, -1, -1, 47, -1, 49,
1116 14, 51, 52, 53, 54, 55, 56, 57, 58, 59,
1117 60, 61, 62, 63, -1, 65, 66, 67, 68, 69,
1118 -1, 71, 72, 73, 74, -1, -1, 77, 78, -1,
1119 44, -1, -1, 83, 84, 49, 50, 51, 52, 53,
1120 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1121 64, 65, 66, 67, 68, 69, -1, 71, 72, 73,
1122 74, 75, 76, 77, 78, -1, -1, -1, 12, -1,
1123 -1, -1, 86, 17, 18, 19, 20, 12, 22, -1,
1124 24, -1, 17, 18, 19, 20, -1, 22, -1, 24,
1125 -1, -1, 36, 37, 38, 39, 40, 41, 42, -1,
1126 -1, 36, 37, 38, 39, 40, 41, 42, -1, -1,
1127 -1, -1, 14, -1, -1, -1, -1, -1, -1, -1,
1128 64, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1129 -1, -1, -1, 14, -1, -1, -1, -1, 82, -1,
1130 -1, -1, 44, -1, -1, -1, 81, 49, 50, 51,
1131 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
1132 62, 63, 64, 65, 66, 67, 68, 69, 14, 71,
1133 72, 73, 74, 75, 76, 77, 78, -1, -1, -1,
1134 82, 62, 63, 64, 65, 66, 67, 68, 69, 14,
1135 71, 72, 73, 74, 75, 76, 77, 78, 44, -1,
1136 -1, -1, -1, 49, 50, 51, 52, 53, 54, 55,
1137 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
1138 66, 67, 68, 69, 14, 71, 72, 73, 74, 75,
1139 76, 77, 78, -1, -1, -1, 82, -1, -1, 64,
1140 65, 66, 67, 68, 69, 14, 71, 72, 73, 74,
1141 75, 76, 77, 78, 44, -1, -1, -1, -1, 49,
1142 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
1143 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
1144 14, 71, 72, 73, 74, 75, 76, 77, 78, -1,
1145 -1, -1, 82, -1, -1, -1, 65, 66, 67, 68,
1146 69, 14, 71, 72, 73, 74, 75, 76, 77, 78,
1147 44, -1, -1, -1, -1, 49, 50, 51, 52, 53,
1148 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1149 64, 65, 66, 67, 68, 69, 14, 71, 72, 73,
1150 74, 75, 76, 77, 78, -1, -1, -1, 82, -1,
1151 -1, -1, -1, -1, 67, 68, 69, -1, 71, 72,
1152 73, 74, 75, 76, 77, 78, 44, -1, -1, -1,
1153 -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
1154 58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
1155 68, 69, 14, 71, 72, 73, 74, 75, 76, 77,
1156 78, -1, -1, -1, 82, -1, -1, -1, -1, -1,
1157 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1158 -1, -1, 44, -1, -1, -1, -1, 49, 50, 51,
1159 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
1160 62, 63, 64, 65, 66, 67, 68, 69, 14, 71,
1161 72, 73, 74, 75, 76, 77, 78, -1, -1, -1,
1162 82, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1163 -1, -1, -1, -1, -1, -1, -1, -1, 44, -1,
1164 -1, -1, -1, 49, 50, 51, 52, 53, 54, 55,
1165 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
1166 66, 67, 68, 69, 14, 71, 72, 73, 74, 75,
1167 76, 77, 78, -1, -1, -1, 82, -1, -1, -1,
1168 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1169 -1, -1, -1, 14, 44, -1, -1, -1, -1, 49,
1170 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
1171 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
1172 14, 71, 72, 73, 74, 75, 76, 77, 78, 50,
1173 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
1174 61, 62, 63, 64, 65, 66, 67, 68, 69, 14,
1175 71, 72, 73, 74, 75, 76, 77, 78, 52, 53,
1176 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1177 64, 65, 66, 67, 68, 69, 14, 71, 72, 73,
1178 74, 75, 76, 77, 78, -1, -1, -1, 53, 54,
1179 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
1180 65, 66, 67, 68, 69, 14, 71, 72, 73, 74,
1181 75, 76, 77, 78, -1, -1, 54, 55, 56, 57,
1182 58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
1183 68, 69, 14, 71, 72, 73, 74, 75, 76, 77,
1184 78, -1, -1, -1, -1, -1, 55, 56, 57, 58,
1185 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
1186 69, 14, 71, 72, 73, 74, 75, 76, 77, 78,
1187 -1, -1, -1, -1, 56, 57, 58, 59, 60, 61,
1188 62, 63, 64, 65, 66, 67, 68, 69, -1, 71,
1189 72, 73, 74, 75, 76, 77, 78, -1, -1, -1,
1190 -1, -1, -1, -1, -1, 58, 59, 60, 61, 62,
1191 63, 64, 65, 66, 67, 68, 69, -1, 71, 72,
1192 73, 74, 75, 76, 77, 78
1193 };
1194
1195 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1196 symbol of state STATE-NUM. */
1197 static const yytype_uint8 yystos[] =
1198 {
1199 0, 3, 4, 5, 6, 7, 8, 9, 10, 12,
1200 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
1201 24, 28, 29, 30, 31, 33, 34, 35, 36, 37,
1202 38, 39, 40, 41, 42, 43, 45, 46, 55, 65,
1203 66, 67, 71, 72, 78, 79, 80, 83, 84, 87,
1204 90, 91, 92, 93, 102, 104, 105, 106, 108, 109,
1205 110, 111, 113, 114, 115, 125, 126, 130, 133, 134,
1206 135, 137, 78, 78, 23, 12, 13, 93, 12, 14,
1207 26, 27, 44, 47, 49, 51, 52, 53, 54, 55,
1208 56, 57, 58, 59, 60, 61, 62, 63, 65, 66,
1209 67, 68, 69, 71, 72, 73, 74, 77, 78, 83,
1210 84, 126, 131, 9, 10, 11, 12, 15, 79, 135,
1211 136, 11, 136, 11, 136, 11, 136, 12, 78, 93,
1212 12, 37, 38, 39, 127, 10, 79, 137, 136, 58,
1213 58, 58, 58, 78, 78, 78, 37, 38, 127, 22,
1214 36, 37, 39, 42, 22, 36, 39, 41, 40, 93,
1215 93, 93, 93, 93, 93, 91, 92, 93, 93, 0,
1216 47, 14, 44, 49, 50, 51, 52, 53, 54, 55,
1217 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
1218 66, 67, 68, 69, 71, 72, 73, 74, 75, 76,
1219 77, 78, 91, 93, 103, 23, 5, 23, 64, 112,
1220 126, 115, 14, 52, 55, 67, 77, 78, 117, 120,
1221 121, 122, 123, 124, 32, 136, 101, 84, 136, 94,
1222 95, 96, 85, 14, 77, 14, 77, 85, 82, 117,
1223 132, 11, 11, 11, 11, 125, 37, 39, 39, 58,
1224 91, 91, 91, 91, 93, 125, 93, 91, 93, 37,
1225 39, 39, 39, 22, 36, 39, 39, 39, 82, 82,
1226 93, 92, 93, 93, 93, 93, 93, 93, 93, 93,
1227 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
1228 93, 93, 93, 93, 11, 12, 84, 111, 136, 93,
1229 11, 84, 111, 136, 93, 92, 82, 100, 125, 128,
1230 129, 88, 107, 47, 107, 136, 136, 9, 113, 134,
1231 3, 85, 117, 117, 119, 3, 85, 82, 121, 128,
1232 67, 122, 78, 123, 124, 82, 103, 136, 23, 47,
1233 86, 97, 98, 99, 136, 97, 97, 85, 85, 85,
1234 85, 67, 132, 82, 39, 125, 59, 59, 59, 59,
1235 82, 82, 82, 82, 82, 39, 39, 39, 93, 85,
1236 86, 136, 11, 136, 11, 85, 113, 103, 82, 47,
1237 93, 93, 85, 115, 116, 85, 82, 82, 118, 82,
1238 136, 93, 93, 85, 99, 136, 86, 85, 85, 59,
1239 78, 78, 78, 78, 93, 11, 11, 82, 113, 81,
1240 125, 116, 93, 93, 93, 93, 93, 82, 82, 82,
1241 82
1242 };
1243
1244 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1245 static const yytype_uint8 yyr1[] =
1246 {
1247 0, 89, 90, 90, 91, 91, 91, 91, 92, 92,
1248 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
1249 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
1250 93, 93, 93, 93, 93, 93, 93, 93, 93, 94,
1251 93, 95, 93, 96, 93, 97, 97, 98, 98, 99,
1252 99, 99, 100, 93, 93, 101, 93, 102, 103, 103,
1253 103, 104, 105, 93, 106, 106, 93, 107, 93, 93,
1254 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
1255 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
1256 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
1257 93, 93, 93, 93, 93, 93, 108, 108, 93, 93,
1258 93, 93, 109, 109, 109, 110, 110, 111, 111, 111,
1259 110, 110, 110, 112, 113, 113, 114, 115, 115, 116,
1260 116, 118, 117, 119, 117, 117, 117, 117, 117, 120,
1261 121, 121, 121, 122, 122, 122, 122, 122, 123, 123,
1262 123, 123, 124, 124, 125, 126, 126, 126, 126, 126,
1263 126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
1264 126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
1265 126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
1266 126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
1267 126, 126, 126, 127, 127, 127, 127, 128, 128, 129,
1268 129, 130, 130, 131, 132, 132, 133, 133, 134, 134,
1269 134, 135, 135, 135, 135, 135, 135, 135, 135, 135,
1270 135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
1271 135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
1272 135, 135, 135, 135, 135, 135, 135, 135, 136, 136,
1273 136, 136, 136, 136, 137, 137, 137, 137
1274 };
1275
1276 /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
1277 static const yytype_uint8 yyr2[] =
1278 {
1279 0, 2, 1, 1, 1, 4, 4, 4, 1, 3,
1280 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1281 4, 4, 2, 3, 4, 3, 4, 5, 3, 3,
1282 3, 4, 3, 4, 5, 3, 3, 4, 4, 0,
1283 5, 0, 5, 0, 5, 1, 1, 1, 2, 3,
1284 2, 2, 0, 5, 3, 0, 5, 1, 0, 1,
1285 3, 5, 4, 1, 1, 1, 3, 1, 3, 4,
1286 4, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1287 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1288 3, 5, 3, 3, 1, 1, 1, 1, 1, 1,
1289 4, 4, 7, 7, 7, 7, 1, 2, 1, 1,
1290 1, 1, 1, 1, 3, 2, 3, 3, 4, 5,
1291 1, 2, 1, 2, 1, 0, 3, 1, 1, 1,
1292 0, 0, 4, 0, 3, 1, 2, 1, 2, 1,
1293 2, 1, 1, 3, 2, 1, 2, 1, 2, 2,
1294 3, 3, 2, 3, 1, 1, 1, 1, 1, 2,
1295 3, 2, 3, 3, 3, 2, 2, 3, 4, 3,
1296 3, 4, 3, 4, 3, 4, 2, 3, 2, 3,
1297 2, 3, 1, 2, 2, 2, 3, 2, 2, 3,
1298 2, 2, 3, 2, 2, 3, 2, 1, 2, 1,
1299 5, 2, 2, 1, 1, 1, 1, 1, 3, 1,
1300 3, 1, 2, 2, 0, 2, 2, 2, 1, 1,
1301 1, 2, 2, 4, 4, 4, 4, 2, 2, 2,
1302 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1303 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1304 2, 2, 2, 2, 3, 3, 3, 2, 1, 1,
1305 1, 1, 1, 1, 1, 1, 1, 1
1306 };
1307
1308
1309 #define yyerrok (yyerrstatus = 0)
1310 #define yyclearin (yychar = YYEMPTY)
1311 #define YYEMPTY (-2)
1312 #define YYEOF 0
1313
1314 #define YYACCEPT goto yyacceptlab
1315 #define YYABORT goto yyabortlab
1316 #define YYERROR goto yyerrorlab
1317
1318
1319 #define YYRECOVERING() (!!yyerrstatus)
1320
1321 #define YYBACKUP(Token, Value) \
1322 do \
1323 if (yychar == YYEMPTY) \
1324 { \
1325 yychar = (Token); \
1326 yylval = (Value); \
1327 YYPOPSTACK (yylen); \
1328 yystate = *yyssp; \
1329 goto yybackup; \
1330 } \
1331 else \
1332 { \
1333 yyerror (YY_("syntax error: cannot back up")); \
1334 YYERROR; \
1335 } \
1336 while (0)
1337
1338 /* Error token number */
1339 #define YYTERROR 1
1340 #define YYERRCODE 256
1341
1342
1343
1344 /* Enable debugging if requested. */
1345 #if YYDEBUG
1346
1347 # ifndef YYFPRINTF
1348 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1349 # define YYFPRINTF fprintf
1350 # endif
1351
1352 # define YYDPRINTF(Args) \
1353 do { \
1354 if (yydebug) \
1355 YYFPRINTF Args; \
1356 } while (0)
1357
1358 /* This macro is provided for backward compatibility. */
1359 #ifndef YY_LOCATION_PRINT
1360 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1361 #endif
1362
1363
1364 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1365 do { \
1366 if (yydebug) \
1367 { \
1368 YYFPRINTF (stderr, "%s ", Title); \
1369 yy_symbol_print (stderr, \
1370 Type, Value); \
1371 YYFPRINTF (stderr, "\n"); \
1372 } \
1373 } while (0)
1374
1375
1376 /*----------------------------------------.
1377 | Print this symbol's value on YYOUTPUT. |
1378 `----------------------------------------*/
1379
1380 static void
1381 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1382 {
1383 FILE *yyo = yyoutput;
1384 YYUSE (yyo);
1385 if (!yyvaluep)
1386 return;
1387 # ifdef YYPRINT
1388 if (yytype < YYNTOKENS)
1389 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1390 # endif
1391 YYUSE (yytype);
1392 }
1393
1394
1395 /*--------------------------------.
1396 | Print this symbol on YYOUTPUT. |
1397 `--------------------------------*/
1398
1399 static void
1400 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1401 {
1402 YYFPRINTF (yyoutput, "%s %s (",
1403 yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
1404
1405 yy_symbol_value_print (yyoutput, yytype, yyvaluep);
1406 YYFPRINTF (yyoutput, ")");
1407 }
1408
1409 /*------------------------------------------------------------------.
1410 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1411 | TOP (included). |
1412 `------------------------------------------------------------------*/
1413
1414 static void
1415 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1416 {
1417 YYFPRINTF (stderr, "Stack now");
1418 for (; yybottom <= yytop; yybottom++)
1419 {
1420 int yybot = *yybottom;
1421 YYFPRINTF (stderr, " %d", yybot);
1422 }
1423 YYFPRINTF (stderr, "\n");
1424 }
1425
1426 # define YY_STACK_PRINT(Bottom, Top) \
1427 do { \
1428 if (yydebug) \
1429 yy_stack_print ((Bottom), (Top)); \
1430 } while (0)
1431
1432
1433 /*------------------------------------------------.
1434 | Report that the YYRULE is going to be reduced. |
1435 `------------------------------------------------*/
1436
1437 static void
1438 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule)
1439 {
1440 unsigned long int yylno = yyrline[yyrule];
1441 int yynrhs = yyr2[yyrule];
1442 int yyi;
1443 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1444 yyrule - 1, yylno);
1445 /* The symbols being reduced. */
1446 for (yyi = 0; yyi < yynrhs; yyi++)
1447 {
1448 YYFPRINTF (stderr, " $%d = ", yyi + 1);
1449 yy_symbol_print (stderr,
1450 yystos[yyssp[yyi + 1 - yynrhs]],
1451 &(yyvsp[(yyi + 1) - (yynrhs)])
1452 );
1453 YYFPRINTF (stderr, "\n");
1454 }
1455 }
1456
1457 # define YY_REDUCE_PRINT(Rule) \
1458 do { \
1459 if (yydebug) \
1460 yy_reduce_print (yyssp, yyvsp, Rule); \
1461 } while (0)
1462
1463 /* Nonzero means print parse trace. It is left uninitialized so that
1464 multiple parsers can coexist. */
1465 int yydebug;
1466 #else /* !YYDEBUG */
1467 # define YYDPRINTF(Args)
1468 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1469 # define YY_STACK_PRINT(Bottom, Top)
1470 # define YY_REDUCE_PRINT(Rule)
1471 #endif /* !YYDEBUG */
1472
1473
1474 /* YYINITDEPTH -- initial size of the parser's stacks. */
1475 #ifndef YYINITDEPTH
1476 # define YYINITDEPTH 200
1477 #endif
1478
1479 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1480 if the built-in stack extension method is used).
1481
1482 Do not make this value too large; the results are undefined if
1483 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1484 evaluated with infinite-precision integer arithmetic. */
1485
1486 #ifndef YYMAXDEPTH
1487 # define YYMAXDEPTH 10000
1488 #endif
1489
1490
1491 #if YYERROR_VERBOSE
1492
1493 # ifndef yystrlen
1494 # if defined __GLIBC__ && defined _STRING_H
1495 # define yystrlen strlen
1496 # else
1497 /* Return the length of YYSTR. */
1498 static YYSIZE_T
1499 yystrlen (const char *yystr)
1500 {
1501 YYSIZE_T yylen;
1502 for (yylen = 0; yystr[yylen]; yylen++)
1503 continue;
1504 return yylen;
1505 }
1506 # endif
1507 # endif
1508
1509 # ifndef yystpcpy
1510 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1511 # define yystpcpy stpcpy
1512 # else
1513 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1514 YYDEST. */
1515 static char *
1516 yystpcpy (char *yydest, const char *yysrc)
1517 {
1518 char *yyd = yydest;
1519 const char *yys = yysrc;
1520
1521 while ((*yyd++ = *yys++) != '\0')
1522 continue;
1523
1524 return yyd - 1;
1525 }
1526 # endif
1527 # endif
1528
1529 # ifndef yytnamerr
1530 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1531 quotes and backslashes, so that it's suitable for yyerror. The
1532 heuristic is that double-quoting is unnecessary unless the string
1533 contains an apostrophe, a comma, or backslash (other than
1534 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1535 null, do not copy; instead, return the length of what the result
1536 would have been. */
1537 static YYSIZE_T
1538 yytnamerr (char *yyres, const char *yystr)
1539 {
1540 if (*yystr == '"')
1541 {
1542 YYSIZE_T yyn = 0;
1543 char const *yyp = yystr;
1544
1545 for (;;)
1546 switch (*++yyp)
1547 {
1548 case '\'':
1549 case ',':
1550 goto do_not_strip_quotes;
1551
1552 case '\\':
1553 if (*++yyp != '\\')
1554 goto do_not_strip_quotes;
1555 /* Fall through. */
1556 default:
1557 if (yyres)
1558 yyres[yyn] = *yyp;
1559 yyn++;
1560 break;
1561
1562 case '"':
1563 if (yyres)
1564 yyres[yyn] = '\0';
1565 return yyn;
1566 }
1567 do_not_strip_quotes: ;
1568 }
1569
1570 if (! yyres)
1571 return yystrlen (yystr);
1572
1573 return yystpcpy (yyres, yystr) - yyres;
1574 }
1575 # endif
1576
1577 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1578 about the unexpected token YYTOKEN for the state stack whose top is
1579 YYSSP.
1580
1581 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
1582 not large enough to hold the message. In that case, also set
1583 *YYMSG_ALLOC to the required number of bytes. Return 2 if the
1584 required number of bytes is too large to store. */
1585 static int
1586 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1587 yytype_int16 *yyssp, int yytoken)
1588 {
1589 YYSIZE_T yysize0 = yytnamerr (YY_NULLPTRPTR, yytname[yytoken]);
1590 YYSIZE_T yysize = yysize0;
1591 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1592 /* Internationalized format string. */
1593 const char *yyformat = YY_NULLPTRPTR;
1594 /* Arguments of yyformat. */
1595 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1596 /* Number of reported tokens (one for the "unexpected", one per
1597 "expected"). */
1598 int yycount = 0;
1599
1600 /* There are many possibilities here to consider:
1601 - If this state is a consistent state with a default action, then
1602 the only way this function was invoked is if the default action
1603 is an error action. In that case, don't check for expected
1604 tokens because there are none.
1605 - The only way there can be no lookahead present (in yychar) is if
1606 this state is a consistent state with a default action. Thus,
1607 detecting the absence of a lookahead is sufficient to determine
1608 that there is no unexpected or expected token to report. In that
1609 case, just report a simple "syntax error".
1610 - Don't assume there isn't a lookahead just because this state is a
1611 consistent state with a default action. There might have been a
1612 previous inconsistent state, consistent state with a non-default
1613 action, or user semantic action that manipulated yychar.
1614 - Of course, the expected token list depends on states to have
1615 correct lookahead information, and it depends on the parser not
1616 to perform extra reductions after fetching a lookahead from the
1617 scanner and before detecting a syntax error. Thus, state merging
1618 (from LALR or IELR) and default reductions corrupt the expected
1619 token list. However, the list is correct for canonical LR with
1620 one exception: it will still contain any token that will not be
1621 accepted due to an error action in a later state.
1622 */
1623 if (yytoken != YYEMPTY)
1624 {
1625 int yyn = yypact[*yyssp];
1626 yyarg[yycount++] = yytname[yytoken];
1627 if (!yypact_value_is_default (yyn))
1628 {
1629 /* Start YYX at -YYN if negative to avoid negative indexes in
1630 YYCHECK. In other words, skip the first -YYN actions for
1631 this state because they are default actions. */
1632 int yyxbegin = yyn < 0 ? -yyn : 0;
1633 /* Stay within bounds of both yycheck and yytname. */
1634 int yychecklim = YYLAST - yyn + 1;
1635 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1636 int yyx;
1637
1638 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1639 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1640 && !yytable_value_is_error (yytable[yyx + yyn]))
1641 {
1642 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1643 {
1644 yycount = 1;
1645 yysize = yysize0;
1646 break;
1647 }
1648 yyarg[yycount++] = yytname[yyx];
1649 {
1650 YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTRPTR, yytname[yyx]);
1651 if (! (yysize <= yysize1
1652 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1653 return 2;
1654 yysize = yysize1;
1655 }
1656 }
1657 }
1658 }
1659
1660 switch (yycount)
1661 {
1662 # define YYCASE_(N, S) \
1663 case N: \
1664 yyformat = S; \
1665 break
1666 YYCASE_(0, YY_("syntax error"));
1667 YYCASE_(1, YY_("syntax error, unexpected %s"));
1668 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1669 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1670 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1671 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1672 # undef YYCASE_
1673 }
1674
1675 {
1676 YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
1677 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1678 return 2;
1679 yysize = yysize1;
1680 }
1681
1682 if (*yymsg_alloc < yysize)
1683 {
1684 *yymsg_alloc = 2 * yysize;
1685 if (! (yysize <= *yymsg_alloc
1686 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1687 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1688 return 1;
1689 }
1690
1691 /* Avoid sprintf, as that infringes on the user's name space.
1692 Don't have undefined behavior even if the translation
1693 produced a string with the wrong number of "%s"s. */
1694 {
1695 char *yyp = *yymsg;
1696 int yyi = 0;
1697 while ((*yyp = *yyformat) != '\0')
1698 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1699 {
1700 yyp += yytnamerr (yyp, yyarg[yyi++]);
1701 yyformat += 2;
1702 }
1703 else
1704 {
1705 yyp++;
1706 yyformat++;
1707 }
1708 }
1709 return 0;
1710 }
1711 #endif /* YYERROR_VERBOSE */
1712
1713 /*-----------------------------------------------.
1714 | Release the memory associated to this symbol. |
1715 `-----------------------------------------------*/
1716
1717 static void
1718 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1719 {
1720 YYUSE (yyvaluep);
1721 if (!yymsg)
1722 yymsg = "Deleting";
1723 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1724
1725 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1726 YYUSE (yytype);
1727 YY_IGNORE_MAYBE_UNINITIALIZED_END
1728 }
1729
1730
1731
1732
1733 /* The lookahead symbol. */
1734 int yychar;
1735
1736 /* The semantic value of the lookahead symbol. */
1737 YYSTYPE yylval;
1738 /* Number of syntax errors so far. */
1739 int yynerrs;
1740
1741
1742 /*----------.
1743 | yyparse. |
1744 `----------*/
1745
1746 int
1747 yyparse (void)
1748 {
1749 int yystate;
1750 /* Number of tokens to shift before error messages enabled. */
1751 int yyerrstatus;
1752
1753 /* The stacks and their tools:
1754 'yyss': related to states.
1755 'yyvs': related to semantic values.
1756
1757 Refer to the stacks through separate pointers, to allow yyoverflow
1758 to xreallocate them elsewhere. */
1759
1760 /* The state stack. */
1761 yytype_int16 yyssa[YYINITDEPTH];
1762 yytype_int16 *yyss;
1763 yytype_int16 *yyssp;
1764
1765 /* The semantic value stack. */
1766 YYSTYPE yyvsa[YYINITDEPTH];
1767 YYSTYPE *yyvs;
1768 YYSTYPE *yyvsp;
1769
1770 YYSIZE_T yystacksize;
1771
1772 int yyn;
1773 int yyresult;
1774 /* Lookahead token as an internal (translated) token number. */
1775 int yytoken = 0;
1776 /* The variables used to return semantic value and location from the
1777 action routines. */
1778 YYSTYPE yyval;
1779
1780 #if YYERROR_VERBOSE
1781 /* Buffer for error messages, and its allocated size. */
1782 char yymsgbuf[128];
1783 char *yymsg = yymsgbuf;
1784 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1785 #endif
1786
1787 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1788
1789 /* The number of symbols on the RHS of the reduced rule.
1790 Keep to zero when no symbol should be popped. */
1791 int yylen = 0;
1792
1793 yyssp = yyss = yyssa;
1794 yyvsp = yyvs = yyvsa;
1795 yystacksize = YYINITDEPTH;
1796
1797 YYDPRINTF ((stderr, "Starting parse\n"));
1798
1799 yystate = 0;
1800 yyerrstatus = 0;
1801 yynerrs = 0;
1802 yychar = YYEMPTY; /* Cause a token to be read. */
1803 goto yysetstate;
1804
1805 /*------------------------------------------------------------.
1806 | yynewstate -- Push a new state, which is found in yystate. |
1807 `------------------------------------------------------------*/
1808 yynewstate:
1809 /* In all cases, when you get here, the value and location stacks
1810 have just been pushed. So pushing a state here evens the stacks. */
1811 yyssp++;
1812
1813 yysetstate:
1814 *yyssp = yystate;
1815
1816 if (yyss + yystacksize - 1 <= yyssp)
1817 {
1818 /* Get the current used size of the three stacks, in elements. */
1819 YYSIZE_T yysize = yyssp - yyss + 1;
1820
1821 #ifdef yyoverflow
1822 {
1823 /* Give user a chance to xreallocate the stack. Use copies of
1824 these so that the &'s don't force the real ones into
1825 memory. */
1826 YYSTYPE *yyvs1 = yyvs;
1827 yytype_int16 *yyss1 = yyss;
1828
1829 /* Each stack pointer address is followed by the size of the
1830 data in use in that stack, in bytes. This used to be a
1831 conditional around just the two extra args, but that might
1832 be undefined if yyoverflow is a macro. */
1833 yyoverflow (YY_("memory exhausted"),
1834 &yyss1, yysize * sizeof (*yyssp),
1835 &yyvs1, yysize * sizeof (*yyvsp),
1836 &yystacksize);
1837
1838 yyss = yyss1;
1839 yyvs = yyvs1;
1840 }
1841 #else /* no yyoverflow */
1842 # ifndef YYSTACK_RELOCATE
1843 goto yyexhaustedlab;
1844 # else
1845 /* Extend the stack our own way. */
1846 if (YYMAXDEPTH <= yystacksize)
1847 goto yyexhaustedlab;
1848 yystacksize *= 2;
1849 if (YYMAXDEPTH < yystacksize)
1850 yystacksize = YYMAXDEPTH;
1851
1852 {
1853 yytype_int16 *yyss1 = yyss;
1854 union yyalloc *yyptr =
1855 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1856 if (! yyptr)
1857 goto yyexhaustedlab;
1858 YYSTACK_RELOCATE (yyss_alloc, yyss);
1859 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1860 # undef YYSTACK_RELOCATE
1861 if (yyss1 != yyssa)
1862 YYSTACK_FREE (yyss1);
1863 }
1864 # endif
1865 #endif /* no yyoverflow */
1866
1867 yyssp = yyss + yysize - 1;
1868 yyvsp = yyvs + yysize - 1;
1869
1870 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1871 (unsigned long int) yystacksize));
1872
1873 if (yyss + yystacksize - 1 <= yyssp)
1874 YYABORT;
1875 }
1876
1877 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1878
1879 if (yystate == YYFINAL)
1880 YYACCEPT;
1881
1882 goto yybackup;
1883
1884 /*-----------.
1885 | yybackup. |
1886 `-----------*/
1887 yybackup:
1888
1889 /* Do appropriate processing given the current state. Read a
1890 lookahead token if we need one and don't already have one. */
1891
1892 /* First try to decide what to do without reference to lookahead token. */
1893 yyn = yypact[yystate];
1894 if (yypact_value_is_default (yyn))
1895 goto yydefault;
1896
1897 /* Not known => get a lookahead token if don't already have one. */
1898
1899 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1900 if (yychar == YYEMPTY)
1901 {
1902 YYDPRINTF ((stderr, "Reading a token: "));
1903 yychar = yylex ();
1904 }
1905
1906 if (yychar <= YYEOF)
1907 {
1908 yychar = yytoken = YYEOF;
1909 YYDPRINTF ((stderr, "Now at end of input.\n"));
1910 }
1911 else
1912 {
1913 yytoken = YYTRANSLATE (yychar);
1914 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1915 }
1916
1917 /* If the proper action on seeing token YYTOKEN is to reduce or to
1918 detect an error, take that action. */
1919 yyn += yytoken;
1920 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1921 goto yydefault;
1922 yyn = yytable[yyn];
1923 if (yyn <= 0)
1924 {
1925 if (yytable_value_is_error (yyn))
1926 goto yyerrlab;
1927 yyn = -yyn;
1928 goto yyreduce;
1929 }
1930
1931 /* Count tokens shifted since error; after three, turn off error
1932 status. */
1933 if (yyerrstatus)
1934 yyerrstatus--;
1935
1936 /* Shift the lookahead token. */
1937 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1938
1939 /* Discard the shifted token. */
1940 yychar = YYEMPTY;
1941
1942 yystate = yyn;
1943 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1944 *++yyvsp = yylval;
1945 YY_IGNORE_MAYBE_UNINITIALIZED_END
1946
1947 goto yynewstate;
1948
1949
1950 /*-----------------------------------------------------------.
1951 | yydefault -- do the default action for the current state. |
1952 `-----------------------------------------------------------*/
1953 yydefault:
1954 yyn = yydefact[yystate];
1955 if (yyn == 0)
1956 goto yyerrlab;
1957 goto yyreduce;
1958
1959
1960 /*-----------------------------.
1961 | yyreduce -- Do a reduction. |
1962 `-----------------------------*/
1963 yyreduce:
1964 /* yyn is the number of a rule to reduce with. */
1965 yylen = yyr2[yyn];
1966
1967 /* If YYLEN is nonzero, implement the default value of the action:
1968 '$$ = $1'.
1969
1970 Otherwise, the following line sets YYVAL to garbage.
1971 This behavior is undocumented and Bison
1972 users should not rely upon it. Assigning to YYVAL
1973 unconditionally makes the parser a bit smaller, and it avoids a
1974 GCC warning that YYVAL may be used uninitialized. */
1975 yyval = yyvsp[1-yylen];
1976
1977
1978 YY_REDUCE_PRINT (yyn);
1979 switch (yyn)
1980 {
1981 case 4:
1982 #line 232 "c-exp.y" /* yacc.c:1646 */
1983 { write_exp_elt_opcode(pstate, OP_TYPE);
1984 write_exp_elt_type(pstate, (yyvsp[0].tval));
1985 write_exp_elt_opcode(pstate, OP_TYPE);}
1986 #line 1988 "c-exp.c" /* yacc.c:1646 */
1987 break;
1988
1989 case 5:
1990 #line 236 "c-exp.y" /* yacc.c:1646 */
1991 {
1992 write_exp_elt_opcode (pstate, OP_TYPEOF);
1993 }
1994 #line 1996 "c-exp.c" /* yacc.c:1646 */
1995 break;
1996
1997 case 6:
1998 #line 240 "c-exp.y" /* yacc.c:1646 */
1999 {
2000 write_exp_elt_opcode (pstate, OP_TYPE);
2001 write_exp_elt_type (pstate, (yyvsp[-1].tval));
2002 write_exp_elt_opcode (pstate, OP_TYPE);
2003 }
2004 #line 2006 "c-exp.c" /* yacc.c:1646 */
2005 break;
2006
2007 case 7:
2008 #line 246 "c-exp.y" /* yacc.c:1646 */
2009 {
2010 write_exp_elt_opcode (pstate, OP_DECLTYPE);
2011 }
2012 #line 2014 "c-exp.c" /* yacc.c:1646 */
2013 break;
2014
2015 case 9:
2016 #line 254 "c-exp.y" /* yacc.c:1646 */
2017 { write_exp_elt_opcode (pstate, BINOP_COMMA); }
2018 #line 2020 "c-exp.c" /* yacc.c:1646 */
2019 break;
2020
2021 case 10:
2022 #line 259 "c-exp.y" /* yacc.c:1646 */
2023 { write_exp_elt_opcode (pstate, UNOP_IND); }
2024 #line 2026 "c-exp.c" /* yacc.c:1646 */
2025 break;
2026
2027 case 11:
2028 #line 263 "c-exp.y" /* yacc.c:1646 */
2029 { write_exp_elt_opcode (pstate, UNOP_ADDR); }
2030 #line 2032 "c-exp.c" /* yacc.c:1646 */
2031 break;
2032
2033 case 12:
2034 #line 267 "c-exp.y" /* yacc.c:1646 */
2035 { write_exp_elt_opcode (pstate, UNOP_NEG); }
2036 #line 2038 "c-exp.c" /* yacc.c:1646 */
2037 break;
2038
2039 case 13:
2040 #line 271 "c-exp.y" /* yacc.c:1646 */
2041 { write_exp_elt_opcode (pstate, UNOP_PLUS); }
2042 #line 2044 "c-exp.c" /* yacc.c:1646 */
2043 break;
2044
2045 case 14:
2046 #line 275 "c-exp.y" /* yacc.c:1646 */
2047 { write_exp_elt_opcode (pstate, UNOP_LOGICAL_NOT); }
2048 #line 2050 "c-exp.c" /* yacc.c:1646 */
2049 break;
2050
2051 case 15:
2052 #line 279 "c-exp.y" /* yacc.c:1646 */
2053 { write_exp_elt_opcode (pstate, UNOP_COMPLEMENT); }
2054 #line 2056 "c-exp.c" /* yacc.c:1646 */
2055 break;
2056
2057 case 16:
2058 #line 283 "c-exp.y" /* yacc.c:1646 */
2059 { write_exp_elt_opcode (pstate, UNOP_PREINCREMENT); }
2060 #line 2062 "c-exp.c" /* yacc.c:1646 */
2061 break;
2062
2063 case 17:
2064 #line 287 "c-exp.y" /* yacc.c:1646 */
2065 { write_exp_elt_opcode (pstate, UNOP_PREDECREMENT); }
2066 #line 2068 "c-exp.c" /* yacc.c:1646 */
2067 break;
2068
2069 case 18:
2070 #line 291 "c-exp.y" /* yacc.c:1646 */
2071 { write_exp_elt_opcode (pstate, UNOP_POSTINCREMENT); }
2072 #line 2074 "c-exp.c" /* yacc.c:1646 */
2073 break;
2074
2075 case 19:
2076 #line 295 "c-exp.y" /* yacc.c:1646 */
2077 { write_exp_elt_opcode (pstate, UNOP_POSTDECREMENT); }
2078 #line 2080 "c-exp.c" /* yacc.c:1646 */
2079 break;
2080
2081 case 20:
2082 #line 299 "c-exp.y" /* yacc.c:1646 */
2083 { write_exp_elt_opcode (pstate, OP_TYPEID); }
2084 #line 2086 "c-exp.c" /* yacc.c:1646 */
2085 break;
2086
2087 case 21:
2088 #line 303 "c-exp.y" /* yacc.c:1646 */
2089 { write_exp_elt_opcode (pstate, OP_TYPEID); }
2090 #line 2092 "c-exp.c" /* yacc.c:1646 */
2091 break;
2092
2093 case 22:
2094 #line 307 "c-exp.y" /* yacc.c:1646 */
2095 { write_exp_elt_opcode (pstate, UNOP_SIZEOF); }
2096 #line 2098 "c-exp.c" /* yacc.c:1646 */
2097 break;
2098
2099 case 23:
2100 #line 311 "c-exp.y" /* yacc.c:1646 */
2101 { write_exp_elt_opcode (pstate, STRUCTOP_PTR);
2102 write_exp_string (pstate, (yyvsp[0].sval));
2103 write_exp_elt_opcode (pstate, STRUCTOP_PTR); }
2104 #line 2106 "c-exp.c" /* yacc.c:1646 */
2105 break;
2106
2107 case 24:
2108 #line 317 "c-exp.y" /* yacc.c:1646 */
2109 { mark_struct_expression (pstate);
2110 write_exp_elt_opcode (pstate, STRUCTOP_PTR);
2111 write_exp_string (pstate, (yyvsp[-1].sval));
2112 write_exp_elt_opcode (pstate, STRUCTOP_PTR); }
2113 #line 2115 "c-exp.c" /* yacc.c:1646 */
2114 break;
2115
2116 case 25:
2117 #line 324 "c-exp.y" /* yacc.c:1646 */
2118 { struct stoken s;
2119 mark_struct_expression (pstate);
2120 write_exp_elt_opcode (pstate, STRUCTOP_PTR);
2121 s.ptr = "";
2122 s.length = 0;
2123 write_exp_string (pstate, s);
2124 write_exp_elt_opcode (pstate, STRUCTOP_PTR); }
2125 #line 2127 "c-exp.c" /* yacc.c:1646 */
2126 break;
2127
2128 case 26:
2129 #line 334 "c-exp.y" /* yacc.c:1646 */
2130 { write_exp_elt_opcode (pstate, STRUCTOP_PTR);
2131 write_destructor_name (pstate, (yyvsp[0].sval));
2132 write_exp_elt_opcode (pstate, STRUCTOP_PTR); }
2133 #line 2135 "c-exp.c" /* yacc.c:1646 */
2134 break;
2135
2136 case 27:
2137 #line 340 "c-exp.y" /* yacc.c:1646 */
2138 { mark_struct_expression (pstate);
2139 write_exp_elt_opcode (pstate, STRUCTOP_PTR);
2140 write_destructor_name (pstate, (yyvsp[-1].sval));
2141 write_exp_elt_opcode (pstate, STRUCTOP_PTR); }
2142 #line 2144 "c-exp.c" /* yacc.c:1646 */
2143 break;
2144
2145 case 28:
2146 #line 347 "c-exp.y" /* yacc.c:1646 */
2147 { /* exp->type::name becomes exp->*(&type::name) */
2148 /* Note: this doesn't work if name is a
2149 static member! FIXME */
2150 write_exp_elt_opcode (pstate, UNOP_ADDR);
2151 write_exp_elt_opcode (pstate, STRUCTOP_MPTR); }
2152 #line 2154 "c-exp.c" /* yacc.c:1646 */
2153 break;
2154
2155 case 29:
2156 #line 355 "c-exp.y" /* yacc.c:1646 */
2157 { write_exp_elt_opcode (pstate, STRUCTOP_MPTR); }
2158 #line 2160 "c-exp.c" /* yacc.c:1646 */
2159 break;
2160
2161 case 30:
2162 #line 359 "c-exp.y" /* yacc.c:1646 */
2163 { write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
2164 write_exp_string (pstate, (yyvsp[0].sval));
2165 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
2166 #line 2168 "c-exp.c" /* yacc.c:1646 */
2167 break;
2168
2169 case 31:
2170 #line 365 "c-exp.y" /* yacc.c:1646 */
2171 { mark_struct_expression (pstate);
2172 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
2173 write_exp_string (pstate, (yyvsp[-1].sval));
2174 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
2175 #line 2177 "c-exp.c" /* yacc.c:1646 */
2176 break;
2177
2178 case 32:
2179 #line 372 "c-exp.y" /* yacc.c:1646 */
2180 { struct stoken s;
2181 mark_struct_expression (pstate);
2182 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
2183 s.ptr = "";
2184 s.length = 0;
2185 write_exp_string (pstate, s);
2186 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
2187 #line 2189 "c-exp.c" /* yacc.c:1646 */
2188 break;
2189
2190 case 33:
2191 #line 382 "c-exp.y" /* yacc.c:1646 */
2192 { write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
2193 write_destructor_name (pstate, (yyvsp[0].sval));
2194 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
2195 #line 2197 "c-exp.c" /* yacc.c:1646 */
2196 break;
2197
2198 case 34:
2199 #line 388 "c-exp.y" /* yacc.c:1646 */
2200 { mark_struct_expression (pstate);
2201 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
2202 write_destructor_name (pstate, (yyvsp[-1].sval));
2203 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
2204 #line 2206 "c-exp.c" /* yacc.c:1646 */
2205 break;
2206
2207 case 35:
2208 #line 395 "c-exp.y" /* yacc.c:1646 */
2209 { /* exp.type::name becomes exp.*(&type::name) */
2210 /* Note: this doesn't work if name is a
2211 static member! FIXME */
2212 write_exp_elt_opcode (pstate, UNOP_ADDR);
2213 write_exp_elt_opcode (pstate, STRUCTOP_MEMBER); }
2214 #line 2216 "c-exp.c" /* yacc.c:1646 */
2215 break;
2216
2217 case 36:
2218 #line 403 "c-exp.y" /* yacc.c:1646 */
2219 { write_exp_elt_opcode (pstate, STRUCTOP_MEMBER); }
2220 #line 2222 "c-exp.c" /* yacc.c:1646 */
2221 break;
2222
2223 case 37:
2224 #line 407 "c-exp.y" /* yacc.c:1646 */
2225 { write_exp_elt_opcode (pstate, BINOP_SUBSCRIPT); }
2226 #line 2228 "c-exp.c" /* yacc.c:1646 */
2227 break;
2228
2229 case 38:
2230 #line 411 "c-exp.y" /* yacc.c:1646 */
2231 { write_exp_elt_opcode (pstate, BINOP_SUBSCRIPT); }
2232 #line 2234 "c-exp.c" /* yacc.c:1646 */
2233 break;
2234
2235 case 39:
2236 #line 420 "c-exp.y" /* yacc.c:1646 */
2237 {
2238 CORE_ADDR theclass;
2239
2240 theclass = lookup_objc_class (parse_gdbarch (pstate),
2241 copy_name ((yyvsp[0].tsym).stoken));
2242 if (theclass == 0)
2243 error (_("%s is not an ObjC Class"),
2244 copy_name ((yyvsp[0].tsym).stoken));
2245 write_exp_elt_opcode (pstate, OP_LONG);
2246 write_exp_elt_type (pstate,
2247 parse_type (pstate)->builtin_int);
2248 write_exp_elt_longcst (pstate, (LONGEST) theclass);
2249 write_exp_elt_opcode (pstate, OP_LONG);
2250 start_msglist();
2251 }
2252 #line 2254 "c-exp.c" /* yacc.c:1646 */
2253 break;
2254
2255 case 40:
2256 #line 436 "c-exp.y" /* yacc.c:1646 */
2257 { write_exp_elt_opcode (pstate, OP_OBJC_MSGCALL);
2258 end_msglist (pstate);
2259 write_exp_elt_opcode (pstate, OP_OBJC_MSGCALL);
2260 }
2261 #line 2263 "c-exp.c" /* yacc.c:1646 */
2262 break;
2263
2264 case 41:
2265 #line 443 "c-exp.y" /* yacc.c:1646 */
2266 {
2267 write_exp_elt_opcode (pstate, OP_LONG);
2268 write_exp_elt_type (pstate,
2269 parse_type (pstate)->builtin_int);
2270 write_exp_elt_longcst (pstate, (LONGEST) (yyvsp[0].theclass).theclass);
2271 write_exp_elt_opcode (pstate, OP_LONG);
2272 start_msglist();
2273 }
2274 #line 2276 "c-exp.c" /* yacc.c:1646 */
2275 break;
2276
2277 case 42:
2278 #line 452 "c-exp.y" /* yacc.c:1646 */
2279 { write_exp_elt_opcode (pstate, OP_OBJC_MSGCALL);
2280 end_msglist (pstate);
2281 write_exp_elt_opcode (pstate, OP_OBJC_MSGCALL);
2282 }
2283 #line 2285 "c-exp.c" /* yacc.c:1646 */
2284 break;
2285
2286 case 43:
2287 #line 459 "c-exp.y" /* yacc.c:1646 */
2288 { start_msglist(); }
2289 #line 2291 "c-exp.c" /* yacc.c:1646 */
2290 break;
2291
2292 case 44:
2293 #line 461 "c-exp.y" /* yacc.c:1646 */
2294 { write_exp_elt_opcode (pstate, OP_OBJC_MSGCALL);
2295 end_msglist (pstate);
2296 write_exp_elt_opcode (pstate, OP_OBJC_MSGCALL);
2297 }
2298 #line 2300 "c-exp.c" /* yacc.c:1646 */
2299 break;
2300
2301 case 45:
2302 #line 468 "c-exp.y" /* yacc.c:1646 */
2303 { add_msglist(&(yyvsp[0].sval), 0); }
2304 #line 2306 "c-exp.c" /* yacc.c:1646 */
2305 break;
2306
2307 case 49:
2308 #line 477 "c-exp.y" /* yacc.c:1646 */
2309 { add_msglist(&(yyvsp[-2].sval), 1); }
2310 #line 2312 "c-exp.c" /* yacc.c:1646 */
2311 break;
2312
2313 case 50:
2314 #line 479 "c-exp.y" /* yacc.c:1646 */
2315 { add_msglist(0, 1); }
2316 #line 2318 "c-exp.c" /* yacc.c:1646 */
2317 break;
2318
2319 case 51:
2320 #line 481 "c-exp.y" /* yacc.c:1646 */
2321 { add_msglist(0, 0); }
2322 #line 2324 "c-exp.c" /* yacc.c:1646 */
2323 break;
2324
2325 case 52:
2326 #line 487 "c-exp.y" /* yacc.c:1646 */
2327 { start_arglist (); }
2328 #line 2330 "c-exp.c" /* yacc.c:1646 */
2329 break;
2330
2331 case 53:
2332 #line 489 "c-exp.y" /* yacc.c:1646 */
2333 { write_exp_elt_opcode (pstate, OP_FUNCALL);
2334 write_exp_elt_longcst (pstate,
2335 (LONGEST) end_arglist ());
2336 write_exp_elt_opcode (pstate, OP_FUNCALL); }
2337 #line 2339 "c-exp.c" /* yacc.c:1646 */
2338 break;
2339
2340 case 54:
2341 #line 499 "c-exp.y" /* yacc.c:1646 */
2342 { start_arglist ();
2343 write_exp_elt_opcode (pstate, OP_FUNCALL);
2344 write_exp_elt_longcst (pstate,
2345 (LONGEST) end_arglist ());
2346 write_exp_elt_opcode (pstate, OP_FUNCALL); }
2347 #line 2349 "c-exp.c" /* yacc.c:1646 */
2348 break;
2349
2350 case 55:
2351 #line 508 "c-exp.y" /* yacc.c:1646 */
2352 {
2353 /* This could potentially be a an argument defined
2354 lookup function (Koenig). */
2355 write_exp_elt_opcode (pstate, OP_ADL_FUNC);
2356 write_exp_elt_block (pstate,
2357 expression_context_block);
2358 write_exp_elt_sym (pstate,
2359 NULL); /* Placeholder. */
2360 write_exp_string (pstate, (yyvsp[-1].ssym).stoken);
2361 write_exp_elt_opcode (pstate, OP_ADL_FUNC);
2362
2363 /* This is to save the value of arglist_len
2364 being accumulated by an outer function call. */
2365
2366 start_arglist ();
2367 }
2368 #line 2370 "c-exp.c" /* yacc.c:1646 */
2369 break;
2370
2371 case 56:
2372 #line 525 "c-exp.y" /* yacc.c:1646 */
2373 {
2374 write_exp_elt_opcode (pstate, OP_FUNCALL);
2375 write_exp_elt_longcst (pstate,
2376 (LONGEST) end_arglist ());
2377 write_exp_elt_opcode (pstate, OP_FUNCALL);
2378 }
2379 #line 2381 "c-exp.c" /* yacc.c:1646 */
2380 break;
2381
2382 case 57:
2383 #line 534 "c-exp.y" /* yacc.c:1646 */
2384 { start_arglist (); }
2385 #line 2387 "c-exp.c" /* yacc.c:1646 */
2386 break;
2387
2388 case 59:
2389 #line 541 "c-exp.y" /* yacc.c:1646 */
2390 { arglist_len = 1; }
2391 #line 2393 "c-exp.c" /* yacc.c:1646 */
2392 break;
2393
2394 case 60:
2395 #line 545 "c-exp.y" /* yacc.c:1646 */
2396 { arglist_len++; }
2397 #line 2399 "c-exp.c" /* yacc.c:1646 */
2398 break;
2399
2400 case 61:
2401 #line 549 "c-exp.y" /* yacc.c:1646 */
2402 { int i;
2403 VEC (type_ptr) *type_list = (yyvsp[-2].tvec);
2404 struct type *type_elt;
2405 LONGEST len = VEC_length (type_ptr, type_list);
2406
2407 write_exp_elt_opcode (pstate, TYPE_INSTANCE);
2408 /* Save the const/volatile qualifiers as
2409 recorded by the const_or_volatile
2410 production's actions. */
2411 write_exp_elt_longcst (pstate,
2412 follow_type_instance_flags ());
2413 write_exp_elt_longcst (pstate, len);
2414 for (i = 0;
2415 VEC_iterate (type_ptr, type_list, i, type_elt);
2416 ++i)
2417 write_exp_elt_type (pstate, type_elt);
2418 write_exp_elt_longcst(pstate, len);
2419 write_exp_elt_opcode (pstate, TYPE_INSTANCE);
2420 VEC_free (type_ptr, type_list);
2421 }
2422 #line 2424 "c-exp.c" /* yacc.c:1646 */
2423 break;
2424
2425 case 62:
2426 #line 572 "c-exp.y" /* yacc.c:1646 */
2427 { write_exp_elt_opcode (pstate, TYPE_INSTANCE);
2428 /* See above. */
2429 write_exp_elt_longcst (pstate,
2430 follow_type_instance_flags ());
2431 write_exp_elt_longcst (pstate, 0);
2432 write_exp_elt_longcst (pstate, 0);
2433 write_exp_elt_opcode (pstate, TYPE_INSTANCE);
2434 }
2435 #line 2437 "c-exp.c" /* yacc.c:1646 */
2436 break;
2437
2438 case 66:
2439 #line 594 "c-exp.y" /* yacc.c:1646 */
2440 {
2441 write_exp_elt_opcode (pstate, OP_FUNC_STATIC_VAR);
2442 write_exp_string (pstate, (yyvsp[0].sval));
2443 write_exp_elt_opcode (pstate, OP_FUNC_STATIC_VAR);
2444 }
2445 #line 2447 "c-exp.c" /* yacc.c:1646 */
2446 break;
2447
2448 case 67:
2449 #line 602 "c-exp.y" /* yacc.c:1646 */
2450 { (yyval.lval) = end_arglist () - 1; }
2451 #line 2453 "c-exp.c" /* yacc.c:1646 */
2452 break;
2453
2454 case 68:
2455 #line 605 "c-exp.y" /* yacc.c:1646 */
2456 { write_exp_elt_opcode (pstate, OP_ARRAY);
2457 write_exp_elt_longcst (pstate, (LONGEST) 0);
2458 write_exp_elt_longcst (pstate, (LONGEST) (yyvsp[0].lval));
2459 write_exp_elt_opcode (pstate, OP_ARRAY); }
2460 #line 2462 "c-exp.c" /* yacc.c:1646 */
2461 break;
2462
2463 case 69:
2464 #line 612 "c-exp.y" /* yacc.c:1646 */
2465 { write_exp_elt_opcode (pstate, UNOP_MEMVAL_TYPE); }
2466 #line 2468 "c-exp.c" /* yacc.c:1646 */
2467 break;
2468
2469 case 70:
2470 #line 616 "c-exp.y" /* yacc.c:1646 */
2471 { write_exp_elt_opcode (pstate, UNOP_CAST_TYPE); }
2472 #line 2474 "c-exp.c" /* yacc.c:1646 */
2473 break;
2474
2475 case 71:
2476 #line 620 "c-exp.y" /* yacc.c:1646 */
2477 { }
2478 #line 2480 "c-exp.c" /* yacc.c:1646 */
2479 break;
2480
2481 case 72:
2482 #line 626 "c-exp.y" /* yacc.c:1646 */
2483 { write_exp_elt_opcode (pstate, BINOP_REPEAT); }
2484 #line 2486 "c-exp.c" /* yacc.c:1646 */
2485 break;
2486
2487 case 73:
2488 #line 630 "c-exp.y" /* yacc.c:1646 */
2489 { write_exp_elt_opcode (pstate, BINOP_MUL); }
2490 #line 2492 "c-exp.c" /* yacc.c:1646 */
2491 break;
2492
2493 case 74:
2494 #line 634 "c-exp.y" /* yacc.c:1646 */
2495 { write_exp_elt_opcode (pstate, BINOP_DIV); }
2496 #line 2498 "c-exp.c" /* yacc.c:1646 */
2497 break;
2498
2499 case 75:
2500 #line 638 "c-exp.y" /* yacc.c:1646 */
2501 { write_exp_elt_opcode (pstate, BINOP_REM); }
2502 #line 2504 "c-exp.c" /* yacc.c:1646 */
2503 break;
2504
2505 case 76:
2506 #line 642 "c-exp.y" /* yacc.c:1646 */
2507 { write_exp_elt_opcode (pstate, BINOP_ADD); }
2508 #line 2510 "c-exp.c" /* yacc.c:1646 */
2509 break;
2510
2511 case 77:
2512 #line 646 "c-exp.y" /* yacc.c:1646 */
2513 { write_exp_elt_opcode (pstate, BINOP_SUB); }
2514 #line 2516 "c-exp.c" /* yacc.c:1646 */
2515 break;
2516
2517 case 78:
2518 #line 650 "c-exp.y" /* yacc.c:1646 */
2519 { write_exp_elt_opcode (pstate, BINOP_LSH); }
2520 #line 2522 "c-exp.c" /* yacc.c:1646 */
2521 break;
2522
2523 case 79:
2524 #line 654 "c-exp.y" /* yacc.c:1646 */
2525 { write_exp_elt_opcode (pstate, BINOP_RSH); }
2526 #line 2528 "c-exp.c" /* yacc.c:1646 */
2527 break;
2528
2529 case 80:
2530 #line 658 "c-exp.y" /* yacc.c:1646 */
2531 { write_exp_elt_opcode (pstate, BINOP_EQUAL); }
2532 #line 2534 "c-exp.c" /* yacc.c:1646 */
2533 break;
2534
2535 case 81:
2536 #line 662 "c-exp.y" /* yacc.c:1646 */
2537 { write_exp_elt_opcode (pstate, BINOP_NOTEQUAL); }
2538 #line 2540 "c-exp.c" /* yacc.c:1646 */
2539 break;
2540
2541 case 82:
2542 #line 666 "c-exp.y" /* yacc.c:1646 */
2543 { write_exp_elt_opcode (pstate, BINOP_LEQ); }
2544 #line 2546 "c-exp.c" /* yacc.c:1646 */
2545 break;
2546
2547 case 83:
2548 #line 670 "c-exp.y" /* yacc.c:1646 */
2549 { write_exp_elt_opcode (pstate, BINOP_GEQ); }
2550 #line 2552 "c-exp.c" /* yacc.c:1646 */
2551 break;
2552
2553 case 84:
2554 #line 674 "c-exp.y" /* yacc.c:1646 */
2555 { write_exp_elt_opcode (pstate, BINOP_LESS); }
2556 #line 2558 "c-exp.c" /* yacc.c:1646 */
2557 break;
2558
2559 case 85:
2560 #line 678 "c-exp.y" /* yacc.c:1646 */
2561 { write_exp_elt_opcode (pstate, BINOP_GTR); }
2562 #line 2564 "c-exp.c" /* yacc.c:1646 */
2563 break;
2564
2565 case 86:
2566 #line 682 "c-exp.y" /* yacc.c:1646 */
2567 { write_exp_elt_opcode (pstate, BINOP_BITWISE_AND); }
2568 #line 2570 "c-exp.c" /* yacc.c:1646 */
2569 break;
2570
2571 case 87:
2572 #line 686 "c-exp.y" /* yacc.c:1646 */
2573 { write_exp_elt_opcode (pstate, BINOP_BITWISE_XOR); }
2574 #line 2576 "c-exp.c" /* yacc.c:1646 */
2575 break;
2576
2577 case 88:
2578 #line 690 "c-exp.y" /* yacc.c:1646 */
2579 { write_exp_elt_opcode (pstate, BINOP_BITWISE_IOR); }
2580 #line 2582 "c-exp.c" /* yacc.c:1646 */
2581 break;
2582
2583 case 89:
2584 #line 694 "c-exp.y" /* yacc.c:1646 */
2585 { write_exp_elt_opcode (pstate, BINOP_LOGICAL_AND); }
2586 #line 2588 "c-exp.c" /* yacc.c:1646 */
2587 break;
2588
2589 case 90:
2590 #line 698 "c-exp.y" /* yacc.c:1646 */
2591 { write_exp_elt_opcode (pstate, BINOP_LOGICAL_OR); }
2592 #line 2594 "c-exp.c" /* yacc.c:1646 */
2593 break;
2594
2595 case 91:
2596 #line 702 "c-exp.y" /* yacc.c:1646 */
2597 { write_exp_elt_opcode (pstate, TERNOP_COND); }
2598 #line 2600 "c-exp.c" /* yacc.c:1646 */
2599 break;
2600
2601 case 92:
2602 #line 706 "c-exp.y" /* yacc.c:1646 */
2603 { write_exp_elt_opcode (pstate, BINOP_ASSIGN); }
2604 #line 2606 "c-exp.c" /* yacc.c:1646 */
2605 break;
2606
2607 case 93:
2608 #line 710 "c-exp.y" /* yacc.c:1646 */
2609 { write_exp_elt_opcode (pstate, BINOP_ASSIGN_MODIFY);
2610 write_exp_elt_opcode (pstate, (yyvsp[-1].opcode));
2611 write_exp_elt_opcode (pstate,
2612 BINOP_ASSIGN_MODIFY); }
2613 #line 2615 "c-exp.c" /* yacc.c:1646 */
2614 break;
2615
2616 case 94:
2617 #line 717 "c-exp.y" /* yacc.c:1646 */
2618 { write_exp_elt_opcode (pstate, OP_LONG);
2619 write_exp_elt_type (pstate, (yyvsp[0].typed_val_int).type);
2620 write_exp_elt_longcst (pstate, (LONGEST) ((yyvsp[0].typed_val_int).val));
2621 write_exp_elt_opcode (pstate, OP_LONG); }
2622 #line 2624 "c-exp.c" /* yacc.c:1646 */
2623 break;
2624
2625 case 95:
2626 #line 724 "c-exp.y" /* yacc.c:1646 */
2627 {
2628 struct stoken_vector vec;
2629 vec.len = 1;
2630 vec.tokens = &(yyvsp[0].tsval);
2631 write_exp_string_vector (pstate, (yyvsp[0].tsval).type, &vec);
2632 }
2633 #line 2635 "c-exp.c" /* yacc.c:1646 */
2634 break;
2635
2636 case 96:
2637 #line 733 "c-exp.y" /* yacc.c:1646 */
2638 { YYSTYPE val;
2639 parse_number (pstate, (yyvsp[0].ssym).stoken.ptr,
2640 (yyvsp[0].ssym).stoken.length, 0, &val);
2641 write_exp_elt_opcode (pstate, OP_LONG);
2642 write_exp_elt_type (pstate, val.typed_val_int.type);
2643 write_exp_elt_longcst (pstate,
2644 (LONGEST) val.typed_val_int.val);
2645 write_exp_elt_opcode (pstate, OP_LONG);
2646 }
2647 #line 2649 "c-exp.c" /* yacc.c:1646 */
2648 break;
2649
2650 case 97:
2651 #line 746 "c-exp.y" /* yacc.c:1646 */
2652 { write_exp_elt_opcode (pstate, OP_FLOAT);
2653 write_exp_elt_type (pstate, (yyvsp[0].typed_val_float).type);
2654 write_exp_elt_floatcst (pstate, (yyvsp[0].typed_val_float).val);
2655 write_exp_elt_opcode (pstate, OP_FLOAT); }
2656 #line 2658 "c-exp.c" /* yacc.c:1646 */
2657 break;
2658
2659 case 99:
2660 #line 756 "c-exp.y" /* yacc.c:1646 */
2661 {
2662 write_dollar_variable (pstate, (yyvsp[0].sval));
2663 }
2664 #line 2666 "c-exp.c" /* yacc.c:1646 */
2665 break;
2666
2667 case 100:
2668 #line 762 "c-exp.y" /* yacc.c:1646 */
2669 {
2670 write_exp_elt_opcode (pstate, OP_OBJC_SELECTOR);
2671 write_exp_string (pstate, (yyvsp[-1].sval));
2672 write_exp_elt_opcode (pstate, OP_OBJC_SELECTOR); }
2673 #line 2675 "c-exp.c" /* yacc.c:1646 */
2674 break;
2675
2676 case 101:
2677 #line 769 "c-exp.y" /* yacc.c:1646 */
2678 { struct type *type = (yyvsp[-1].tval);
2679 write_exp_elt_opcode (pstate, OP_LONG);
2680 write_exp_elt_type (pstate, lookup_signed_typename
2681 (parse_language (pstate),
2682 parse_gdbarch (pstate),
2683 "int"));
2684 type = check_typedef (type);
2685
2686 /* $5.3.3/2 of the C++ Standard (n3290 draft)
2687 says of sizeof: "When applied to a reference
2688 or a reference type, the result is the size of
2689 the referenced type." */
2690 if (TYPE_IS_REFERENCE (type))
2691 type = check_typedef (TYPE_TARGET_TYPE (type));
2692 write_exp_elt_longcst (pstate,
2693 (LONGEST) TYPE_LENGTH (type));
2694 write_exp_elt_opcode (pstate, OP_LONG); }
2695 #line 2697 "c-exp.c" /* yacc.c:1646 */
2696 break;
2697
2698 case 102:
2699 #line 789 "c-exp.y" /* yacc.c:1646 */
2700 { write_exp_elt_opcode (pstate,
2701 UNOP_REINTERPRET_CAST); }
2702 #line 2704 "c-exp.c" /* yacc.c:1646 */
2703 break;
2704
2705 case 103:
2706 #line 794 "c-exp.y" /* yacc.c:1646 */
2707 { write_exp_elt_opcode (pstate, UNOP_CAST_TYPE); }
2708 #line 2710 "c-exp.c" /* yacc.c:1646 */
2709 break;
2710
2711 case 104:
2712 #line 798 "c-exp.y" /* yacc.c:1646 */
2713 { write_exp_elt_opcode (pstate, UNOP_DYNAMIC_CAST); }
2714 #line 2716 "c-exp.c" /* yacc.c:1646 */
2715 break;
2716
2717 case 105:
2718 #line 802 "c-exp.y" /* yacc.c:1646 */
2719 { /* We could do more error checking here, but
2720 it doesn't seem worthwhile. */
2721 write_exp_elt_opcode (pstate, UNOP_CAST_TYPE); }
2722 #line 2724 "c-exp.c" /* yacc.c:1646 */
2723 break;
2724
2725 case 106:
2726 #line 809 "c-exp.y" /* yacc.c:1646 */
2727 {
2728 /* We copy the string here, and not in the
2729 lexer, to guarantee that we do not leak a
2730 string. Note that we follow the
2731 NUL-termination convention of the
2732 lexer. */
2733 struct typed_stoken *vec = XNEW (struct typed_stoken);
2734 (yyval.svec).len = 1;
2735 (yyval.svec).tokens = vec;
2736
2737 vec->type = (yyvsp[0].tsval).type;
2738 vec->length = (yyvsp[0].tsval).length;
2739 vec->ptr = (char *) xmalloc ((yyvsp[0].tsval).length + 1);
2740 memcpy (vec->ptr, (yyvsp[0].tsval).ptr, (yyvsp[0].tsval).length + 1);
2741 }
2742 #line 2744 "c-exp.c" /* yacc.c:1646 */
2743 break;
2744
2745 case 107:
2746 #line 826 "c-exp.y" /* yacc.c:1646 */
2747 {
2748 /* Note that we NUL-terminate here, but just
2749 for convenience. */
2750 char *p;
2751 ++(yyval.svec).len;
2752 (yyval.svec).tokens = XRESIZEVEC (struct typed_stoken,
2753 (yyval.svec).tokens, (yyval.svec).len);
2754
2755 p = (char *) xmalloc ((yyvsp[0].tsval).length + 1);
2756 memcpy (p, (yyvsp[0].tsval).ptr, (yyvsp[0].tsval).length + 1);
2757
2758 (yyval.svec).tokens[(yyval.svec).len - 1].type = (yyvsp[0].tsval).type;
2759 (yyval.svec).tokens[(yyval.svec).len - 1].length = (yyvsp[0].tsval).length;
2760 (yyval.svec).tokens[(yyval.svec).len - 1].ptr = p;
2761 }
2762 #line 2764 "c-exp.c" /* yacc.c:1646 */
2763 break;
2764
2765 case 108:
2766 #line 844 "c-exp.y" /* yacc.c:1646 */
2767 {
2768 int i;
2769 c_string_type type = C_STRING;
2770
2771 for (i = 0; i < (yyvsp[0].svec).len; ++i)
2772 {
2773 switch ((yyvsp[0].svec).tokens[i].type)
2774 {
2775 case C_STRING:
2776 break;
2777 case C_WIDE_STRING:
2778 case C_STRING_16:
2779 case C_STRING_32:
2780 if (type != C_STRING
2781 && type != (yyvsp[0].svec).tokens[i].type)
2782 error (_("Undefined string concatenation."));
2783 type = (enum c_string_type_values) (yyvsp[0].svec).tokens[i].type;
2784 break;
2785 default:
2786 /* internal error */
2787 internal_error (__FILE__, __LINE__,
2788 "unrecognized type in string concatenation");
2789 }
2790 }
2791
2792 write_exp_string_vector (pstate, type, &(yyvsp[0].svec));
2793 for (i = 0; i < (yyvsp[0].svec).len; ++i)
2794 xfree ((yyvsp[0].svec).tokens[i].ptr);
2795 xfree ((yyvsp[0].svec).tokens);
2796 }
2797 #line 2799 "c-exp.c" /* yacc.c:1646 */
2798 break;
2799
2800 case 109:
2801 #line 879 "c-exp.y" /* yacc.c:1646 */
2802 { write_exp_elt_opcode (pstate, OP_OBJC_NSSTRING);
2803 write_exp_string (pstate, (yyvsp[0].sval));
2804 write_exp_elt_opcode (pstate, OP_OBJC_NSSTRING); }
2805 #line 2807 "c-exp.c" /* yacc.c:1646 */
2806 break;
2807
2808 case 110:
2809 #line 886 "c-exp.y" /* yacc.c:1646 */
2810 { write_exp_elt_opcode (pstate, OP_LONG);
2811 write_exp_elt_type (pstate,
2812 parse_type (pstate)->builtin_bool);
2813 write_exp_elt_longcst (pstate, (LONGEST) 1);
2814 write_exp_elt_opcode (pstate, OP_LONG); }
2815 #line 2817 "c-exp.c" /* yacc.c:1646 */
2816 break;
2817
2818 case 111:
2819 #line 894 "c-exp.y" /* yacc.c:1646 */
2820 { write_exp_elt_opcode (pstate, OP_LONG);
2821 write_exp_elt_type (pstate,
2822 parse_type (pstate)->builtin_bool);
2823 write_exp_elt_longcst (pstate, (LONGEST) 0);
2824 write_exp_elt_opcode (pstate, OP_LONG); }
2825 #line 2827 "c-exp.c" /* yacc.c:1646 */
2826 break;
2827
2828 case 112:
2829 #line 904 "c-exp.y" /* yacc.c:1646 */
2830 {
2831 if ((yyvsp[0].ssym).sym.symbol)
2832 (yyval.bval) = SYMBOL_BLOCK_VALUE ((yyvsp[0].ssym).sym.symbol);
2833 else
2834 error (_("No file or function \"%s\"."),
2835 copy_name ((yyvsp[0].ssym).stoken));
2836 }
2837 #line 2839 "c-exp.c" /* yacc.c:1646 */
2838 break;
2839
2840 case 113:
2841 #line 912 "c-exp.y" /* yacc.c:1646 */
2842 {
2843 (yyval.bval) = (yyvsp[0].bval);
2844 }
2845 #line 2847 "c-exp.c" /* yacc.c:1646 */
2846 break;
2847
2848 case 114:
2849 #line 918 "c-exp.y" /* yacc.c:1646 */
2850 { struct symbol *tem
2851 = lookup_symbol (copy_name ((yyvsp[0].sval)), (yyvsp[-2].bval),
2852 VAR_DOMAIN, NULL).symbol;
2853
2854 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
2855 error (_("No function \"%s\" in specified context."),
2856 copy_name ((yyvsp[0].sval)));
2857 (yyval.bval) = SYMBOL_BLOCK_VALUE (tem); }
2858 #line 2860 "c-exp.c" /* yacc.c:1646 */
2859 break;
2860
2861 case 115:
2862 #line 929 "c-exp.y" /* yacc.c:1646 */
2863 { struct symbol *sym = (yyvsp[-1].ssym).sym.symbol;
2864
2865 if (sym == NULL || !SYMBOL_IS_ARGUMENT (sym)
2866 || !symbol_read_needs_frame (sym))
2867 error (_("@entry can be used only for function "
2868 "parameters, not for \"%s\""),
2869 copy_name ((yyvsp[-1].ssym).stoken));
2870
2871 write_exp_elt_opcode (pstate, OP_VAR_ENTRY_VALUE);
2872 write_exp_elt_sym (pstate, sym);
2873 write_exp_elt_opcode (pstate, OP_VAR_ENTRY_VALUE);
2874 }
2875 #line 2877 "c-exp.c" /* yacc.c:1646 */
2876 break;
2877
2878 case 116:
2879 #line 944 "c-exp.y" /* yacc.c:1646 */
2880 { struct block_symbol sym
2881 = lookup_symbol (copy_name ((yyvsp[0].sval)), (yyvsp[-2].bval),
2882 VAR_DOMAIN, NULL);
2883
2884 if (sym.symbol == 0)
2885 error (_("No symbol \"%s\" in specified context."),
2886 copy_name ((yyvsp[0].sval)));
2887 if (symbol_read_needs_frame (sym.symbol))
2888 {
2889 if (innermost_block == 0
2890 || contained_in (sym.block,
2891 innermost_block))
2892 innermost_block = sym.block;
2893 }
2894
2895 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
2896 write_exp_elt_block (pstate, sym.block);
2897 write_exp_elt_sym (pstate, sym.symbol);
2898 write_exp_elt_opcode (pstate, OP_VAR_VALUE); }
2899 #line 2901 "c-exp.c" /* yacc.c:1646 */
2900 break;
2901
2902 case 117:
2903 #line 966 "c-exp.y" /* yacc.c:1646 */
2904 {
2905 struct type *type = (yyvsp[-2].tsym).type;
2906 type = check_typedef (type);
2907 if (!type_aggregate_p (type))
2908 error (_("`%s' is not defined as an aggregate type."),
2909 TYPE_SAFE_NAME (type));
2910
2911 write_exp_elt_opcode (pstate, OP_SCOPE);
2912 write_exp_elt_type (pstate, type);
2913 write_exp_string (pstate, (yyvsp[0].sval));
2914 write_exp_elt_opcode (pstate, OP_SCOPE);
2915 }
2916 #line 2918 "c-exp.c" /* yacc.c:1646 */
2917 break;
2918
2919 case 118:
2920 #line 979 "c-exp.y" /* yacc.c:1646 */
2921 {
2922 struct type *type = (yyvsp[-3].tsym).type;
2923 struct stoken tmp_token;
2924 char *buf;
2925
2926 type = check_typedef (type);
2927 if (!type_aggregate_p (type))
2928 error (_("`%s' is not defined as an aggregate type."),
2929 TYPE_SAFE_NAME (type));
2930 buf = (char *) alloca ((yyvsp[0].sval).length + 2);
2931 tmp_token.ptr = buf;
2932 tmp_token.length = (yyvsp[0].sval).length + 1;
2933 buf[0] = '~';
2934 memcpy (buf+1, (yyvsp[0].sval).ptr, (yyvsp[0].sval).length);
2935 buf[tmp_token.length] = 0;
2936
2937 /* Check for valid destructor name. */
2938 destructor_name_p (tmp_token.ptr, (yyvsp[-3].tsym).type);
2939 write_exp_elt_opcode (pstate, OP_SCOPE);
2940 write_exp_elt_type (pstate, type);
2941 write_exp_string (pstate, tmp_token);
2942 write_exp_elt_opcode (pstate, OP_SCOPE);
2943 }
2944 #line 2946 "c-exp.c" /* yacc.c:1646 */
2945 break;
2946
2947 case 119:
2948 #line 1003 "c-exp.y" /* yacc.c:1646 */
2949 {
2950 char *copy = copy_name ((yyvsp[-2].sval));
2951 error (_("No type \"%s\" within class "
2952 "or namespace \"%s\"."),
2953 copy, TYPE_SAFE_NAME ((yyvsp[-4].tsym).type));
2954 }
2955 #line 2957 "c-exp.c" /* yacc.c:1646 */
2956 break;
2957
2958 case 121:
2959 #line 1013 "c-exp.y" /* yacc.c:1646 */
2960 {
2961 char *name = copy_name ((yyvsp[0].ssym).stoken);
2962 struct symbol *sym;
2963 struct bound_minimal_symbol msymbol;
2964
2965 sym
2966 = lookup_symbol (name, (const struct block *) NULL,
2967 VAR_DOMAIN, NULL).symbol;
2968 if (sym)
2969 {
2970 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
2971 write_exp_elt_block (pstate, NULL);
2972 write_exp_elt_sym (pstate, sym);
2973 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
2974 break;
2975 }
2976
2977 msymbol = lookup_bound_minimal_symbol (name);
2978 if (msymbol.minsym != NULL)
2979 write_exp_msymbol (pstate, msymbol);
2980 else if (!have_full_symbols () && !have_partial_symbols ())
2981 error (_("No symbol table is loaded. Use the \"file\" command."));
2982 else
2983 error (_("No symbol \"%s\" in current context."), name);
2984 }
2985 #line 2987 "c-exp.c" /* yacc.c:1646 */
2986 break;
2987
2988 case 122:
2989 #line 1041 "c-exp.y" /* yacc.c:1646 */
2990 { struct block_symbol sym = (yyvsp[0].ssym).sym;
2991
2992 if (sym.symbol)
2993 {
2994 if (symbol_read_needs_frame (sym.symbol))
2995 {
2996 if (innermost_block == 0
2997 || contained_in (sym.block,
2998 innermost_block))
2999 innermost_block = sym.block;
3000 }
3001
3002 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
3003 write_exp_elt_block (pstate, sym.block);
3004 write_exp_elt_sym (pstate, sym.symbol);
3005 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
3006 }
3007 else if ((yyvsp[0].ssym).is_a_field_of_this)
3008 {
3009 /* C++: it hangs off of `this'. Must
3010 not inadvertently convert from a method call
3011 to data ref. */
3012 if (innermost_block == 0
3013 || contained_in (sym.block,
3014 innermost_block))
3015 innermost_block = sym.block;
3016 write_exp_elt_opcode (pstate, OP_THIS);
3017 write_exp_elt_opcode (pstate, OP_THIS);
3018 write_exp_elt_opcode (pstate, STRUCTOP_PTR);
3019 write_exp_string (pstate, (yyvsp[0].ssym).stoken);
3020 write_exp_elt_opcode (pstate, STRUCTOP_PTR);
3021 }
3022 else
3023 {
3024 char *arg = copy_name ((yyvsp[0].ssym).stoken);
3025
3026 bound_minimal_symbol msymbol
3027 = lookup_bound_minimal_symbol (arg);
3028 if (msymbol.minsym == NULL)
3029 {
3030 if (!have_full_symbols () && !have_partial_symbols ())
3031 error (_("No symbol table is loaded. Use the \"file\" command."));
3032 else
3033 error (_("No symbol \"%s\" in current context."),
3034 copy_name ((yyvsp[0].ssym).stoken));
3035 }
3036
3037 /* This minsym might be an alias for
3038 another function. See if we can find
3039 the debug symbol for the target, and
3040 if so, use it instead, since it has
3041 return type / prototype info. This
3042 is important for example for "p
3043 *__errno_location()". */
3044 symbol *alias_target
3045 = find_function_alias_target (msymbol);
3046 if (alias_target != NULL)
3047 {
3048 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
3049 write_exp_elt_block
3050 (pstate, SYMBOL_BLOCK_VALUE (alias_target));
3051 write_exp_elt_sym (pstate, alias_target);
3052 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
3053 }
3054 else
3055 write_exp_msymbol (pstate, msymbol);
3056 }
3057 }
3058 #line 3060 "c-exp.c" /* yacc.c:1646 */
3059 break;
3060
3061 case 123:
3062 #line 1112 "c-exp.y" /* yacc.c:1646 */
3063 { insert_type_address_space (pstate, copy_name ((yyvsp[0].ssym).stoken)); }
3064 #line 3066 "c-exp.c" /* yacc.c:1646 */
3065 break;
3066
3067 case 131:
3068 #line 1133 "c-exp.y" /* yacc.c:1646 */
3069 { insert_type (tp_pointer); }
3070 #line 3072 "c-exp.c" /* yacc.c:1646 */
3071 break;
3072
3073 case 133:
3074 #line 1136 "c-exp.y" /* yacc.c:1646 */
3075 { insert_type (tp_pointer); }
3076 #line 3078 "c-exp.c" /* yacc.c:1646 */
3077 break;
3078
3079 case 135:
3080 #line 1139 "c-exp.y" /* yacc.c:1646 */
3081 { insert_type (tp_reference); }
3082 #line 3084 "c-exp.c" /* yacc.c:1646 */
3083 break;
3084
3085 case 136:
3086 #line 1141 "c-exp.y" /* yacc.c:1646 */
3087 { insert_type (tp_reference); }
3088 #line 3090 "c-exp.c" /* yacc.c:1646 */
3089 break;
3090
3091 case 137:
3092 #line 1143 "c-exp.y" /* yacc.c:1646 */
3093 { insert_type (tp_rvalue_reference); }
3094 #line 3096 "c-exp.c" /* yacc.c:1646 */
3095 break;
3096
3097 case 138:
3098 #line 1145 "c-exp.y" /* yacc.c:1646 */
3099 { insert_type (tp_rvalue_reference); }
3100 #line 3102 "c-exp.c" /* yacc.c:1646 */
3101 break;
3102
3103 case 139:
3104 #line 1149 "c-exp.y" /* yacc.c:1646 */
3105 {
3106 (yyval.type_stack) = get_type_stack ();
3107 /* This cleanup is eventually run by
3108 c_parse. */
3109 make_cleanup (type_stack_cleanup, (yyval.type_stack));
3110 }
3111 #line 3113 "c-exp.c" /* yacc.c:1646 */
3112 break;
3113
3114 case 140:
3115 #line 1158 "c-exp.y" /* yacc.c:1646 */
3116 { (yyval.type_stack) = append_type_stack ((yyvsp[0].type_stack), (yyvsp[-1].type_stack)); }
3117 #line 3119 "c-exp.c" /* yacc.c:1646 */
3118 break;
3119
3120 case 143:
3121 #line 1164 "c-exp.y" /* yacc.c:1646 */
3122 { (yyval.type_stack) = (yyvsp[-1].type_stack); }
3123 #line 3125 "c-exp.c" /* yacc.c:1646 */
3124 break;
3125
3126 case 144:
3127 #line 1166 "c-exp.y" /* yacc.c:1646 */
3128 {
3129 push_type_stack ((yyvsp[-1].type_stack));
3130 push_type_int ((yyvsp[0].lval));
3131 push_type (tp_array);
3132 (yyval.type_stack) = get_type_stack ();
3133 }
3134 #line 3136 "c-exp.c" /* yacc.c:1646 */
3135 break;
3136
3137 case 145:
3138 #line 1173 "c-exp.y" /* yacc.c:1646 */
3139 {
3140 push_type_int ((yyvsp[0].lval));
3141 push_type (tp_array);
3142 (yyval.type_stack) = get_type_stack ();
3143 }
3144 #line 3146 "c-exp.c" /* yacc.c:1646 */
3145 break;
3146
3147 case 146:
3148 #line 1180 "c-exp.y" /* yacc.c:1646 */
3149 {
3150 push_type_stack ((yyvsp[-1].type_stack));
3151 push_typelist ((yyvsp[0].tvec));
3152 (yyval.type_stack) = get_type_stack ();
3153 }
3154 #line 3156 "c-exp.c" /* yacc.c:1646 */
3155 break;
3156
3157 case 147:
3158 #line 1186 "c-exp.y" /* yacc.c:1646 */
3159 {
3160 push_typelist ((yyvsp[0].tvec));
3161 (yyval.type_stack) = get_type_stack ();
3162 }
3163 #line 3165 "c-exp.c" /* yacc.c:1646 */
3164 break;
3165
3166 case 148:
3167 #line 1193 "c-exp.y" /* yacc.c:1646 */
3168 { (yyval.lval) = -1; }
3169 #line 3171 "c-exp.c" /* yacc.c:1646 */
3170 break;
3171
3172 case 149:
3173 #line 1195 "c-exp.y" /* yacc.c:1646 */
3174 { (yyval.lval) = -1; }
3175 #line 3177 "c-exp.c" /* yacc.c:1646 */
3176 break;
3177
3178 case 150:
3179 #line 1197 "c-exp.y" /* yacc.c:1646 */
3180 { (yyval.lval) = (yyvsp[-1].typed_val_int).val; }
3181 #line 3183 "c-exp.c" /* yacc.c:1646 */
3182 break;
3183
3184 case 151:
3185 #line 1199 "c-exp.y" /* yacc.c:1646 */
3186 { (yyval.lval) = (yyvsp[-1].typed_val_int).val; }
3187 #line 3189 "c-exp.c" /* yacc.c:1646 */
3188 break;
3189
3190 case 152:
3191 #line 1203 "c-exp.y" /* yacc.c:1646 */
3192 { (yyval.tvec) = NULL; }
3193 #line 3195 "c-exp.c" /* yacc.c:1646 */
3194 break;
3195
3196 case 153:
3197 #line 1205 "c-exp.y" /* yacc.c:1646 */
3198 { (yyval.tvec) = (yyvsp[-1].tvec); }
3199 #line 3201 "c-exp.c" /* yacc.c:1646 */
3200 break;
3201
3202 case 155:
3203 #line 1221 "c-exp.y" /* yacc.c:1646 */
3204 { (yyval.tval) = (yyvsp[0].tsym).type; }
3205 #line 3207 "c-exp.c" /* yacc.c:1646 */
3206 break;
3207
3208 case 156:
3209 #line 1223 "c-exp.y" /* yacc.c:1646 */
3210 { (yyval.tval) = lookup_signed_typename (parse_language (pstate),
3211 parse_gdbarch (pstate),
3212 "int"); }
3213 #line 3215 "c-exp.c" /* yacc.c:1646 */
3214 break;
3215
3216 case 157:
3217 #line 1227 "c-exp.y" /* yacc.c:1646 */
3218 { (yyval.tval) = lookup_signed_typename (parse_language (pstate),
3219 parse_gdbarch (pstate),
3220 "long"); }
3221 #line 3223 "c-exp.c" /* yacc.c:1646 */
3222 break;
3223
3224 case 158:
3225 #line 1231 "c-exp.y" /* yacc.c:1646 */
3226 { (yyval.tval) = lookup_signed_typename (parse_language (pstate),
3227 parse_gdbarch (pstate),
3228 "short"); }
3229 #line 3231 "c-exp.c" /* yacc.c:1646 */
3230 break;
3231
3232 case 159:
3233 #line 1235 "c-exp.y" /* yacc.c:1646 */
3234 { (yyval.tval) = lookup_signed_typename (parse_language (pstate),
3235 parse_gdbarch (pstate),
3236 "long"); }
3237 #line 3239 "c-exp.c" /* yacc.c:1646 */
3238 break;
3239
3240 case 160:
3241 #line 1239 "c-exp.y" /* yacc.c:1646 */
3242 { (yyval.tval) = lookup_signed_typename (parse_language (pstate),
3243 parse_gdbarch (pstate),
3244 "long"); }
3245 #line 3247 "c-exp.c" /* yacc.c:1646 */
3246 break;
3247
3248 case 161:
3249 #line 1243 "c-exp.y" /* yacc.c:1646 */
3250 { (yyval.tval) = lookup_signed_typename (parse_language (pstate),
3251 parse_gdbarch (pstate),
3252 "long"); }
3253 #line 3255 "c-exp.c" /* yacc.c:1646 */
3254 break;
3255
3256 case 162:
3257 #line 1247 "c-exp.y" /* yacc.c:1646 */
3258 { (yyval.tval) = lookup_signed_typename (parse_language (pstate),
3259 parse_gdbarch (pstate),
3260 "long"); }
3261 #line 3263 "c-exp.c" /* yacc.c:1646 */
3262 break;
3263
3264 case 163:
3265 #line 1251 "c-exp.y" /* yacc.c:1646 */
3266 { (yyval.tval) = lookup_unsigned_typename (parse_language (pstate),
3267 parse_gdbarch (pstate),
3268 "long"); }
3269 #line 3271 "c-exp.c" /* yacc.c:1646 */
3270 break;
3271
3272 case 164:
3273 #line 1255 "c-exp.y" /* yacc.c:1646 */
3274 { (yyval.tval) = lookup_unsigned_typename (parse_language (pstate),
3275 parse_gdbarch (pstate),
3276 "long"); }
3277 #line 3279 "c-exp.c" /* yacc.c:1646 */
3278 break;
3279
3280 case 165:
3281 #line 1259 "c-exp.y" /* yacc.c:1646 */
3282 { (yyval.tval) = lookup_unsigned_typename (parse_language (pstate),
3283 parse_gdbarch (pstate),
3284 "long"); }
3285 #line 3287 "c-exp.c" /* yacc.c:1646 */
3286 break;
3287
3288 case 166:
3289 #line 1263 "c-exp.y" /* yacc.c:1646 */
3290 { (yyval.tval) = lookup_signed_typename (parse_language (pstate),
3291 parse_gdbarch (pstate),
3292 "long long"); }
3293 #line 3295 "c-exp.c" /* yacc.c:1646 */
3294 break;
3295
3296 case 167:
3297 #line 1267 "c-exp.y" /* yacc.c:1646 */
3298 { (yyval.tval) = lookup_signed_typename (parse_language (pstate),
3299 parse_gdbarch (pstate),
3300 "long long"); }
3301 #line 3303 "c-exp.c" /* yacc.c:1646 */
3302 break;
3303
3304 case 168:
3305 #line 1271 "c-exp.y" /* yacc.c:1646 */
3306 { (yyval.tval) = lookup_signed_typename (parse_language (pstate),
3307 parse_gdbarch (pstate),
3308 "long long"); }
3309 #line 3311 "c-exp.c" /* yacc.c:1646 */
3310 break;
3311
3312 case 169:
3313 #line 1275 "c-exp.y" /* yacc.c:1646 */
3314 { (yyval.tval) = lookup_signed_typename (parse_language (pstate),
3315 parse_gdbarch (pstate),
3316 "long long"); }
3317 #line 3319 "c-exp.c" /* yacc.c:1646 */
3318 break;
3319
3320 case 170:
3321 #line 1279 "c-exp.y" /* yacc.c:1646 */
3322 { (yyval.tval) = lookup_signed_typename (parse_language (pstate),
3323 parse_gdbarch (pstate),
3324 "long long"); }
3325 #line 3327 "c-exp.c" /* yacc.c:1646 */
3326 break;
3327
3328 case 171:
3329 #line 1283 "c-exp.y" /* yacc.c:1646 */
3330 { (yyval.tval) = lookup_signed_typename (parse_language (pstate),
3331 parse_gdbarch (pstate),
3332 "long long"); }
3333 #line 3335 "c-exp.c" /* yacc.c:1646 */
3334 break;
3335
3336 case 172:
3337 #line 1287 "c-exp.y" /* yacc.c:1646 */
3338 { (yyval.tval) = lookup_unsigned_typename (parse_language (pstate),
3339 parse_gdbarch (pstate),
3340 "long long"); }
3341 #line 3343 "c-exp.c" /* yacc.c:1646 */
3342 break;
3343
3344 case 173:
3345 #line 1291 "c-exp.y" /* yacc.c:1646 */
3346 { (yyval.tval) = lookup_unsigned_typename (parse_language (pstate),
3347 parse_gdbarch (pstate),
3348 "long long"); }
3349 #line 3351 "c-exp.c" /* yacc.c:1646 */
3350 break;
3351
3352 case 174:
3353 #line 1295 "c-exp.y" /* yacc.c:1646 */
3354 { (yyval.tval) = lookup_unsigned_typename (parse_language (pstate),
3355 parse_gdbarch (pstate),
3356 "long long"); }
3357 #line 3359 "c-exp.c" /* yacc.c:1646 */
3358 break;
3359
3360 case 175:
3361 #line 1299 "c-exp.y" /* yacc.c:1646 */
3362 { (yyval.tval) = lookup_unsigned_typename (parse_language (pstate),
3363 parse_gdbarch (pstate),
3364 "long long"); }
3365 #line 3367 "c-exp.c" /* yacc.c:1646 */
3366 break;
3367
3368 case 176:
3369 #line 1303 "c-exp.y" /* yacc.c:1646 */
3370 { (yyval.tval) = lookup_signed_typename (parse_language (pstate),
3371 parse_gdbarch (pstate),
3372 "short"); }
3373 #line 3375 "c-exp.c" /* yacc.c:1646 */
3374 break;
3375
3376 case 177:
3377 #line 1307 "c-exp.y" /* yacc.c:1646 */
3378 { (yyval.tval) = lookup_signed_typename (parse_language (pstate),
3379 parse_gdbarch (pstate),
3380 "short"); }
3381 #line 3383 "c-exp.c" /* yacc.c:1646 */
3382 break;
3383
3384 case 178:
3385 #line 1311 "c-exp.y" /* yacc.c:1646 */
3386 { (yyval.tval) = lookup_signed_typename (parse_language (pstate),
3387 parse_gdbarch (pstate),
3388 "short"); }
3389 #line 3391 "c-exp.c" /* yacc.c:1646 */
3390 break;
3391
3392 case 179:
3393 #line 1315 "c-exp.y" /* yacc.c:1646 */
3394 { (yyval.tval) = lookup_unsigned_typename (parse_language (pstate),
3395 parse_gdbarch (pstate),
3396 "short"); }
3397 #line 3399 "c-exp.c" /* yacc.c:1646 */
3398 break;
3399
3400 case 180:
3401 #line 1319 "c-exp.y" /* yacc.c:1646 */
3402 { (yyval.tval) = lookup_unsigned_typename (parse_language (pstate),
3403 parse_gdbarch (pstate),
3404 "short"); }
3405 #line 3407 "c-exp.c" /* yacc.c:1646 */
3406 break;
3407
3408 case 181:
3409 #line 1323 "c-exp.y" /* yacc.c:1646 */
3410 { (yyval.tval) = lookup_unsigned_typename (parse_language (pstate),
3411 parse_gdbarch (pstate),
3412 "short"); }
3413 #line 3415 "c-exp.c" /* yacc.c:1646 */
3414 break;
3415
3416 case 182:
3417 #line 1327 "c-exp.y" /* yacc.c:1646 */
3418 { (yyval.tval) = lookup_typename (parse_language (pstate),
3419 parse_gdbarch (pstate),
3420 "double",
3421 (struct block *) NULL,
3422 0); }
3423 #line 3425 "c-exp.c" /* yacc.c:1646 */
3424 break;
3425
3426 case 183:
3427 #line 1333 "c-exp.y" /* yacc.c:1646 */
3428 { (yyval.tval) = lookup_typename (parse_language (pstate),
3429 parse_gdbarch (pstate),
3430 "long double",
3431 (struct block *) NULL,
3432 0); }
3433 #line 3435 "c-exp.c" /* yacc.c:1646 */
3434 break;
3435
3436 case 184:
3437 #line 1339 "c-exp.y" /* yacc.c:1646 */
3438 { (yyval.tval) = lookup_struct (copy_name ((yyvsp[0].sval)),
3439 expression_context_block); }
3440 #line 3442 "c-exp.c" /* yacc.c:1646 */
3441 break;
3442
3443 case 185:
3444 #line 1342 "c-exp.y" /* yacc.c:1646 */
3445 {
3446 mark_completion_tag (TYPE_CODE_STRUCT, "", 0);
3447 (yyval.tval) = NULL;
3448 }
3449 #line 3451 "c-exp.c" /* yacc.c:1646 */
3450 break;
3451
3452 case 186:
3453 #line 1347 "c-exp.y" /* yacc.c:1646 */
3454 {
3455 mark_completion_tag (TYPE_CODE_STRUCT, (yyvsp[-1].sval).ptr,
3456 (yyvsp[-1].sval).length);
3457 (yyval.tval) = NULL;
3458 }
3459 #line 3461 "c-exp.c" /* yacc.c:1646 */
3460 break;
3461
3462 case 187:
3463 #line 1353 "c-exp.y" /* yacc.c:1646 */
3464 { (yyval.tval) = lookup_struct (copy_name ((yyvsp[0].sval)),
3465 expression_context_block); }
3466 #line 3468 "c-exp.c" /* yacc.c:1646 */
3467 break;
3468
3469 case 188:
3470 #line 1356 "c-exp.y" /* yacc.c:1646 */
3471 {
3472 mark_completion_tag (TYPE_CODE_STRUCT, "", 0);
3473 (yyval.tval) = NULL;
3474 }
3475 #line 3477 "c-exp.c" /* yacc.c:1646 */
3476 break;
3477
3478 case 189:
3479 #line 1361 "c-exp.y" /* yacc.c:1646 */
3480 {
3481 mark_completion_tag (TYPE_CODE_STRUCT, (yyvsp[-1].sval).ptr,
3482 (yyvsp[-1].sval).length);
3483 (yyval.tval) = NULL;
3484 }
3485 #line 3487 "c-exp.c" /* yacc.c:1646 */
3486 break;
3487
3488 case 190:
3489 #line 1367 "c-exp.y" /* yacc.c:1646 */
3490 { (yyval.tval) = lookup_union (copy_name ((yyvsp[0].sval)),
3491 expression_context_block); }
3492 #line 3494 "c-exp.c" /* yacc.c:1646 */
3493 break;
3494
3495 case 191:
3496 #line 1370 "c-exp.y" /* yacc.c:1646 */
3497 {
3498 mark_completion_tag (TYPE_CODE_UNION, "", 0);
3499 (yyval.tval) = NULL;
3500 }
3501 #line 3503 "c-exp.c" /* yacc.c:1646 */
3502 break;
3503
3504 case 192:
3505 #line 1375 "c-exp.y" /* yacc.c:1646 */
3506 {
3507 mark_completion_tag (TYPE_CODE_UNION, (yyvsp[-1].sval).ptr,
3508 (yyvsp[-1].sval).length);
3509 (yyval.tval) = NULL;
3510 }
3511 #line 3513 "c-exp.c" /* yacc.c:1646 */
3512 break;
3513
3514 case 193:
3515 #line 1381 "c-exp.y" /* yacc.c:1646 */
3516 { (yyval.tval) = lookup_enum (copy_name ((yyvsp[0].sval)),
3517 expression_context_block); }
3518 #line 3520 "c-exp.c" /* yacc.c:1646 */
3519 break;
3520
3521 case 194:
3522 #line 1384 "c-exp.y" /* yacc.c:1646 */
3523 {
3524 mark_completion_tag (TYPE_CODE_ENUM, "", 0);
3525 (yyval.tval) = NULL;
3526 }
3527 #line 3529 "c-exp.c" /* yacc.c:1646 */
3528 break;
3529
3530 case 195:
3531 #line 1389 "c-exp.y" /* yacc.c:1646 */
3532 {
3533 mark_completion_tag (TYPE_CODE_ENUM, (yyvsp[-1].sval).ptr,
3534 (yyvsp[-1].sval).length);
3535 (yyval.tval) = NULL;
3536 }
3537 #line 3539 "c-exp.c" /* yacc.c:1646 */
3538 break;
3539
3540 case 196:
3541 #line 1395 "c-exp.y" /* yacc.c:1646 */
3542 { (yyval.tval) = lookup_unsigned_typename (parse_language (pstate),
3543 parse_gdbarch (pstate),
3544 TYPE_NAME((yyvsp[0].tsym).type)); }
3545 #line 3547 "c-exp.c" /* yacc.c:1646 */
3546 break;
3547
3548 case 197:
3549 #line 1399 "c-exp.y" /* yacc.c:1646 */
3550 { (yyval.tval) = lookup_unsigned_typename (parse_language (pstate),
3551 parse_gdbarch (pstate),
3552 "int"); }
3553 #line 3555 "c-exp.c" /* yacc.c:1646 */
3554 break;
3555
3556 case 198:
3557 #line 1403 "c-exp.y" /* yacc.c:1646 */
3558 { (yyval.tval) = lookup_signed_typename (parse_language (pstate),
3559 parse_gdbarch (pstate),
3560 TYPE_NAME((yyvsp[0].tsym).type)); }
3561 #line 3563 "c-exp.c" /* yacc.c:1646 */
3562 break;
3563
3564 case 199:
3565 #line 1407 "c-exp.y" /* yacc.c:1646 */
3566 { (yyval.tval) = lookup_signed_typename (parse_language (pstate),
3567 parse_gdbarch (pstate),
3568 "int"); }
3569 #line 3571 "c-exp.c" /* yacc.c:1646 */
3570 break;
3571
3572 case 200:
3573 #line 1414 "c-exp.y" /* yacc.c:1646 */
3574 { (yyval.tval) = lookup_template_type(copy_name((yyvsp[-3].sval)), (yyvsp[-1].tval),
3575 expression_context_block);
3576 }
3577 #line 3579 "c-exp.c" /* yacc.c:1646 */
3578 break;
3579
3580 case 201:
3581 #line 1418 "c-exp.y" /* yacc.c:1646 */
3582 { (yyval.tval) = follow_types ((yyvsp[0].tval)); }
3583 #line 3585 "c-exp.c" /* yacc.c:1646 */
3584 break;
3585
3586 case 202:
3587 #line 1420 "c-exp.y" /* yacc.c:1646 */
3588 { (yyval.tval) = follow_types ((yyvsp[-1].tval)); }
3589 #line 3591 "c-exp.c" /* yacc.c:1646 */
3590 break;
3591
3592 case 204:
3593 #line 1425 "c-exp.y" /* yacc.c:1646 */
3594 {
3595 (yyval.tsym).stoken.ptr = "int";
3596 (yyval.tsym).stoken.length = 3;
3597 (yyval.tsym).type = lookup_signed_typename (parse_language (pstate),
3598 parse_gdbarch (pstate),
3599 "int");
3600 }
3601 #line 3603 "c-exp.c" /* yacc.c:1646 */
3602 break;
3603
3604 case 205:
3605 #line 1433 "c-exp.y" /* yacc.c:1646 */
3606 {
3607 (yyval.tsym).stoken.ptr = "long";
3608 (yyval.tsym).stoken.length = 4;
3609 (yyval.tsym).type = lookup_signed_typename (parse_language (pstate),
3610 parse_gdbarch (pstate),
3611 "long");
3612 }
3613 #line 3615 "c-exp.c" /* yacc.c:1646 */
3614 break;
3615
3616 case 206:
3617 #line 1441 "c-exp.y" /* yacc.c:1646 */
3618 {
3619 (yyval.tsym).stoken.ptr = "short";
3620 (yyval.tsym).stoken.length = 5;
3621 (yyval.tsym).type = lookup_signed_typename (parse_language (pstate),
3622 parse_gdbarch (pstate),
3623 "short");
3624 }
3625 #line 3627 "c-exp.c" /* yacc.c:1646 */
3626 break;
3627
3628 case 207:
3629 #line 1452 "c-exp.y" /* yacc.c:1646 */
3630 { check_parameter_typelist ((yyvsp[0].tvec)); }
3631 #line 3633 "c-exp.c" /* yacc.c:1646 */
3632 break;
3633
3634 case 208:
3635 #line 1454 "c-exp.y" /* yacc.c:1646 */
3636 {
3637 VEC_safe_push (type_ptr, (yyvsp[-2].tvec), NULL);
3638 check_parameter_typelist ((yyvsp[-2].tvec));
3639 (yyval.tvec) = (yyvsp[-2].tvec);
3640 }
3641 #line 3643 "c-exp.c" /* yacc.c:1646 */
3642 break;
3643
3644 case 209:
3645 #line 1463 "c-exp.y" /* yacc.c:1646 */
3646 {
3647 VEC (type_ptr) *typelist = NULL;
3648 VEC_safe_push (type_ptr, typelist, (yyvsp[0].tval));
3649 (yyval.tvec) = typelist;
3650 }
3651 #line 3653 "c-exp.c" /* yacc.c:1646 */
3652 break;
3653
3654 case 210:
3655 #line 1469 "c-exp.y" /* yacc.c:1646 */
3656 {
3657 VEC_safe_push (type_ptr, (yyvsp[-2].tvec), (yyvsp[0].tval));
3658 (yyval.tvec) = (yyvsp[-2].tvec);
3659 }
3660 #line 3662 "c-exp.c" /* yacc.c:1646 */
3661 break;
3662
3663 case 212:
3664 #line 1477 "c-exp.y" /* yacc.c:1646 */
3665 {
3666 push_type_stack ((yyvsp[0].type_stack));
3667 (yyval.tval) = follow_types ((yyvsp[-1].tval));
3668 }
3669 #line 3671 "c-exp.c" /* yacc.c:1646 */
3670 break;
3671
3672 case 213:
3673 #line 1484 "c-exp.y" /* yacc.c:1646 */
3674 { (yyval.tval) = follow_types ((yyvsp[-1].tval)); }
3675 #line 3677 "c-exp.c" /* yacc.c:1646 */
3676 break;
3677
3678 case 218:
3679 #line 1496 "c-exp.y" /* yacc.c:1646 */
3680 { insert_type (tp_const);
3681 insert_type (tp_volatile);
3682 }
3683 #line 3685 "c-exp.c" /* yacc.c:1646 */
3684 break;
3685
3686 case 219:
3687 #line 1500 "c-exp.y" /* yacc.c:1646 */
3688 { insert_type (tp_const); }
3689 #line 3691 "c-exp.c" /* yacc.c:1646 */
3690 break;
3691
3692 case 220:
3693 #line 1502 "c-exp.y" /* yacc.c:1646 */
3694 { insert_type (tp_volatile); }
3695 #line 3697 "c-exp.c" /* yacc.c:1646 */
3696 break;
3697
3698 case 221:
3699 #line 1506 "c-exp.y" /* yacc.c:1646 */
3700 { (yyval.sval) = operator_stoken (" new"); }
3701 #line 3703 "c-exp.c" /* yacc.c:1646 */
3702 break;
3703
3704 case 222:
3705 #line 1508 "c-exp.y" /* yacc.c:1646 */
3706 { (yyval.sval) = operator_stoken (" delete"); }
3707 #line 3709 "c-exp.c" /* yacc.c:1646 */
3708 break;
3709
3710 case 223:
3711 #line 1510 "c-exp.y" /* yacc.c:1646 */
3712 { (yyval.sval) = operator_stoken (" new[]"); }
3713 #line 3715 "c-exp.c" /* yacc.c:1646 */
3714 break;
3715
3716 case 224:
3717 #line 1512 "c-exp.y" /* yacc.c:1646 */
3718 { (yyval.sval) = operator_stoken (" delete[]"); }
3719 #line 3721 "c-exp.c" /* yacc.c:1646 */
3720 break;
3721
3722 case 225:
3723 #line 1514 "c-exp.y" /* yacc.c:1646 */
3724 { (yyval.sval) = operator_stoken (" new[]"); }
3725 #line 3727 "c-exp.c" /* yacc.c:1646 */
3726 break;
3727
3728 case 226:
3729 #line 1516 "c-exp.y" /* yacc.c:1646 */
3730 { (yyval.sval) = operator_stoken (" delete[]"); }
3731 #line 3733 "c-exp.c" /* yacc.c:1646 */
3732 break;
3733
3734 case 227:
3735 #line 1518 "c-exp.y" /* yacc.c:1646 */
3736 { (yyval.sval) = operator_stoken ("+"); }
3737 #line 3739 "c-exp.c" /* yacc.c:1646 */
3738 break;
3739
3740 case 228:
3741 #line 1520 "c-exp.y" /* yacc.c:1646 */
3742 { (yyval.sval) = operator_stoken ("-"); }
3743 #line 3745 "c-exp.c" /* yacc.c:1646 */
3744 break;
3745
3746 case 229:
3747 #line 1522 "c-exp.y" /* yacc.c:1646 */
3748 { (yyval.sval) = operator_stoken ("*"); }
3749 #line 3751 "c-exp.c" /* yacc.c:1646 */
3750 break;
3751
3752 case 230:
3753 #line 1524 "c-exp.y" /* yacc.c:1646 */
3754 { (yyval.sval) = operator_stoken ("/"); }
3755 #line 3757 "c-exp.c" /* yacc.c:1646 */
3756 break;
3757
3758 case 231:
3759 #line 1526 "c-exp.y" /* yacc.c:1646 */
3760 { (yyval.sval) = operator_stoken ("%"); }
3761 #line 3763 "c-exp.c" /* yacc.c:1646 */
3762 break;
3763
3764 case 232:
3765 #line 1528 "c-exp.y" /* yacc.c:1646 */
3766 { (yyval.sval) = operator_stoken ("^"); }
3767 #line 3769 "c-exp.c" /* yacc.c:1646 */
3768 break;
3769
3770 case 233:
3771 #line 1530 "c-exp.y" /* yacc.c:1646 */
3772 { (yyval.sval) = operator_stoken ("&"); }
3773 #line 3775 "c-exp.c" /* yacc.c:1646 */
3774 break;
3775
3776 case 234:
3777 #line 1532 "c-exp.y" /* yacc.c:1646 */
3778 { (yyval.sval) = operator_stoken ("|"); }
3779 #line 3781 "c-exp.c" /* yacc.c:1646 */
3780 break;
3781
3782 case 235:
3783 #line 1534 "c-exp.y" /* yacc.c:1646 */
3784 { (yyval.sval) = operator_stoken ("~"); }
3785 #line 3787 "c-exp.c" /* yacc.c:1646 */
3786 break;
3787
3788 case 236:
3789 #line 1536 "c-exp.y" /* yacc.c:1646 */
3790 { (yyval.sval) = operator_stoken ("!"); }
3791 #line 3793 "c-exp.c" /* yacc.c:1646 */
3792 break;
3793
3794 case 237:
3795 #line 1538 "c-exp.y" /* yacc.c:1646 */
3796 { (yyval.sval) = operator_stoken ("="); }
3797 #line 3799 "c-exp.c" /* yacc.c:1646 */
3798 break;
3799
3800 case 238:
3801 #line 1540 "c-exp.y" /* yacc.c:1646 */
3802 { (yyval.sval) = operator_stoken ("<"); }
3803 #line 3805 "c-exp.c" /* yacc.c:1646 */
3804 break;
3805
3806 case 239:
3807 #line 1542 "c-exp.y" /* yacc.c:1646 */
3808 { (yyval.sval) = operator_stoken (">"); }
3809 #line 3811 "c-exp.c" /* yacc.c:1646 */
3810 break;
3811
3812 case 240:
3813 #line 1544 "c-exp.y" /* yacc.c:1646 */
3814 { const char *op = " unknown";
3815 switch ((yyvsp[0].opcode))
3816 {
3817 case BINOP_RSH:
3818 op = ">>=";
3819 break;
3820 case BINOP_LSH:
3821 op = "<<=";
3822 break;
3823 case BINOP_ADD:
3824 op = "+=";
3825 break;
3826 case BINOP_SUB:
3827 op = "-=";
3828 break;
3829 case BINOP_MUL:
3830 op = "*=";
3831 break;
3832 case BINOP_DIV:
3833 op = "/=";
3834 break;
3835 case BINOP_REM:
3836 op = "%=";
3837 break;
3838 case BINOP_BITWISE_IOR:
3839 op = "|=";
3840 break;
3841 case BINOP_BITWISE_AND:
3842 op = "&=";
3843 break;
3844 case BINOP_BITWISE_XOR:
3845 op = "^=";
3846 break;
3847 default:
3848 break;
3849 }
3850
3851 (yyval.sval) = operator_stoken (op);
3852 }
3853 #line 3855 "c-exp.c" /* yacc.c:1646 */
3854 break;
3855
3856 case 241:
3857 #line 1584 "c-exp.y" /* yacc.c:1646 */
3858 { (yyval.sval) = operator_stoken ("<<"); }
3859 #line 3861 "c-exp.c" /* yacc.c:1646 */
3860 break;
3861
3862 case 242:
3863 #line 1586 "c-exp.y" /* yacc.c:1646 */
3864 { (yyval.sval) = operator_stoken (">>"); }
3865 #line 3867 "c-exp.c" /* yacc.c:1646 */
3866 break;
3867
3868 case 243:
3869 #line 1588 "c-exp.y" /* yacc.c:1646 */
3870 { (yyval.sval) = operator_stoken ("=="); }
3871 #line 3873 "c-exp.c" /* yacc.c:1646 */
3872 break;
3873
3874 case 244:
3875 #line 1590 "c-exp.y" /* yacc.c:1646 */
3876 { (yyval.sval) = operator_stoken ("!="); }
3877 #line 3879 "c-exp.c" /* yacc.c:1646 */
3878 break;
3879
3880 case 245:
3881 #line 1592 "c-exp.y" /* yacc.c:1646 */
3882 { (yyval.sval) = operator_stoken ("<="); }
3883 #line 3885 "c-exp.c" /* yacc.c:1646 */
3884 break;
3885
3886 case 246:
3887 #line 1594 "c-exp.y" /* yacc.c:1646 */
3888 { (yyval.sval) = operator_stoken (">="); }
3889 #line 3891 "c-exp.c" /* yacc.c:1646 */
3890 break;
3891
3892 case 247:
3893 #line 1596 "c-exp.y" /* yacc.c:1646 */
3894 { (yyval.sval) = operator_stoken ("&&"); }
3895 #line 3897 "c-exp.c" /* yacc.c:1646 */
3896 break;
3897
3898 case 248:
3899 #line 1598 "c-exp.y" /* yacc.c:1646 */
3900 { (yyval.sval) = operator_stoken ("||"); }
3901 #line 3903 "c-exp.c" /* yacc.c:1646 */
3902 break;
3903
3904 case 249:
3905 #line 1600 "c-exp.y" /* yacc.c:1646 */
3906 { (yyval.sval) = operator_stoken ("++"); }
3907 #line 3909 "c-exp.c" /* yacc.c:1646 */
3908 break;
3909
3910 case 250:
3911 #line 1602 "c-exp.y" /* yacc.c:1646 */
3912 { (yyval.sval) = operator_stoken ("--"); }
3913 #line 3915 "c-exp.c" /* yacc.c:1646 */
3914 break;
3915
3916 case 251:
3917 #line 1604 "c-exp.y" /* yacc.c:1646 */
3918 { (yyval.sval) = operator_stoken (","); }
3919 #line 3921 "c-exp.c" /* yacc.c:1646 */
3920 break;
3921
3922 case 252:
3923 #line 1606 "c-exp.y" /* yacc.c:1646 */
3924 { (yyval.sval) = operator_stoken ("->*"); }
3925 #line 3927 "c-exp.c" /* yacc.c:1646 */
3926 break;
3927
3928 case 253:
3929 #line 1608 "c-exp.y" /* yacc.c:1646 */
3930 { (yyval.sval) = operator_stoken ("->"); }
3931 #line 3933 "c-exp.c" /* yacc.c:1646 */
3932 break;
3933
3934 case 254:
3935 #line 1610 "c-exp.y" /* yacc.c:1646 */
3936 { (yyval.sval) = operator_stoken ("()"); }
3937 #line 3939 "c-exp.c" /* yacc.c:1646 */
3938 break;
3939
3940 case 255:
3941 #line 1612 "c-exp.y" /* yacc.c:1646 */
3942 { (yyval.sval) = operator_stoken ("[]"); }
3943 #line 3945 "c-exp.c" /* yacc.c:1646 */
3944 break;
3945
3946 case 256:
3947 #line 1614 "c-exp.y" /* yacc.c:1646 */
3948 { (yyval.sval) = operator_stoken ("[]"); }
3949 #line 3951 "c-exp.c" /* yacc.c:1646 */
3950 break;
3951
3952 case 257:
3953 #line 1616 "c-exp.y" /* yacc.c:1646 */
3954 { string_file buf;
3955
3956 c_print_type ((yyvsp[0].tval), NULL, &buf, -1, 0,
3957 &type_print_raw_options);
3958
3959 /* This also needs canonicalization. */
3960 std::string canon
3961 = cp_canonicalize_string (buf.c_str ());
3962 if (canon.empty ())
3963 canon = std::move (buf.string ());
3964 (yyval.sval) = operator_stoken ((" " + canon).c_str ());
3965 }
3966 #line 3968 "c-exp.c" /* yacc.c:1646 */
3967 break;
3968
3969 case 258:
3970 #line 1632 "c-exp.y" /* yacc.c:1646 */
3971 { (yyval.sval) = (yyvsp[0].ssym).stoken; }
3972 #line 3974 "c-exp.c" /* yacc.c:1646 */
3973 break;
3974
3975 case 259:
3976 #line 1633 "c-exp.y" /* yacc.c:1646 */
3977 { (yyval.sval) = (yyvsp[0].ssym).stoken; }
3978 #line 3980 "c-exp.c" /* yacc.c:1646 */
3979 break;
3980
3981 case 260:
3982 #line 1634 "c-exp.y" /* yacc.c:1646 */
3983 { (yyval.sval) = (yyvsp[0].tsym).stoken; }
3984 #line 3986 "c-exp.c" /* yacc.c:1646 */
3985 break;
3986
3987 case 261:
3988 #line 1635 "c-exp.y" /* yacc.c:1646 */
3989 { (yyval.sval) = (yyvsp[0].ssym).stoken; }
3990 #line 3992 "c-exp.c" /* yacc.c:1646 */
3991 break;
3992
3993 case 262:
3994 #line 1636 "c-exp.y" /* yacc.c:1646 */
3995 { (yyval.sval) = (yyvsp[0].ssym).stoken; }
3996 #line 3998 "c-exp.c" /* yacc.c:1646 */
3997 break;
3998
3999 case 263:
4000 #line 1637 "c-exp.y" /* yacc.c:1646 */
4001 { (yyval.sval) = (yyvsp[0].sval); }
4002 #line 4004 "c-exp.c" /* yacc.c:1646 */
4003 break;
4004
4005 case 266:
4006 #line 1650 "c-exp.y" /* yacc.c:1646 */
4007 {
4008 struct field_of_this_result is_a_field_of_this;
4009
4010 (yyval.ssym).stoken = (yyvsp[0].sval);
4011 (yyval.ssym).sym = lookup_symbol ((yyvsp[0].sval).ptr,
4012 expression_context_block,
4013 VAR_DOMAIN,
4014 &is_a_field_of_this);
4015 (yyval.ssym).is_a_field_of_this
4016 = is_a_field_of_this.type != NULL;
4017 }
4018 #line 4020 "c-exp.c" /* yacc.c:1646 */
4019 break;
4020
4021
4022 #line 4024 "c-exp.c" /* yacc.c:1646 */
4023 default: break;
4024 }
4025 /* User semantic actions sometimes alter yychar, and that requires
4026 that yytoken be updated with the new translation. We take the
4027 approach of translating immediately before every use of yytoken.
4028 One alternative is translating here after every semantic action,
4029 but that translation would be missed if the semantic action invokes
4030 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
4031 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
4032 incorrect destructor might then be invoked immediately. In the
4033 case of YYERROR or YYBACKUP, subsequent parser actions might lead
4034 to an incorrect destructor call or verbose syntax error message
4035 before the lookahead is translated. */
4036 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
4037
4038 YYPOPSTACK (yylen);
4039 yylen = 0;
4040 YY_STACK_PRINT (yyss, yyssp);
4041
4042 *++yyvsp = yyval;
4043
4044 /* Now 'shift' the result of the reduction. Determine what state
4045 that goes to, based on the state we popped back to and the rule
4046 number reduced by. */
4047
4048 yyn = yyr1[yyn];
4049
4050 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
4051 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
4052 yystate = yytable[yystate];
4053 else
4054 yystate = yydefgoto[yyn - YYNTOKENS];
4055
4056 goto yynewstate;
4057
4058
4059 /*--------------------------------------.
4060 | yyerrlab -- here on detecting error. |
4061 `--------------------------------------*/
4062 yyerrlab:
4063 /* Make sure we have latest lookahead translation. See comments at
4064 user semantic actions for why this is necessary. */
4065 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
4066
4067 /* If not already recovering from an error, report this error. */
4068 if (!yyerrstatus)
4069 {
4070 ++yynerrs;
4071 #if ! YYERROR_VERBOSE
4072 yyerror (YY_("syntax error"));
4073 #else
4074 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
4075 yyssp, yytoken)
4076 {
4077 char const *yymsgp = YY_("syntax error");
4078 int yysyntax_error_status;
4079 yysyntax_error_status = YYSYNTAX_ERROR;
4080 if (yysyntax_error_status == 0)
4081 yymsgp = yymsg;
4082 else if (yysyntax_error_status == 1)
4083 {
4084 if (yymsg != yymsgbuf)
4085 YYSTACK_FREE (yymsg);
4086 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
4087 if (!yymsg)
4088 {
4089 yymsg = yymsgbuf;
4090 yymsg_alloc = sizeof yymsgbuf;
4091 yysyntax_error_status = 2;
4092 }
4093 else
4094 {
4095 yysyntax_error_status = YYSYNTAX_ERROR;
4096 yymsgp = yymsg;
4097 }
4098 }
4099 yyerror (yymsgp);
4100 if (yysyntax_error_status == 2)
4101 goto yyexhaustedlab;
4102 }
4103 # undef YYSYNTAX_ERROR
4104 #endif
4105 }
4106
4107
4108
4109 if (yyerrstatus == 3)
4110 {
4111 /* If just tried and failed to reuse lookahead token after an
4112 error, discard it. */
4113
4114 if (yychar <= YYEOF)
4115 {
4116 /* Return failure if at end of input. */
4117 if (yychar == YYEOF)
4118 YYABORT;
4119 }
4120 else
4121 {
4122 yydestruct ("Error: discarding",
4123 yytoken, &yylval);
4124 yychar = YYEMPTY;
4125 }
4126 }
4127
4128 /* Else will try to reuse lookahead token after shifting the error
4129 token. */
4130 goto yyerrlab1;
4131
4132
4133 /*---------------------------------------------------.
4134 | yyerrorlab -- error raised explicitly by YYERROR. |
4135 `---------------------------------------------------*/
4136 yyerrorlab:
4137
4138 /* Pacify compilers like GCC when the user code never invokes
4139 YYERROR and the label yyerrorlab therefore never appears in user
4140 code. */
4141 if (/*CONSTCOND*/ 0)
4142 goto yyerrorlab;
4143
4144 /* Do not reclaim the symbols of the rule whose action triggered
4145 this YYERROR. */
4146 YYPOPSTACK (yylen);
4147 yylen = 0;
4148 YY_STACK_PRINT (yyss, yyssp);
4149 yystate = *yyssp;
4150 goto yyerrlab1;
4151
4152
4153 /*-------------------------------------------------------------.
4154 | yyerrlab1 -- common code for both syntax error and YYERROR. |
4155 `-------------------------------------------------------------*/
4156 yyerrlab1:
4157 yyerrstatus = 3; /* Each real token shifted decrements this. */
4158
4159 for (;;)
4160 {
4161 yyn = yypact[yystate];
4162 if (!yypact_value_is_default (yyn))
4163 {
4164 yyn += YYTERROR;
4165 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
4166 {
4167 yyn = yytable[yyn];
4168 if (0 < yyn)
4169 break;
4170 }
4171 }
4172
4173 /* Pop the current state because it cannot handle the error token. */
4174 if (yyssp == yyss)
4175 YYABORT;
4176
4177
4178 yydestruct ("Error: popping",
4179 yystos[yystate], yyvsp);
4180 YYPOPSTACK (1);
4181 yystate = *yyssp;
4182 YY_STACK_PRINT (yyss, yyssp);
4183 }
4184
4185 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
4186 *++yyvsp = yylval;
4187 YY_IGNORE_MAYBE_UNINITIALIZED_END
4188
4189
4190 /* Shift the error token. */
4191 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
4192
4193 yystate = yyn;
4194 goto yynewstate;
4195
4196
4197 /*-------------------------------------.
4198 | yyacceptlab -- YYACCEPT comes here. |
4199 `-------------------------------------*/
4200 yyacceptlab:
4201 yyresult = 0;
4202 goto yyreturn;
4203
4204 /*-----------------------------------.
4205 | yyabortlab -- YYABORT comes here. |
4206 `-----------------------------------*/
4207 yyabortlab:
4208 yyresult = 1;
4209 goto yyreturn;
4210
4211 #if !defined yyoverflow || YYERROR_VERBOSE
4212 /*-------------------------------------------------.
4213 | yyexhaustedlab -- memory exhaustion comes here. |
4214 `-------------------------------------------------*/
4215 yyexhaustedlab:
4216 yyerror (YY_("memory exhausted"));
4217 yyresult = 2;
4218 /* Fall through. */
4219 #endif
4220
4221 yyreturn:
4222 if (yychar != YYEMPTY)
4223 {
4224 /* Make sure we have latest lookahead translation. See comments at
4225 user semantic actions for why this is necessary. */
4226 yytoken = YYTRANSLATE (yychar);
4227 yydestruct ("Cleanup: discarding lookahead",
4228 yytoken, &yylval);
4229 }
4230 /* Do not reclaim the symbols of the rule whose action triggered
4231 this YYABORT or YYACCEPT. */
4232 YYPOPSTACK (yylen);
4233 YY_STACK_PRINT (yyss, yyssp);
4234 while (yyssp != yyss)
4235 {
4236 yydestruct ("Cleanup: popping",
4237 yystos[*yyssp], yyvsp);
4238 YYPOPSTACK (1);
4239 }
4240 #ifndef yyoverflow
4241 if (yyss != yyssa)
4242 YYSTACK_FREE (yyss);
4243 #endif
4244 #if YYERROR_VERBOSE
4245 if (yymsg != yymsgbuf)
4246 YYSTACK_FREE (yymsg);
4247 #endif
4248 return yyresult;
4249 }
4250 #line 1664 "c-exp.y" /* yacc.c:1906 */
4251
4252
4253 /* Like write_exp_string, but prepends a '~'. */
4254
4255 static void
4256 write_destructor_name (struct parser_state *par_state, struct stoken token)
4257 {
4258 char *copy = (char *) alloca (token.length + 1);
4259
4260 copy[0] = '~';
4261 memcpy (&copy[1], token.ptr, token.length);
4262
4263 token.ptr = copy;
4264 ++token.length;
4265
4266 write_exp_string (par_state, token);
4267 }
4268
4269 /* Returns a stoken of the operator name given by OP (which does not
4270 include the string "operator"). */
4271
4272 static struct stoken
4273 operator_stoken (const char *op)
4274 {
4275 struct stoken st = { NULL, 0 };
4276 char *buf;
4277
4278 st.length = CP_OPERATOR_LEN + strlen (op);
4279 buf = (char *) xmalloc (st.length + 1);
4280 strcpy (buf, CP_OPERATOR_STR);
4281 strcat (buf, op);
4282 st.ptr = buf;
4283
4284 /* The toplevel (c_parse) will free the memory allocated here. */
4285 make_cleanup (xfree, buf);
4286 return st;
4287 };
4288
4289 /* Return true if the type is aggregate-like. */
4290
4291 static int
4292 type_aggregate_p (struct type *type)
4293 {
4294 return (TYPE_CODE (type) == TYPE_CODE_STRUCT
4295 || TYPE_CODE (type) == TYPE_CODE_UNION
4296 || TYPE_CODE (type) == TYPE_CODE_NAMESPACE
4297 || (TYPE_CODE (type) == TYPE_CODE_ENUM
4298 && TYPE_DECLARED_CLASS (type)));
4299 }
4300
4301 /* Validate a parameter typelist. */
4302
4303 static void
4304 check_parameter_typelist (VEC (type_ptr) *params)
4305 {
4306 struct type *type;
4307 int ix;
4308
4309 for (ix = 0; VEC_iterate (type_ptr, params, ix, type); ++ix)
4310 {
4311 if (type != NULL && TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
4312 {
4313 if (ix == 0)
4314 {
4315 if (VEC_length (type_ptr, params) == 1)
4316 {
4317 /* Ok. */
4318 break;
4319 }
4320 VEC_free (type_ptr, params);
4321 error (_("parameter types following 'void'"));
4322 }
4323 else
4324 {
4325 VEC_free (type_ptr, params);
4326 error (_("'void' invalid as parameter type"));
4327 }
4328 }
4329 }
4330 }
4331
4332 /* Take care of parsing a number (anything that starts with a digit).
4333 Set yylval and return the token type; update lexptr.
4334 LEN is the number of characters in it. */
4335
4336 /*** Needs some error checking for the float case ***/
4337
4338 static int
4339 parse_number (struct parser_state *par_state,
4340 const char *buf, int len, int parsed_float, YYSTYPE *putithere)
4341 {
4342 /* FIXME: Shouldn't these be unsigned? We don't deal with negative values
4343 here, and we do kind of silly things like cast to unsigned. */
4344 LONGEST n = 0;
4345 LONGEST prevn = 0;
4346 ULONGEST un;
4347
4348 int i = 0;
4349 int c;
4350 int base = input_radix;
4351 int unsigned_p = 0;
4352
4353 /* Number of "L" suffixes encountered. */
4354 int long_p = 0;
4355
4356 /* We have found a "L" or "U" suffix. */
4357 int found_suffix = 0;
4358
4359 ULONGEST high_bit;
4360 struct type *signed_type;
4361 struct type *unsigned_type;
4362 char *p;
4363
4364 p = (char *) alloca (len);
4365 memcpy (p, buf, len);
4366
4367 if (parsed_float)
4368 {
4369 /* Handle suffixes for decimal floating-point: "df", "dd" or "dl". */
4370 if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'f')
4371 {
4372 putithere->typed_val_float.type
4373 = parse_type (par_state)->builtin_decfloat;
4374 len -= 2;
4375 }
4376 else if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'd')
4377 {
4378 putithere->typed_val_float.type
4379 = parse_type (par_state)->builtin_decdouble;
4380 len -= 2;
4381 }
4382 else if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'l')
4383 {
4384 putithere->typed_val_float.type
4385 = parse_type (par_state)->builtin_declong;
4386 len -= 2;
4387 }
4388 /* Handle suffixes: 'f' for float, 'l' for long double. */
4389 else if (len >= 1 && tolower (p[len - 1]) == 'f')
4390 {
4391 putithere->typed_val_float.type
4392 = parse_type (par_state)->builtin_float;
4393 len -= 1;
4394 }
4395 else if (len >= 1 && tolower (p[len - 1]) == 'l')
4396 {
4397 putithere->typed_val_float.type
4398 = parse_type (par_state)->builtin_long_double;
4399 len -= 1;
4400 }
4401 /* Default type for floating-point literals is double. */
4402 else
4403 {
4404 putithere->typed_val_float.type
4405 = parse_type (par_state)->builtin_double;
4406 }
4407
4408 if (!parse_float (p, len,
4409 putithere->typed_val_float.type,
4410 putithere->typed_val_float.val))
4411 return ERROR;
4412 return FLOAT;
4413 }
4414
4415 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
4416 if (p[0] == '0' && len > 1)
4417 switch (p[1])
4418 {
4419 case 'x':
4420 case 'X':
4421 if (len >= 3)
4422 {
4423 p += 2;
4424 base = 16;
4425 len -= 2;
4426 }
4427 break;
4428
4429 case 'b':
4430 case 'B':
4431 if (len >= 3)
4432 {
4433 p += 2;
4434 base = 2;
4435 len -= 2;
4436 }
4437 break;
4438
4439 case 't':
4440 case 'T':
4441 case 'd':
4442 case 'D':
4443 if (len >= 3)
4444 {
4445 p += 2;
4446 base = 10;
4447 len -= 2;
4448 }
4449 break;
4450
4451 default:
4452 base = 8;
4453 break;
4454 }
4455
4456 while (len-- > 0)
4457 {
4458 c = *p++;
4459 if (c >= 'A' && c <= 'Z')
4460 c += 'a' - 'A';
4461 if (c != 'l' && c != 'u')
4462 n *= base;
4463 if (c >= '0' && c <= '9')
4464 {
4465 if (found_suffix)
4466 return ERROR;
4467 n += i = c - '0';
4468 }
4469 else
4470 {
4471 if (base > 10 && c >= 'a' && c <= 'f')
4472 {
4473 if (found_suffix)
4474 return ERROR;
4475 n += i = c - 'a' + 10;
4476 }
4477 else if (c == 'l')
4478 {
4479 ++long_p;
4480 found_suffix = 1;
4481 }
4482 else if (c == 'u')
4483 {
4484 unsigned_p = 1;
4485 found_suffix = 1;
4486 }
4487 else
4488 return ERROR; /* Char not a digit */
4489 }
4490 if (i >= base)
4491 return ERROR; /* Invalid digit in this base */
4492
4493 /* Portably test for overflow (only works for nonzero values, so make
4494 a second check for zero). FIXME: Can't we just make n and prevn
4495 unsigned and avoid this? */
4496 if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
4497 unsigned_p = 1; /* Try something unsigned */
4498
4499 /* Portably test for unsigned overflow.
4500 FIXME: This check is wrong; for example it doesn't find overflow
4501 on 0x123456789 when LONGEST is 32 bits. */
4502 if (c != 'l' && c != 'u' && n != 0)
4503 {
4504 if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n))
4505 error (_("Numeric constant too large."));
4506 }
4507 prevn = n;
4508 }
4509
4510 /* An integer constant is an int, a long, or a long long. An L
4511 suffix forces it to be long; an LL suffix forces it to be long
4512 long. If not forced to a larger size, it gets the first type of
4513 the above that it fits in. To figure out whether it fits, we
4514 shift it right and see whether anything remains. Note that we
4515 can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
4516 operation, because many compilers will warn about such a shift
4517 (which always produces a zero result). Sometimes gdbarch_int_bit
4518 or gdbarch_long_bit will be that big, sometimes not. To deal with
4519 the case where it is we just always shift the value more than
4520 once, with fewer bits each time. */
4521
4522 un = (ULONGEST)n >> 2;
4523 if (long_p == 0
4524 && (un >> (gdbarch_int_bit (parse_gdbarch (par_state)) - 2)) == 0)
4525 {
4526 high_bit
4527 = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch (par_state)) - 1);
4528
4529 /* A large decimal (not hex or octal) constant (between INT_MAX
4530 and UINT_MAX) is a long or unsigned long, according to ANSI,
4531 never an unsigned int, but this code treats it as unsigned
4532 int. This probably should be fixed. GCC gives a warning on
4533 such constants. */
4534
4535 unsigned_type = parse_type (par_state)->builtin_unsigned_int;
4536 signed_type = parse_type (par_state)->builtin_int;
4537 }
4538 else if (long_p <= 1
4539 && (un >> (gdbarch_long_bit (parse_gdbarch (par_state)) - 2)) == 0)
4540 {
4541 high_bit
4542 = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch (par_state)) - 1);
4543 unsigned_type = parse_type (par_state)->builtin_unsigned_long;
4544 signed_type = parse_type (par_state)->builtin_long;
4545 }
4546 else
4547 {
4548 int shift;
4549 if (sizeof (ULONGEST) * HOST_CHAR_BIT
4550 < gdbarch_long_long_bit (parse_gdbarch (par_state)))
4551 /* A long long does not fit in a LONGEST. */
4552 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
4553 else
4554 shift = (gdbarch_long_long_bit (parse_gdbarch (par_state)) - 1);
4555 high_bit = (ULONGEST) 1 << shift;
4556 unsigned_type = parse_type (par_state)->builtin_unsigned_long_long;
4557 signed_type = parse_type (par_state)->builtin_long_long;
4558 }
4559
4560 putithere->typed_val_int.val = n;
4561
4562 /* If the high bit of the worked out type is set then this number
4563 has to be unsigned. */
4564
4565 if (unsigned_p || (n & high_bit))
4566 {
4567 putithere->typed_val_int.type = unsigned_type;
4568 }
4569 else
4570 {
4571 putithere->typed_val_int.type = signed_type;
4572 }
4573
4574 return INT;
4575 }
4576
4577 /* Temporary obstack used for holding strings. */
4578 static struct obstack tempbuf;
4579 static int tempbuf_init;
4580
4581 /* Parse a C escape sequence. The initial backslash of the sequence
4582 is at (*PTR)[-1]. *PTR will be updated to point to just after the
4583 last character of the sequence. If OUTPUT is not NULL, the
4584 translated form of the escape sequence will be written there. If
4585 OUTPUT is NULL, no output is written and the call will only affect
4586 *PTR. If an escape sequence is expressed in target bytes, then the
4587 entire sequence will simply be copied to OUTPUT. Return 1 if any
4588 character was emitted, 0 otherwise. */
4589
4590 int
4591 c_parse_escape (const char **ptr, struct obstack *output)
4592 {
4593 const char *tokptr = *ptr;
4594 int result = 1;
4595
4596 /* Some escape sequences undergo character set conversion. Those we
4597 translate here. */
4598 switch (*tokptr)
4599 {
4600 /* Hex escapes do not undergo character set conversion, so keep
4601 the escape sequence for later. */
4602 case 'x':
4603 if (output)
4604 obstack_grow_str (output, "\\x");
4605 ++tokptr;
4606 if (!isxdigit (*tokptr))
4607 error (_("\\x escape without a following hex digit"));
4608 while (isxdigit (*tokptr))
4609 {
4610 if (output)
4611 obstack_1grow (output, *tokptr);
4612 ++tokptr;
4613 }
4614 break;
4615
4616 /* Octal escapes do not undergo character set conversion, so
4617 keep the escape sequence for later. */
4618 case '0':
4619 case '1':
4620 case '2':
4621 case '3':
4622 case '4':
4623 case '5':
4624 case '6':
4625 case '7':
4626 {
4627 int i;
4628 if (output)
4629 obstack_grow_str (output, "\\");
4630 for (i = 0;
4631 i < 3 && isdigit (*tokptr) && *tokptr != '8' && *tokptr != '9';
4632 ++i)
4633 {
4634 if (output)
4635 obstack_1grow (output, *tokptr);
4636 ++tokptr;
4637 }
4638 }
4639 break;
4640
4641 /* We handle UCNs later. We could handle them here, but that
4642 would mean a spurious error in the case where the UCN could
4643 be converted to the target charset but not the host
4644 charset. */
4645 case 'u':
4646 case 'U':
4647 {
4648 char c = *tokptr;
4649 int i, len = c == 'U' ? 8 : 4;
4650 if (output)
4651 {
4652 obstack_1grow (output, '\\');
4653 obstack_1grow (output, *tokptr);
4654 }
4655 ++tokptr;
4656 if (!isxdigit (*tokptr))
4657 error (_("\\%c escape without a following hex digit"), c);
4658 for (i = 0; i < len && isxdigit (*tokptr); ++i)
4659 {
4660 if (output)
4661 obstack_1grow (output, *tokptr);
4662 ++tokptr;
4663 }
4664 }
4665 break;
4666
4667 /* We must pass backslash through so that it does not
4668 cause quoting during the second expansion. */
4669 case '\\':
4670 if (output)
4671 obstack_grow_str (output, "\\\\");
4672 ++tokptr;
4673 break;
4674
4675 /* Escapes which undergo conversion. */
4676 case 'a':
4677 if (output)
4678 obstack_1grow (output, '\a');
4679 ++tokptr;
4680 break;
4681 case 'b':
4682 if (output)
4683 obstack_1grow (output, '\b');
4684 ++tokptr;
4685 break;
4686 case 'f':
4687 if (output)
4688 obstack_1grow (output, '\f');
4689 ++tokptr;
4690 break;
4691 case 'n':
4692 if (output)
4693 obstack_1grow (output, '\n');
4694 ++tokptr;
4695 break;
4696 case 'r':
4697 if (output)
4698 obstack_1grow (output, '\r');
4699 ++tokptr;
4700 break;
4701 case 't':
4702 if (output)
4703 obstack_1grow (output, '\t');
4704 ++tokptr;
4705 break;
4706 case 'v':
4707 if (output)
4708 obstack_1grow (output, '\v');
4709 ++tokptr;
4710 break;
4711
4712 /* GCC extension. */
4713 case 'e':
4714 if (output)
4715 obstack_1grow (output, HOST_ESCAPE_CHAR);
4716 ++tokptr;
4717 break;
4718
4719 /* Backslash-newline expands to nothing at all. */
4720 case '\n':
4721 ++tokptr;
4722 result = 0;
4723 break;
4724
4725 /* A few escapes just expand to the character itself. */
4726 case '\'':
4727 case '\"':
4728 case '?':
4729 /* GCC extensions. */
4730 case '(':
4731 case '{':
4732 case '[':
4733 case '%':
4734 /* Unrecognized escapes turn into the character itself. */
4735 default:
4736 if (output)
4737 obstack_1grow (output, *tokptr);
4738 ++tokptr;
4739 break;
4740 }
4741 *ptr = tokptr;
4742 return result;
4743 }
4744
4745 /* Parse a string or character literal from TOKPTR. The string or
4746 character may be wide or unicode. *OUTPTR is set to just after the
4747 end of the literal in the input string. The resulting token is
4748 stored in VALUE. This returns a token value, either STRING or
4749 CHAR, depending on what was parsed. *HOST_CHARS is set to the
4750 number of host characters in the literal. */
4751
4752 static int
4753 parse_string_or_char (const char *tokptr, const char **outptr,
4754 struct typed_stoken *value, int *host_chars)
4755 {
4756 int quote;
4757 c_string_type type;
4758 int is_objc = 0;
4759
4760 /* Build the gdb internal form of the input string in tempbuf. Note
4761 that the buffer is null byte terminated *only* for the
4762 convenience of debugging gdb itself and printing the buffer
4763 contents when the buffer contains no embedded nulls. Gdb does
4764 not depend upon the buffer being null byte terminated, it uses
4765 the length string instead. This allows gdb to handle C strings
4766 (as well as strings in other languages) with embedded null
4767 bytes */
4768
4769 if (!tempbuf_init)
4770 tempbuf_init = 1;
4771 else
4772 obstack_free (&tempbuf, NULL);
4773 obstack_init (&tempbuf);
4774
4775 /* Record the string type. */
4776 if (*tokptr == 'L')
4777 {
4778 type = C_WIDE_STRING;
4779 ++tokptr;
4780 }
4781 else if (*tokptr == 'u')
4782 {
4783 type = C_STRING_16;
4784 ++tokptr;
4785 }
4786 else if (*tokptr == 'U')
4787 {
4788 type = C_STRING_32;
4789 ++tokptr;
4790 }
4791 else if (*tokptr == '@')
4792 {
4793 /* An Objective C string. */
4794 is_objc = 1;
4795 type = C_STRING;
4796 ++tokptr;
4797 }
4798 else
4799 type = C_STRING;
4800
4801 /* Skip the quote. */
4802 quote = *tokptr;
4803 if (quote == '\'')
4804 type |= C_CHAR;
4805 ++tokptr;
4806
4807 *host_chars = 0;
4808
4809 while (*tokptr)
4810 {
4811 char c = *tokptr;
4812 if (c == '\\')
4813 {
4814 ++tokptr;
4815 *host_chars += c_parse_escape (&tokptr, &tempbuf);
4816 }
4817 else if (c == quote)
4818 break;
4819 else
4820 {
4821 obstack_1grow (&tempbuf, c);
4822 ++tokptr;
4823 /* FIXME: this does the wrong thing with multi-byte host
4824 characters. We could use mbrlen here, but that would
4825 make "set host-charset" a bit less useful. */
4826 ++*host_chars;
4827 }
4828 }
4829
4830 if (*tokptr != quote)
4831 {
4832 if (quote == '"')
4833 error (_("Unterminated string in expression."));
4834 else
4835 error (_("Unmatched single quote."));
4836 }
4837 ++tokptr;
4838
4839 value->type = type;
4840 value->ptr = (char *) obstack_base (&tempbuf);
4841 value->length = obstack_object_size (&tempbuf);
4842
4843 *outptr = tokptr;
4844
4845 return quote == '"' ? (is_objc ? NSSTRING : STRING) : CHAR;
4846 }
4847
4848 /* This is used to associate some attributes with a token. */
4849
4850 enum token_flag
4851 {
4852 /* If this bit is set, the token is C++-only. */
4853
4854 FLAG_CXX = 1,
4855
4856 /* If this bit is set, the token is conditional: if there is a
4857 symbol of the same name, then the token is a symbol; otherwise,
4858 the token is a keyword. */
4859
4860 FLAG_SHADOW = 2
4861 };
4862 DEF_ENUM_FLAGS_TYPE (enum token_flag, token_flags);
4863
4864 struct token
4865 {
4866 const char *oper;
4867 int token;
4868 enum exp_opcode opcode;
4869 token_flags flags;
4870 };
4871
4872 static const struct token tokentab3[] =
4873 {
4874 {">>=", ASSIGN_MODIFY, BINOP_RSH, 0},
4875 {"<<=", ASSIGN_MODIFY, BINOP_LSH, 0},
4876 {"->*", ARROW_STAR, BINOP_END, FLAG_CXX},
4877 {"...", DOTDOTDOT, BINOP_END, 0}
4878 };
4879
4880 static const struct token tokentab2[] =
4881 {
4882 {"+=", ASSIGN_MODIFY, BINOP_ADD, 0},
4883 {"-=", ASSIGN_MODIFY, BINOP_SUB, 0},
4884 {"*=", ASSIGN_MODIFY, BINOP_MUL, 0},
4885 {"/=", ASSIGN_MODIFY, BINOP_DIV, 0},
4886 {"%=", ASSIGN_MODIFY, BINOP_REM, 0},
4887 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR, 0},
4888 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND, 0},
4889 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR, 0},
4890 {"++", INCREMENT, BINOP_END, 0},
4891 {"--", DECREMENT, BINOP_END, 0},
4892 {"->", ARROW, BINOP_END, 0},
4893 {"&&", ANDAND, BINOP_END, 0},
4894 {"||", OROR, BINOP_END, 0},
4895 /* "::" is *not* only C++: gdb overrides its meaning in several
4896 different ways, e.g., 'filename'::func, function::variable. */
4897 {"::", COLONCOLON, BINOP_END, 0},
4898 {"<<", LSH, BINOP_END, 0},
4899 {">>", RSH, BINOP_END, 0},
4900 {"==", EQUAL, BINOP_END, 0},
4901 {"!=", NOTEQUAL, BINOP_END, 0},
4902 {"<=", LEQ, BINOP_END, 0},
4903 {">=", GEQ, BINOP_END, 0},
4904 {".*", DOT_STAR, BINOP_END, FLAG_CXX}
4905 };
4906
4907 /* Identifier-like tokens. */
4908 static const struct token ident_tokens[] =
4909 {
4910 {"unsigned", UNSIGNED, OP_NULL, 0},
4911 {"template", TEMPLATE, OP_NULL, FLAG_CXX},
4912 {"volatile", VOLATILE_KEYWORD, OP_NULL, 0},
4913 {"struct", STRUCT, OP_NULL, 0},
4914 {"signed", SIGNED_KEYWORD, OP_NULL, 0},
4915 {"sizeof", SIZEOF, OP_NULL, 0},
4916 {"double", DOUBLE_KEYWORD, OP_NULL, 0},
4917 {"false", FALSEKEYWORD, OP_NULL, FLAG_CXX},
4918 {"class", CLASS, OP_NULL, FLAG_CXX},
4919 {"union", UNION, OP_NULL, 0},
4920 {"short", SHORT, OP_NULL, 0},
4921 {"const", CONST_KEYWORD, OP_NULL, 0},
4922 {"enum", ENUM, OP_NULL, 0},
4923 {"long", LONG, OP_NULL, 0},
4924 {"true", TRUEKEYWORD, OP_NULL, FLAG_CXX},
4925 {"int", INT_KEYWORD, OP_NULL, 0},
4926 {"new", NEW, OP_NULL, FLAG_CXX},
4927 {"delete", DELETE, OP_NULL, FLAG_CXX},
4928 {"operator", OPERATOR, OP_NULL, FLAG_CXX},
4929
4930 {"and", ANDAND, BINOP_END, FLAG_CXX},
4931 {"and_eq", ASSIGN_MODIFY, BINOP_BITWISE_AND, FLAG_CXX},
4932 {"bitand", '&', OP_NULL, FLAG_CXX},
4933 {"bitor", '|', OP_NULL, FLAG_CXX},
4934 {"compl", '~', OP_NULL, FLAG_CXX},
4935 {"not", '!', OP_NULL, FLAG_CXX},
4936 {"not_eq", NOTEQUAL, BINOP_END, FLAG_CXX},
4937 {"or", OROR, BINOP_END, FLAG_CXX},
4938 {"or_eq", ASSIGN_MODIFY, BINOP_BITWISE_IOR, FLAG_CXX},
4939 {"xor", '^', OP_NULL, FLAG_CXX},
4940 {"xor_eq", ASSIGN_MODIFY, BINOP_BITWISE_XOR, FLAG_CXX},
4941
4942 {"const_cast", CONST_CAST, OP_NULL, FLAG_CXX },
4943 {"dynamic_cast", DYNAMIC_CAST, OP_NULL, FLAG_CXX },
4944 {"static_cast", STATIC_CAST, OP_NULL, FLAG_CXX },
4945 {"reinterpret_cast", REINTERPRET_CAST, OP_NULL, FLAG_CXX },
4946
4947 {"__typeof__", TYPEOF, OP_TYPEOF, 0 },
4948 {"__typeof", TYPEOF, OP_TYPEOF, 0 },
4949 {"typeof", TYPEOF, OP_TYPEOF, FLAG_SHADOW },
4950 {"__decltype", DECLTYPE, OP_DECLTYPE, FLAG_CXX },
4951 {"decltype", DECLTYPE, OP_DECLTYPE, FLAG_CXX | FLAG_SHADOW },
4952
4953 {"typeid", TYPEID, OP_TYPEID, FLAG_CXX}
4954 };
4955
4956 /* When we find that lexptr (the global var defined in parse.c) is
4957 pointing at a macro invocation, we expand the invocation, and call
4958 scan_macro_expansion to save the old lexptr here and point lexptr
4959 into the expanded text. When we reach the end of that, we call
4960 end_macro_expansion to pop back to the value we saved here. The
4961 macro expansion code promises to return only fully-expanded text,
4962 so we don't need to "push" more than one level.
4963
4964 This is disgusting, of course. It would be cleaner to do all macro
4965 expansion beforehand, and then hand that to lexptr. But we don't
4966 really know where the expression ends. Remember, in a command like
4967
4968 (gdb) break *ADDRESS if CONDITION
4969
4970 we evaluate ADDRESS in the scope of the current frame, but we
4971 evaluate CONDITION in the scope of the breakpoint's location. So
4972 it's simply wrong to try to macro-expand the whole thing at once. */
4973 static const char *macro_original_text;
4974
4975 /* We save all intermediate macro expansions on this obstack for the
4976 duration of a single parse. The expansion text may sometimes have
4977 to live past the end of the expansion, due to yacc lookahead.
4978 Rather than try to be clever about saving the data for a single
4979 token, we simply keep it all and delete it after parsing has
4980 completed. */
4981 static struct obstack expansion_obstack;
4982
4983 static void
4984 scan_macro_expansion (char *expansion)
4985 {
4986 char *copy;
4987
4988 /* We'd better not be trying to push the stack twice. */
4989 gdb_assert (! macro_original_text);
4990
4991 /* Copy to the obstack, and then free the intermediate
4992 expansion. */
4993 copy = (char *) obstack_copy0 (&expansion_obstack, expansion,
4994 strlen (expansion));
4995 xfree (expansion);
4996
4997 /* Save the old lexptr value, so we can return to it when we're done
4998 parsing the expanded text. */
4999 macro_original_text = lexptr;
5000 lexptr = copy;
5001 }
5002
5003 static int
5004 scanning_macro_expansion (void)
5005 {
5006 return macro_original_text != 0;
5007 }
5008
5009 static void
5010 finished_macro_expansion (void)
5011 {
5012 /* There'd better be something to pop back to. */
5013 gdb_assert (macro_original_text);
5014
5015 /* Pop back to the original text. */
5016 lexptr = macro_original_text;
5017 macro_original_text = 0;
5018 }
5019
5020 static void
5021 scan_macro_cleanup (void *dummy)
5022 {
5023 if (macro_original_text)
5024 finished_macro_expansion ();
5025
5026 obstack_free (&expansion_obstack, NULL);
5027 }
5028
5029 /* Return true iff the token represents a C++ cast operator. */
5030
5031 static int
5032 is_cast_operator (const char *token, int len)
5033 {
5034 return (! strncmp (token, "dynamic_cast", len)
5035 || ! strncmp (token, "static_cast", len)
5036 || ! strncmp (token, "reinterpret_cast", len)
5037 || ! strncmp (token, "const_cast", len));
5038 }
5039
5040 /* The scope used for macro expansion. */
5041 static struct macro_scope *expression_macro_scope;
5042
5043 /* This is set if a NAME token appeared at the very end of the input
5044 string, with no whitespace separating the name from the EOF. This
5045 is used only when parsing to do field name completion. */
5046 static int saw_name_at_eof;
5047
5048 /* This is set if the previously-returned token was a structure
5049 operator -- either '.' or ARROW. This is used only when parsing to
5050 do field name completion. */
5051 static int last_was_structop;
5052
5053 /* Read one token, getting characters through lexptr. */
5054
5055 static int
5056 lex_one_token (struct parser_state *par_state, int *is_quoted_name)
5057 {
5058 int c;
5059 int namelen;
5060 unsigned int i;
5061 const char *tokstart;
5062 int saw_structop = last_was_structop;
5063 char *copy;
5064
5065 last_was_structop = 0;
5066 *is_quoted_name = 0;
5067
5068 retry:
5069
5070 /* Check if this is a macro invocation that we need to expand. */
5071 if (! scanning_macro_expansion ())
5072 {
5073 char *expanded = macro_expand_next (&lexptr,
5074 standard_macro_lookup,
5075 expression_macro_scope);
5076
5077 if (expanded)
5078 scan_macro_expansion (expanded);
5079 }
5080
5081 prev_lexptr = lexptr;
5082
5083 tokstart = lexptr;
5084 /* See if it is a special token of length 3. */
5085 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
5086 if (strncmp (tokstart, tokentab3[i].oper, 3) == 0)
5087 {
5088 if ((tokentab3[i].flags & FLAG_CXX) != 0
5089 && parse_language (par_state)->la_language != language_cplus)
5090 break;
5091
5092 lexptr += 3;
5093 yylval.opcode = tokentab3[i].opcode;
5094 return tokentab3[i].token;
5095 }
5096
5097 /* See if it is a special token of length 2. */
5098 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
5099 if (strncmp (tokstart, tokentab2[i].oper, 2) == 0)
5100 {
5101 if ((tokentab2[i].flags & FLAG_CXX) != 0
5102 && parse_language (par_state)->la_language != language_cplus)
5103 break;
5104
5105 lexptr += 2;
5106 yylval.opcode = tokentab2[i].opcode;
5107 if (parse_completion && tokentab2[i].token == ARROW)
5108 last_was_structop = 1;
5109 return tokentab2[i].token;
5110 }
5111
5112 switch (c = *tokstart)
5113 {
5114 case 0:
5115 /* If we were just scanning the result of a macro expansion,
5116 then we need to resume scanning the original text.
5117 If we're parsing for field name completion, and the previous
5118 token allows such completion, return a COMPLETE token.
5119 Otherwise, we were already scanning the original text, and
5120 we're really done. */
5121 if (scanning_macro_expansion ())
5122 {
5123 finished_macro_expansion ();
5124 goto retry;
5125 }
5126 else if (saw_name_at_eof)
5127 {
5128 saw_name_at_eof = 0;
5129 return COMPLETE;
5130 }
5131 else if (saw_structop)
5132 return COMPLETE;
5133 else
5134 return 0;
5135
5136 case ' ':
5137 case '\t':
5138 case '\n':
5139 lexptr++;
5140 goto retry;
5141
5142 case '[':
5143 case '(':
5144 paren_depth++;
5145 lexptr++;
5146 if (parse_language (par_state)->la_language == language_objc
5147 && c == '[')
5148 return OBJC_LBRAC;
5149 return c;
5150
5151 case ']':
5152 case ')':
5153 if (paren_depth == 0)
5154 return 0;
5155 paren_depth--;
5156 lexptr++;
5157 return c;
5158
5159 case ',':
5160 if (comma_terminates
5161 && paren_depth == 0
5162 && ! scanning_macro_expansion ())
5163 return 0;
5164 lexptr++;
5165 return c;
5166
5167 case '.':
5168 /* Might be a floating point number. */
5169 if (lexptr[1] < '0' || lexptr[1] > '9')
5170 {
5171 if (parse_completion)
5172 last_was_structop = 1;
5173 goto symbol; /* Nope, must be a symbol. */
5174 }
5175 /* FALL THRU into number case. */
5176
5177 case '0':
5178 case '1':
5179 case '2':
5180 case '3':
5181 case '4':
5182 case '5':
5183 case '6':
5184 case '7':
5185 case '8':
5186 case '9':
5187 {
5188 /* It's a number. */
5189 int got_dot = 0, got_e = 0, toktype;
5190 const char *p = tokstart;
5191 int hex = input_radix > 10;
5192
5193 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
5194 {
5195 p += 2;
5196 hex = 1;
5197 }
5198 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
5199 {
5200 p += 2;
5201 hex = 0;
5202 }
5203
5204 for (;; ++p)
5205 {
5206 /* This test includes !hex because 'e' is a valid hex digit
5207 and thus does not indicate a floating point number when
5208 the radix is hex. */
5209 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
5210 got_dot = got_e = 1;
5211 /* This test does not include !hex, because a '.' always indicates
5212 a decimal floating point number regardless of the radix. */
5213 else if (!got_dot && *p == '.')
5214 got_dot = 1;
5215 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
5216 && (*p == '-' || *p == '+'))
5217 /* This is the sign of the exponent, not the end of the
5218 number. */
5219 continue;
5220 /* We will take any letters or digits. parse_number will
5221 complain if past the radix, or if L or U are not final. */
5222 else if ((*p < '0' || *p > '9')
5223 && ((*p < 'a' || *p > 'z')
5224 && (*p < 'A' || *p > 'Z')))
5225 break;
5226 }
5227 toktype = parse_number (par_state, tokstart, p - tokstart,
5228 got_dot|got_e, &yylval);
5229 if (toktype == ERROR)
5230 {
5231 char *err_copy = (char *) alloca (p - tokstart + 1);
5232
5233 memcpy (err_copy, tokstart, p - tokstart);
5234 err_copy[p - tokstart] = 0;
5235 error (_("Invalid number \"%s\"."), err_copy);
5236 }
5237 lexptr = p;
5238 return toktype;
5239 }
5240
5241 case '@':
5242 {
5243 const char *p = &tokstart[1];
5244 size_t len = strlen ("entry");
5245
5246 if (parse_language (par_state)->la_language == language_objc)
5247 {
5248 size_t len = strlen ("selector");
5249
5250 if (strncmp (p, "selector", len) == 0
5251 && (p[len] == '\0' || isspace (p[len])))
5252 {
5253 lexptr = p + len;
5254 return SELECTOR;
5255 }
5256 else if (*p == '"')
5257 goto parse_string;
5258 }
5259
5260 while (isspace (*p))
5261 p++;
5262 if (strncmp (p, "entry", len) == 0 && !isalnum (p[len])
5263 && p[len] != '_')
5264 {
5265 lexptr = &p[len];
5266 return ENTRY;
5267 }
5268 }
5269 /* FALLTHRU */
5270 case '+':
5271 case '-':
5272 case '*':
5273 case '/':
5274 case '%':
5275 case '|':
5276 case '&':
5277 case '^':
5278 case '~':
5279 case '!':
5280 case '<':
5281 case '>':
5282 case '?':
5283 case ':':
5284 case '=':
5285 case '{':
5286 case '}':
5287 symbol:
5288 lexptr++;
5289 return c;
5290
5291 case 'L':
5292 case 'u':
5293 case 'U':
5294 if (tokstart[1] != '"' && tokstart[1] != '\'')
5295 break;
5296 /* Fall through. */
5297 case '\'':
5298 case '"':
5299
5300 parse_string:
5301 {
5302 int host_len;
5303 int result = parse_string_or_char (tokstart, &lexptr, &yylval.tsval,
5304 &host_len);
5305 if (result == CHAR)
5306 {
5307 if (host_len == 0)
5308 error (_("Empty character constant."));
5309 else if (host_len > 2 && c == '\'')
5310 {
5311 ++tokstart;
5312 namelen = lexptr - tokstart - 1;
5313 *is_quoted_name = 1;
5314
5315 goto tryname;
5316 }
5317 else if (host_len > 1)
5318 error (_("Invalid character constant."));
5319 }
5320 return result;
5321 }
5322 }
5323
5324 if (!(c == '_' || c == '$'
5325 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
5326 /* We must have come across a bad character (e.g. ';'). */
5327 error (_("Invalid character '%c' in expression."), c);
5328
5329 /* It's a name. See how long it is. */
5330 namelen = 0;
5331 for (c = tokstart[namelen];
5332 (c == '_' || c == '$' || (c >= '0' && c <= '9')
5333 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
5334 {
5335 /* Template parameter lists are part of the name.
5336 FIXME: This mishandles `print $a<4&&$a>3'. */
5337
5338 if (c == '<')
5339 {
5340 if (! is_cast_operator (tokstart, namelen))
5341 {
5342 /* Scan ahead to get rest of the template specification. Note
5343 that we look ahead only when the '<' adjoins non-whitespace
5344 characters; for comparison expressions, e.g. "a < b > c",
5345 there must be spaces before the '<', etc. */
5346 const char *p = find_template_name_end (tokstart + namelen);
5347
5348 if (p)
5349 namelen = p - tokstart;
5350 }
5351 break;
5352 }
5353 c = tokstart[++namelen];
5354 }
5355
5356 /* The token "if" terminates the expression and is NOT removed from
5357 the input stream. It doesn't count if it appears in the
5358 expansion of a macro. */
5359 if (namelen == 2
5360 && tokstart[0] == 'i'
5361 && tokstart[1] == 'f'
5362 && ! scanning_macro_expansion ())
5363 {
5364 return 0;
5365 }
5366
5367 /* For the same reason (breakpoint conditions), "thread N"
5368 terminates the expression. "thread" could be an identifier, but
5369 an identifier is never followed by a number without intervening
5370 punctuation. "task" is similar. Handle abbreviations of these,
5371 similarly to breakpoint.c:find_condition_and_thread. */
5372 if (namelen >= 1
5373 && (strncmp (tokstart, "thread", namelen) == 0
5374 || strncmp (tokstart, "task", namelen) == 0)
5375 && (tokstart[namelen] == ' ' || tokstart[namelen] == '\t')
5376 && ! scanning_macro_expansion ())
5377 {
5378 const char *p = tokstart + namelen + 1;
5379
5380 while (*p == ' ' || *p == '\t')
5381 p++;
5382 if (*p >= '0' && *p <= '9')
5383 return 0;
5384 }
5385
5386 lexptr += namelen;
5387
5388 tryname:
5389
5390 yylval.sval.ptr = tokstart;
5391 yylval.sval.length = namelen;
5392
5393 /* Catch specific keywords. */
5394 copy = copy_name (yylval.sval);
5395 for (i = 0; i < sizeof ident_tokens / sizeof ident_tokens[0]; i++)
5396 if (strcmp (copy, ident_tokens[i].oper) == 0)
5397 {
5398 if ((ident_tokens[i].flags & FLAG_CXX) != 0
5399 && parse_language (par_state)->la_language != language_cplus)
5400 break;
5401
5402 if ((ident_tokens[i].flags & FLAG_SHADOW) != 0)
5403 {
5404 struct field_of_this_result is_a_field_of_this;
5405
5406 if (lookup_symbol (copy, expression_context_block,
5407 VAR_DOMAIN,
5408 (parse_language (par_state)->la_language
5409 == language_cplus ? &is_a_field_of_this
5410 : NULL)).symbol
5411 != NULL)
5412 {
5413 /* The keyword is shadowed. */
5414 break;
5415 }
5416 }
5417
5418 /* It is ok to always set this, even though we don't always
5419 strictly need to. */
5420 yylval.opcode = ident_tokens[i].opcode;
5421 return ident_tokens[i].token;
5422 }
5423
5424 if (*tokstart == '$')
5425 return VARIABLE;
5426
5427 if (parse_completion && *lexptr == '\0')
5428 saw_name_at_eof = 1;
5429
5430 yylval.ssym.stoken = yylval.sval;
5431 yylval.ssym.sym.symbol = NULL;
5432 yylval.ssym.sym.block = NULL;
5433 yylval.ssym.is_a_field_of_this = 0;
5434 return NAME;
5435 }
5436
5437 /* An object of this type is pushed on a FIFO by the "outer" lexer. */
5438 typedef struct
5439 {
5440 int token;
5441 YYSTYPE value;
5442 } token_and_value;
5443
5444 DEF_VEC_O (token_and_value);
5445
5446 /* A FIFO of tokens that have been read but not yet returned to the
5447 parser. */
5448 static VEC (token_and_value) *token_fifo;
5449
5450 /* Non-zero if the lexer should return tokens from the FIFO. */
5451 static int popping;
5452
5453 /* Temporary storage for c_lex; this holds symbol names as they are
5454 built up. */
5455 auto_obstack name_obstack;
5456
5457 /* Classify a NAME token. The contents of the token are in `yylval'.
5458 Updates yylval and returns the new token type. BLOCK is the block
5459 in which lookups start; this can be NULL to mean the global scope.
5460 IS_QUOTED_NAME is non-zero if the name token was originally quoted
5461 in single quotes. */
5462
5463 static int
5464 classify_name (struct parser_state *par_state, const struct block *block,
5465 int is_quoted_name)
5466 {
5467 struct block_symbol bsym;
5468 char *copy;
5469 struct field_of_this_result is_a_field_of_this;
5470
5471 copy = copy_name (yylval.sval);
5472
5473 /* Initialize this in case we *don't* use it in this call; that way
5474 we can refer to it unconditionally below. */
5475 memset (&is_a_field_of_this, 0, sizeof (is_a_field_of_this));
5476
5477 bsym = lookup_symbol (copy, block, VAR_DOMAIN,
5478 parse_language (par_state)->la_name_of_this
5479 ? &is_a_field_of_this : NULL);
5480
5481 if (bsym.symbol && SYMBOL_CLASS (bsym.symbol) == LOC_BLOCK)
5482 {
5483 yylval.ssym.sym = bsym;
5484 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
5485 return BLOCKNAME;
5486 }
5487 else if (!bsym.symbol)
5488 {
5489 /* If we found a field of 'this', we might have erroneously
5490 found a constructor where we wanted a type name. Handle this
5491 case by noticing that we found a constructor and then look up
5492 the type tag instead. */
5493 if (is_a_field_of_this.type != NULL
5494 && is_a_field_of_this.fn_field != NULL
5495 && TYPE_FN_FIELD_CONSTRUCTOR (is_a_field_of_this.fn_field->fn_fields,
5496 0))
5497 {
5498 struct field_of_this_result inner_is_a_field_of_this;
5499
5500 bsym = lookup_symbol (copy, block, STRUCT_DOMAIN,
5501 &inner_is_a_field_of_this);
5502 if (bsym.symbol != NULL)
5503 {
5504 yylval.tsym.type = SYMBOL_TYPE (bsym.symbol);
5505 return TYPENAME;
5506 }
5507 }
5508
5509 /* If we found a field, then we want to prefer it over a
5510 filename. However, if the name was quoted, then it is better
5511 to check for a filename or a block, since this is the only
5512 way the user has of requiring the extension to be used. */
5513 if (is_a_field_of_this.type == NULL || is_quoted_name)
5514 {
5515 /* See if it's a file name. */
5516 struct symtab *symtab;
5517
5518 symtab = lookup_symtab (copy);
5519 if (symtab)
5520 {
5521 yylval.bval = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (symtab),
5522 STATIC_BLOCK);
5523 return FILENAME;
5524 }
5525 }
5526 }
5527
5528 if (bsym.symbol && SYMBOL_CLASS (bsym.symbol) == LOC_TYPEDEF)
5529 {
5530 yylval.tsym.type = SYMBOL_TYPE (bsym.symbol);
5531 return TYPENAME;
5532 }
5533
5534 /* See if it's an ObjC classname. */
5535 if (parse_language (par_state)->la_language == language_objc && !bsym.symbol)
5536 {
5537 CORE_ADDR Class = lookup_objc_class (parse_gdbarch (par_state), copy);
5538 if (Class)
5539 {
5540 struct symbol *sym;
5541
5542 yylval.theclass.theclass = Class;
5543 sym = lookup_struct_typedef (copy, expression_context_block, 1);
5544 if (sym)
5545 yylval.theclass.type = SYMBOL_TYPE (sym);
5546 return CLASSNAME;
5547 }
5548 }
5549
5550 /* Input names that aren't symbols but ARE valid hex numbers, when
5551 the input radix permits them, can be names or numbers depending
5552 on the parse. Note we support radixes > 16 here. */
5553 if (!bsym.symbol
5554 && ((copy[0] >= 'a' && copy[0] < 'a' + input_radix - 10)
5555 || (copy[0] >= 'A' && copy[0] < 'A' + input_radix - 10)))
5556 {
5557 YYSTYPE newlval; /* Its value is ignored. */
5558 int hextype = parse_number (par_state, copy, yylval.sval.length,
5559 0, &newlval);
5560
5561 if (hextype == INT)
5562 {
5563 yylval.ssym.sym = bsym;
5564 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
5565 return NAME_OR_INT;
5566 }
5567 }
5568
5569 /* Any other kind of symbol */
5570 yylval.ssym.sym = bsym;
5571 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
5572
5573 if (bsym.symbol == NULL
5574 && parse_language (par_state)->la_language == language_cplus
5575 && is_a_field_of_this.type == NULL
5576 && lookup_minimal_symbol (copy, NULL, NULL).minsym == NULL)
5577 return UNKNOWN_CPP_NAME;
5578
5579 return NAME;
5580 }
5581
5582 /* Like classify_name, but used by the inner loop of the lexer, when a
5583 name might have already been seen. CONTEXT is the context type, or
5584 NULL if this is the first component of a name. */
5585
5586 static int
5587 classify_inner_name (struct parser_state *par_state,
5588 const struct block *block, struct type *context)
5589 {
5590 struct type *type;
5591 char *copy;
5592
5593 if (context == NULL)
5594 return classify_name (par_state, block, 0);
5595
5596 type = check_typedef (context);
5597 if (!type_aggregate_p (type))
5598 return ERROR;
5599
5600 copy = copy_name (yylval.ssym.stoken);
5601 /* N.B. We assume the symbol can only be in VAR_DOMAIN. */
5602 yylval.ssym.sym = cp_lookup_nested_symbol (type, copy, block, VAR_DOMAIN);
5603
5604 /* If no symbol was found, search for a matching base class named
5605 COPY. This will allow users to enter qualified names of class members
5606 relative to the `this' pointer. */
5607 if (yylval.ssym.sym.symbol == NULL)
5608 {
5609 struct type *base_type = cp_find_type_baseclass_by_name (type, copy);
5610
5611 if (base_type != NULL)
5612 {
5613 yylval.tsym.type = base_type;
5614 return TYPENAME;
5615 }
5616
5617 return ERROR;
5618 }
5619
5620 switch (SYMBOL_CLASS (yylval.ssym.sym.symbol))
5621 {
5622 case LOC_BLOCK:
5623 case LOC_LABEL:
5624 /* cp_lookup_nested_symbol might have accidentally found a constructor
5625 named COPY when we really wanted a base class of the same name.
5626 Double-check this case by looking for a base class. */
5627 {
5628 struct type *base_type = cp_find_type_baseclass_by_name (type, copy);
5629
5630 if (base_type != NULL)
5631 {
5632 yylval.tsym.type = base_type;
5633 return TYPENAME;
5634 }
5635 }
5636 return ERROR;
5637
5638 case LOC_TYPEDEF:
5639 yylval.tsym.type = SYMBOL_TYPE (yylval.ssym.sym.symbol);
5640 return TYPENAME;
5641
5642 default:
5643 return NAME;
5644 }
5645 internal_error (__FILE__, __LINE__, _("not reached"));
5646 }
5647
5648 /* The outer level of a two-level lexer. This calls the inner lexer
5649 to return tokens. It then either returns these tokens, or
5650 aggregates them into a larger token. This lets us work around a
5651 problem in our parsing approach, where the parser could not
5652 distinguish between qualified names and qualified types at the
5653 right point.
5654
5655 This approach is still not ideal, because it mishandles template
5656 types. See the comment in lex_one_token for an example. However,
5657 this is still an improvement over the earlier approach, and will
5658 suffice until we move to better parsing technology. */
5659
5660 static int
5661 yylex (void)
5662 {
5663 token_and_value current;
5664 int first_was_coloncolon, last_was_coloncolon;
5665 struct type *context_type = NULL;
5666 int last_to_examine, next_to_examine, checkpoint;
5667 const struct block *search_block;
5668 int is_quoted_name;
5669
5670 if (popping && !VEC_empty (token_and_value, token_fifo))
5671 goto do_pop;
5672 popping = 0;
5673
5674 /* Read the first token and decide what to do. Most of the
5675 subsequent code is C++-only; but also depends on seeing a "::" or
5676 name-like token. */
5677 current.token = lex_one_token (pstate, &is_quoted_name);
5678 if (current.token == NAME)
5679 current.token = classify_name (pstate, expression_context_block,
5680 is_quoted_name);
5681 if (parse_language (pstate)->la_language != language_cplus
5682 || (current.token != TYPENAME && current.token != COLONCOLON
5683 && current.token != FILENAME))
5684 return current.token;
5685
5686 /* Read any sequence of alternating "::" and name-like tokens into
5687 the token FIFO. */
5688 current.value = yylval;
5689 VEC_safe_push (token_and_value, token_fifo, &current);
5690 last_was_coloncolon = current.token == COLONCOLON;
5691 while (1)
5692 {
5693 int ignore;
5694
5695 /* We ignore quoted names other than the very first one.
5696 Subsequent ones do not have any special meaning. */
5697 current.token = lex_one_token (pstate, &ignore);
5698 current.value = yylval;
5699 VEC_safe_push (token_and_value, token_fifo, &current);
5700
5701 if ((last_was_coloncolon && current.token != NAME)
5702 || (!last_was_coloncolon && current.token != COLONCOLON))
5703 break;
5704 last_was_coloncolon = !last_was_coloncolon;
5705 }
5706 popping = 1;
5707
5708 /* We always read one extra token, so compute the number of tokens
5709 to examine accordingly. */
5710 last_to_examine = VEC_length (token_and_value, token_fifo) - 2;
5711 next_to_examine = 0;
5712
5713 current = *VEC_index (token_and_value, token_fifo, next_to_examine);
5714 ++next_to_examine;
5715
5716 name_obstack.clear ();
5717 checkpoint = 0;
5718 if (current.token == FILENAME)
5719 search_block = current.value.bval;
5720 else if (current.token == COLONCOLON)
5721 search_block = NULL;
5722 else
5723 {
5724 gdb_assert (current.token == TYPENAME);
5725 search_block = expression_context_block;
5726 obstack_grow (&name_obstack, current.value.sval.ptr,
5727 current.value.sval.length);
5728 context_type = current.value.tsym.type;
5729 checkpoint = 1;
5730 }
5731
5732 first_was_coloncolon = current.token == COLONCOLON;
5733 last_was_coloncolon = first_was_coloncolon;
5734
5735 while (next_to_examine <= last_to_examine)
5736 {
5737 token_and_value *next;
5738
5739 next = VEC_index (token_and_value, token_fifo, next_to_examine);
5740 ++next_to_examine;
5741
5742 if (next->token == NAME && last_was_coloncolon)
5743 {
5744 int classification;
5745
5746 yylval = next->value;
5747 classification = classify_inner_name (pstate, search_block,
5748 context_type);
5749 /* We keep going until we either run out of names, or until
5750 we have a qualified name which is not a type. */
5751 if (classification != TYPENAME && classification != NAME)
5752 break;
5753
5754 /* Accept up to this token. */
5755 checkpoint = next_to_examine;
5756
5757 /* Update the partial name we are constructing. */
5758 if (context_type != NULL)
5759 {
5760 /* We don't want to put a leading "::" into the name. */
5761 obstack_grow_str (&name_obstack, "::");
5762 }
5763 obstack_grow (&name_obstack, next->value.sval.ptr,
5764 next->value.sval.length);
5765
5766 yylval.sval.ptr = (const char *) obstack_base (&name_obstack);
5767 yylval.sval.length = obstack_object_size (&name_obstack);
5768 current.value = yylval;
5769 current.token = classification;
5770
5771 last_was_coloncolon = 0;
5772
5773 if (classification == NAME)
5774 break;
5775
5776 context_type = yylval.tsym.type;
5777 }
5778 else if (next->token == COLONCOLON && !last_was_coloncolon)
5779 last_was_coloncolon = 1;
5780 else
5781 {
5782 /* We've reached the end of the name. */
5783 break;
5784 }
5785 }
5786
5787 /* If we have a replacement token, install it as the first token in
5788 the FIFO, and delete the other constituent tokens. */
5789 if (checkpoint > 0)
5790 {
5791 current.value.sval.ptr
5792 = (const char *) obstack_copy0 (&expansion_obstack,
5793 current.value.sval.ptr,
5794 current.value.sval.length);
5795
5796 VEC_replace (token_and_value, token_fifo, 0, &current);
5797 if (checkpoint > 1)
5798 VEC_block_remove (token_and_value, token_fifo, 1, checkpoint - 1);
5799 }
5800
5801 do_pop:
5802 current = *VEC_index (token_and_value, token_fifo, 0);
5803 VEC_ordered_remove (token_and_value, token_fifo, 0);
5804 yylval = current.value;
5805 return current.token;
5806 }
5807
5808 int
5809 c_parse (struct parser_state *par_state)
5810 {
5811 int result;
5812 struct cleanup *back_to;
5813
5814 /* Setting up the parser state. */
5815 scoped_restore pstate_restore = make_scoped_restore (&pstate);
5816 gdb_assert (par_state != NULL);
5817 pstate = par_state;
5818
5819 /* Note that parsing (within yyparse) freely installs cleanups
5820 assuming they'll be run here (below). */
5821
5822 back_to = make_cleanup (free_current_contents, &expression_macro_scope);
5823
5824 /* Set up the scope for macro expansion. */
5825 expression_macro_scope = NULL;
5826
5827 if (expression_context_block)
5828 expression_macro_scope
5829 = sal_macro_scope (find_pc_line (expression_context_pc, 0));
5830 else
5831 expression_macro_scope = default_macro_scope ();
5832 if (! expression_macro_scope)
5833 expression_macro_scope = user_macro_scope ();
5834
5835 /* Initialize macro expansion code. */
5836 obstack_init (&expansion_obstack);
5837 gdb_assert (! macro_original_text);
5838 make_cleanup (scan_macro_cleanup, 0);
5839
5840 scoped_restore restore_yydebug = make_scoped_restore (&yydebug,
5841 parser_debug);
5842
5843 /* Initialize some state used by the lexer. */
5844 last_was_structop = 0;
5845 saw_name_at_eof = 0;
5846
5847 VEC_free (token_and_value, token_fifo);
5848 popping = 0;
5849 name_obstack.clear ();
5850
5851 result = yyparse ();
5852 do_cleanups (back_to);
5853
5854 return result;
5855 }
5856
5857 #ifdef YYBISON
5858
5859 /* This is called via the YYPRINT macro when parser debugging is
5860 enabled. It prints a token's value. */
5861
5862 static void
5863 c_print_token (FILE *file, int type, YYSTYPE value)
5864 {
5865 switch (type)
5866 {
5867 case INT:
5868 parser_fprintf (file, "typed_val_int<%s, %s>",
5869 TYPE_SAFE_NAME (value.typed_val_int.type),
5870 pulongest (value.typed_val_int.val));
5871 break;
5872
5873 case CHAR:
5874 case STRING:
5875 {
5876 char *copy = (char *) alloca (value.tsval.length + 1);
5877
5878 memcpy (copy, value.tsval.ptr, value.tsval.length);
5879 copy[value.tsval.length] = '\0';
5880
5881 parser_fprintf (file, "tsval<type=%d, %s>", value.tsval.type, copy);
5882 }
5883 break;
5884
5885 case NSSTRING:
5886 case VARIABLE:
5887 parser_fprintf (file, "sval<%s>", copy_name (value.sval));
5888 break;
5889
5890 case TYPENAME:
5891 parser_fprintf (file, "tsym<type=%s, name=%s>",
5892 TYPE_SAFE_NAME (value.tsym.type),
5893 copy_name (value.tsym.stoken));
5894 break;
5895
5896 case NAME:
5897 case UNKNOWN_CPP_NAME:
5898 case NAME_OR_INT:
5899 case BLOCKNAME:
5900 parser_fprintf (file, "ssym<name=%s, sym=%s, field_of_this=%d>",
5901 copy_name (value.ssym.stoken),
5902 (value.ssym.sym.symbol == NULL
5903 ? "(null)" : SYMBOL_PRINT_NAME (value.ssym.sym.symbol)),
5904 value.ssym.is_a_field_of_this);
5905 break;
5906
5907 case FILENAME:
5908 parser_fprintf (file, "bval<%s>", host_address_to_string (value.bval));
5909 break;
5910 }
5911 }
5912
5913 #endif
5914
5915 void
5916 yyerror (const char *msg)
5917 {
5918 if (prev_lexptr)
5919 lexptr = prev_lexptr;
5920
5921 error (_("A %s in expression, near `%s'."), (msg ? msg : "error"), lexptr);
5922 }
TYPE_CODE_NAMESPACE
Definition: gdbtypes.h:171
type::length
unsigned int length
Definition: gdbtypes.h:803
string
const char * string
Definition: signals.c:50
ttype::type
struct type * type
Definition: parser-defs.h:115
follow_type_instance_flags
type_instance_flags follow_type_instance_flags()
Definition: parse.c:1556
YYFPRINTF
#define YYFPRINTF
Definition: yy-remap.h:92
yylen
#define yylen
Definition: cp-name-parser.c:195
ABOVE_COMMA
#define ABOVE_COMMA
Definition: c-exp.c:248
yypact
static const yytype_int16 yypact[]
Definition: c-exp.c:725
yystos
static const yytype_uint8 yystos[]
Definition: c-exp.c:1197
yytype_uint16
unsigned short int yytype_uint16
Definition: c-exp.c:352
DOUBLE_KEYWORD
#define DOUBLE_KEYWORD
Definition: c-exp.c:243
NOTEQUAL
#define NOTEQUAL
Definition: c-exp.c:252
TYPE_CODE_ENUM
Definition: gdbtypes.h:108
end_msglist
int end_msglist(struct parser_state *ps)
Definition: objc-lang.c:486
write_exp_elt_sym
void write_exp_elt_sym(struct parser_state *ps, struct symbol *expelt)
Definition: parse.c:215
parse_language
#define parse_language(ps)
Definition: parser-defs.h:36
VEC_replace
#define VEC_replace(T, V, I, O)
Definition: vec.h:318
token_and_value::token
int token
Definition: c-exp.c:5440
COLONCOLON
#define COLONCOLON
Definition: c-exp.c:224
SYMBOL_PRINT_NAME
#define SYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:542
YYSTYPE::typed_val_int
struct YYSTYPE::@18 typed_val_int
push_type_stack
void push_type_stack(struct type_stack *stack)
Definition: parse.c:1503
lookup_signed_typename
struct type * lookup_signed_typename(const struct language_defn *language, struct gdbarch *gdbarch, const char *name)
Definition: gdbtypes.c:1537
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
YYNTOKENS
#define YYNTOKENS
Definition: c-exp.c:575
parse_gdbarch
#define parse_gdbarch(ps)
Definition: parser-defs.h:35
value::type
struct type * type
Definition: value.c:266
objc_class_str::theclass
int theclass
Definition: parser-defs.h:129
fn_fieldlist::fn_fields
struct fn_field * fn_fields
Definition: gdbtypes.h:827
YY_IGNORE_MAYBE_UNINITIALIZED_END
#define YY_IGNORE_MAYBE_UNINITIALIZED_END
Definition: c-exp.c:435
parse_float
bool parse_float(const char *p, int len, const struct type *type, gdb_byte *data)
Definition: parse.c:1331
type_stack_cleanup
void type_stack_cleanup(void *arg)
Definition: parse.c:1530
yyvs
#define yyvs
Definition: cp-name-parser.c:207
VOLATILE_KEYWORD
#define VOLATILE_KEYWORD
Definition: c-exp.c:242
yylloc
#define yylloc
Definition: cp-name-parser.c:189
DEF_ENUM_FLAGS_TYPE
DEF_ENUM_FLAGS_TYPE(enum token_flag, token_flags)
stoken::ptr
const char * ptr
Definition: parser-defs.h:91
yyssp
#define yyssp
Definition: cp-name-parser.c:205
LOC_BLOCK
Definition: symtab.h:854
expression_context_pc
CORE_ADDR expression_context_pc
Definition: parse.c:70
classify_inner_name
static int classify_inner_name(struct parser_state *par_state, const struct block *block, struct type *context)
Definition: c-exp.c:5587
macro_original_text
static const char * macro_original_text
Definition: c-exp.c:4973
yyerror
void yyerror(const char *)
Definition: c-exp.c:5916
comma_terminates
int comma_terminates
Definition: parse.c:77
token_flag
token_flag
Definition: c-exp.c:4850
gdbarch_int_bit
int gdbarch_int_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1579
if
if(!(yy_init))
Definition: ada-lex.c:1075
C_CHAR
Definition: c-lang.h:51
parse_completion
int parse_completion
Definition: parse.c:80
macro_scope
Definition: macroscope.h:33
YYEMPTY
#define YYEMPTY
Definition: c-exp.c:1311
TYPE_NAME
#define TYPE_NAME(thistype)
Definition: gdbtypes.h:1224
typed_stoken
Definition: parser-defs.h:96
expression_macro_scope
static struct macro_scope * expression_macro_scope
Definition: c-exp.c:5041
YYMAXDEPTH
#define YYMAXDEPTH
Definition: c-exp.c:1487
YYLAST
#define YYLAST
Definition: c-exp.c:572
C_STRING_32
Definition: c-lang.h:47
yyvsp
#define yyvsp
Definition: cp-name-parser.c:208
LSH
#define LSH
Definition: c-exp.c:255
stoken_vector::len
int len
Definition: parser-defs.h:108
end_arglist
int end_arglist(void)
Definition: parse.c:143
type_print_raw_options
const struct type_print_options type_print_raw_options
Definition: typeprint.c:40
STRING
#define STRING
Definition: c-exp.c:206
arglist_len
int arglist_len
Definition: parse.c:72
charset.h
parse_type
#define parse_type(ps)
Definition: c-exp.c:86
HOST_ESCAPE_CHAR
#define HOST_ESCAPE_CHAR
Definition: charset.h:156
lookup_symtab
struct symtab * lookup_symtab(const char *name)
Definition: symtab.c:502
SYMBOL_CLASS
#define SYMBOL_CLASS(symbol)
Definition: symtab.h:1155
memset
void * memset(T *s, int c, size_t n)=delete
internal_error
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
YYABORT
#define YYABORT
Definition: c-exp.c:1315
tp_rvalue_reference
Definition: parser-defs.h:142
standard_macro_lookup
struct macro_definition * standard_macro_lookup(const char *name, void *baton)
Definition: macroscope.c:147
VEC_block_remove
#define VEC_block_remove(T, V, I, L)
Definition: vec.h:376
tokentab3
static const struct token tokentab3[]
Definition: c-exp.c:4872
typed_stoken::length
int length
Definition: parser-defs.h:103
YYSTYPE::ssym
struct symtoken ssym
Definition: c-exp.c:287
yyr2
static const yytype_uint8 yyr2[]
Definition: c-exp.c:1277
DECREMENT
#define DECREMENT
Definition: c-exp.c:259
operator_stoken
static struct stoken operator_stoken(const char *)
Definition: c-exp.c:4273
SHORT
#define SHORT
Definition: c-exp.c:239
gdbarch_long_bit
int gdbarch_long_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1596
innermost_block
const struct block * innermost_block
Definition: parse.c:71
yyrline
static const yytype_uint16 yyrline[]
Definition: c-exp.c:631
have_partial_symbols
int have_partial_symbols(void)
Definition: objfiles.c:1023
cp-support.h
LOC_TYPEDEF
Definition: symtab.h:844
token
Definition: c-exp.c:4864
VEC_safe_push
#define VEC_safe_push(T, V, O)
Definition: vec.h:276
BLOCKVECTOR_BLOCK
#define BLOCKVECTOR_BLOCK(blocklist, n)
Definition: block.h:125
ARROW_STAR
#define ARROW_STAR
Definition: c-exp.c:261
lookup_symbol
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:1893
token::token
int token
Definition: c-exp.c:4867
push_type
void push_type(enum type_pieces tp)
Definition: parse.c:1408
insert_type
static void insert_type(struct compile_c_instance *context, struct type *type, gcc_type gcc_type)
Definition: compile-c-types.c:70
lookup_objc_class
CORE_ADDR lookup_objc_class(struct gdbarch *gdbarch, const char *classname)
Definition: objc-lang.c:109
cleanup
Definition: cleanups.c:38
c_parse_escape
int c_parse_escape(const char **ptr, struct obstack *output)
Definition: c-exp.c:4591
STRUCT_DOMAIN
Definition: symtab.h:745
_
#define _(String)
Definition: gdb_locale.h:35
sal_macro_scope
struct macro_scope * sal_macro_scope(struct symtab_and_line sal)
Definition: macroscope.c:39
SELECTOR
#define SELECTOR
Definition: c-exp.c:208
INT
#define INT
Definition: c-exp.c:204
YYTRANSLATE
#define YYTRANSLATE(YYX)
Definition: c-exp.c:588
defs.h
YYPRINT
#define YYPRINT(FILE, TYPE, VALUE)
Definition: c-exp.c:328
NSSTRING
#define NSSTRING
Definition: c-exp.c:207
yy_symbol_value_print
static void yy_symbol_value_print(FILE *yyoutput, int yytype, YYSTYPE const *const yyvaluep)
Definition: c-exp.c:1381
yytype_int16
short int yytype_int16
Definition: c-exp.c:358
default_macro_scope
struct macro_scope * default_macro_scope(void)
Definition: macroscope.c:102
typed_val_float
Definition: rust-exp.c:99
INT_KEYWORD
#define INT_KEYWORD
Definition: c-exp.c:240
YYDPRINTF
#define YYDPRINTF(Args)
Definition: c-exp.c:1352
yycheck
static const yytype_int16 yycheck[]
Definition: c-exp.c:1020
yytable_value_is_error
#define yytable_value_is_error(Yytable_value)
Definition: c-exp.c:720
FILENAME
#define FILENAME
Definition: c-exp.c:264
macroscope.h
objfiles.h
C_WIDE_STRING
Definition: c-lang.h:43
CONST_KEYWORD
#define CONST_KEYWORD
Definition: c-exp.c:241
host_address_to_string
#define host_address_to_string(ADDR)
Definition: print-utils.h:75
TYPE_IS_REFERENCE
#define TYPE_IS_REFERENCE(t)
Definition: gdbtypes.h:332
XNEW
#define XNEW(T)
Definition: poison.h:109
input_radix
unsigned input_radix
Definition: valprint.c:157
tempbuf_init
static int tempbuf_init
Definition: c-exp.c:4579
token_and_value
Definition: c-exp.c:5438
make_scoped_restore
scoped_restore_tmpl< T > make_scoped_restore(T *var)
Definition: scoped_restore.h:105
push_type_int
void push_type_int(int n)
Definition: parse.c:1415
parser-defs.h
flags
mach_port_t kern_return_t mach_port_t msgports mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition: gnu-nat.c:1891
tp_const
Definition: parser-defs.h:146
STATIC_CAST
#define STATIC_CAST
Definition: c-exp.c:231
TYPE_CODE_VOID
Definition: gdbtypes.h:124
yydefgoto
static const yytype_int16 yydefgoto[]
Definition: c-exp.c:833
c_string_type_values
c_string_type_values
Definition: c-lang.h:38
yydestruct
static void yydestruct(const char *yymsg, int yytype, YYSTYPE *yyvaluep)
Definition: c-exp.c:1718
YYSTYPE::tsval
struct typed_stoken tsval
Definition: c-exp.c:285
INCREMENT
#define INCREMENT
Definition: c-exp.c:258
field_of_this_result::fn_field
struct fn_fieldlist * fn_field
Definition: symtab.h:1545
UNKNOWN_CPP_NAME
#define UNKNOWN_CPP_NAME
Definition: c-exp.c:211
lookup_typename
struct type * lookup_typename(const struct language_defn *language, struct gdbarch *gdbarch, const char *name, const struct block *block, int noerr)
Definition: gdbtypes.c:1509
C_STRING
Definition: c-lang.h:41
name
const char *const name
Definition: aarch64-tdep.c:76
write_exp_elt_block
void write_exp_elt_block(struct parser_state *ps, const struct block *b)
Definition: parse.c:235
SYMTAB_BLOCKVECTOR
#define SYMTAB_BLOCKVECTOR(symtab)
Definition: symtab.h:1334
yytranslate
static const yytype_uint8 yytranslate[]
Definition: c-exp.c:593
parse_string_or_char
static int parse_string_or_char(const char *tokptr, const char **outptr, struct typed_stoken *value, int *host_chars)
Definition: c-exp.c:4753
write_exp_elt_longcst
void write_exp_elt_longcst(struct parser_state *ps, LONGEST expelt)
Definition: parse.c:255
ERROR
#define ERROR
Definition: c-exp.c:226
VEC_iterate
#define VEC_iterate(T, V, I, P)
Definition: vec.h:181
check_typedef
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2421
UNARY
#define UNARY
Definition: c-exp.c:257
objc_class_str
Definition: parser-defs.h:125
UNSIGNED
#define UNSIGNED
Definition: c-exp.c:223
contained_in
int contained_in(const struct block *a, const struct block *b)
Definition: block.c:73
RSH
#define RSH
Definition: c-exp.c:256
NAME_OR_INT
#define NAME_OR_INT
Definition: c-exp.c:216
DECLTYPE
#define DECLTYPE
Definition: c-exp.c:235
type_aggregate_p
static int type_aggregate_p(struct type *)
Definition: c-exp.c:4292
YY_SYMBOL_PRINT
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: c-exp.c:1364
ANDAND
#define ANDAND
Definition: c-exp.c:250
follow_types
struct type * follow_types(struct type *follow_type)
Definition: parse.c:1580
find_pc_line
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
Definition: symtab.c:3288
YYACCEPT
#define YYACCEPT
Definition: c-exp.c:1314
symtoken::sym
struct block_symbol sym
Definition: parser-defs.h:121
yyss
#define yyss
Definition: cp-name-parser.c:203
start_msglist
void start_msglist(void)
Definition: objc-lang.c:434
YYPOPSTACK
#define YYPOPSTACK(N)
yyr1
static const yytype_uint8 yyr1[]
Definition: c-exp.c:1245
YYSTYPE::svec
struct stoken_vector svec
Definition: c-exp.c:292
tempbuf
static struct obstack tempbuf
Definition: c-exp.c:4578
VEC
static VEC(token_and_value)
Definition: c-exp.c:5448
lookup_struct
struct type * lookup_struct(const char *name, const struct block *block)
Definition: gdbtypes.c:1556
yypgoto
static const yytype_int16 yypgoto[]
Definition: c-exp.c:823
token::oper
const char * oper
Definition: c-exp.c:4866
block_symbol::block
const struct block * block
Definition: symtab.h:1140
ENTRY
#define ENTRY
Definition: c-exp.c:233
YYSTYPE::typed_val_float
struct YYSTYPE::@2 typed_val_float
bound_minimal_symbol
Definition: minsyms.h:29
yy-remap.h
ASSIGN_MODIFY
#define ASSIGN_MODIFY
Definition: c-exp.c:245
push_typelist
void push_typelist(VEC(type_ptr) *list)
Definition: parse.c:1543
find_function_alias_target
symbol * find_function_alias_target(bound_minimal_symbol msymbol)
Definition: symtab.c:3953
symbol_read_needs_frame
int symbol_read_needs_frame(struct symbol *sym)
Definition: findvar.c:392
YYSTACK_ALLOC_MAXIMUM
#define YYSTACK_ALLOC_MAXIMUM
Definition: c-exp.c:483
token::flags
token_flags flags
Definition: c-exp.c:4869
yypact_value_is_default
#define yypact_value_is_default(Yystate)
Definition: c-exp.c:715
block_symbol
Definition: symtab.h:1133
expression.h
free_current_contents
void free_current_contents(void *ptr)
Definition: utils.c:199
CLASS
#define CLASS
Definition: c-exp.c:219
VEC_length
#define VEC_length(T, V)
Definition: vec.h:140
lookup_enum
struct type * lookup_enum(const char *name, const struct block *block)
Definition: gdbtypes.c:1602
CONST_CAST
#define CONST_CAST
Definition: c-exp.c:232
yy_reduce_print
static void yy_reduce_print(yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule)
Definition: c-exp.c:1438
expansion_obstack
static struct obstack expansion_obstack
Definition: c-exp.c:4981
yychar
int yychar
Definition: c-exp.c:1734
make_cleanup
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:116
BLOCKNAME
#define BLOCKNAME
Definition: c-exp.c:263
add_msglist
void add_msglist(struct stoken *str, int addcolon)
Definition: objc-lang.c:448
yyalloc::yyss_alloc
yytype_int16 yyss_alloc
Definition: ada-exp.c:500
yytype_uint8
unsigned char yytype_uint8
Definition: c-exp.c:340
TYPE_CODE_UNION
Definition: gdbtypes.h:107
pulongest
char * pulongest(ULONGEST u)
Definition: print-utils.c:129
scoped_restore_base
Definition: scoped_restore.h:24
type
Definition: gdbtypes.h:749
language.h
typed_stoken::ptr
char * ptr
Definition: parser-defs.h:101
tp_volatile
Definition: parser-defs.h:147
VEC_index
#define VEC_index(T, V, I)
Definition: vec.h:167
YYSTYPE::voidval
int voidval
Definition: c-exp.c:288
yytokentype
yytokentype
Definition: ada-exp.c:178
yytoknum
static const yytype_uint16 yytoknum[]
Definition: c-exp.c:699
macro_expand_next
char * macro_expand_next(const char **lexptr, macro_lookup_ftype *lookup_func, void *lookup_baton)
Definition: macroexp.c:1521
write_dollar_variable
void write_dollar_variable(struct parser_state *ps, struct stoken str)
Definition: parse.c:594
GEQ
#define GEQ
Definition: c-exp.c:254
find_template_name_end
const char * find_template_name_end(const char *p)
Definition: parse.c:690
type
static const char * type
Definition: language.c:113
ident_tokens
static const struct token ident_tokens[]
Definition: c-exp.c:4908
mark_struct_expression
void mark_struct_expression(struct parser_state *ps)
Definition: parse.c:544
token_and_value::value
YYSTYPE value
Definition: c-exp.c:5441
get_type_stack
struct type_stack * get_type_stack(void)
Definition: parse.c:1515
pstate
static struct parser_state * pstate
Definition: c-exp.c:96
dummy
unsigned dummy
Definition: go32-nat.c:1073
LEQ
#define LEQ
Definition: c-exp.c:253
yyalloc::yyvs_alloc
YYSTYPE yyvs_alloc
Definition: ada-exp.c:501
yyrule
#define yyrule
Definition: cp-name-parser.c:193
lookup_union
struct type * lookup_union(const char *name, const struct block *block)
Definition: gdbtypes.c:1578
yytype_uint16
unsigned short int yytype_uint16
Definition: ada-exp.c:336
type_stack
Definition: parser-defs.h:162
YYSTYPE::lval
LONGEST lval
Definition: ada-exp.c:283
DEF_VEC_O
DEF_VEC_O(token_and_value)
yylex
static int yylex(void)
Definition: c-exp.c:5661
yytype_int8
signed char yytype_int8
Definition: c-exp.c:346
classify_name
static int classify_name(struct parser_state *par_state, const struct block *block)
Definition: go-exp.c:3017
STRUCT
#define STRUCT
Definition: c-exp.c:218
parser_state
Definition: parser-defs.h:38
YYSTYPE::bval
const struct block * bval
Definition: ada-exp.c:294
LONG
#define LONG
Definition: c-exp.c:238
YYEOF
#define YYEOF
Definition: c-exp.c:1312
symtab
Definition: symtab.h:1291
FALSEKEYWORD
#define FALSEKEYWORD
Definition: c-exp.c:247
typed_stoken::type
int type
Definition: parser-defs.h:99
UNION
#define UNION
Definition: c-exp.c:220
XRESIZEVEC
#define XRESIZEVEC(T, P, N)
Definition: poison.h:169
REINTERPRET_CAST
#define REINTERPRET_CAST
Definition: c-exp.c:229
parser_debug
int parser_debug
Definition: parse.c:104
TYPENAME
#define TYPENAME
Definition: c-exp.c:213
TYPE_CODE_STRUCT
Definition: gdbtypes.h:106
symtoken::is_a_field_of_this
int is_a_field_of_this
Definition: parser-defs.h:122
write_exp_msymbol
void write_exp_msymbol(struct parser_state *ps, struct bound_minimal_symbol bound_msym)
Definition: parse.c:531
paren_depth
int paren_depth
Definition: parse.c:76
c_parse
int c_parse(struct parser_state *par_state)
Definition: c-exp.c:5809
type_stack
static struct type_stack type_stack
Definition: parse.c:73
parse_number
static int parse_number(struct parser_state *par_state, const char *, int, int, YYSTYPE *)
Definition: c-exp.c:4339
block_symbol::symbol
struct symbol * symbol
Definition: symtab.h:1136
destructor_name_p
int destructor_name_p(const char *name, struct type *type)
Definition: valops.c:3160
finished_macro_expansion
static void finished_macro_expansion(void)
Definition: c-exp.c:5010
string_file::string
std::string & string()
Definition: ui-file.h:132
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
block
Definition: block.h:60
field_of_this_result::type
struct type * type
Definition: symtab.h:1535
VEC_empty
#define VEC_empty(T, V)
Definition: vec.h:148
value
Definition: value.c:169
write_destructor_name
static void write_destructor_name(struct parser_state *par_state, struct stoken)
Definition: c-exp.c:4256
scanning_macro_expansion
static int scanning_macro_expansion(void)
Definition: c-exp.c:5004
CP_OPERATOR_STR
#define CP_OPERATOR_STR
Definition: cp-support.h:51
SIZEOF
#define SIZEOF
Definition: c-exp.c:222
CP_OPERATOR_LEN
#define CP_OPERATOR_LEN
Definition: cp-support.h:55
YYTERROR
#define YYTERROR
Definition: c-exp.c:1339
YYSTYPE::val
LONGEST val
Definition: ada-exp.c:285
write_exp_elt_opcode
void write_exp_elt_opcode(struct parser_state *ps, enum exp_opcode expelt)
Definition: parse.c:205
YYSTACK_RELOCATE
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
Definition: c-exp.c:536
CLASSNAME
#define CLASSNAME
Definition: c-exp.c:214
typed_val_int
Definition: rust-exp.c:91
lexptr
static const char * lexptr
Definition: cp-name-parser.c:84
C_STRING_16
Definition: c-lang.h:45
yyalloc
Definition: ada-exp.c:498
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
insert_type_address_space
void insert_type_address_space(struct parser_state *pstate, char *string)
Definition: parse.c:1430
symtoken
Definition: parser-defs.h:118
YY_
#define YY_(Msgid)
Definition: c-exp.c:384
scan_macro_expansion
static void scan_macro_expansion(char *expansion)
Definition: c-exp.c:4984
FLAG_SHADOW
Definition: c-exp.c:4860
yytype_uint8
unsigned char yytype_uint8
Definition: ada-exp.c:324
YY_REDUCE_PRINT
#define YY_REDUCE_PRINT(Rule)
Definition: c-exp.c:1457
TYPE_TARGET_TYPE
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1226
yy_stack_print
static void yy_stack_print(yytype_int16 *yybottom, yytype_int16 *yytop)
Definition: c-exp.c:1415
c_print_token
static void c_print_token(FILE *file, int type, YYSTYPE value)
Definition: c-exp.c:5863
yynerrs
int yynerrs
Definition: c-exp.c:1739
YY_STACK_PRINT
#define YY_STACK_PRINT(Bottom, Top)
Definition: c-exp.c:1426
yylval
YYSTYPE yylval
Definition: c-exp.c:1737
lookup_template_type
struct type * lookup_template_type(char *name, struct type *type, const struct block *block)
Definition: gdbtypes.c:1623
YYSTYPE::tsym
struct ttype tsym
Definition: c-exp.c:286
SIGNED_KEYWORD
#define SIGNED_KEYWORD
Definition: c-exp.c:237
yys
#define yys
Definition: cp-name-parser.c:182
SYMBOL_BLOCK_VALUE
#define SYMBOL_BLOCK_VALUE(symbol)
Definition: symtab.h:467
TYPE_CODE
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1238
string_file::c_str
const char * c_str() const
Definition: ui-file.h:137
c-lang.h
DOTDOTDOT
#define DOTDOTDOT
Definition: c-exp.c:265
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
Definition: c-exp.c:434
yydefact
static const yytype_uint16 yydefact[]
Definition: c-exp.c:775
bound_minimal_symbol::minsym
struct minimal_symbol * minsym
Definition: minsyms.h:34
parser_fprintf
void parser_fprintf(FILE *x, const char *y,...)
Definition: parse.c:1705
c_print_type
void c_print_type(struct type *, const char *, struct ui_file *, int, int, const struct type_print_options *)
Definition: c-typeprint.c:164
gdbarch_long_long_bit
int gdbarch_long_long_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1613
ENUM
#define ENUM
Definition: c-exp.c:221
YY_NULLPTRPTR
#define YY_NULLPTRPTR
Definition: c-exp.c:113
symbol
const char * symbol
Definition: signals.c:48
YYSTYPE
Definition: ada-exp.c:279
YYSTYPE::tval
struct type * tval
Definition: ada-exp.c:292
lookup_bound_minimal_symbol
struct bound_minimal_symbol lookup_bound_minimal_symbol(const char *name)
Definition: minsyms.c:430
OBJC_LBRAC
#define OBJC_LBRAC
Definition: c-exp.c:215
VEC_free
#define VEC_free(T, V)
Definition: vec.h:196
CHAR
#define CHAR
Definition: c-exp.c:209
yystate
#define yystate
Definition: cp-name-parser.c:184
exp_opcode
exp_opcode
Definition: expression.h:42
YYSTYPE::opcode
enum exp_opcode opcode
Definition: c-exp.c:290
TRUEKEYWORD
#define TRUEKEYWORD
Definition: c-exp.c:246
obstack_grow_str
#define obstack_grow_str(OBSTACK, STRING)
Definition: gdb_obstack.h:46
LOC_LABEL
Definition: symtab.h:848
cp_canonicalize_string
std::string cp_canonicalize_string(const char *string)
Definition: cp-support.c:552
lookup_unsigned_typename
struct type * lookup_unsigned_typename(const struct language_defn *language, struct gdbarch *gdbarch, const char *name)
Definition: gdbtypes.c:1526
append_type_stack
struct type_stack * append_type_stack(struct type_stack *to, struct type_stack *from)
Definition: parse.c:1489
yydebug
int yydebug
Definition: c-exp.c:1465
VARIABLE
#define VARIABLE
Definition: c-exp.c:244
xfree
void xfree(void *)
VAR_DOMAIN
Definition: symtab.h:739
is_cast_operator
static int is_cast_operator(const char *token, int len)
Definition: c-exp.c:5032
value.h
scan_macro_cleanup
static void scan_macro_cleanup(void *dummy)
Definition: c-exp.c:5021
have_full_symbols
int have_full_symbols(void)
Definition: objfiles.c:1040
TYPEID
#define TYPEID
Definition: c-exp.c:236
tp_reference
Definition: parser-defs.h:141
language_objc
Definition: defs.h:208
FLAG_CXX
Definition: c-exp.c:4854
yy_symbol_print
static void yy_symbol_print(FILE *yyoutput, int yytype, YYSTYPE const *const yyvaluep)
Definition: c-exp.c:1400
yyparse
int yyparse(void)
Definition: c-exp.c:1747
expression_context_block
const struct block * expression_context_block
Definition: parse.c:69
YYSTYPE::type
struct type * type
Definition: ada-exp.c:286
typeprint.h
YYSTACK_ALLOC
#define YYSTACK_ALLOC
Definition: c-exp.c:480
stoken_vector
Definition: parser-defs.h:106
ULONGEST
unsigned long long ULONGEST
Definition: common-types.h:53
stoken_vector::tokens
struct typed_stoken * tokens
Definition: parser-defs.h:109
YYSIZE_T
#define YYSIZE_T
Definition: c-exp.c:368
tp_pointer
Definition: parser-defs.h:140
STATIC_BLOCK
Definition: defs.h:687
ignore
static int ignore(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: corelow.c:879
field_of_this_result
Definition: symtab.h:1529
SYMBOL_TYPE
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:1161
yyval
#define yyval
Definition: cp-name-parser.c:188
symbol
Definition: symtab.h:1049
YYSTYPE::tvec
struct type ** tvec
Definition: f-exp.c:243
NAME
#define NAME
Definition: c-exp.c:210
mark_completion_tag
void mark_completion_tag(enum type_code tag, const char *ptr, int length)
Definition: parse.c:556
YYUSE
#define YYUSE(E)
Definition: c-exp.c:417
start_arglist
void start_arglist(void)
Definition: parse.c:133
objc-lang.h
COMPLETE
#define COMPLETE
Definition: c-exp.c:212
TYPE_LENGTH
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1235
TYPEOF
#define TYPEOF
Definition: c-exp.c:234
saw_name_at_eof
static int saw_name_at_eof
Definition: c-exp.c:5046
yytype_int16
short int yytype_int16
Definition: ada-exp.c:342
DYNAMIC_CAST
#define DYNAMIC_CAST
Definition: c-exp.c:230
HOST_CHAR_BIT
#define HOST_CHAR_BIT
Definition: host-defs.h:40
last_was_structop
static int last_was_structop
Definition: c-exp.c:5051
YYSTACK_BYTES
#define YYSTACK_BYTES(N)
Definition: c-exp.c:525
xmalloc
void * xmalloc(YYSIZE_T)
TYPE_FN_FIELD_CONSTRUCTOR
#define TYPE_FN_FIELD_CONSTRUCTOR(thisfn, n)
Definition: gdbtypes.h:1435
ttype
Definition: parser-defs.h:112
YYINITDEPTH
#define YYINITDEPTH
Definition: c-exp.c:1476
auto_obstack
Definition: gdb_obstack.h:67
lookup_struct_typedef
struct symbol * lookup_struct_typedef(const char *name, const struct block *block, int noerr)
Definition: objc-lang.c:84
DELETE
#define DELETE
Definition: c-exp.c:228
OROR
#define OROR
Definition: c-exp.c:249
YYSTYPE::sval
struct stoken sval
Definition: ada-exp.c:293
TYPE_DECLARED_CLASS
#define TYPE_DECLARED_CLASS(t)
Definition: gdbtypes.h:299
tokentab2
static const struct token tokentab2[]
Definition: c-exp.c:4880
tp_array
Definition: parser-defs.h:143
TEMPLATE
#define TEMPLATE
Definition: c-exp.c:225
lookup_minimal_symbol
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:311
lex_one_token
static int lex_one_token(struct parser_state *par_state, int *is_quoted_name)
Definition: c-exp.c:5056
prev_lexptr
static const char * prev_lexptr
Definition: cp-name-parser.c:84
write_exp_elt_floatcst
void write_exp_elt_floatcst(struct parser_state *ps, const gdb_byte expelt[16])
Definition: parse.c:265
YYFINAL
#define YYFINAL
Definition: c-exp.c:570
stoken
Definition: parser-defs.h:88
write_exp_string
void write_exp_string(struct parser_state *ps, struct stoken str)
Definition: parse.c:318
cp_find_type_baseclass_by_name
struct type * cp_find_type_baseclass_by_name(struct type *parent_type, const char *name)
Definition: cp-namespace.c:777
write_exp_elt_type
void write_exp_elt_type(struct parser_state *ps, struct type *expelt)
Definition: parse.c:277
check_parameter_typelist
static void check_parameter_typelist(VEC(type_ptr) *)
Definition: c-exp.c:4304
auto_obstack::clear
void clear()
Definition: gdb_obstack.h:77
yystacksize
#define yystacksize
Definition: cp-name-parser.c:206
yytable
static const yytype_int16 yytable[]
Definition: c-exp.c:845
OPERATOR
#define OPERATOR
Definition: c-exp.c:217
language_cplus
Definition: defs.h:209
EQUAL
#define EQUAL
Definition: c-exp.c:251
error
void error(const char *fmt,...)
Definition: errors.c:38
cp_lookup_nested_symbol
struct block_symbol cp_lookup_nested_symbol(struct type *parent_type, const char *nested_name, const struct block *block, const domain_enum domain)
Definition: cp-namespace.c:913
DOT_STAR
#define DOT_STAR
Definition: c-exp.c:262
write_exp_string_vector
void write_exp_string_vector(struct parser_state *ps, int type, struct stoken_vector *vec)
Definition: parse.c:360
symtoken::stoken
struct stoken stoken
Definition: parser-defs.h:120
block.h
LONGEST
long long LONGEST
Definition: common-types.h:52
cp-abi.h
do_cleanups
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:174
SYMBOL_IS_ARGUMENT
#define SYMBOL_IS_ARGUMENT(symbol)
Definition: symtab.h:1157
TYPE_SAFE_NAME
#define TYPE_SAFE_NAME(type)
Definition: gdbtypes.h:1483
stoken::length
int length
Definition: parser-defs.h:93
NEW
#define NEW
Definition: c-exp.c:227
symfile.h
copy_name
char * copy_name(struct stoken token)
Definition: parse.c:761
YYSTACK_FREE
#define YYSTACK_FREE
Definition: c-exp.c:481
yytname
static const char *const yytname[]
Definition: c-exp.c:666
ARROW
#define ARROW
Definition: c-exp.c:260
user_macro_scope
struct macro_scope * user_macro_scope(void)
Definition: macroscope.c:91
VEC_ordered_remove
#define VEC_ordered_remove(T, V, I)
Definition: vec.h:355
token::opcode
enum exp_opcode opcode
Definition: c-exp.c:4868
string_file
Definition: ui-file.h:106
FLOAT
#define FLOAT
Definition: c-exp.c:205