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