xref: /netbsd-src/external/gpl3/gdb.old/dist/gdb/c-exp.y (revision 8b657b0747480f8989760d71343d6dd33f8d4cf9)
1 /* YACC parser for C expressions, for GDB.
2    Copyright (C) 1986-2023 Free Software Foundation, Inc.
3 
4    This file is part of GDB.
5 
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10 
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15 
16    You should have received a copy of the GNU General Public License
17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
18 
19 /* Parse a C expression from text in a string,
20    and return the result as a  struct expression  pointer.
21    That structure contains arithmetic operations in reverse polish,
22    with constants represented by operations that are followed by special data.
23    See expression.h for the details of the format.
24    What is important here is that it can be built up sequentially
25    during the process of parsing; the lower levels of the tree always
26    come first in the result.
27 
28    Note that malloc's and realloc's in this file are transformed to
29    xmalloc and xrealloc respectively by the same sed command in the
30    makefile that remaps any other malloc/realloc inserted by the parser
31    generator.  Doing this with #defines and trying to control the interaction
32    with include files (<malloc.h> and <stdlib.h> for example) just became
33    too messy, particularly when such includes can be inserted at random
34    times by the parser generator.  */
35 
36 %{
37 
38 #include "defs.h"
39 #include <ctype.h>
40 #include "expression.h"
41 #include "value.h"
42 #include "parser-defs.h"
43 #include "language.h"
44 #include "c-lang.h"
45 #include "c-support.h"
46 #include "bfd.h" /* Required by objfiles.h.  */
47 #include "symfile.h" /* Required by objfiles.h.  */
48 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
49 #include "charset.h"
50 #include "block.h"
51 #include "cp-support.h"
52 #include "macroscope.h"
53 #include "objc-lang.h"
54 #include "typeprint.h"
55 #include "cp-abi.h"
56 #include "type-stack.h"
57 #include "target-float.h"
58 #include "c-exp.h"
59 
60 #define parse_type(ps) builtin_type (ps->gdbarch ())
61 
62 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror,
63    etc).  */
64 #define GDB_YY_REMAP_PREFIX c_
65 #include "yy-remap.h"
66 
67 /* The state of the parser, used internally when we are parsing the
68    expression.  */
69 
70 static struct parser_state *pstate = NULL;
71 
72 /* Data that must be held for the duration of a parse.  */
73 
74 struct c_parse_state
75 {
76   /* These are used to hold type lists and type stacks that are
77      allocated during the parse.  */
78   std::vector<std::unique_ptr<std::vector<struct type *>>> type_lists;
79   std::vector<std::unique_ptr<struct type_stack>> type_stacks;
80 
81   /* Storage for some strings allocated during the parse.  */
82   std::vector<gdb::unique_xmalloc_ptr<char>> strings;
83 
84   /* When we find that lexptr (the global var defined in parse.c) is
85      pointing at a macro invocation, we expand the invocation, and call
86      scan_macro_expansion to save the old lexptr here and point lexptr
87      into the expanded text.  When we reach the end of that, we call
88      end_macro_expansion to pop back to the value we saved here.  The
89      macro expansion code promises to return only fully-expanded text,
90      so we don't need to "push" more than one level.
91 
92      This is disgusting, of course.  It would be cleaner to do all macro
93      expansion beforehand, and then hand that to lexptr.  But we don't
94      really know where the expression ends.  Remember, in a command like
95 
96      (gdb) break *ADDRESS if CONDITION
97 
98      we evaluate ADDRESS in the scope of the current frame, but we
99      evaluate CONDITION in the scope of the breakpoint's location.  So
100      it's simply wrong to try to macro-expand the whole thing at once.  */
101   const char *macro_original_text = nullptr;
102 
103   /* We save all intermediate macro expansions on this obstack for the
104      duration of a single parse.  The expansion text may sometimes have
105      to live past the end of the expansion, due to yacc lookahead.
106      Rather than try to be clever about saving the data for a single
107      token, we simply keep it all and delete it after parsing has
108      completed.  */
109   auto_obstack expansion_obstack;
110 
111   /* The type stack.  */
112   struct type_stack type_stack;
113 };
114 
115 /* This is set and cleared in c_parse.  */
116 
117 static struct c_parse_state *cpstate;
118 
119 int yyparse (void);
120 
121 static int yylex (void);
122 
123 static void yyerror (const char *);
124 
125 static int type_aggregate_p (struct type *);
126 
127 using namespace expr;
128 %}
129 
130 /* Although the yacc "value" of an expression is not used,
131    since the result is stored in the structure being created,
132    other node types do have values.  */
133 
134 %union
135   {
136     LONGEST lval;
137     struct {
138       LONGEST val;
139       struct type *type;
140     } typed_val_int;
141     struct {
142       gdb_byte val[16];
143       struct type *type;
144     } typed_val_float;
145     struct type *tval;
146     struct stoken sval;
147     struct typed_stoken tsval;
148     struct ttype tsym;
149     struct symtoken ssym;
150     int voidval;
151     const struct block *bval;
152     enum exp_opcode opcode;
153 
154     struct stoken_vector svec;
155     std::vector<struct type *> *tvec;
156 
157     struct type_stack *type_stack;
158 
159     struct objc_class_str theclass;
160   }
161 
162 %{
163 /* YYSTYPE gets defined by %union */
164 static int parse_number (struct parser_state *par_state,
165 			 const char *, int, int, YYSTYPE *);
166 static struct stoken operator_stoken (const char *);
167 static struct stoken typename_stoken (const char *);
168 static void check_parameter_typelist (std::vector<struct type *> *);
169 
170 #if defined(YYBISON) && YYBISON < 30800
171 static void c_print_token (FILE *file, int type, YYSTYPE value);
172 #define YYPRINT(FILE, TYPE, VALUE) c_print_token (FILE, TYPE, VALUE)
173 #endif
174 %}
175 
176 %type <voidval> exp exp1 type_exp start variable qualified_name lcurly function_method
177 %type <lval> rcurly
178 %type <tval> type typebase scalar_type
179 %type <tvec> nonempty_typelist func_mod parameter_typelist
180 /* %type <bval> block */
181 
182 /* Fancy type parsing.  */
183 %type <tval> ptype
184 %type <lval> array_mod
185 %type <tval> conversion_type_id
186 
187 %type <type_stack> ptr_operator_ts abs_decl direct_abs_decl
188 
189 %token <typed_val_int> INT COMPLEX_INT
190 %token <typed_val_float> FLOAT COMPLEX_FLOAT
191 
192 /* Both NAME and TYPENAME tokens represent symbols in the input,
193    and both convey their data as strings.
194    But a TYPENAME is a string that happens to be defined as a typedef
195    or builtin type name (such as int or char)
196    and a NAME is any other symbol.
197    Contexts where this distinction is not important can use the
198    nonterminal "name", which matches either NAME or TYPENAME.  */
199 
200 %token <tsval> STRING
201 %token <sval> NSSTRING		/* ObjC Foundation "NSString" literal */
202 %token SELECTOR			/* ObjC "@selector" pseudo-operator   */
203 %token <tsval> CHAR
204 %token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */
205 %token <ssym> UNKNOWN_CPP_NAME
206 %token <voidval> COMPLETE
207 %token <tsym> TYPENAME
208 %token <theclass> CLASSNAME	/* ObjC Class name */
209 %type <sval> name field_name
210 %type <svec> string_exp
211 %type <ssym> name_not_typename
212 %type <tsym> type_name
213 
214  /* This is like a '[' token, but is only generated when parsing
215     Objective C.  This lets us reuse the same parser without
216     erroneously parsing ObjC-specific expressions in C.  */
217 %token OBJC_LBRAC
218 
219 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
220    but which would parse as a valid number in the current input radix.
221    E.g. "c" when input_radix==16.  Depending on the parse, it will be
222    turned into a name or into a number.  */
223 
224 %token <ssym> NAME_OR_INT
225 
226 %token OPERATOR
227 %token STRUCT CLASS UNION ENUM SIZEOF ALIGNOF UNSIGNED COLONCOLON
228 %token TEMPLATE
229 %token ERROR
230 %token NEW DELETE
231 %type <sval> oper
232 %token REINTERPRET_CAST DYNAMIC_CAST STATIC_CAST CONST_CAST
233 %token ENTRY
234 %token TYPEOF
235 %token DECLTYPE
236 %token TYPEID
237 
238 /* Special type cases, put in to allow the parser to distinguish different
239    legal basetypes.  */
240 %token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD DOUBLE_KEYWORD
241 %token RESTRICT ATOMIC
242 %token FLOAT_KEYWORD COMPLEX
243 
244 %token <sval> DOLLAR_VARIABLE
245 
246 %token <opcode> ASSIGN_MODIFY
247 
248 /* C++ */
249 %token TRUEKEYWORD
250 %token FALSEKEYWORD
251 
252 
253 %left ','
254 %left ABOVE_COMMA
255 %right '=' ASSIGN_MODIFY
256 %right '?'
257 %left OROR
258 %left ANDAND
259 %left '|'
260 %left '^'
261 %left '&'
262 %left EQUAL NOTEQUAL
263 %left '<' '>' LEQ GEQ
264 %left LSH RSH
265 %left '@'
266 %left '+' '-'
267 %left '*' '/' '%'
268 %right UNARY INCREMENT DECREMENT
269 %right ARROW ARROW_STAR '.' DOT_STAR '[' OBJC_LBRAC '('
270 %token <ssym> BLOCKNAME
271 %token <bval> FILENAME
272 %type <bval> block
273 %left COLONCOLON
274 
275 %token DOTDOTDOT
276 
277 
278 %%
279 
280 start   :	exp1
281 	|	type_exp
282 	;
283 
284 type_exp:	type
285 			{
286 			  pstate->push_new<type_operation> ($1);
287 			}
288 	|	TYPEOF '(' exp ')'
289 			{
290 			  pstate->wrap<typeof_operation> ();
291 			}
292 	|	TYPEOF '(' type ')'
293 			{
294 			  pstate->push_new<type_operation> ($3);
295 			}
296 	|	DECLTYPE '(' exp ')'
297 			{
298 			  pstate->wrap<decltype_operation> ();
299 			}
300 	;
301 
302 /* Expressions, including the comma operator.  */
303 exp1	:	exp
304 	|	exp1 ',' exp
305 			{ pstate->wrap2<comma_operation> (); }
306 	;
307 
308 /* Expressions, not including the comma operator.  */
309 exp	:	'*' exp    %prec UNARY
310 			{ pstate->wrap<unop_ind_operation> (); }
311 	;
312 
313 exp	:	'&' exp    %prec UNARY
314 			{ pstate->wrap<unop_addr_operation> (); }
315 	;
316 
317 exp	:	'-' exp    %prec UNARY
318 			{ pstate->wrap<unary_neg_operation> (); }
319 	;
320 
321 exp	:	'+' exp    %prec UNARY
322 			{ pstate->wrap<unary_plus_operation> (); }
323 	;
324 
325 exp	:	'!' exp    %prec UNARY
326 			{
327 			  if (pstate->language ()->la_language
328 			      == language_opencl)
329 			    pstate->wrap<opencl_not_operation> ();
330 			  else
331 			    pstate->wrap<unary_logical_not_operation> ();
332 			}
333 	;
334 
335 exp	:	'~' exp    %prec UNARY
336 			{ pstate->wrap<unary_complement_operation> (); }
337 	;
338 
339 exp	:	INCREMENT exp    %prec UNARY
340 			{ pstate->wrap<preinc_operation> (); }
341 	;
342 
343 exp	:	DECREMENT exp    %prec UNARY
344 			{ pstate->wrap<predec_operation> (); }
345 	;
346 
347 exp	:	exp INCREMENT    %prec UNARY
348 			{ pstate->wrap<postinc_operation> (); }
349 	;
350 
351 exp	:	exp DECREMENT    %prec UNARY
352 			{ pstate->wrap<postdec_operation> (); }
353 	;
354 
355 exp	:	TYPEID '(' exp ')' %prec UNARY
356 			{ pstate->wrap<typeid_operation> (); }
357 	;
358 
359 exp	:	TYPEID '(' type_exp ')' %prec UNARY
360 			{ pstate->wrap<typeid_operation> (); }
361 	;
362 
363 exp	:	SIZEOF exp       %prec UNARY
364 			{ pstate->wrap<unop_sizeof_operation> (); }
365 	;
366 
367 exp	:	ALIGNOF '(' type_exp ')'	%prec UNARY
368 			{ pstate->wrap<unop_alignof_operation> (); }
369 	;
370 
371 exp	:	exp ARROW field_name
372 			{
373 			  pstate->push_new<structop_ptr_operation>
374 			    (pstate->pop (), copy_name ($3));
375 			}
376 	;
377 
378 exp	:	exp ARROW field_name COMPLETE
379 			{
380 			  structop_base_operation *op
381 			    = new structop_ptr_operation (pstate->pop (),
382 							  copy_name ($3));
383 			  pstate->mark_struct_expression (op);
384 			  pstate->push (operation_up (op));
385 			}
386 	;
387 
388 exp	:	exp ARROW COMPLETE
389 			{
390 			  structop_base_operation *op
391 			    = new structop_ptr_operation (pstate->pop (), "");
392 			  pstate->mark_struct_expression (op);
393 			  pstate->push (operation_up (op));
394 			}
395 	;
396 
397 exp	:	exp ARROW '~' name
398 			{
399 			  pstate->push_new<structop_ptr_operation>
400 			    (pstate->pop (), "~" + copy_name ($4));
401 			}
402 	;
403 
404 exp	:	exp ARROW '~' name COMPLETE
405 			{
406 			  structop_base_operation *op
407 			    = new structop_ptr_operation (pstate->pop (),
408 							  "~" + copy_name ($4));
409 			  pstate->mark_struct_expression (op);
410 			  pstate->push (operation_up (op));
411 			}
412 	;
413 
414 exp	:	exp ARROW qualified_name
415 			{ /* exp->type::name becomes exp->*(&type::name) */
416 			  /* Note: this doesn't work if name is a
417 			     static member!  FIXME */
418 			  pstate->wrap<unop_addr_operation> ();
419 			  pstate->wrap2<structop_mptr_operation> (); }
420 	;
421 
422 exp	:	exp ARROW_STAR exp
423 			{ pstate->wrap2<structop_mptr_operation> (); }
424 	;
425 
426 exp	:	exp '.' field_name
427 			{
428 			  if (pstate->language ()->la_language
429 			      == language_opencl)
430 			    pstate->push_new<opencl_structop_operation>
431 			      (pstate->pop (), copy_name ($3));
432 			  else
433 			    pstate->push_new<structop_operation>
434 			      (pstate->pop (), copy_name ($3));
435 			}
436 	;
437 
438 exp	:	exp '.' field_name COMPLETE
439 			{
440 			  structop_base_operation *op
441 			    = new structop_operation (pstate->pop (),
442 						      copy_name ($3));
443 			  pstate->mark_struct_expression (op);
444 			  pstate->push (operation_up (op));
445 			}
446 	;
447 
448 exp	:	exp '.' COMPLETE
449 			{
450 			  structop_base_operation *op
451 			    = new structop_operation (pstate->pop (), "");
452 			  pstate->mark_struct_expression (op);
453 			  pstate->push (operation_up (op));
454 			}
455 	;
456 
457 exp	:	exp '.' '~' name
458 			{
459 			  pstate->push_new<structop_operation>
460 			    (pstate->pop (), "~" + copy_name ($4));
461 			}
462 	;
463 
464 exp	:	exp '.' '~' name COMPLETE
465 			{
466 			  structop_base_operation *op
467 			    = new structop_operation (pstate->pop (),
468 						      "~" + copy_name ($4));
469 			  pstate->mark_struct_expression (op);
470 			  pstate->push (operation_up (op));
471 			}
472 	;
473 
474 exp	:	exp '.' qualified_name
475 			{ /* exp.type::name becomes exp.*(&type::name) */
476 			  /* Note: this doesn't work if name is a
477 			     static member!  FIXME */
478 			  pstate->wrap<unop_addr_operation> ();
479 			  pstate->wrap2<structop_member_operation> (); }
480 	;
481 
482 exp	:	exp DOT_STAR exp
483 			{ pstate->wrap2<structop_member_operation> (); }
484 	;
485 
486 exp	:	exp '[' exp1 ']'
487 			{ pstate->wrap2<subscript_operation> (); }
488 	;
489 
490 exp	:	exp OBJC_LBRAC exp1 ']'
491 			{ pstate->wrap2<subscript_operation> (); }
492 	;
493 
494 /*
495  * The rules below parse ObjC message calls of the form:
496  *	'[' target selector {':' argument}* ']'
497  */
498 
499 exp	: 	OBJC_LBRAC TYPENAME
500 			{
501 			  CORE_ADDR theclass;
502 
503 			  std::string copy = copy_name ($2.stoken);
504 			  theclass = lookup_objc_class (pstate->gdbarch (),
505 							copy.c_str ());
506 			  if (theclass == 0)
507 			    error (_("%s is not an ObjC Class"),
508 				   copy.c_str ());
509 			  pstate->push_new<long_const_operation>
510 			    (parse_type (pstate)->builtin_int,
511 			     (LONGEST) theclass);
512 			  start_msglist();
513 			}
514 		msglist ']'
515 			{ end_msglist (pstate); }
516 	;
517 
518 exp	:	OBJC_LBRAC CLASSNAME
519 			{
520 			  pstate->push_new<long_const_operation>
521 			    (parse_type (pstate)->builtin_int,
522 			     (LONGEST) $2.theclass);
523 			  start_msglist();
524 			}
525 		msglist ']'
526 			{ end_msglist (pstate); }
527 	;
528 
529 exp	:	OBJC_LBRAC exp
530 			{ start_msglist(); }
531 		msglist ']'
532 			{ end_msglist (pstate); }
533 	;
534 
535 msglist :	name
536 			{ add_msglist(&$1, 0); }
537 	|	msgarglist
538 	;
539 
540 msgarglist :	msgarg
541 	|	msgarglist msgarg
542 	;
543 
544 msgarg	:	name ':' exp
545 			{ add_msglist(&$1, 1); }
546 	|	':' exp	/* Unnamed arg.  */
547 			{ add_msglist(0, 1);   }
548 	|	',' exp	/* Variable number of args.  */
549 			{ add_msglist(0, 0);   }
550 	;
551 
552 exp	:	exp '('
553 			/* This is to save the value of arglist_len
554 			   being accumulated by an outer function call.  */
555 			{ pstate->start_arglist (); }
556 		arglist ')'	%prec ARROW
557 			{
558 			  std::vector<operation_up> args
559 			    = pstate->pop_vector (pstate->end_arglist ());
560 			  pstate->push_new<funcall_operation>
561 			    (pstate->pop (), std::move (args));
562 			}
563 	;
564 
565 /* This is here to disambiguate with the production for
566    "func()::static_var" further below, which uses
567    function_method_void.  */
568 exp	:	exp '(' ')' %prec ARROW
569 			{
570 			  pstate->push_new<funcall_operation>
571 			    (pstate->pop (), std::vector<operation_up> ());
572 			}
573 	;
574 
575 
576 exp	:	UNKNOWN_CPP_NAME '('
577 			{
578 			  /* This could potentially be a an argument defined
579 			     lookup function (Koenig).  */
580 			  /* This is to save the value of arglist_len
581 			     being accumulated by an outer function call.  */
582 			  pstate->start_arglist ();
583 			}
584 		arglist ')'	%prec ARROW
585 			{
586 			  std::vector<operation_up> args
587 			    = pstate->pop_vector (pstate->end_arglist ());
588 			  pstate->push_new<adl_func_operation>
589 			    (copy_name ($1.stoken),
590 			     pstate->expression_context_block,
591 			     std::move (args));
592 			}
593 	;
594 
595 lcurly	:	'{'
596 			{ pstate->start_arglist (); }
597 	;
598 
599 arglist	:
600 	;
601 
602 arglist	:	exp
603 			{ pstate->arglist_len = 1; }
604 	;
605 
606 arglist	:	arglist ',' exp   %prec ABOVE_COMMA
607 			{ pstate->arglist_len++; }
608 	;
609 
610 function_method:       exp '(' parameter_typelist ')' const_or_volatile
611 			{
612 			  std::vector<struct type *> *type_list = $3;
613 			  /* Save the const/volatile qualifiers as
614 			     recorded by the const_or_volatile
615 			     production's actions.  */
616 			  type_instance_flags flags
617 			    = (cpstate->type_stack
618 			       .follow_type_instance_flags ());
619 			  pstate->push_new<type_instance_operation>
620 			    (flags, std::move (*type_list),
621 			     pstate->pop ());
622 			}
623 	;
624 
625 function_method_void:	    exp '(' ')' const_or_volatile
626 		       {
627 			  type_instance_flags flags
628 			    = (cpstate->type_stack
629 			       .follow_type_instance_flags ());
630 			  pstate->push_new<type_instance_operation>
631 			    (flags, std::vector<type *> (), pstate->pop ());
632 		       }
633        ;
634 
635 exp     :       function_method
636 	;
637 
638 /* Normally we must interpret "func()" as a function call, instead of
639    a type.  The user needs to write func(void) to disambiguate.
640    However, in the "func()::static_var" case, there's no
641    ambiguity.  */
642 function_method_void_or_typelist: function_method
643 	|               function_method_void
644 	;
645 
646 exp     :       function_method_void_or_typelist COLONCOLON name
647 			{
648 			  pstate->push_new<func_static_var_operation>
649 			    (pstate->pop (), copy_name ($3));
650 			}
651 	;
652 
653 rcurly	:	'}'
654 			{ $$ = pstate->end_arglist () - 1; }
655 	;
656 exp	:	lcurly arglist rcurly	%prec ARROW
657 			{
658 			  std::vector<operation_up> args
659 			    = pstate->pop_vector ($3 + 1);
660 			  pstate->push_new<array_operation> (0, $3,
661 							     std::move (args));
662 			}
663 	;
664 
665 exp	:	lcurly type_exp rcurly exp  %prec UNARY
666 			{ pstate->wrap2<unop_memval_type_operation> (); }
667 	;
668 
669 exp	:	'(' type_exp ')' exp  %prec UNARY
670 			{
671 			  if (pstate->language ()->la_language
672 			      == language_opencl)
673 			    pstate->wrap2<opencl_cast_type_operation> ();
674 			  else
675 			    pstate->wrap2<unop_cast_type_operation> ();
676 			}
677 	;
678 
679 exp	:	'(' exp1 ')'
680 			{ }
681 	;
682 
683 /* Binary operators in order of decreasing precedence.  */
684 
685 exp	:	exp '@' exp
686 			{ pstate->wrap2<repeat_operation> (); }
687 	;
688 
689 exp	:	exp '*' exp
690 			{ pstate->wrap2<mul_operation> (); }
691 	;
692 
693 exp	:	exp '/' exp
694 			{ pstate->wrap2<div_operation> (); }
695 	;
696 
697 exp	:	exp '%' exp
698 			{ pstate->wrap2<rem_operation> (); }
699 	;
700 
701 exp	:	exp '+' exp
702 			{ pstate->wrap2<add_operation> (); }
703 	;
704 
705 exp	:	exp '-' exp
706 			{ pstate->wrap2<sub_operation> (); }
707 	;
708 
709 exp	:	exp LSH exp
710 			{ pstate->wrap2<lsh_operation> (); }
711 	;
712 
713 exp	:	exp RSH exp
714 			{ pstate->wrap2<rsh_operation> (); }
715 	;
716 
717 exp	:	exp EQUAL exp
718 			{
719 			  if (pstate->language ()->la_language
720 			      == language_opencl)
721 			    pstate->wrap2<opencl_equal_operation> ();
722 			  else
723 			    pstate->wrap2<equal_operation> ();
724 			}
725 	;
726 
727 exp	:	exp NOTEQUAL exp
728 			{
729 			  if (pstate->language ()->la_language
730 			      == language_opencl)
731 			    pstate->wrap2<opencl_notequal_operation> ();
732 			  else
733 			    pstate->wrap2<notequal_operation> ();
734 			}
735 	;
736 
737 exp	:	exp LEQ exp
738 			{
739 			  if (pstate->language ()->la_language
740 			      == language_opencl)
741 			    pstate->wrap2<opencl_leq_operation> ();
742 			  else
743 			    pstate->wrap2<leq_operation> ();
744 			}
745 	;
746 
747 exp	:	exp GEQ exp
748 			{
749 			  if (pstate->language ()->la_language
750 			      == language_opencl)
751 			    pstate->wrap2<opencl_geq_operation> ();
752 			  else
753 			    pstate->wrap2<geq_operation> ();
754 			}
755 	;
756 
757 exp	:	exp '<' exp
758 			{
759 			  if (pstate->language ()->la_language
760 			      == language_opencl)
761 			    pstate->wrap2<opencl_less_operation> ();
762 			  else
763 			    pstate->wrap2<less_operation> ();
764 			}
765 	;
766 
767 exp	:	exp '>' exp
768 			{
769 			  if (pstate->language ()->la_language
770 			      == language_opencl)
771 			    pstate->wrap2<opencl_gtr_operation> ();
772 			  else
773 			    pstate->wrap2<gtr_operation> ();
774 			}
775 	;
776 
777 exp	:	exp '&' exp
778 			{ pstate->wrap2<bitwise_and_operation> (); }
779 	;
780 
781 exp	:	exp '^' exp
782 			{ pstate->wrap2<bitwise_xor_operation> (); }
783 	;
784 
785 exp	:	exp '|' exp
786 			{ pstate->wrap2<bitwise_ior_operation> (); }
787 	;
788 
789 exp	:	exp ANDAND exp
790 			{
791 			  if (pstate->language ()->la_language
792 			      == language_opencl)
793 			    {
794 			      operation_up rhs = pstate->pop ();
795 			      operation_up lhs = pstate->pop ();
796 			      pstate->push_new<opencl_logical_binop_operation>
797 				(BINOP_LOGICAL_AND, std::move (lhs),
798 				 std::move (rhs));
799 			    }
800 			  else
801 			    pstate->wrap2<logical_and_operation> ();
802 			}
803 	;
804 
805 exp	:	exp OROR exp
806 			{
807 			  if (pstate->language ()->la_language
808 			      == language_opencl)
809 			    {
810 			      operation_up rhs = pstate->pop ();
811 			      operation_up lhs = pstate->pop ();
812 			      pstate->push_new<opencl_logical_binop_operation>
813 				(BINOP_LOGICAL_OR, std::move (lhs),
814 				 std::move (rhs));
815 			    }
816 			  else
817 			    pstate->wrap2<logical_or_operation> ();
818 			}
819 	;
820 
821 exp	:	exp '?' exp ':' exp	%prec '?'
822 			{
823 			  operation_up last = pstate->pop ();
824 			  operation_up mid = pstate->pop ();
825 			  operation_up first = pstate->pop ();
826 			  if (pstate->language ()->la_language
827 			      == language_opencl)
828 			    pstate->push_new<opencl_ternop_cond_operation>
829 			      (std::move (first), std::move (mid),
830 			       std::move (last));
831 			  else
832 			    pstate->push_new<ternop_cond_operation>
833 			      (std::move (first), std::move (mid),
834 			       std::move (last));
835 			}
836 	;
837 
838 exp	:	exp '=' exp
839 			{
840 			  if (pstate->language ()->la_language
841 			      == language_opencl)
842 			    pstate->wrap2<opencl_assign_operation> ();
843 			  else
844 			    pstate->wrap2<assign_operation> ();
845 			}
846 	;
847 
848 exp	:	exp ASSIGN_MODIFY exp
849 			{
850 			  operation_up rhs = pstate->pop ();
851 			  operation_up lhs = pstate->pop ();
852 			  pstate->push_new<assign_modify_operation>
853 			    ($2, std::move (lhs), std::move (rhs));
854 			}
855 	;
856 
857 exp	:	INT
858 			{
859 			  pstate->push_new<long_const_operation>
860 			    ($1.type, $1.val);
861 			}
862 	;
863 
864 exp	:	COMPLEX_INT
865 			{
866 			  operation_up real
867 			    = (make_operation<long_const_operation>
868 			       ($1.type->target_type (), 0));
869 			  operation_up imag
870 			    = (make_operation<long_const_operation>
871 			       ($1.type->target_type (), $1.val));
872 			  pstate->push_new<complex_operation>
873 			    (std::move (real), std::move (imag), $1.type);
874 			}
875 	;
876 
877 exp	:	CHAR
878 			{
879 			  struct stoken_vector vec;
880 			  vec.len = 1;
881 			  vec.tokens = &$1;
882 			  pstate->push_c_string ($1.type, &vec);
883 			}
884 	;
885 
886 exp	:	NAME_OR_INT
887 			{ YYSTYPE val;
888 			  parse_number (pstate, $1.stoken.ptr,
889 					$1.stoken.length, 0, &val);
890 			  pstate->push_new<long_const_operation>
891 			    (val.typed_val_int.type,
892 			     val.typed_val_int.val);
893 			}
894 	;
895 
896 
897 exp	:	FLOAT
898 			{
899 			  float_data data;
900 			  std::copy (std::begin ($1.val), std::end ($1.val),
901 				     std::begin (data));
902 			  pstate->push_new<float_const_operation> ($1.type, data);
903 			}
904 	;
905 
906 exp	:	COMPLEX_FLOAT
907 			{
908 			  struct type *underlying = $1.type->target_type ();
909 
910 			  float_data val;
911 			  target_float_from_host_double (val.data (),
912 							 underlying, 0);
913 			  operation_up real
914 			    = (make_operation<float_const_operation>
915 			       (underlying, val));
916 
917 			  std::copy (std::begin ($1.val), std::end ($1.val),
918 				     std::begin (val));
919 			  operation_up imag
920 			    = (make_operation<float_const_operation>
921 			       (underlying, val));
922 
923 			  pstate->push_new<complex_operation>
924 			    (std::move (real), std::move (imag),
925 			     $1.type);
926 			}
927 	;
928 
929 exp	:	variable
930 	;
931 
932 exp	:	DOLLAR_VARIABLE
933 			{
934 			  pstate->push_dollar ($1);
935 			}
936 	;
937 
938 exp	:	SELECTOR '(' name ')'
939 			{
940 			  pstate->push_new<objc_selector_operation>
941 			    (copy_name ($3));
942 			}
943 	;
944 
945 exp	:	SIZEOF '(' type ')'	%prec UNARY
946 			{ struct type *type = $3;
947 			  struct type *int_type
948 			    = lookup_signed_typename (pstate->language (),
949 						      "int");
950 			  type = check_typedef (type);
951 
952 			    /* $5.3.3/2 of the C++ Standard (n3290 draft)
953 			       says of sizeof:  "When applied to a reference
954 			       or a reference type, the result is the size of
955 			       the referenced type."  */
956 			  if (TYPE_IS_REFERENCE (type))
957 			    type = check_typedef (type->target_type ());
958 
959 			  pstate->push_new<long_const_operation>
960 			    (int_type, type->length ());
961 			}
962 	;
963 
964 exp	:	REINTERPRET_CAST '<' type_exp '>' '(' exp ')' %prec UNARY
965 			{ pstate->wrap2<reinterpret_cast_operation> (); }
966 	;
967 
968 exp	:	STATIC_CAST '<' type_exp '>' '(' exp ')' %prec UNARY
969 			{ pstate->wrap2<unop_cast_type_operation> (); }
970 	;
971 
972 exp	:	DYNAMIC_CAST '<' type_exp '>' '(' exp ')' %prec UNARY
973 			{ pstate->wrap2<dynamic_cast_operation> (); }
974 	;
975 
976 exp	:	CONST_CAST '<' type_exp '>' '(' exp ')' %prec UNARY
977 			{ /* We could do more error checking here, but
978 			     it doesn't seem worthwhile.  */
979 			  pstate->wrap2<unop_cast_type_operation> (); }
980 	;
981 
982 string_exp:
983 		STRING
984 			{
985 			  /* We copy the string here, and not in the
986 			     lexer, to guarantee that we do not leak a
987 			     string.  Note that we follow the
988 			     NUL-termination convention of the
989 			     lexer.  */
990 			  struct typed_stoken *vec = XNEW (struct typed_stoken);
991 			  $$.len = 1;
992 			  $$.tokens = vec;
993 
994 			  vec->type = $1.type;
995 			  vec->length = $1.length;
996 			  vec->ptr = (char *) malloc ($1.length + 1);
997 			  memcpy (vec->ptr, $1.ptr, $1.length + 1);
998 			}
999 
1000 	|	string_exp STRING
1001 			{
1002 			  /* Note that we NUL-terminate here, but just
1003 			     for convenience.  */
1004 			  char *p;
1005 			  ++$$.len;
1006 			  $$.tokens = XRESIZEVEC (struct typed_stoken,
1007 						  $$.tokens, $$.len);
1008 
1009 			  p = (char *) malloc ($2.length + 1);
1010 			  memcpy (p, $2.ptr, $2.length + 1);
1011 
1012 			  $$.tokens[$$.len - 1].type = $2.type;
1013 			  $$.tokens[$$.len - 1].length = $2.length;
1014 			  $$.tokens[$$.len - 1].ptr = p;
1015 			}
1016 		;
1017 
1018 exp	:	string_exp
1019 			{
1020 			  int i;
1021 			  c_string_type type = C_STRING;
1022 
1023 			  for (i = 0; i < $1.len; ++i)
1024 			    {
1025 			      switch ($1.tokens[i].type)
1026 				{
1027 				case C_STRING:
1028 				  break;
1029 				case C_WIDE_STRING:
1030 				case C_STRING_16:
1031 				case C_STRING_32:
1032 				  if (type != C_STRING
1033 				      && type != $1.tokens[i].type)
1034 				    error (_("Undefined string concatenation."));
1035 				  type = (enum c_string_type_values) $1.tokens[i].type;
1036 				  break;
1037 				default:
1038 				  /* internal error */
1039 				  internal_error ("unrecognized type in string concatenation");
1040 				}
1041 			    }
1042 
1043 			  pstate->push_c_string (type, &$1);
1044 			  for (i = 0; i < $1.len; ++i)
1045 			    free ($1.tokens[i].ptr);
1046 			  free ($1.tokens);
1047 			}
1048 	;
1049 
1050 exp     :	NSSTRING	/* ObjC NextStep NSString constant
1051 				 * of the form '@' '"' string '"'.
1052 				 */
1053 			{
1054 			  pstate->push_new<objc_nsstring_operation>
1055 			    (copy_name ($1));
1056 			}
1057 	;
1058 
1059 /* C++.  */
1060 exp     :       TRUEKEYWORD
1061 			{ pstate->push_new<long_const_operation>
1062 			    (parse_type (pstate)->builtin_bool, 1);
1063 			}
1064 	;
1065 
1066 exp     :       FALSEKEYWORD
1067 			{ pstate->push_new<long_const_operation>
1068 			    (parse_type (pstate)->builtin_bool, 0);
1069 			}
1070 	;
1071 
1072 /* end of C++.  */
1073 
1074 block	:	BLOCKNAME
1075 			{
1076 			  if ($1.sym.symbol)
1077 			    $$ = $1.sym.symbol->value_block ();
1078 			  else
1079 			    error (_("No file or function \"%s\"."),
1080 				   copy_name ($1.stoken).c_str ());
1081 			}
1082 	|	FILENAME
1083 			{
1084 			  $$ = $1;
1085 			}
1086 	;
1087 
1088 block	:	block COLONCOLON name
1089 			{
1090 			  std::string copy = copy_name ($3);
1091 			  struct symbol *tem
1092 			    = lookup_symbol (copy.c_str (), $1,
1093 					     VAR_DOMAIN, NULL).symbol;
1094 
1095 			  if (!tem || tem->aclass () != LOC_BLOCK)
1096 			    error (_("No function \"%s\" in specified context."),
1097 				   copy.c_str ());
1098 			  $$ = tem->value_block (); }
1099 	;
1100 
1101 variable:	name_not_typename ENTRY
1102 			{ struct symbol *sym = $1.sym.symbol;
1103 
1104 			  if (sym == NULL || !sym->is_argument ()
1105 			      || !symbol_read_needs_frame (sym))
1106 			    error (_("@entry can be used only for function "
1107 				     "parameters, not for \"%s\""),
1108 				   copy_name ($1.stoken).c_str ());
1109 
1110 			  pstate->push_new<var_entry_value_operation> (sym);
1111 			}
1112 	;
1113 
1114 variable:	block COLONCOLON name
1115 			{
1116 			  std::string copy = copy_name ($3);
1117 			  struct block_symbol sym
1118 			    = lookup_symbol (copy.c_str (), $1,
1119 					     VAR_DOMAIN, NULL);
1120 
1121 			  if (sym.symbol == 0)
1122 			    error (_("No symbol \"%s\" in specified context."),
1123 				   copy.c_str ());
1124 			  if (symbol_read_needs_frame (sym.symbol))
1125 			    pstate->block_tracker->update (sym);
1126 
1127 			  pstate->push_new<var_value_operation> (sym);
1128 			}
1129 	;
1130 
1131 qualified_name:	TYPENAME COLONCOLON name
1132 			{
1133 			  struct type *type = $1.type;
1134 			  type = check_typedef (type);
1135 			  if (!type_aggregate_p (type))
1136 			    error (_("`%s' is not defined as an aggregate type."),
1137 				   TYPE_SAFE_NAME (type));
1138 
1139 			  pstate->push_new<scope_operation> (type,
1140 							     copy_name ($3));
1141 			}
1142 	|	TYPENAME COLONCOLON '~' name
1143 			{
1144 			  struct type *type = $1.type;
1145 
1146 			  type = check_typedef (type);
1147 			  if (!type_aggregate_p (type))
1148 			    error (_("`%s' is not defined as an aggregate type."),
1149 				   TYPE_SAFE_NAME (type));
1150 			  std::string name = "~" + std::string ($4.ptr,
1151 								$4.length);
1152 
1153 			  /* Check for valid destructor name.  */
1154 			  destructor_name_p (name.c_str (), $1.type);
1155 			  pstate->push_new<scope_operation> (type,
1156 							     std::move (name));
1157 			}
1158 	|	TYPENAME COLONCOLON name COLONCOLON name
1159 			{
1160 			  std::string copy = copy_name ($3);
1161 			  error (_("No type \"%s\" within class "
1162 				   "or namespace \"%s\"."),
1163 				 copy.c_str (), TYPE_SAFE_NAME ($1.type));
1164 			}
1165 	;
1166 
1167 variable:	qualified_name
1168 	|	COLONCOLON name_not_typename
1169 			{
1170 			  std::string name = copy_name ($2.stoken);
1171 			  struct block_symbol sym
1172 			    = lookup_symbol (name.c_str (),
1173 					     (const struct block *) NULL,
1174 					     VAR_DOMAIN, NULL);
1175 			  pstate->push_symbol (name.c_str (), sym);
1176 			}
1177 	;
1178 
1179 variable:	name_not_typename
1180 			{ struct block_symbol sym = $1.sym;
1181 
1182 			  if (sym.symbol)
1183 			    {
1184 			      if (symbol_read_needs_frame (sym.symbol))
1185 				pstate->block_tracker->update (sym);
1186 
1187 			      /* If we found a function, see if it's
1188 				 an ifunc resolver that has the same
1189 				 address as the ifunc symbol itself.
1190 				 If so, prefer the ifunc symbol.  */
1191 
1192 			      bound_minimal_symbol resolver
1193 				= find_gnu_ifunc (sym.symbol);
1194 			      if (resolver.minsym != NULL)
1195 				pstate->push_new<var_msym_value_operation>
1196 				  (resolver);
1197 			      else
1198 				pstate->push_new<var_value_operation> (sym);
1199 			    }
1200 			  else if ($1.is_a_field_of_this)
1201 			    {
1202 			      /* C++: it hangs off of `this'.  Must
1203 				 not inadvertently convert from a method call
1204 				 to data ref.  */
1205 			      pstate->block_tracker->update (sym);
1206 			      operation_up thisop
1207 				= make_operation<op_this_operation> ();
1208 			      pstate->push_new<structop_ptr_operation>
1209 				(std::move (thisop), copy_name ($1.stoken));
1210 			    }
1211 			  else
1212 			    {
1213 			      std::string arg = copy_name ($1.stoken);
1214 
1215 			      bound_minimal_symbol msymbol
1216 				= lookup_bound_minimal_symbol (arg.c_str ());
1217 			      if (msymbol.minsym == NULL)
1218 				{
1219 				  if (!have_full_symbols () && !have_partial_symbols ())
1220 				    error (_("No symbol table is loaded.  Use the \"file\" command."));
1221 				  else
1222 				    error (_("No symbol \"%s\" in current context."),
1223 					   arg.c_str ());
1224 				}
1225 
1226 			      /* This minsym might be an alias for
1227 				 another function.  See if we can find
1228 				 the debug symbol for the target, and
1229 				 if so, use it instead, since it has
1230 				 return type / prototype info.  This
1231 				 is important for example for "p
1232 				 *__errno_location()".  */
1233 			      symbol *alias_target
1234 				= ((msymbol.minsym->type () != mst_text_gnu_ifunc
1235 				    && msymbol.minsym->type () != mst_data_gnu_ifunc)
1236 				   ? find_function_alias_target (msymbol)
1237 				   : NULL);
1238 			      if (alias_target != NULL)
1239 				{
1240 				  block_symbol bsym { alias_target,
1241 				    alias_target->value_block () };
1242 				  pstate->push_new<var_value_operation> (bsym);
1243 				}
1244 			      else
1245 				pstate->push_new<var_msym_value_operation>
1246 				  (msymbol);
1247 			    }
1248 			}
1249 	;
1250 
1251 const_or_volatile: const_or_volatile_noopt
1252 	|
1253 	;
1254 
1255 single_qualifier:
1256 		CONST_KEYWORD
1257 			{ cpstate->type_stack.insert (tp_const); }
1258 	| 	VOLATILE_KEYWORD
1259 			{ cpstate->type_stack.insert (tp_volatile); }
1260 	| 	ATOMIC
1261 			{ cpstate->type_stack.insert (tp_atomic); }
1262 	| 	RESTRICT
1263 			{ cpstate->type_stack.insert (tp_restrict); }
1264 	|	'@' NAME
1265 		{
1266 		  cpstate->type_stack.insert (pstate,
1267 					      copy_name ($2.stoken).c_str ());
1268 		}
1269 	|	'@' UNKNOWN_CPP_NAME
1270 		{
1271 		  cpstate->type_stack.insert (pstate,
1272 					      copy_name ($2.stoken).c_str ());
1273 		}
1274 	;
1275 
1276 qualifier_seq_noopt:
1277 		single_qualifier
1278 	| 	qualifier_seq_noopt single_qualifier
1279 	;
1280 
1281 qualifier_seq:
1282 		qualifier_seq_noopt
1283 	|
1284 	;
1285 
1286 ptr_operator:
1287 		ptr_operator '*'
1288 			{ cpstate->type_stack.insert (tp_pointer); }
1289 		qualifier_seq
1290 	|	'*'
1291 			{ cpstate->type_stack.insert (tp_pointer); }
1292 		qualifier_seq
1293 	|	'&'
1294 			{ cpstate->type_stack.insert (tp_reference); }
1295 	|	'&' ptr_operator
1296 			{ cpstate->type_stack.insert (tp_reference); }
1297 	|       ANDAND
1298 			{ cpstate->type_stack.insert (tp_rvalue_reference); }
1299 	|       ANDAND ptr_operator
1300 			{ cpstate->type_stack.insert (tp_rvalue_reference); }
1301 	;
1302 
1303 ptr_operator_ts: ptr_operator
1304 			{
1305 			  $$ = cpstate->type_stack.create ();
1306 			  cpstate->type_stacks.emplace_back ($$);
1307 			}
1308 	;
1309 
1310 abs_decl:	ptr_operator_ts direct_abs_decl
1311 			{ $$ = $2->append ($1); }
1312 	|	ptr_operator_ts
1313 	|	direct_abs_decl
1314 	;
1315 
1316 direct_abs_decl: '(' abs_decl ')'
1317 			{ $$ = $2; }
1318 	|	direct_abs_decl array_mod
1319 			{
1320 			  cpstate->type_stack.push ($1);
1321 			  cpstate->type_stack.push ($2);
1322 			  cpstate->type_stack.push (tp_array);
1323 			  $$ = cpstate->type_stack.create ();
1324 			  cpstate->type_stacks.emplace_back ($$);
1325 			}
1326 	|	array_mod
1327 			{
1328 			  cpstate->type_stack.push ($1);
1329 			  cpstate->type_stack.push (tp_array);
1330 			  $$ = cpstate->type_stack.create ();
1331 			  cpstate->type_stacks.emplace_back ($$);
1332 			}
1333 
1334 	| 	direct_abs_decl func_mod
1335 			{
1336 			  cpstate->type_stack.push ($1);
1337 			  cpstate->type_stack.push ($2);
1338 			  $$ = cpstate->type_stack.create ();
1339 			  cpstate->type_stacks.emplace_back ($$);
1340 			}
1341 	|	func_mod
1342 			{
1343 			  cpstate->type_stack.push ($1);
1344 			  $$ = cpstate->type_stack.create ();
1345 			  cpstate->type_stacks.emplace_back ($$);
1346 			}
1347 	;
1348 
1349 array_mod:	'[' ']'
1350 			{ $$ = -1; }
1351 	|	OBJC_LBRAC ']'
1352 			{ $$ = -1; }
1353 	|	'[' INT ']'
1354 			{ $$ = $2.val; }
1355 	|	OBJC_LBRAC INT ']'
1356 			{ $$ = $2.val; }
1357 	;
1358 
1359 func_mod:	'(' ')'
1360 			{
1361 			  $$ = new std::vector<struct type *>;
1362 			  cpstate->type_lists.emplace_back ($$);
1363 			}
1364 	|	'(' parameter_typelist ')'
1365 			{ $$ = $2; }
1366 	;
1367 
1368 /* We used to try to recognize pointer to member types here, but
1369    that didn't work (shift/reduce conflicts meant that these rules never
1370    got executed).  The problem is that
1371      int (foo::bar::baz::bizzle)
1372    is a function type but
1373      int (foo::bar::baz::bizzle::*)
1374    is a pointer to member type.  Stroustrup loses again!  */
1375 
1376 type	:	ptype
1377 	;
1378 
1379 /* A helper production that recognizes scalar types that can validly
1380    be used with _Complex.  */
1381 
1382 scalar_type:
1383 		INT_KEYWORD
1384 			{ $$ = lookup_signed_typename (pstate->language (),
1385 						       "int"); }
1386 	|	LONG
1387 			{ $$ = lookup_signed_typename (pstate->language (),
1388 						       "long"); }
1389 	|	SHORT
1390 			{ $$ = lookup_signed_typename (pstate->language (),
1391 						       "short"); }
1392 	|	LONG INT_KEYWORD
1393 			{ $$ = lookup_signed_typename (pstate->language (),
1394 						       "long"); }
1395 	|	LONG SIGNED_KEYWORD INT_KEYWORD
1396 			{ $$ = lookup_signed_typename (pstate->language (),
1397 						       "long"); }
1398 	|	LONG SIGNED_KEYWORD
1399 			{ $$ = lookup_signed_typename (pstate->language (),
1400 						       "long"); }
1401 	|	SIGNED_KEYWORD LONG INT_KEYWORD
1402 			{ $$ = lookup_signed_typename (pstate->language (),
1403 						       "long"); }
1404 	|	UNSIGNED LONG INT_KEYWORD
1405 			{ $$ = lookup_unsigned_typename (pstate->language (),
1406 							 "long"); }
1407 	|	LONG UNSIGNED INT_KEYWORD
1408 			{ $$ = lookup_unsigned_typename (pstate->language (),
1409 							 "long"); }
1410 	|	LONG UNSIGNED
1411 			{ $$ = lookup_unsigned_typename (pstate->language (),
1412 							 "long"); }
1413 	|	LONG LONG
1414 			{ $$ = lookup_signed_typename (pstate->language (),
1415 						       "long long"); }
1416 	|	LONG LONG INT_KEYWORD
1417 			{ $$ = lookup_signed_typename (pstate->language (),
1418 						       "long long"); }
1419 	|	LONG LONG SIGNED_KEYWORD INT_KEYWORD
1420 			{ $$ = lookup_signed_typename (pstate->language (),
1421 						       "long long"); }
1422 	|	LONG LONG SIGNED_KEYWORD
1423 			{ $$ = lookup_signed_typename (pstate->language (),
1424 						       "long long"); }
1425 	|	SIGNED_KEYWORD LONG LONG
1426 			{ $$ = lookup_signed_typename (pstate->language (),
1427 						       "long long"); }
1428 	|	SIGNED_KEYWORD LONG LONG INT_KEYWORD
1429 			{ $$ = lookup_signed_typename (pstate->language (),
1430 						       "long long"); }
1431 	|	UNSIGNED LONG LONG
1432 			{ $$ = lookup_unsigned_typename (pstate->language (),
1433 							 "long long"); }
1434 	|	UNSIGNED LONG LONG INT_KEYWORD
1435 			{ $$ = lookup_unsigned_typename (pstate->language (),
1436 							 "long long"); }
1437 	|	LONG LONG UNSIGNED
1438 			{ $$ = lookup_unsigned_typename (pstate->language (),
1439 							 "long long"); }
1440 	|	LONG LONG UNSIGNED INT_KEYWORD
1441 			{ $$ = lookup_unsigned_typename (pstate->language (),
1442 							 "long long"); }
1443 	|	SHORT INT_KEYWORD
1444 			{ $$ = lookup_signed_typename (pstate->language (),
1445 						       "short"); }
1446 	|	SHORT SIGNED_KEYWORD INT_KEYWORD
1447 			{ $$ = lookup_signed_typename (pstate->language (),
1448 						       "short"); }
1449 	|	SHORT SIGNED_KEYWORD
1450 			{ $$ = lookup_signed_typename (pstate->language (),
1451 						       "short"); }
1452 	|	UNSIGNED SHORT INT_KEYWORD
1453 			{ $$ = lookup_unsigned_typename (pstate->language (),
1454 							 "short"); }
1455 	|	SHORT UNSIGNED
1456 			{ $$ = lookup_unsigned_typename (pstate->language (),
1457 							 "short"); }
1458 	|	SHORT UNSIGNED INT_KEYWORD
1459 			{ $$ = lookup_unsigned_typename (pstate->language (),
1460 							 "short"); }
1461 	|	DOUBLE_KEYWORD
1462 			{ $$ = lookup_typename (pstate->language (),
1463 						"double",
1464 						NULL,
1465 						0); }
1466 	|	FLOAT_KEYWORD
1467 			{ $$ = lookup_typename (pstate->language (),
1468 						"float",
1469 						NULL,
1470 						0); }
1471 	|	LONG DOUBLE_KEYWORD
1472 			{ $$ = lookup_typename (pstate->language (),
1473 						"long double",
1474 						NULL,
1475 						0); }
1476 	|	UNSIGNED type_name
1477 			{ $$ = lookup_unsigned_typename (pstate->language (),
1478 							 $2.type->name ()); }
1479 	|	UNSIGNED
1480 			{ $$ = lookup_unsigned_typename (pstate->language (),
1481 							 "int"); }
1482 	|	SIGNED_KEYWORD type_name
1483 			{ $$ = lookup_signed_typename (pstate->language (),
1484 						       $2.type->name ()); }
1485 	|	SIGNED_KEYWORD
1486 			{ $$ = lookup_signed_typename (pstate->language (),
1487 						       "int"); }
1488 	;
1489 
1490 /* Implements (approximately): (type-qualifier)* type-specifier.
1491 
1492    When type-specifier is only ever a single word, like 'float' then these
1493    arrive as pre-built TYPENAME tokens thanks to the classify_name
1494    function.  However, when a type-specifier can contain multiple words,
1495    for example 'double' can appear as just 'double' or 'long double', and
1496    similarly 'long' can appear as just 'long' or in 'long double', then
1497    these type-specifiers are parsed into their own tokens in the function
1498    lex_one_token and the ident_tokens array.  These separate tokens are all
1499    recognised here.  */
1500 typebase
1501 	:	TYPENAME
1502 			{ $$ = $1.type; }
1503 	|	scalar_type
1504 			{ $$ = $1; }
1505 	|	COMPLEX scalar_type
1506 			{
1507 			  $$ = init_complex_type (nullptr, $2);
1508 			}
1509 	|	STRUCT name
1510 			{ $$
1511 			    = lookup_struct (copy_name ($2).c_str (),
1512 					     pstate->expression_context_block);
1513 			}
1514 	|	STRUCT COMPLETE
1515 			{
1516 			  pstate->mark_completion_tag (TYPE_CODE_STRUCT,
1517 						       "", 0);
1518 			  $$ = NULL;
1519 			}
1520 	|	STRUCT name COMPLETE
1521 			{
1522 			  pstate->mark_completion_tag (TYPE_CODE_STRUCT,
1523 						       $2.ptr, $2.length);
1524 			  $$ = NULL;
1525 			}
1526 	|	CLASS name
1527 			{ $$ = lookup_struct
1528 			    (copy_name ($2).c_str (),
1529 			     pstate->expression_context_block);
1530 			}
1531 	|	CLASS COMPLETE
1532 			{
1533 			  pstate->mark_completion_tag (TYPE_CODE_STRUCT,
1534 						       "", 0);
1535 			  $$ = NULL;
1536 			}
1537 	|	CLASS name COMPLETE
1538 			{
1539 			  pstate->mark_completion_tag (TYPE_CODE_STRUCT,
1540 						       $2.ptr, $2.length);
1541 			  $$ = NULL;
1542 			}
1543 	|	UNION name
1544 			{ $$
1545 			    = lookup_union (copy_name ($2).c_str (),
1546 					    pstate->expression_context_block);
1547 			}
1548 	|	UNION COMPLETE
1549 			{
1550 			  pstate->mark_completion_tag (TYPE_CODE_UNION,
1551 						       "", 0);
1552 			  $$ = NULL;
1553 			}
1554 	|	UNION name COMPLETE
1555 			{
1556 			  pstate->mark_completion_tag (TYPE_CODE_UNION,
1557 						       $2.ptr, $2.length);
1558 			  $$ = NULL;
1559 			}
1560 	|	ENUM name
1561 			{ $$ = lookup_enum (copy_name ($2).c_str (),
1562 					    pstate->expression_context_block);
1563 			}
1564 	|	ENUM COMPLETE
1565 			{
1566 			  pstate->mark_completion_tag (TYPE_CODE_ENUM, "", 0);
1567 			  $$ = NULL;
1568 			}
1569 	|	ENUM name COMPLETE
1570 			{
1571 			  pstate->mark_completion_tag (TYPE_CODE_ENUM, $2.ptr,
1572 						       $2.length);
1573 			  $$ = NULL;
1574 			}
1575 		/* It appears that this rule for templates is never
1576 		   reduced; template recognition happens by lookahead
1577 		   in the token processing code in yylex. */
1578 	|	TEMPLATE name '<' type '>'
1579 			{ $$ = lookup_template_type
1580 			    (copy_name($2).c_str (), $4,
1581 			     pstate->expression_context_block);
1582 			}
1583 	|	qualifier_seq_noopt typebase
1584 			{ $$ = cpstate->type_stack.follow_types ($2); }
1585 	|	typebase qualifier_seq_noopt
1586 			{ $$ = cpstate->type_stack.follow_types ($1); }
1587 	;
1588 
1589 type_name:	TYPENAME
1590 	|	INT_KEYWORD
1591 		{
1592 		  $$.stoken.ptr = "int";
1593 		  $$.stoken.length = 3;
1594 		  $$.type = lookup_signed_typename (pstate->language (),
1595 						    "int");
1596 		}
1597 	|	LONG
1598 		{
1599 		  $$.stoken.ptr = "long";
1600 		  $$.stoken.length = 4;
1601 		  $$.type = lookup_signed_typename (pstate->language (),
1602 						    "long");
1603 		}
1604 	|	SHORT
1605 		{
1606 		  $$.stoken.ptr = "short";
1607 		  $$.stoken.length = 5;
1608 		  $$.type = lookup_signed_typename (pstate->language (),
1609 						    "short");
1610 		}
1611 	;
1612 
1613 parameter_typelist:
1614 		nonempty_typelist
1615 			{ check_parameter_typelist ($1); }
1616 	|	nonempty_typelist ',' DOTDOTDOT
1617 			{
1618 			  $1->push_back (NULL);
1619 			  check_parameter_typelist ($1);
1620 			  $$ = $1;
1621 			}
1622 	;
1623 
1624 nonempty_typelist
1625 	:	type
1626 		{
1627 		  std::vector<struct type *> *typelist
1628 		    = new std::vector<struct type *>;
1629 		  cpstate->type_lists.emplace_back (typelist);
1630 
1631 		  typelist->push_back ($1);
1632 		  $$ = typelist;
1633 		}
1634 	|	nonempty_typelist ',' type
1635 		{
1636 		  $1->push_back ($3);
1637 		  $$ = $1;
1638 		}
1639 	;
1640 
1641 ptype	:	typebase
1642 	|	ptype abs_decl
1643 		{
1644 		  cpstate->type_stack.push ($2);
1645 		  $$ = cpstate->type_stack.follow_types ($1);
1646 		}
1647 	;
1648 
1649 conversion_type_id: typebase conversion_declarator
1650 		{ $$ = cpstate->type_stack.follow_types ($1); }
1651 	;
1652 
1653 conversion_declarator:  /* Nothing.  */
1654 	| ptr_operator conversion_declarator
1655 	;
1656 
1657 const_and_volatile: 	CONST_KEYWORD VOLATILE_KEYWORD
1658 	| 		VOLATILE_KEYWORD CONST_KEYWORD
1659 	;
1660 
1661 const_or_volatile_noopt:  	const_and_volatile
1662 			{ cpstate->type_stack.insert (tp_const);
1663 			  cpstate->type_stack.insert (tp_volatile);
1664 			}
1665 	| 		CONST_KEYWORD
1666 			{ cpstate->type_stack.insert (tp_const); }
1667 	| 		VOLATILE_KEYWORD
1668 			{ cpstate->type_stack.insert (tp_volatile); }
1669 	;
1670 
1671 oper:	OPERATOR NEW
1672 			{ $$ = operator_stoken (" new"); }
1673 	|	OPERATOR DELETE
1674 			{ $$ = operator_stoken (" delete"); }
1675 	|	OPERATOR NEW '[' ']'
1676 			{ $$ = operator_stoken (" new[]"); }
1677 	|	OPERATOR DELETE '[' ']'
1678 			{ $$ = operator_stoken (" delete[]"); }
1679 	|	OPERATOR NEW OBJC_LBRAC ']'
1680 			{ $$ = operator_stoken (" new[]"); }
1681 	|	OPERATOR DELETE OBJC_LBRAC ']'
1682 			{ $$ = operator_stoken (" delete[]"); }
1683 	|	OPERATOR '+'
1684 			{ $$ = operator_stoken ("+"); }
1685 	|	OPERATOR '-'
1686 			{ $$ = operator_stoken ("-"); }
1687 	|	OPERATOR '*'
1688 			{ $$ = operator_stoken ("*"); }
1689 	|	OPERATOR '/'
1690 			{ $$ = operator_stoken ("/"); }
1691 	|	OPERATOR '%'
1692 			{ $$ = operator_stoken ("%"); }
1693 	|	OPERATOR '^'
1694 			{ $$ = operator_stoken ("^"); }
1695 	|	OPERATOR '&'
1696 			{ $$ = operator_stoken ("&"); }
1697 	|	OPERATOR '|'
1698 			{ $$ = operator_stoken ("|"); }
1699 	|	OPERATOR '~'
1700 			{ $$ = operator_stoken ("~"); }
1701 	|	OPERATOR '!'
1702 			{ $$ = operator_stoken ("!"); }
1703 	|	OPERATOR '='
1704 			{ $$ = operator_stoken ("="); }
1705 	|	OPERATOR '<'
1706 			{ $$ = operator_stoken ("<"); }
1707 	|	OPERATOR '>'
1708 			{ $$ = operator_stoken (">"); }
1709 	|	OPERATOR ASSIGN_MODIFY
1710 			{ const char *op = " unknown";
1711 			  switch ($2)
1712 			    {
1713 			    case BINOP_RSH:
1714 			      op = ">>=";
1715 			      break;
1716 			    case BINOP_LSH:
1717 			      op = "<<=";
1718 			      break;
1719 			    case BINOP_ADD:
1720 			      op = "+=";
1721 			      break;
1722 			    case BINOP_SUB:
1723 			      op = "-=";
1724 			      break;
1725 			    case BINOP_MUL:
1726 			      op = "*=";
1727 			      break;
1728 			    case BINOP_DIV:
1729 			      op = "/=";
1730 			      break;
1731 			    case BINOP_REM:
1732 			      op = "%=";
1733 			      break;
1734 			    case BINOP_BITWISE_IOR:
1735 			      op = "|=";
1736 			      break;
1737 			    case BINOP_BITWISE_AND:
1738 			      op = "&=";
1739 			      break;
1740 			    case BINOP_BITWISE_XOR:
1741 			      op = "^=";
1742 			      break;
1743 			    default:
1744 			      break;
1745 			    }
1746 
1747 			  $$ = operator_stoken (op);
1748 			}
1749 	|	OPERATOR LSH
1750 			{ $$ = operator_stoken ("<<"); }
1751 	|	OPERATOR RSH
1752 			{ $$ = operator_stoken (">>"); }
1753 	|	OPERATOR EQUAL
1754 			{ $$ = operator_stoken ("=="); }
1755 	|	OPERATOR NOTEQUAL
1756 			{ $$ = operator_stoken ("!="); }
1757 	|	OPERATOR LEQ
1758 			{ $$ = operator_stoken ("<="); }
1759 	|	OPERATOR GEQ
1760 			{ $$ = operator_stoken (">="); }
1761 	|	OPERATOR ANDAND
1762 			{ $$ = operator_stoken ("&&"); }
1763 	|	OPERATOR OROR
1764 			{ $$ = operator_stoken ("||"); }
1765 	|	OPERATOR INCREMENT
1766 			{ $$ = operator_stoken ("++"); }
1767 	|	OPERATOR DECREMENT
1768 			{ $$ = operator_stoken ("--"); }
1769 	|	OPERATOR ','
1770 			{ $$ = operator_stoken (","); }
1771 	|	OPERATOR ARROW_STAR
1772 			{ $$ = operator_stoken ("->*"); }
1773 	|	OPERATOR ARROW
1774 			{ $$ = operator_stoken ("->"); }
1775 	|	OPERATOR '(' ')'
1776 			{ $$ = operator_stoken ("()"); }
1777 	|	OPERATOR '[' ']'
1778 			{ $$ = operator_stoken ("[]"); }
1779 	|	OPERATOR OBJC_LBRAC ']'
1780 			{ $$ = operator_stoken ("[]"); }
1781 	|	OPERATOR conversion_type_id
1782 			{
1783 			  string_file buf;
1784 			  c_print_type ($2, NULL, &buf, -1, 0,
1785 					pstate->language ()->la_language,
1786 					&type_print_raw_options);
1787 			  std::string name = buf.release ();
1788 
1789 			  /* This also needs canonicalization.  */
1790 			  gdb::unique_xmalloc_ptr<char> canon
1791 			    = cp_canonicalize_string (name.c_str ());
1792 			  if (canon != nullptr)
1793 			    name = canon.get ();
1794 			  $$ = operator_stoken ((" " + name).c_str ());
1795 			}
1796 	;
1797 
1798 /* This rule exists in order to allow some tokens that would not normally
1799    match the 'name' rule to appear as fields within a struct.  The example
1800    that initially motivated this was the RISC-V target which models the
1801    floating point registers as a union with fields called 'float' and
1802    'double'.  */
1803 field_name
1804 	:	name
1805 	|	DOUBLE_KEYWORD { $$ = typename_stoken ("double"); }
1806 	|	FLOAT_KEYWORD { $$ = typename_stoken ("float"); }
1807 	|	INT_KEYWORD { $$ = typename_stoken ("int"); }
1808 	|	LONG { $$ = typename_stoken ("long"); }
1809 	|	SHORT { $$ = typename_stoken ("short"); }
1810 	|	SIGNED_KEYWORD { $$ = typename_stoken ("signed"); }
1811 	|	UNSIGNED { $$ = typename_stoken ("unsigned"); }
1812 	;
1813 
1814 name	:	NAME { $$ = $1.stoken; }
1815 	|	BLOCKNAME { $$ = $1.stoken; }
1816 	|	TYPENAME { $$ = $1.stoken; }
1817 	|	NAME_OR_INT  { $$ = $1.stoken; }
1818 	|	UNKNOWN_CPP_NAME  { $$ = $1.stoken; }
1819 	|	oper { $$ = $1; }
1820 	;
1821 
1822 name_not_typename :	NAME
1823 	|	BLOCKNAME
1824 /* These would be useful if name_not_typename was useful, but it is just
1825    a fake for "variable", so these cause reduce/reduce conflicts because
1826    the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
1827    =exp) or just an exp.  If name_not_typename was ever used in an lvalue
1828    context where only a name could occur, this might be useful.
1829   	|	NAME_OR_INT
1830  */
1831 	|	oper
1832 			{
1833 			  struct field_of_this_result is_a_field_of_this;
1834 
1835 			  $$.stoken = $1;
1836 			  $$.sym
1837 			    = lookup_symbol ($1.ptr,
1838 					     pstate->expression_context_block,
1839 					     VAR_DOMAIN,
1840 					     &is_a_field_of_this);
1841 			  $$.is_a_field_of_this
1842 			    = is_a_field_of_this.type != NULL;
1843 			}
1844 	|	UNKNOWN_CPP_NAME
1845 	;
1846 
1847 %%
1848 
1849 /* Returns a stoken of the operator name given by OP (which does not
1850    include the string "operator").  */
1851 
1852 static struct stoken
1853 operator_stoken (const char *op)
1854 {
1855   struct stoken st = { NULL, 0 };
1856   char *buf;
1857 
1858   st.length = CP_OPERATOR_LEN + strlen (op);
1859   buf = (char *) malloc (st.length + 1);
1860   strcpy (buf, CP_OPERATOR_STR);
1861   strcat (buf, op);
1862   st.ptr = buf;
1863 
1864   /* The toplevel (c_parse) will free the memory allocated here.  */
1865   cpstate->strings.emplace_back (buf);
1866   return st;
1867 };
1868 
1869 /* Returns a stoken of the type named TYPE.  */
1870 
1871 static struct stoken
1872 typename_stoken (const char *type)
1873 {
1874   struct stoken st = { type, 0 };
1875   st.length = strlen (type);
1876   return st;
1877 };
1878 
1879 /* Return true if the type is aggregate-like.  */
1880 
1881 static int
1882 type_aggregate_p (struct type *type)
1883 {
1884   return (type->code () == TYPE_CODE_STRUCT
1885 	  || type->code () == TYPE_CODE_UNION
1886 	  || type->code () == TYPE_CODE_NAMESPACE
1887 	  || (type->code () == TYPE_CODE_ENUM
1888 	      && type->is_declared_class ()));
1889 }
1890 
1891 /* Validate a parameter typelist.  */
1892 
1893 static void
1894 check_parameter_typelist (std::vector<struct type *> *params)
1895 {
1896   struct type *type;
1897   int ix;
1898 
1899   for (ix = 0; ix < params->size (); ++ix)
1900     {
1901       type = (*params)[ix];
1902       if (type != NULL && check_typedef (type)->code () == TYPE_CODE_VOID)
1903 	{
1904 	  if (ix == 0)
1905 	    {
1906 	      if (params->size () == 1)
1907 		{
1908 		  /* Ok.  */
1909 		  break;
1910 		}
1911 	      error (_("parameter types following 'void'"));
1912 	    }
1913 	  else
1914 	    error (_("'void' invalid as parameter type"));
1915 	}
1916     }
1917 }
1918 
1919 /* Take care of parsing a number (anything that starts with a digit).
1920    Set yylval and return the token type; update lexptr.
1921    LEN is the number of characters in it.  */
1922 
1923 /*** Needs some error checking for the float case ***/
1924 
1925 static int
1926 parse_number (struct parser_state *par_state,
1927 	      const char *buf, int len, int parsed_float, YYSTYPE *putithere)
1928 {
1929   ULONGEST n = 0;
1930   ULONGEST prevn = 0;
1931 
1932   int i = 0;
1933   int c;
1934   int base = input_radix;
1935   int unsigned_p = 0;
1936 
1937   /* Number of "L" suffixes encountered.  */
1938   int long_p = 0;
1939 
1940   /* Imaginary number.  */
1941   bool imaginary_p = false;
1942 
1943   /* We have found a "L" or "U" (or "i") suffix.  */
1944   int found_suffix = 0;
1945 
1946   char *p;
1947 
1948   p = (char *) alloca (len);
1949   memcpy (p, buf, len);
1950 
1951   if (parsed_float)
1952     {
1953       if (len >= 1 && p[len - 1] == 'i')
1954 	{
1955 	  imaginary_p = true;
1956 	  --len;
1957 	}
1958 
1959       /* Handle suffixes for decimal floating-point: "df", "dd" or "dl".  */
1960       if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'f')
1961 	{
1962 	  putithere->typed_val_float.type
1963 	    = parse_type (par_state)->builtin_decfloat;
1964 	  len -= 2;
1965 	}
1966       else if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'd')
1967 	{
1968 	  putithere->typed_val_float.type
1969 	    = parse_type (par_state)->builtin_decdouble;
1970 	  len -= 2;
1971 	}
1972       else if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'l')
1973 	{
1974 	  putithere->typed_val_float.type
1975 	    = parse_type (par_state)->builtin_declong;
1976 	  len -= 2;
1977 	}
1978       /* Handle suffixes: 'f' for float, 'l' for long double.  */
1979       else if (len >= 1 && TOLOWER (p[len - 1]) == 'f')
1980 	{
1981 	  putithere->typed_val_float.type
1982 	    = parse_type (par_state)->builtin_float;
1983 	  len -= 1;
1984 	}
1985       else if (len >= 1 && TOLOWER (p[len - 1]) == 'l')
1986 	{
1987 	  putithere->typed_val_float.type
1988 	    = parse_type (par_state)->builtin_long_double;
1989 	  len -= 1;
1990 	}
1991       /* Default type for floating-point literals is double.  */
1992       else
1993 	{
1994 	  putithere->typed_val_float.type
1995 	    = parse_type (par_state)->builtin_double;
1996 	}
1997 
1998       if (!parse_float (p, len,
1999 			putithere->typed_val_float.type,
2000 			putithere->typed_val_float.val))
2001 	return ERROR;
2002 
2003       if (imaginary_p)
2004 	putithere->typed_val_float.type
2005 	  = init_complex_type (nullptr, putithere->typed_val_float.type);
2006 
2007       return imaginary_p ? COMPLEX_FLOAT : FLOAT;
2008     }
2009 
2010   /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
2011   if (p[0] == '0' && len > 1)
2012     switch (p[1])
2013       {
2014       case 'x':
2015       case 'X':
2016 	if (len >= 3)
2017 	  {
2018 	    p += 2;
2019 	    base = 16;
2020 	    len -= 2;
2021 	  }
2022 	break;
2023 
2024       case 'b':
2025       case 'B':
2026 	if (len >= 3)
2027 	  {
2028 	    p += 2;
2029 	    base = 2;
2030 	    len -= 2;
2031 	  }
2032 	break;
2033 
2034       case 't':
2035       case 'T':
2036       case 'd':
2037       case 'D':
2038 	if (len >= 3)
2039 	  {
2040 	    p += 2;
2041 	    base = 10;
2042 	    len -= 2;
2043 	  }
2044 	break;
2045 
2046       default:
2047 	base = 8;
2048 	break;
2049       }
2050 
2051   while (len-- > 0)
2052     {
2053       c = *p++;
2054       if (c >= 'A' && c <= 'Z')
2055 	c += 'a' - 'A';
2056       if (c != 'l' && c != 'u' && c != 'i')
2057 	n *= base;
2058       if (c >= '0' && c <= '9')
2059 	{
2060 	  if (found_suffix)
2061 	    return ERROR;
2062 	  n += i = c - '0';
2063 	}
2064       else
2065 	{
2066 	  if (base > 10 && c >= 'a' && c <= 'f')
2067 	    {
2068 	      if (found_suffix)
2069 		return ERROR;
2070 	      n += i = c - 'a' + 10;
2071 	    }
2072 	  else if (c == 'l')
2073 	    {
2074 	      ++long_p;
2075 	      found_suffix = 1;
2076 	    }
2077 	  else if (c == 'u')
2078 	    {
2079 	      unsigned_p = 1;
2080 	      found_suffix = 1;
2081 	    }
2082 	  else if (c == 'i')
2083 	    {
2084 	      imaginary_p = true;
2085 	      found_suffix = 1;
2086 	    }
2087 	  else
2088 	    return ERROR;	/* Char not a digit */
2089 	}
2090       if (i >= base)
2091 	return ERROR;		/* Invalid digit in this base */
2092 
2093       if (c != 'l' && c != 'u' && c != 'i')
2094 	{
2095 	  /* Test for overflow.  */
2096 	  if (prevn == 0 && n == 0)
2097 	    ;
2098 	  else if (prevn >= n)
2099 	    error (_("Numeric constant too large."));
2100 	}
2101       prevn = n;
2102     }
2103 
2104   /* An integer constant is an int, a long, or a long long.  An L
2105      suffix forces it to be long; an LL suffix forces it to be long
2106      long.  If not forced to a larger size, it gets the first type of
2107      the above that it fits in.  To figure out whether it fits, we
2108      shift it right and see whether anything remains.  Note that we
2109      can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
2110      operation, because many compilers will warn about such a shift
2111      (which always produces a zero result).  Sometimes gdbarch_int_bit
2112      or gdbarch_long_bit will be that big, sometimes not.  To deal with
2113      the case where it is we just always shift the value more than
2114      once, with fewer bits each time.  */
2115   int int_bits = gdbarch_int_bit (par_state->gdbarch ());
2116   int long_bits = gdbarch_long_bit (par_state->gdbarch ());
2117   int long_long_bits = gdbarch_long_long_bit (par_state->gdbarch ());
2118   bool have_signed
2119     /* No 'u' suffix.  */
2120     = !unsigned_p;
2121   bool have_unsigned
2122     = ((/* 'u' suffix.  */
2123 	unsigned_p)
2124        || (/* Not a decimal.  */
2125 	   base != 10)
2126        || (/* Allowed as a convenience, in case decimal doesn't fit in largest
2127 	      signed type.  */
2128 	   !fits_in_type (1, n, long_long_bits, true)));
2129   bool have_int
2130     /* No 'l' or 'll' suffix.  */
2131     = long_p == 0;
2132   bool have_long
2133     /* No 'll' suffix.  */
2134     = long_p <= 1;
2135   if (have_int && have_signed && fits_in_type (1, n, int_bits, true))
2136     putithere->typed_val_int.type = parse_type (par_state)->builtin_int;
2137   else if (have_int && have_unsigned && fits_in_type (1, n, int_bits, false))
2138     putithere->typed_val_int.type
2139       = parse_type (par_state)->builtin_unsigned_int;
2140   else if (have_long && have_signed && fits_in_type (1, n, long_bits, true))
2141     putithere->typed_val_int.type = parse_type (par_state)->builtin_long;
2142   else if (have_long && have_unsigned && fits_in_type (1, n, long_bits, false))
2143     putithere->typed_val_int.type
2144       = parse_type (par_state)->builtin_unsigned_long;
2145   else if (have_signed && fits_in_type (1, n, long_long_bits, true))
2146     putithere->typed_val_int.type
2147       = parse_type (par_state)->builtin_long_long;
2148   else if (have_unsigned && fits_in_type (1, n, long_long_bits, false))
2149     putithere->typed_val_int.type
2150       = parse_type (par_state)->builtin_unsigned_long_long;
2151   else
2152     error (_("Numeric constant too large."));
2153   putithere->typed_val_int.val = n;
2154 
2155    if (imaginary_p)
2156      putithere->typed_val_int.type
2157        = init_complex_type (nullptr, putithere->typed_val_int.type);
2158 
2159    return imaginary_p ? COMPLEX_INT : INT;
2160 }
2161 
2162 /* Temporary obstack used for holding strings.  */
2163 static struct obstack tempbuf;
2164 static int tempbuf_init;
2165 
2166 /* Parse a C escape sequence.  The initial backslash of the sequence
2167    is at (*PTR)[-1].  *PTR will be updated to point to just after the
2168    last character of the sequence.  If OUTPUT is not NULL, the
2169    translated form of the escape sequence will be written there.  If
2170    OUTPUT is NULL, no output is written and the call will only affect
2171    *PTR.  If an escape sequence is expressed in target bytes, then the
2172    entire sequence will simply be copied to OUTPUT.  Return 1 if any
2173    character was emitted, 0 otherwise.  */
2174 
2175 int
2176 c_parse_escape (const char **ptr, struct obstack *output)
2177 {
2178   const char *tokptr = *ptr;
2179   int result = 1;
2180 
2181   /* Some escape sequences undergo character set conversion.  Those we
2182      translate here.  */
2183   switch (*tokptr)
2184     {
2185       /* Hex escapes do not undergo character set conversion, so keep
2186 	 the escape sequence for later.  */
2187     case 'x':
2188       if (output)
2189 	obstack_grow_str (output, "\\x");
2190       ++tokptr;
2191       if (!ISXDIGIT (*tokptr))
2192 	error (_("\\x escape without a following hex digit"));
2193       while (ISXDIGIT (*tokptr))
2194 	{
2195 	  if (output)
2196 	    obstack_1grow (output, *tokptr);
2197 	  ++tokptr;
2198 	}
2199       break;
2200 
2201       /* Octal escapes do not undergo character set conversion, so
2202 	 keep the escape sequence for later.  */
2203     case '0':
2204     case '1':
2205     case '2':
2206     case '3':
2207     case '4':
2208     case '5':
2209     case '6':
2210     case '7':
2211       {
2212 	int i;
2213 	if (output)
2214 	  obstack_grow_str (output, "\\");
2215 	for (i = 0;
2216 	     i < 3 && ISDIGIT (*tokptr) && *tokptr != '8' && *tokptr != '9';
2217 	     ++i)
2218 	  {
2219 	    if (output)
2220 	      obstack_1grow (output, *tokptr);
2221 	    ++tokptr;
2222 	  }
2223       }
2224       break;
2225 
2226       /* We handle UCNs later.  We could handle them here, but that
2227 	 would mean a spurious error in the case where the UCN could
2228 	 be converted to the target charset but not the host
2229 	 charset.  */
2230     case 'u':
2231     case 'U':
2232       {
2233 	char c = *tokptr;
2234 	int i, len = c == 'U' ? 8 : 4;
2235 	if (output)
2236 	  {
2237 	    obstack_1grow (output, '\\');
2238 	    obstack_1grow (output, *tokptr);
2239 	  }
2240 	++tokptr;
2241 	if (!ISXDIGIT (*tokptr))
2242 	  error (_("\\%c escape without a following hex digit"), c);
2243 	for (i = 0; i < len && ISXDIGIT (*tokptr); ++i)
2244 	  {
2245 	    if (output)
2246 	      obstack_1grow (output, *tokptr);
2247 	    ++tokptr;
2248 	  }
2249       }
2250       break;
2251 
2252       /* We must pass backslash through so that it does not
2253 	 cause quoting during the second expansion.  */
2254     case '\\':
2255       if (output)
2256 	obstack_grow_str (output, "\\\\");
2257       ++tokptr;
2258       break;
2259 
2260       /* Escapes which undergo conversion.  */
2261     case 'a':
2262       if (output)
2263 	obstack_1grow (output, '\a');
2264       ++tokptr;
2265       break;
2266     case 'b':
2267       if (output)
2268 	obstack_1grow (output, '\b');
2269       ++tokptr;
2270       break;
2271     case 'f':
2272       if (output)
2273 	obstack_1grow (output, '\f');
2274       ++tokptr;
2275       break;
2276     case 'n':
2277       if (output)
2278 	obstack_1grow (output, '\n');
2279       ++tokptr;
2280       break;
2281     case 'r':
2282       if (output)
2283 	obstack_1grow (output, '\r');
2284       ++tokptr;
2285       break;
2286     case 't':
2287       if (output)
2288 	obstack_1grow (output, '\t');
2289       ++tokptr;
2290       break;
2291     case 'v':
2292       if (output)
2293 	obstack_1grow (output, '\v');
2294       ++tokptr;
2295       break;
2296 
2297       /* GCC extension.  */
2298     case 'e':
2299       if (output)
2300 	obstack_1grow (output, HOST_ESCAPE_CHAR);
2301       ++tokptr;
2302       break;
2303 
2304       /* Backslash-newline expands to nothing at all.  */
2305     case '\n':
2306       ++tokptr;
2307       result = 0;
2308       break;
2309 
2310       /* A few escapes just expand to the character itself.  */
2311     case '\'':
2312     case '\"':
2313     case '?':
2314       /* GCC extensions.  */
2315     case '(':
2316     case '{':
2317     case '[':
2318     case '%':
2319       /* Unrecognized escapes turn into the character itself.  */
2320     default:
2321       if (output)
2322 	obstack_1grow (output, *tokptr);
2323       ++tokptr;
2324       break;
2325     }
2326   *ptr = tokptr;
2327   return result;
2328 }
2329 
2330 /* Parse a string or character literal from TOKPTR.  The string or
2331    character may be wide or unicode.  *OUTPTR is set to just after the
2332    end of the literal in the input string.  The resulting token is
2333    stored in VALUE.  This returns a token value, either STRING or
2334    CHAR, depending on what was parsed.  *HOST_CHARS is set to the
2335    number of host characters in the literal.  */
2336 
2337 static int
2338 parse_string_or_char (const char *tokptr, const char **outptr,
2339 		      struct typed_stoken *value, int *host_chars)
2340 {
2341   int quote;
2342   c_string_type type;
2343   int is_objc = 0;
2344 
2345   /* Build the gdb internal form of the input string in tempbuf.  Note
2346      that the buffer is null byte terminated *only* for the
2347      convenience of debugging gdb itself and printing the buffer
2348      contents when the buffer contains no embedded nulls.  Gdb does
2349      not depend upon the buffer being null byte terminated, it uses
2350      the length string instead.  This allows gdb to handle C strings
2351      (as well as strings in other languages) with embedded null
2352      bytes */
2353 
2354   if (!tempbuf_init)
2355     tempbuf_init = 1;
2356   else
2357     obstack_free (&tempbuf, NULL);
2358   obstack_init (&tempbuf);
2359 
2360   /* Record the string type.  */
2361   if (*tokptr == 'L')
2362     {
2363       type = C_WIDE_STRING;
2364       ++tokptr;
2365     }
2366   else if (*tokptr == 'u')
2367     {
2368       type = C_STRING_16;
2369       ++tokptr;
2370     }
2371   else if (*tokptr == 'U')
2372     {
2373       type = C_STRING_32;
2374       ++tokptr;
2375     }
2376   else if (*tokptr == '@')
2377     {
2378       /* An Objective C string.  */
2379       is_objc = 1;
2380       type = C_STRING;
2381       ++tokptr;
2382     }
2383   else
2384     type = C_STRING;
2385 
2386   /* Skip the quote.  */
2387   quote = *tokptr;
2388   if (quote == '\'')
2389     type |= C_CHAR;
2390   ++tokptr;
2391 
2392   *host_chars = 0;
2393 
2394   while (*tokptr)
2395     {
2396       char c = *tokptr;
2397       if (c == '\\')
2398 	{
2399 	  ++tokptr;
2400 	  *host_chars += c_parse_escape (&tokptr, &tempbuf);
2401 	}
2402       else if (c == quote)
2403 	break;
2404       else
2405 	{
2406 	  obstack_1grow (&tempbuf, c);
2407 	  ++tokptr;
2408 	  /* FIXME: this does the wrong thing with multi-byte host
2409 	     characters.  We could use mbrlen here, but that would
2410 	     make "set host-charset" a bit less useful.  */
2411 	  ++*host_chars;
2412 	}
2413     }
2414 
2415   if (*tokptr != quote)
2416     {
2417       if (quote == '"')
2418 	error (_("Unterminated string in expression."));
2419       else
2420 	error (_("Unmatched single quote."));
2421     }
2422   ++tokptr;
2423 
2424   value->type = type;
2425   value->ptr = (char *) obstack_base (&tempbuf);
2426   value->length = obstack_object_size (&tempbuf);
2427 
2428   *outptr = tokptr;
2429 
2430   return quote == '"' ? (is_objc ? NSSTRING : STRING) : CHAR;
2431 }
2432 
2433 /* This is used to associate some attributes with a token.  */
2434 
2435 enum token_flag
2436 {
2437   /* If this bit is set, the token is C++-only.  */
2438 
2439   FLAG_CXX = 1,
2440 
2441   /* If this bit is set, the token is C-only.  */
2442 
2443   FLAG_C = 2,
2444 
2445   /* If this bit is set, the token is conditional: if there is a
2446      symbol of the same name, then the token is a symbol; otherwise,
2447      the token is a keyword.  */
2448 
2449   FLAG_SHADOW = 4
2450 };
2451 DEF_ENUM_FLAGS_TYPE (enum token_flag, token_flags);
2452 
2453 struct token
2454 {
2455   const char *oper;
2456   int token;
2457   enum exp_opcode opcode;
2458   token_flags flags;
2459 };
2460 
2461 static const struct token tokentab3[] =
2462   {
2463     {">>=", ASSIGN_MODIFY, BINOP_RSH, 0},
2464     {"<<=", ASSIGN_MODIFY, BINOP_LSH, 0},
2465     {"->*", ARROW_STAR, OP_NULL, FLAG_CXX},
2466     {"...", DOTDOTDOT, OP_NULL, 0}
2467   };
2468 
2469 static const struct token tokentab2[] =
2470   {
2471     {"+=", ASSIGN_MODIFY, BINOP_ADD, 0},
2472     {"-=", ASSIGN_MODIFY, BINOP_SUB, 0},
2473     {"*=", ASSIGN_MODIFY, BINOP_MUL, 0},
2474     {"/=", ASSIGN_MODIFY, BINOP_DIV, 0},
2475     {"%=", ASSIGN_MODIFY, BINOP_REM, 0},
2476     {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR, 0},
2477     {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND, 0},
2478     {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR, 0},
2479     {"++", INCREMENT, OP_NULL, 0},
2480     {"--", DECREMENT, OP_NULL, 0},
2481     {"->", ARROW, OP_NULL, 0},
2482     {"&&", ANDAND, OP_NULL, 0},
2483     {"||", OROR, OP_NULL, 0},
2484     /* "::" is *not* only C++: gdb overrides its meaning in several
2485        different ways, e.g., 'filename'::func, function::variable.  */
2486     {"::", COLONCOLON, OP_NULL, 0},
2487     {"<<", LSH, OP_NULL, 0},
2488     {">>", RSH, OP_NULL, 0},
2489     {"==", EQUAL, OP_NULL, 0},
2490     {"!=", NOTEQUAL, OP_NULL, 0},
2491     {"<=", LEQ, OP_NULL, 0},
2492     {">=", GEQ, OP_NULL, 0},
2493     {".*", DOT_STAR, OP_NULL, FLAG_CXX}
2494   };
2495 
2496 /* Identifier-like tokens.  Only type-specifiers than can appear in
2497    multi-word type names (for example 'double' can appear in 'long
2498    double') need to be listed here.  type-specifiers that are only ever
2499    single word (like 'char') are handled by the classify_name function.  */
2500 static const struct token ident_tokens[] =
2501   {
2502     {"unsigned", UNSIGNED, OP_NULL, 0},
2503     {"template", TEMPLATE, OP_NULL, FLAG_CXX},
2504     {"volatile", VOLATILE_KEYWORD, OP_NULL, 0},
2505     {"struct", STRUCT, OP_NULL, 0},
2506     {"signed", SIGNED_KEYWORD, OP_NULL, 0},
2507     {"sizeof", SIZEOF, OP_NULL, 0},
2508     {"_Alignof", ALIGNOF, OP_NULL, 0},
2509     {"alignof", ALIGNOF, OP_NULL, FLAG_CXX},
2510     {"double", DOUBLE_KEYWORD, OP_NULL, 0},
2511     {"float", FLOAT_KEYWORD, OP_NULL, 0},
2512     {"false", FALSEKEYWORD, OP_NULL, FLAG_CXX},
2513     {"class", CLASS, OP_NULL, FLAG_CXX},
2514     {"union", UNION, OP_NULL, 0},
2515     {"short", SHORT, OP_NULL, 0},
2516     {"const", CONST_KEYWORD, OP_NULL, 0},
2517     {"restrict", RESTRICT, OP_NULL, FLAG_C | FLAG_SHADOW},
2518     {"__restrict__", RESTRICT, OP_NULL, 0},
2519     {"__restrict", RESTRICT, OP_NULL, 0},
2520     {"_Atomic", ATOMIC, OP_NULL, 0},
2521     {"enum", ENUM, OP_NULL, 0},
2522     {"long", LONG, OP_NULL, 0},
2523     {"_Complex", COMPLEX, OP_NULL, 0},
2524     {"__complex__", COMPLEX, OP_NULL, 0},
2525 
2526     {"true", TRUEKEYWORD, OP_NULL, FLAG_CXX},
2527     {"int", INT_KEYWORD, OP_NULL, 0},
2528     {"new", NEW, OP_NULL, FLAG_CXX},
2529     {"delete", DELETE, OP_NULL, FLAG_CXX},
2530     {"operator", OPERATOR, OP_NULL, FLAG_CXX},
2531 
2532     {"and", ANDAND, OP_NULL, FLAG_CXX},
2533     {"and_eq", ASSIGN_MODIFY, BINOP_BITWISE_AND, FLAG_CXX},
2534     {"bitand", '&', OP_NULL, FLAG_CXX},
2535     {"bitor", '|', OP_NULL, FLAG_CXX},
2536     {"compl", '~', OP_NULL, FLAG_CXX},
2537     {"not", '!', OP_NULL, FLAG_CXX},
2538     {"not_eq", NOTEQUAL, OP_NULL, FLAG_CXX},
2539     {"or", OROR, OP_NULL, FLAG_CXX},
2540     {"or_eq", ASSIGN_MODIFY, BINOP_BITWISE_IOR, FLAG_CXX},
2541     {"xor", '^', OP_NULL, FLAG_CXX},
2542     {"xor_eq", ASSIGN_MODIFY, BINOP_BITWISE_XOR, FLAG_CXX},
2543 
2544     {"const_cast", CONST_CAST, OP_NULL, FLAG_CXX },
2545     {"dynamic_cast", DYNAMIC_CAST, OP_NULL, FLAG_CXX },
2546     {"static_cast", STATIC_CAST, OP_NULL, FLAG_CXX },
2547     {"reinterpret_cast", REINTERPRET_CAST, OP_NULL, FLAG_CXX },
2548 
2549     {"__typeof__", TYPEOF, OP_TYPEOF, 0 },
2550     {"__typeof", TYPEOF, OP_TYPEOF, 0 },
2551     {"typeof", TYPEOF, OP_TYPEOF, FLAG_SHADOW },
2552     {"__decltype", DECLTYPE, OP_DECLTYPE, FLAG_CXX },
2553     {"decltype", DECLTYPE, OP_DECLTYPE, FLAG_CXX | FLAG_SHADOW },
2554 
2555     {"typeid", TYPEID, OP_TYPEID, FLAG_CXX}
2556   };
2557 
2558 
2559 static void
2560 scan_macro_expansion (const char *expansion)
2561 {
2562   /* We'd better not be trying to push the stack twice.  */
2563   gdb_assert (! cpstate->macro_original_text);
2564 
2565   /* Copy to the obstack.  */
2566   const char *copy = obstack_strdup (&cpstate->expansion_obstack, expansion);
2567 
2568   /* Save the old lexptr value, so we can return to it when we're done
2569      parsing the expanded text.  */
2570   cpstate->macro_original_text = pstate->lexptr;
2571   pstate->lexptr = copy;
2572 }
2573 
2574 static int
2575 scanning_macro_expansion (void)
2576 {
2577   return cpstate->macro_original_text != 0;
2578 }
2579 
2580 static void
2581 finished_macro_expansion (void)
2582 {
2583   /* There'd better be something to pop back to.  */
2584   gdb_assert (cpstate->macro_original_text);
2585 
2586   /* Pop back to the original text.  */
2587   pstate->lexptr = cpstate->macro_original_text;
2588   cpstate->macro_original_text = 0;
2589 }
2590 
2591 /* Return true iff the token represents a C++ cast operator.  */
2592 
2593 static int
2594 is_cast_operator (const char *token, int len)
2595 {
2596   return (! strncmp (token, "dynamic_cast", len)
2597 	  || ! strncmp (token, "static_cast", len)
2598 	  || ! strncmp (token, "reinterpret_cast", len)
2599 	  || ! strncmp (token, "const_cast", len));
2600 }
2601 
2602 /* The scope used for macro expansion.  */
2603 static struct macro_scope *expression_macro_scope;
2604 
2605 /* This is set if a NAME token appeared at the very end of the input
2606    string, with no whitespace separating the name from the EOF.  This
2607    is used only when parsing to do field name completion.  */
2608 static int saw_name_at_eof;
2609 
2610 /* This is set if the previously-returned token was a structure
2611    operator -- either '.' or ARROW.  */
2612 static bool last_was_structop;
2613 
2614 /* Depth of parentheses.  */
2615 static int paren_depth;
2616 
2617 static int
2618 get_namelen (const char *tokstart, bool dot)
2619 {
2620   int c;
2621   int namelen;
2622 
2623   for (namelen = 0, c = tokstart[namelen];
2624        (c == '_' || c == '$' || (dot && c == '.') || c_ident_is_alnum (c) || c == '<');)
2625     {
2626       /* Template parameter lists are part of the name.
2627 	 FIXME: This mishandles `print $a<4&&$a>3'.  */
2628 
2629       if (c == '<')
2630 	{
2631 	  if (! is_cast_operator (tokstart, namelen))
2632 	    {
2633 	      /* Scan ahead to get rest of the template specification.  Note
2634 		 that we look ahead only when the '<' adjoins non-whitespace
2635 		 characters; for comparison expressions, e.g. "a < b > c",
2636 		 there must be spaces before the '<', etc. */
2637 	      const char *p = find_template_name_end (tokstart + namelen);
2638 
2639 	      if (p)
2640 		namelen = p - tokstart;
2641 	    }
2642 	  break;
2643 	}
2644       c = tokstart[++namelen];
2645     }
2646   return namelen;
2647 }
2648 
2649 static bool is_generated_symbol (const char *symbol)
2650 {
2651   /* generated symbol are of the form:
2652 
2653      <symbol>.<number>
2654      <symbol>.isra.<number>
2655      <symbol>.part.<number>
2656 
2657     So we see if the symbol ends with .<number>
2658    */
2659 
2660   int len = get_namelen (symbol, true);
2661   int ndigits;
2662 
2663   if (len-- == 0)
2664     return false;
2665 
2666   for (ndigits = 0; ndigits <= len && ISDIGIT(symbol[len - ndigits]); ndigits++)
2667     continue;
2668 
2669   if (ndigits == 0)
2670     return false;
2671 
2672   return symbol[len - ndigits] == '.';
2673 }
2674 
2675 /* Read one token, getting characters through lexptr.  */
2676 
2677 static int
2678 lex_one_token (struct parser_state *par_state, bool *is_quoted_name)
2679 {
2680   int c;
2681   int namelen;
2682   const char *tokstart;
2683   bool saw_structop = last_was_structop;
2684 
2685   last_was_structop = false;
2686   *is_quoted_name = false;
2687 
2688  retry:
2689 
2690   /* Check if this is a macro invocation that we need to expand.  */
2691   if (! scanning_macro_expansion ())
2692     {
2693       gdb::unique_xmalloc_ptr<char> expanded
2694 	= macro_expand_next (&pstate->lexptr, *expression_macro_scope);
2695 
2696       if (expanded != nullptr)
2697 	scan_macro_expansion (expanded.get ());
2698     }
2699 
2700   pstate->prev_lexptr = pstate->lexptr;
2701 
2702   tokstart = pstate->lexptr;
2703   /* See if it is a special token of length 3.  */
2704   for (const auto &token : tokentab3)
2705     if (strncmp (tokstart, token.oper, 3) == 0)
2706       {
2707 	if ((token.flags & FLAG_CXX) != 0
2708 	    && par_state->language ()->la_language != language_cplus)
2709 	  break;
2710 	gdb_assert ((token.flags & FLAG_C) == 0);
2711 
2712 	pstate->lexptr += 3;
2713 	yylval.opcode = token.opcode;
2714 	return token.token;
2715       }
2716 
2717   /* See if it is a special token of length 2.  */
2718   for (const auto &token : tokentab2)
2719     if (strncmp (tokstart, token.oper, 2) == 0)
2720       {
2721 	if ((token.flags & FLAG_CXX) != 0
2722 	    && par_state->language ()->la_language != language_cplus)
2723 	  break;
2724 	gdb_assert ((token.flags & FLAG_C) == 0);
2725 
2726 	pstate->lexptr += 2;
2727 	yylval.opcode = token.opcode;
2728 	if (token.token == ARROW)
2729 	  last_was_structop = 1;
2730 	return token.token;
2731       }
2732 
2733   switch (c = *tokstart)
2734     {
2735     case 0:
2736       /* If we were just scanning the result of a macro expansion,
2737 	 then we need to resume scanning the original text.
2738 	 If we're parsing for field name completion, and the previous
2739 	 token allows such completion, return a COMPLETE token.
2740 	 Otherwise, we were already scanning the original text, and
2741 	 we're really done.  */
2742       if (scanning_macro_expansion ())
2743 	{
2744 	  finished_macro_expansion ();
2745 	  goto retry;
2746 	}
2747       else if (saw_name_at_eof)
2748 	{
2749 	  saw_name_at_eof = 0;
2750 	  return COMPLETE;
2751 	}
2752       else if (par_state->parse_completion && saw_structop)
2753 	return COMPLETE;
2754       else
2755 	return 0;
2756 
2757     case ' ':
2758     case '\t':
2759     case '\n':
2760       pstate->lexptr++;
2761       goto retry;
2762 
2763     case '[':
2764     case '(':
2765       paren_depth++;
2766       pstate->lexptr++;
2767       if (par_state->language ()->la_language == language_objc
2768 	  && c == '[')
2769 	return OBJC_LBRAC;
2770       return c;
2771 
2772     case ']':
2773     case ')':
2774       if (paren_depth == 0)
2775 	return 0;
2776       paren_depth--;
2777       pstate->lexptr++;
2778       return c;
2779 
2780     case ',':
2781       if (pstate->comma_terminates
2782 	  && paren_depth == 0
2783 	  && ! scanning_macro_expansion ())
2784 	return 0;
2785       pstate->lexptr++;
2786       return c;
2787 
2788     case '.':
2789       /* Might be a floating point number.  */
2790       if (pstate->lexptr[1] < '0' || pstate->lexptr[1] > '9')
2791 	{
2792 	  last_was_structop = true;
2793 	  goto symbol;		/* Nope, must be a symbol. */
2794 	}
2795       /* FALL THRU.  */
2796 
2797     case '0':
2798     case '1':
2799     case '2':
2800     case '3':
2801     case '4':
2802     case '5':
2803     case '6':
2804     case '7':
2805     case '8':
2806     case '9':
2807       {
2808 	/* It's a number.  */
2809 	int got_dot = 0, got_e = 0, got_p = 0, toktype;
2810 	const char *p = tokstart;
2811 	int hex = input_radix > 10;
2812 
2813 	if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
2814 	  {
2815 	    p += 2;
2816 	    hex = 1;
2817 	  }
2818 	else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
2819 	  {
2820 	    p += 2;
2821 	    hex = 0;
2822 	  }
2823 
2824 	for (;; ++p)
2825 	  {
2826 	    /* This test includes !hex because 'e' is a valid hex digit
2827 	       and thus does not indicate a floating point number when
2828 	       the radix is hex.  */
2829 	    if (!hex && !got_e && !got_p && (*p == 'e' || *p == 'E'))
2830 	      got_dot = got_e = 1;
2831 	    else if (!got_e && !got_p && (*p == 'p' || *p == 'P'))
2832 	      got_dot = got_p = 1;
2833 	    /* This test does not include !hex, because a '.' always indicates
2834 	       a decimal floating point number regardless of the radix.  */
2835 	    else if (!got_dot && *p == '.')
2836 	      got_dot = 1;
2837 	    else if (((got_e && (p[-1] == 'e' || p[-1] == 'E'))
2838 		      || (got_p && (p[-1] == 'p' || p[-1] == 'P')))
2839 		     && (*p == '-' || *p == '+'))
2840 	      /* This is the sign of the exponent, not the end of the
2841 		 number.  */
2842 	      continue;
2843 	    /* We will take any letters or digits.  parse_number will
2844 	       complain if past the radix, or if L or U are not final.  */
2845 	    else if ((*p < '0' || *p > '9')
2846 		     && ((*p < 'a' || *p > 'z')
2847 				  && (*p < 'A' || *p > 'Z')))
2848 	      break;
2849 	  }
2850 	toktype = parse_number (par_state, tokstart, p - tokstart,
2851 				got_dot | got_e | got_p, &yylval);
2852 	if (toktype == ERROR)
2853 	  {
2854 	    char *err_copy = (char *) alloca (p - tokstart + 1);
2855 
2856 	    memcpy (err_copy, tokstart, p - tokstart);
2857 	    err_copy[p - tokstart] = 0;
2858 	    error (_("Invalid number \"%s\"."), err_copy);
2859 	  }
2860 	pstate->lexptr = p;
2861 	return toktype;
2862       }
2863 
2864     case '@':
2865       {
2866 	const char *p = &tokstart[1];
2867 
2868 	if (par_state->language ()->la_language == language_objc)
2869 	  {
2870 	    size_t len = strlen ("selector");
2871 
2872 	    if (strncmp (p, "selector", len) == 0
2873 		&& (p[len] == '\0' || ISSPACE (p[len])))
2874 	      {
2875 		pstate->lexptr = p + len;
2876 		return SELECTOR;
2877 	      }
2878 	    else if (*p == '"')
2879 	      goto parse_string;
2880 	  }
2881 
2882 	while (ISSPACE (*p))
2883 	  p++;
2884 	size_t len = strlen ("entry");
2885 	if (strncmp (p, "entry", len) == 0 && !c_ident_is_alnum (p[len])
2886 	    && p[len] != '_')
2887 	  {
2888 	    pstate->lexptr = &p[len];
2889 	    return ENTRY;
2890 	  }
2891       }
2892       /* FALLTHRU */
2893     case '+':
2894     case '-':
2895     case '*':
2896     case '/':
2897     case '%':
2898     case '|':
2899     case '&':
2900     case '^':
2901     case '~':
2902     case '!':
2903     case '<':
2904     case '>':
2905     case '?':
2906     case ':':
2907     case '=':
2908     case '{':
2909     case '}':
2910     symbol:
2911       pstate->lexptr++;
2912       return c;
2913 
2914     case 'L':
2915     case 'u':
2916     case 'U':
2917       if (tokstart[1] != '"' && tokstart[1] != '\'')
2918 	break;
2919       /* Fall through.  */
2920     case '\'':
2921     case '"':
2922 
2923     parse_string:
2924       {
2925 	int host_len;
2926 	int result = parse_string_or_char (tokstart, &pstate->lexptr,
2927 					   &yylval.tsval, &host_len);
2928 	if (result == CHAR)
2929 	  {
2930 	    if (host_len == 0)
2931 	      error (_("Empty character constant."));
2932 	    else if (host_len > 2 && c == '\'')
2933 	      {
2934 		++tokstart;
2935 		namelen = pstate->lexptr - tokstart - 1;
2936 		*is_quoted_name = true;
2937 
2938 		goto tryname;
2939 	      }
2940 	    else if (host_len > 1)
2941 	      error (_("Invalid character constant."));
2942 	  }
2943 	return result;
2944       }
2945     }
2946 
2947   if (!(c == '_' || c == '$' || c_ident_is_alpha (c)))
2948     /* We must have come across a bad character (e.g. ';').  */
2949     error (_("Invalid character '%c' in expression."), c);
2950 
2951   /* It's a name.  See how long it is.  */
2952   namelen = get_namelen (tokstart, is_generated_symbol (tokstart));
2953 
2954   /* The token "if" terminates the expression and is NOT removed from
2955      the input stream.  It doesn't count if it appears in the
2956      expansion of a macro.  */
2957   if (namelen == 2
2958       && tokstart[0] == 'i'
2959       && tokstart[1] == 'f'
2960       && ! scanning_macro_expansion ())
2961     {
2962       return 0;
2963     }
2964 
2965   /* For the same reason (breakpoint conditions), "thread N"
2966      terminates the expression.  "thread" could be an identifier, but
2967      an identifier is never followed by a number without intervening
2968      punctuation.  "task" is similar.  Handle abbreviations of these,
2969      similarly to breakpoint.c:find_condition_and_thread.  */
2970   if (namelen >= 1
2971       && (strncmp (tokstart, "thread", namelen) == 0
2972 	  || strncmp (tokstart, "task", namelen) == 0)
2973       && (tokstart[namelen] == ' ' || tokstart[namelen] == '\t')
2974       && ! scanning_macro_expansion ())
2975     {
2976       const char *p = tokstart + namelen + 1;
2977 
2978       while (*p == ' ' || *p == '\t')
2979 	p++;
2980       if (*p >= '0' && *p <= '9')
2981 	return 0;
2982     }
2983 
2984   pstate->lexptr += namelen;
2985 
2986   tryname:
2987 
2988   yylval.sval.ptr = tokstart;
2989   yylval.sval.length = namelen;
2990 
2991   /* Catch specific keywords.  */
2992   std::string copy = copy_name (yylval.sval);
2993   for (const auto &token : ident_tokens)
2994     if (copy == token.oper)
2995       {
2996 	if ((token.flags & FLAG_CXX) != 0
2997 	    && par_state->language ()->la_language != language_cplus)
2998 	  break;
2999 	if ((token.flags & FLAG_C) != 0
3000 	    && par_state->language ()->la_language != language_c
3001 	    && par_state->language ()->la_language != language_objc)
3002 	  break;
3003 
3004 	if ((token.flags & FLAG_SHADOW) != 0)
3005 	  {
3006 	    struct field_of_this_result is_a_field_of_this;
3007 
3008 	    if (lookup_symbol (copy.c_str (),
3009 			       pstate->expression_context_block,
3010 			       VAR_DOMAIN,
3011 			       (par_state->language ()->la_language
3012 				== language_cplus ? &is_a_field_of_this
3013 				: NULL)).symbol
3014 		!= NULL)
3015 	      {
3016 		/* The keyword is shadowed.  */
3017 		break;
3018 	      }
3019 	  }
3020 
3021 	/* It is ok to always set this, even though we don't always
3022 	   strictly need to.  */
3023 	yylval.opcode = token.opcode;
3024 	return token.token;
3025       }
3026 
3027   if (*tokstart == '$')
3028     return DOLLAR_VARIABLE;
3029 
3030   if (pstate->parse_completion && *pstate->lexptr == '\0')
3031     saw_name_at_eof = 1;
3032 
3033   yylval.ssym.stoken = yylval.sval;
3034   yylval.ssym.sym.symbol = NULL;
3035   yylval.ssym.sym.block = NULL;
3036   yylval.ssym.is_a_field_of_this = 0;
3037   return NAME;
3038 }
3039 
3040 /* An object of this type is pushed on a FIFO by the "outer" lexer.  */
3041 struct token_and_value
3042 {
3043   int token;
3044   YYSTYPE value;
3045 };
3046 
3047 /* A FIFO of tokens that have been read but not yet returned to the
3048    parser.  */
3049 static std::vector<token_and_value> token_fifo;
3050 
3051 /* Non-zero if the lexer should return tokens from the FIFO.  */
3052 static int popping;
3053 
3054 /* Temporary storage for c_lex; this holds symbol names as they are
3055    built up.  */
3056 static auto_obstack name_obstack;
3057 
3058 /* Classify a NAME token.  The contents of the token are in `yylval'.
3059    Updates yylval and returns the new token type.  BLOCK is the block
3060    in which lookups start; this can be NULL to mean the global scope.
3061    IS_QUOTED_NAME is non-zero if the name token was originally quoted
3062    in single quotes.  IS_AFTER_STRUCTOP is true if this name follows
3063    a structure operator -- either '.' or ARROW  */
3064 
3065 static int
3066 classify_name (struct parser_state *par_state, const struct block *block,
3067 	       bool is_quoted_name, bool is_after_structop)
3068 {
3069   struct block_symbol bsym;
3070   struct field_of_this_result is_a_field_of_this;
3071 
3072   std::string copy = copy_name (yylval.sval);
3073 
3074   /* Initialize this in case we *don't* use it in this call; that way
3075      we can refer to it unconditionally below.  */
3076   memset (&is_a_field_of_this, 0, sizeof (is_a_field_of_this));
3077 
3078   bsym = lookup_symbol (copy.c_str (), block, VAR_DOMAIN,
3079 			par_state->language ()->name_of_this ()
3080 			? &is_a_field_of_this : NULL);
3081 
3082   if (bsym.symbol && bsym.symbol->aclass () == LOC_BLOCK)
3083     {
3084       yylval.ssym.sym = bsym;
3085       yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
3086       return BLOCKNAME;
3087     }
3088   else if (!bsym.symbol)
3089     {
3090       /* If we found a field of 'this', we might have erroneously
3091 	 found a constructor where we wanted a type name.  Handle this
3092 	 case by noticing that we found a constructor and then look up
3093 	 the type tag instead.  */
3094       if (is_a_field_of_this.type != NULL
3095 	  && is_a_field_of_this.fn_field != NULL
3096 	  && TYPE_FN_FIELD_CONSTRUCTOR (is_a_field_of_this.fn_field->fn_fields,
3097 					0))
3098 	{
3099 	  struct field_of_this_result inner_is_a_field_of_this;
3100 
3101 	  bsym = lookup_symbol (copy.c_str (), block, STRUCT_DOMAIN,
3102 				&inner_is_a_field_of_this);
3103 	  if (bsym.symbol != NULL)
3104 	    {
3105 	      yylval.tsym.type = bsym.symbol->type ();
3106 	      return TYPENAME;
3107 	    }
3108 	}
3109 
3110       /* If we found a field on the "this" object, or we are looking
3111 	 up a field on a struct, then we want to prefer it over a
3112 	 filename.  However, if the name was quoted, then it is better
3113 	 to check for a filename or a block, since this is the only
3114 	 way the user has of requiring the extension to be used.  */
3115       if ((is_a_field_of_this.type == NULL && !is_after_structop)
3116 	  || is_quoted_name)
3117 	{
3118 	  /* See if it's a file name. */
3119 	  struct symtab *symtab;
3120 
3121 	  symtab = lookup_symtab (copy.c_str ());
3122 	  if (symtab)
3123 	    {
3124 	      yylval.bval
3125 		= symtab->compunit ()->blockvector ()->static_block ();
3126 
3127 	      return FILENAME;
3128 	    }
3129 	}
3130     }
3131 
3132   if (bsym.symbol && bsym.symbol->aclass () == LOC_TYPEDEF)
3133     {
3134       yylval.tsym.type = bsym.symbol->type ();
3135       return TYPENAME;
3136     }
3137 
3138   /* See if it's an ObjC classname.  */
3139   if (par_state->language ()->la_language == language_objc && !bsym.symbol)
3140     {
3141       CORE_ADDR Class = lookup_objc_class (par_state->gdbarch (),
3142 					   copy.c_str ());
3143       if (Class)
3144 	{
3145 	  struct symbol *sym;
3146 
3147 	  yylval.theclass.theclass = Class;
3148 	  sym = lookup_struct_typedef (copy.c_str (),
3149 				       par_state->expression_context_block, 1);
3150 	  if (sym)
3151 	    yylval.theclass.type = sym->type ();
3152 	  return CLASSNAME;
3153 	}
3154     }
3155 
3156   /* Input names that aren't symbols but ARE valid hex numbers, when
3157      the input radix permits them, can be names or numbers depending
3158      on the parse.  Note we support radixes > 16 here.  */
3159   if (!bsym.symbol
3160       && ((copy[0] >= 'a' && copy[0] < 'a' + input_radix - 10)
3161 	  || (copy[0] >= 'A' && copy[0] < 'A' + input_radix - 10)))
3162     {
3163       YYSTYPE newlval;	/* Its value is ignored.  */
3164       int hextype = parse_number (par_state, copy.c_str (), yylval.sval.length,
3165 				  0, &newlval);
3166 
3167       if (hextype == INT)
3168 	{
3169 	  yylval.ssym.sym = bsym;
3170 	  yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
3171 	  return NAME_OR_INT;
3172 	}
3173     }
3174 
3175   /* Any other kind of symbol */
3176   yylval.ssym.sym = bsym;
3177   yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
3178 
3179   if (bsym.symbol == NULL
3180       && par_state->language ()->la_language == language_cplus
3181       && is_a_field_of_this.type == NULL
3182       && lookup_minimal_symbol (copy.c_str (), NULL, NULL).minsym == NULL)
3183     return UNKNOWN_CPP_NAME;
3184 
3185   return NAME;
3186 }
3187 
3188 /* Like classify_name, but used by the inner loop of the lexer, when a
3189    name might have already been seen.  CONTEXT is the context type, or
3190    NULL if this is the first component of a name.  */
3191 
3192 static int
3193 classify_inner_name (struct parser_state *par_state,
3194 		     const struct block *block, struct type *context)
3195 {
3196   struct type *type;
3197 
3198   if (context == NULL)
3199     return classify_name (par_state, block, false, false);
3200 
3201   type = check_typedef (context);
3202   if (!type_aggregate_p (type))
3203     return ERROR;
3204 
3205   std::string copy = copy_name (yylval.ssym.stoken);
3206   /* N.B. We assume the symbol can only be in VAR_DOMAIN.  */
3207   yylval.ssym.sym = cp_lookup_nested_symbol (type, copy.c_str (), block,
3208 					     VAR_DOMAIN);
3209 
3210   /* If no symbol was found, search for a matching base class named
3211      COPY.  This will allow users to enter qualified names of class members
3212      relative to the `this' pointer.  */
3213   if (yylval.ssym.sym.symbol == NULL)
3214     {
3215       struct type *base_type = cp_find_type_baseclass_by_name (type,
3216 							       copy.c_str ());
3217 
3218       if (base_type != NULL)
3219 	{
3220 	  yylval.tsym.type = base_type;
3221 	  return TYPENAME;
3222 	}
3223 
3224       return ERROR;
3225     }
3226 
3227   switch (yylval.ssym.sym.symbol->aclass ())
3228     {
3229     case LOC_BLOCK:
3230     case LOC_LABEL:
3231       /* cp_lookup_nested_symbol might have accidentally found a constructor
3232 	 named COPY when we really wanted a base class of the same name.
3233 	 Double-check this case by looking for a base class.  */
3234       {
3235 	struct type *base_type
3236 	  = cp_find_type_baseclass_by_name (type, copy.c_str ());
3237 
3238 	if (base_type != NULL)
3239 	  {
3240 	    yylval.tsym.type = base_type;
3241 	    return TYPENAME;
3242 	  }
3243       }
3244       return ERROR;
3245 
3246     case LOC_TYPEDEF:
3247       yylval.tsym.type = yylval.ssym.sym.symbol->type ();
3248       return TYPENAME;
3249 
3250     default:
3251       return NAME;
3252     }
3253   internal_error (_("not reached"));
3254 }
3255 
3256 /* The outer level of a two-level lexer.  This calls the inner lexer
3257    to return tokens.  It then either returns these tokens, or
3258    aggregates them into a larger token.  This lets us work around a
3259    problem in our parsing approach, where the parser could not
3260    distinguish between qualified names and qualified types at the
3261    right point.
3262 
3263    This approach is still not ideal, because it mishandles template
3264    types.  See the comment in lex_one_token for an example.  However,
3265    this is still an improvement over the earlier approach, and will
3266    suffice until we move to better parsing technology.  */
3267 
3268 static int
3269 yylex (void)
3270 {
3271   token_and_value current;
3272   int first_was_coloncolon, last_was_coloncolon;
3273   struct type *context_type = NULL;
3274   int last_to_examine, next_to_examine, checkpoint;
3275   const struct block *search_block;
3276   bool is_quoted_name, last_lex_was_structop;
3277 
3278   if (popping && !token_fifo.empty ())
3279     goto do_pop;
3280   popping = 0;
3281 
3282   last_lex_was_structop = last_was_structop;
3283 
3284   /* Read the first token and decide what to do.  Most of the
3285      subsequent code is C++-only; but also depends on seeing a "::" or
3286      name-like token.  */
3287   current.token = lex_one_token (pstate, &is_quoted_name);
3288   if (current.token == NAME)
3289     current.token = classify_name (pstate, pstate->expression_context_block,
3290 				   is_quoted_name, last_lex_was_structop);
3291   if (pstate->language ()->la_language != language_cplus
3292       || (current.token != TYPENAME && current.token != COLONCOLON
3293 	  && current.token != FILENAME))
3294     return current.token;
3295 
3296   /* Read any sequence of alternating "::" and name-like tokens into
3297      the token FIFO.  */
3298   current.value = yylval;
3299   token_fifo.push_back (current);
3300   last_was_coloncolon = current.token == COLONCOLON;
3301   while (1)
3302     {
3303       bool ignore;
3304 
3305       /* We ignore quoted names other than the very first one.
3306 	 Subsequent ones do not have any special meaning.  */
3307       current.token = lex_one_token (pstate, &ignore);
3308       current.value = yylval;
3309       token_fifo.push_back (current);
3310 
3311       if ((last_was_coloncolon && current.token != NAME)
3312 	  || (!last_was_coloncolon && current.token != COLONCOLON))
3313 	break;
3314       last_was_coloncolon = !last_was_coloncolon;
3315     }
3316   popping = 1;
3317 
3318   /* We always read one extra token, so compute the number of tokens
3319      to examine accordingly.  */
3320   last_to_examine = token_fifo.size () - 2;
3321   next_to_examine = 0;
3322 
3323   current = token_fifo[next_to_examine];
3324   ++next_to_examine;
3325 
3326   name_obstack.clear ();
3327   checkpoint = 0;
3328   if (current.token == FILENAME)
3329     search_block = current.value.bval;
3330   else if (current.token == COLONCOLON)
3331     search_block = NULL;
3332   else
3333     {
3334       gdb_assert (current.token == TYPENAME);
3335       search_block = pstate->expression_context_block;
3336       obstack_grow (&name_obstack, current.value.sval.ptr,
3337 		    current.value.sval.length);
3338       context_type = current.value.tsym.type;
3339       checkpoint = 1;
3340     }
3341 
3342   first_was_coloncolon = current.token == COLONCOLON;
3343   last_was_coloncolon = first_was_coloncolon;
3344 
3345   while (next_to_examine <= last_to_examine)
3346     {
3347       token_and_value next;
3348 
3349       next = token_fifo[next_to_examine];
3350       ++next_to_examine;
3351 
3352       if (next.token == NAME && last_was_coloncolon)
3353 	{
3354 	  int classification;
3355 
3356 	  yylval = next.value;
3357 	  classification = classify_inner_name (pstate, search_block,
3358 						context_type);
3359 	  /* We keep going until we either run out of names, or until
3360 	     we have a qualified name which is not a type.  */
3361 	  if (classification != TYPENAME && classification != NAME)
3362 	    break;
3363 
3364 	  /* Accept up to this token.  */
3365 	  checkpoint = next_to_examine;
3366 
3367 	  /* Update the partial name we are constructing.  */
3368 	  if (context_type != NULL)
3369 	    {
3370 	      /* We don't want to put a leading "::" into the name.  */
3371 	      obstack_grow_str (&name_obstack, "::");
3372 	    }
3373 	  obstack_grow (&name_obstack, next.value.sval.ptr,
3374 			next.value.sval.length);
3375 
3376 	  yylval.sval.ptr = (const char *) obstack_base (&name_obstack);
3377 	  yylval.sval.length = obstack_object_size (&name_obstack);
3378 	  current.value = yylval;
3379 	  current.token = classification;
3380 
3381 	  last_was_coloncolon = 0;
3382 
3383 	  if (classification == NAME)
3384 	    break;
3385 
3386 	  context_type = yylval.tsym.type;
3387 	}
3388       else if (next.token == COLONCOLON && !last_was_coloncolon)
3389 	last_was_coloncolon = 1;
3390       else
3391 	{
3392 	  /* We've reached the end of the name.  */
3393 	  break;
3394 	}
3395     }
3396 
3397   /* If we have a replacement token, install it as the first token in
3398      the FIFO, and delete the other constituent tokens.  */
3399   if (checkpoint > 0)
3400     {
3401       current.value.sval.ptr
3402 	= obstack_strndup (&cpstate->expansion_obstack,
3403 			   current.value.sval.ptr,
3404 			   current.value.sval.length);
3405 
3406       token_fifo[0] = current;
3407       if (checkpoint > 1)
3408 	token_fifo.erase (token_fifo.begin () + 1,
3409 			  token_fifo.begin () + checkpoint);
3410     }
3411 
3412  do_pop:
3413   current = token_fifo[0];
3414   token_fifo.erase (token_fifo.begin ());
3415   yylval = current.value;
3416   return current.token;
3417 }
3418 
3419 int
3420 c_parse (struct parser_state *par_state)
3421 {
3422   /* Setting up the parser state.  */
3423   scoped_restore pstate_restore = make_scoped_restore (&pstate);
3424   gdb_assert (par_state != NULL);
3425   pstate = par_state;
3426 
3427   c_parse_state cstate;
3428   scoped_restore cstate_restore = make_scoped_restore (&cpstate, &cstate);
3429 
3430   gdb::unique_xmalloc_ptr<struct macro_scope> macro_scope;
3431 
3432   if (par_state->expression_context_block)
3433     macro_scope
3434       = sal_macro_scope (find_pc_line (par_state->expression_context_pc, 0));
3435   else
3436     macro_scope = default_macro_scope ();
3437   if (! macro_scope)
3438     macro_scope = user_macro_scope ();
3439 
3440   scoped_restore restore_macro_scope
3441     = make_scoped_restore (&expression_macro_scope, macro_scope.get ());
3442 
3443   scoped_restore restore_yydebug = make_scoped_restore (&yydebug,
3444 							parser_debug);
3445 
3446   /* Initialize some state used by the lexer.  */
3447   last_was_structop = false;
3448   saw_name_at_eof = 0;
3449   paren_depth = 0;
3450 
3451   token_fifo.clear ();
3452   popping = 0;
3453   name_obstack.clear ();
3454 
3455   int result = yyparse ();
3456   if (!result)
3457     pstate->set_operation (pstate->pop ());
3458   return result;
3459 }
3460 
3461 #if defined(YYBISON) && YYBISON < 30800
3462 
3463 
3464 /* This is called via the YYPRINT macro when parser debugging is
3465    enabled.  It prints a token's value.  */
3466 
3467 static void
3468 c_print_token (FILE *file, int type, YYSTYPE value)
3469 {
3470   switch (type)
3471     {
3472     case INT:
3473       parser_fprintf (file, "typed_val_int<%s, %s>",
3474 		      TYPE_SAFE_NAME (value.typed_val_int.type),
3475 		      pulongest (value.typed_val_int.val));
3476       break;
3477 
3478     case CHAR:
3479     case STRING:
3480       {
3481 	char *copy = (char *) alloca (value.tsval.length + 1);
3482 
3483 	memcpy (copy, value.tsval.ptr, value.tsval.length);
3484 	copy[value.tsval.length] = '\0';
3485 
3486 	parser_fprintf (file, "tsval<type=%d, %s>", value.tsval.type, copy);
3487       }
3488       break;
3489 
3490     case NSSTRING:
3491     case DOLLAR_VARIABLE:
3492       parser_fprintf (file, "sval<%s>", copy_name (value.sval).c_str ());
3493       break;
3494 
3495     case TYPENAME:
3496       parser_fprintf (file, "tsym<type=%s, name=%s>",
3497 		      TYPE_SAFE_NAME (value.tsym.type),
3498 		      copy_name (value.tsym.stoken).c_str ());
3499       break;
3500 
3501     case NAME:
3502     case UNKNOWN_CPP_NAME:
3503     case NAME_OR_INT:
3504     case BLOCKNAME:
3505       parser_fprintf (file, "ssym<name=%s, sym=%s, field_of_this=%d>",
3506 		       copy_name (value.ssym.stoken).c_str (),
3507 		       (value.ssym.sym.symbol == NULL
3508 			? "(null)" : value.ssym.sym.symbol->print_name ()),
3509 		       value.ssym.is_a_field_of_this);
3510       break;
3511 
3512     case FILENAME:
3513       parser_fprintf (file, "bval<%s>", host_address_to_string (value.bval));
3514       break;
3515     }
3516 }
3517 
3518 #endif
3519 
3520 static void
3521 yyerror (const char *msg)
3522 {
3523   if (pstate->prev_lexptr)
3524     pstate->lexptr = pstate->prev_lexptr;
3525 
3526   error (_("A %s in expression, near `%s'."), msg, pstate->lexptr);
3527 }
3528