gdb/c-exp.y

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