gdb/c-exp.y

   1 /* YACC parser for C expressions, for GDB.
   2    Copyright (C) 1986, 1989-2000, 2003-2004, 2006-2012 Free Software
   3    Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 /* Parse a C expression from text in a string,
  21    and return the result as a  struct expression  pointer.
  22    That structure contains arithmetic operations in reverse polish,
  23    with constants represented by operations that are followed by special data.
  24    See expression.h for the details of the format.
  25    What is important here is that it can be built up sequentially
  26    during the process of parsing; the lower levels of the tree always
  27    come first in the result.
  28
  29    Note that malloc's and realloc's in this file are transformed to
  30    xmalloc and xrealloc respectively by the same sed command in the
  31    makefile that remaps any other malloc/realloc inserted by the parser
  32    generator.  Doing this with #defines and trying to control the interaction
  33    with include files (<malloc.h> and <stdlib.h> for example) just became
  34    too messy, particularly when such includes can be inserted at random
  35    times by the parser generator.  */
  36
  37 %{
  38
  39 #include "defs.h"
  40 #include "gdb_string.h"
  41 #include <ctype.h>
  42 #include "expression.h"
  43 #include "value.h"
  44 #include "parser-defs.h"
  45 #include "language.h"
  46 #include "c-lang.h"
  47 #include "bfd.h" /* Required by objfiles.h.  */
  48 #include "symfile.h" /* Required by objfiles.h.  */
  49 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
  50 #include "charset.h"
  51 #include "block.h"
  52 #include "cp-support.h"
  53 #include "dfp.h"
  54 #include "gdb_assert.h"
  55 #include "macroscope.h"
  56
  57 #define parse_type builtin_type (parse_gdbarch)
  58
  59 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
  60    as well as gratuitiously global symbol names, so we can have multiple
  61    yacc generated parsers in gdb.  Note that these are only the variables
  62    produced by yacc.  If other parser generators (bison, byacc, etc) produce
  63    additional global names that conflict at link time, then those parser
  64    generators need to be fixed instead of adding those names to this list. */
  65
  66 #define yymaxdepth c_maxdepth
  67 #define yyparse c_parse_internal
  68 #define yylex   c_lex
  69 #define yyerror c_error
  70 #define yylval  c_lval
  71 #define yychar  c_char
  72 #define yydebug c_debug
  73 #define yypact  c_pact
  74 #define yyr1    c_r1
  75 #define yyr2    c_r2
  76 #define yydef   c_def
  77 #define yychk   c_chk
  78 #define yypgo   c_pgo
  79 #define yyact   c_act
  80 #define yyexca  c_exca
  81 #define yyerrflag c_errflag
  82 #define yynerrs c_nerrs
  83 #define yyps    c_ps
  84 #define yypv    c_pv
  85 #define yys     c_s
  86 #define yy_yys  c_yys
  87 #define yystate c_state
  88 #define yytmp   c_tmp
  89 #define yyv     c_v
  90 #define yy_yyv  c_yyv
  91 #define yyval   c_val
  92 #define yylloc  c_lloc
  93 #define yyreds  c_reds          /* With YYDEBUG defined */
  94 #define yytoks  c_toks          /* With YYDEBUG defined */
  95 #define yyname  c_name          /* With YYDEBUG defined */
  96 #define yyrule  c_rule          /* With YYDEBUG defined */
  97 #define yylhs   c_yylhs
  98 #define yylen   c_yylen
  99 #define yydefred c_yydefred
 100 #define yydgoto c_yydgoto
 101 #define yysindex c_yysindex
 102 #define yyrindex c_yyrindex
 103 #define yygindex c_yygindex
 104 #define yytable  c_yytable
 105 #define yycheck  c_yycheck
 106 #define yyss    c_yyss
 107 #define yysslim c_yysslim
 108 #define yyssp   c_yyssp
 109 #define yystacksize c_yystacksize
 110 #define yyvs    c_yyvs
 111 #define yyvsp   c_yyvsp
 112
 113 #ifndef YYDEBUG
 114 #define YYDEBUG 1               /* Default to yydebug support */
 115 #endif
 116
 117 #define YYFPRINTF parser_fprintf
 118
 119 int yyparse (void);
 120
 121 static int yylex (void);
 122
 123 void yyerror (char *);
 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       DOUBLEST dval;
 140       struct type *type;
 141     } typed_val_float;
 142     struct {
 143       gdb_byte val[16];
 144       struct type *type;
 145     } typed_val_decfloat;
 146     struct symbol *sym;
 147     struct type *tval;
 148     struct stoken sval;
 149     struct typed_stoken tsval;
 150     struct ttype tsym;
 151     struct symtoken ssym;
 152     int voidval;
 153     struct block *bval;
 154     enum exp_opcode opcode;
 155     struct internalvar *ivar;
 156
 157     struct stoken_vector svec;
 158     struct type **tvec;
 159     int *ivec;
 160   }
 161
 162 %{
 163 /* YYSTYPE gets defined by %union */
 164 static int parse_number (char *, int, int, YYSTYPE *);
 165 static struct stoken operator_stoken (const char *);
 166 %}
 167
 168 %type <voidval> exp exp1 type_exp start variable qualified_name lcurly
 169 %type <lval> rcurly
 170 %type <tval> type typebase
 171 %type <tvec> nonempty_typelist
 172 /* %type <bval> block */
 173
 174 /* Fancy type parsing.  */
 175 %type <voidval> func_mod direct_abs_decl abs_decl
 176 %type <tval> ptype
 177 %type <lval> array_mod
 178
 179 %token <typed_val_int> INT
 180 %token <typed_val_float> FLOAT
 181 %token <typed_val_decfloat> DECFLOAT
 182
 183 /* Both NAME and TYPENAME tokens represent symbols in the input,
 184    and both convey their data as strings.
 185    But a TYPENAME is a string that happens to be defined as a typedef
 186    or builtin type name (such as int or char)
 187    and a NAME is any other symbol.
 188    Contexts where this distinction is not important can use the
 189    nonterminal "name", which matches either NAME or TYPENAME.  */
 190
 191 %token <tsval> STRING
 192 %token <tsval> CHAR
 193 %token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */
 194 %token <ssym> UNKNOWN_CPP_NAME
 195 %token <voidval> COMPLETE
 196 %token <tsym> TYPENAME
 197 %type <sval> name
 198 %type <svec> string_exp
 199 %type <ssym> name_not_typename
 200 %type <tsym> typename
 201
 202 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
 203    but which would parse as a valid number in the current input radix.
 204    E.g. "c" when input_radix==16.  Depending on the parse, it will be
 205    turned into a name or into a number.  */
 206
 207 %token <ssym> NAME_OR_INT
 208
 209 %token OPERATOR
 210 %token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
 211 %token TEMPLATE
 212 %token ERROR
 213 %token NEW DELETE
 214 %type <sval> operator
 215 %token REINTERPRET_CAST DYNAMIC_CAST STATIC_CAST CONST_CAST
 216 %token ENTRY
 217
 218 /* Special type cases, put in to allow the parser to distinguish different
 219    legal basetypes.  */
 220 %token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD DOUBLE_KEYWORD
 221
 222 %token <sval> VARIABLE
 223
 224 %token <opcode> ASSIGN_MODIFY
 225
 226 /* C++ */
 227 %token TRUEKEYWORD
 228 %token FALSEKEYWORD
 229
 230
 231 %left ','
 232 %left ABOVE_COMMA
 233 %right '=' ASSIGN_MODIFY
 234 %right '?'
 235 %left OROR
 236 %left ANDAND
 237 %left '|'
 238 %left '^'
 239 %left '&'
 240 %left EQUAL NOTEQUAL
 241 %left '<' '>' LEQ GEQ
 242 %left LSH RSH
 243 %left '@'
 244 %left '+' '-'
 245 %left '*' '/' '%'
 246 %right UNARY INCREMENT DECREMENT
 247 %right ARROW ARROW_STAR '.' DOT_STAR '[' '('
 248 %token <ssym> BLOCKNAME
 249 %token <bval> FILENAME
 250 %type <bval> block
 251 %left COLONCOLON
 252
 253 \f
 254 %%
 255
 256 start   :       exp1
 257         |       type_exp
 258         ;
 259
 260 type_exp:       type
 261                         { write_exp_elt_opcode(OP_TYPE);
 262                           write_exp_elt_type($1);
 263                           write_exp_elt_opcode(OP_TYPE);}
 264         ;
 265
 266 /* Expressions, including the comma operator.  */
 267 exp1    :       exp
 268         |       exp1 ',' exp
 269                         { write_exp_elt_opcode (BINOP_COMMA); }
 270         ;
 271
 272 /* Expressions, not including the comma operator.  */
 273 exp     :       '*' exp    %prec UNARY
 274                         { write_exp_elt_opcode (UNOP_IND); }
 275         ;
 276
 277 exp     :       '&' exp    %prec UNARY
 278                         { write_exp_elt_opcode (UNOP_ADDR); }
 279         ;
 280
 281 exp     :       '-' exp    %prec UNARY
 282                         { write_exp_elt_opcode (UNOP_NEG); }
 283         ;
 284
 285 exp     :       '+' exp    %prec UNARY
 286                         { write_exp_elt_opcode (UNOP_PLUS); }
 287         ;
 288
 289 exp     :       '!' exp    %prec UNARY
 290                         { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
 291         ;
 292
 293 exp     :       '~' exp    %prec UNARY
 294                         { write_exp_elt_opcode (UNOP_COMPLEMENT); }
 295         ;
 296
 297 exp     :       INCREMENT exp    %prec UNARY
 298                         { write_exp_elt_opcode (UNOP_PREINCREMENT); }
 299         ;
 300
 301 exp     :       DECREMENT exp    %prec UNARY
 302                         { write_exp_elt_opcode (UNOP_PREDECREMENT); }
 303         ;
 304
 305 exp     :       exp INCREMENT    %prec UNARY
 306                         { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
 307         ;
 308
 309 exp     :       exp DECREMENT    %prec UNARY
 310                         { write_exp_elt_opcode (UNOP_POSTDECREMENT); }
 311         ;
 312
 313 exp     :       SIZEOF exp       %prec UNARY
 314                         { write_exp_elt_opcode (UNOP_SIZEOF); }
 315         ;
 316
 317 exp     :       exp ARROW name
 318                         { write_exp_elt_opcode (STRUCTOP_PTR);
 319                           write_exp_string ($3);
 320                           write_exp_elt_opcode (STRUCTOP_PTR); }
 321         ;
 322
 323 exp     :       exp ARROW name COMPLETE
 324                         { mark_struct_expression ();
 325                           write_exp_elt_opcode (STRUCTOP_PTR);
 326                           write_exp_string ($3);
 327                           write_exp_elt_opcode (STRUCTOP_PTR); }
 328         ;
 329
 330 exp     :       exp ARROW COMPLETE
 331                         { struct stoken s;
 332                           mark_struct_expression ();
 333                           write_exp_elt_opcode (STRUCTOP_PTR);
 334                           s.ptr = "";
 335                           s.length = 0;
 336                           write_exp_string (s);
 337                           write_exp_elt_opcode (STRUCTOP_PTR); }
 338         ;
 339
 340 exp     :       exp ARROW qualified_name
 341                         { /* exp->type::name becomes exp->*(&type::name) */
 342                           /* Note: this doesn't work if name is a
 343                              static member!  FIXME */
 344                           write_exp_elt_opcode (UNOP_ADDR);
 345                           write_exp_elt_opcode (STRUCTOP_MPTR); }
 346         ;
 347
 348 exp     :       exp ARROW_STAR exp
 349                         { write_exp_elt_opcode (STRUCTOP_MPTR); }
 350         ;
 351
 352 exp     :       exp '.' name
 353                         { write_exp_elt_opcode (STRUCTOP_STRUCT);
 354                           write_exp_string ($3);
 355                           write_exp_elt_opcode (STRUCTOP_STRUCT); }
 356         ;
 357
 358 exp     :       exp '.' name COMPLETE
 359                         { mark_struct_expression ();
 360                           write_exp_elt_opcode (STRUCTOP_STRUCT);
 361                           write_exp_string ($3);
 362                           write_exp_elt_opcode (STRUCTOP_STRUCT); }
 363         ;
 364
 365 exp     :       exp '.' COMPLETE
 366                         { struct stoken s;
 367                           mark_struct_expression ();
 368                           write_exp_elt_opcode (STRUCTOP_STRUCT);
 369                           s.ptr = "";
 370                           s.length = 0;
 371                           write_exp_string (s);
 372                           write_exp_elt_opcode (STRUCTOP_STRUCT); }
 373         ;
 374
 375 exp     :       exp '.' qualified_name
 376                         { /* exp.type::name becomes exp.*(&type::name) */
 377                           /* Note: this doesn't work if name is a
 378                              static member!  FIXME */
 379                           write_exp_elt_opcode (UNOP_ADDR);
 380                           write_exp_elt_opcode (STRUCTOP_MEMBER); }
 381         ;
 382
 383 exp     :       exp DOT_STAR exp
 384                         { write_exp_elt_opcode (STRUCTOP_MEMBER); }
 385         ;
 386
 387 exp     :       exp '[' exp1 ']'
 388                         { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
 389         ;
 390
 391 exp     :       exp '('
 392                         /* This is to save the value of arglist_len
 393                            being accumulated by an outer function call.  */
 394                         { start_arglist (); }
 395                 arglist ')'     %prec ARROW
 396                         { write_exp_elt_opcode (OP_FUNCALL);
 397                           write_exp_elt_longcst ((LONGEST) end_arglist ());
 398                           write_exp_elt_opcode (OP_FUNCALL); }
 399         ;
 400
 401 exp     :       UNKNOWN_CPP_NAME '('
 402                         {
 403                           /* This could potentially be a an argument defined
 404                              lookup function (Koenig).  */
 405                           write_exp_elt_opcode (OP_ADL_FUNC);
 406                           write_exp_elt_block (expression_context_block);
 407                           write_exp_elt_sym (NULL); /* Placeholder.  */
 408                           write_exp_string ($1.stoken);
 409                           write_exp_elt_opcode (OP_ADL_FUNC);
 410
 411                         /* This is to save the value of arglist_len
 412                            being accumulated by an outer function call.  */
 413
 414                           start_arglist ();
 415                         }
 416                 arglist ')'     %prec ARROW
 417                         {
 418                           write_exp_elt_opcode (OP_FUNCALL);
 419                           write_exp_elt_longcst ((LONGEST) end_arglist ());
 420                           write_exp_elt_opcode (OP_FUNCALL);
 421                         }
 422         ;
 423
 424 lcurly  :       '{'
 425                         { start_arglist (); }
 426         ;
 427
 428 arglist :
 429         ;
 430
 431 arglist :       exp
 432                         { arglist_len = 1; }
 433         ;
 434
 435 arglist :       arglist ',' exp   %prec ABOVE_COMMA
 436                         { arglist_len++; }
 437         ;
 438
 439 exp     :       exp '(' nonempty_typelist ')' const_or_volatile
 440                         { int i;
 441                           write_exp_elt_opcode (TYPE_INSTANCE);
 442                           write_exp_elt_longcst ((LONGEST) $<ivec>3[0]);
 443                           for (i = 0; i < $<ivec>3[0]; ++i)
 444                             write_exp_elt_type ($<tvec>3[i + 1]);
 445                           write_exp_elt_longcst((LONGEST) $<ivec>3[0]);
 446                           write_exp_elt_opcode (TYPE_INSTANCE);
 447                           free ($3);
 448                         }
 449         ;
 450
 451 rcurly  :       '}'
 452                         { $$ = end_arglist () - 1; }
 453         ;
 454 exp     :       lcurly arglist rcurly   %prec ARROW
 455                         { write_exp_elt_opcode (OP_ARRAY);
 456                           write_exp_elt_longcst ((LONGEST) 0);
 457                           write_exp_elt_longcst ((LONGEST) $3);
 458                           write_exp_elt_opcode (OP_ARRAY); }
 459         ;
 460
 461 exp     :       lcurly type rcurly exp  %prec UNARY
 462                         { write_exp_elt_opcode (UNOP_MEMVAL);
 463                           write_exp_elt_type ($2);
 464                           write_exp_elt_opcode (UNOP_MEMVAL); }
 465         ;
 466
 467 exp     :       '(' type ')' exp  %prec UNARY
 468                         { write_exp_elt_opcode (UNOP_CAST);
 469                           write_exp_elt_type ($2);
 470                           write_exp_elt_opcode (UNOP_CAST); }
 471         ;
 472
 473 exp     :       '(' exp1 ')'
 474                         { }
 475         ;
 476
 477 /* Binary operators in order of decreasing precedence.  */
 478
 479 exp     :       exp '@' exp
 480                         { write_exp_elt_opcode (BINOP_REPEAT); }
 481         ;
 482
 483 exp     :       exp '*' exp
 484                         { write_exp_elt_opcode (BINOP_MUL); }
 485         ;
 486
 487 exp     :       exp '/' exp
 488                         { write_exp_elt_opcode (BINOP_DIV); }
 489         ;
 490
 491 exp     :       exp '%' exp
 492                         { write_exp_elt_opcode (BINOP_REM); }
 493         ;
 494
 495 exp     :       exp '+' exp
 496                         { write_exp_elt_opcode (BINOP_ADD); }
 497         ;
 498
 499 exp     :       exp '-' exp
 500                         { write_exp_elt_opcode (BINOP_SUB); }
 501         ;
 502
 503 exp     :       exp LSH exp
 504                         { write_exp_elt_opcode (BINOP_LSH); }
 505         ;
 506
 507 exp     :       exp RSH exp
 508                         { write_exp_elt_opcode (BINOP_RSH); }
 509         ;
 510
 511 exp     :       exp EQUAL exp
 512                         { write_exp_elt_opcode (BINOP_EQUAL); }
 513         ;
 514
 515 exp     :       exp NOTEQUAL exp
 516                         { write_exp_elt_opcode (BINOP_NOTEQUAL); }
 517         ;
 518
 519 exp     :       exp LEQ exp
 520                         { write_exp_elt_opcode (BINOP_LEQ); }
 521         ;
 522
 523 exp     :       exp GEQ exp
 524                         { write_exp_elt_opcode (BINOP_GEQ); }
 525         ;
 526
 527 exp     :       exp '<' exp
 528                         { write_exp_elt_opcode (BINOP_LESS); }
 529         ;
 530
 531 exp     :       exp '>' exp
 532                         { write_exp_elt_opcode (BINOP_GTR); }
 533         ;
 534
 535 exp     :       exp '&' exp
 536                         { write_exp_elt_opcode (BINOP_BITWISE_AND); }
 537         ;
 538
 539 exp     :       exp '^' exp
 540                         { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
 541         ;
 542
 543 exp     :       exp '|' exp
 544                         { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
 545         ;
 546
 547 exp     :       exp ANDAND exp
 548                         { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
 549         ;
 550
 551 exp     :       exp OROR exp
 552                         { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
 553         ;
 554
 555 exp     :       exp '?' exp ':' exp     %prec '?'
 556                         { write_exp_elt_opcode (TERNOP_COND); }
 557         ;
 558
 559 exp     :       exp '=' exp
 560                         { write_exp_elt_opcode (BINOP_ASSIGN); }
 561         ;
 562
 563 exp     :       exp ASSIGN_MODIFY exp
 564                         { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
 565                           write_exp_elt_opcode ($2);
 566                           write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
 567         ;
 568
 569 exp     :       INT
 570                         { write_exp_elt_opcode (OP_LONG);
 571                           write_exp_elt_type ($1.type);
 572                           write_exp_elt_longcst ((LONGEST)($1.val));
 573                           write_exp_elt_opcode (OP_LONG); }
 574         ;
 575
 576 exp     :       CHAR
 577                         {
 578                           struct stoken_vector vec;
 579                           vec.len = 1;
 580                           vec.tokens = &$1;
 581                           write_exp_string_vector ($1.type, &vec);
 582                         }
 583         ;
 584
 585 exp     :       NAME_OR_INT
 586                         { YYSTYPE val;
 587                           parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
 588                           write_exp_elt_opcode (OP_LONG);
 589                           write_exp_elt_type (val.typed_val_int.type);
 590                           write_exp_elt_longcst ((LONGEST)val.typed_val_int.val);
 591                           write_exp_elt_opcode (OP_LONG);
 592                         }
 593         ;
 594
 595
 596 exp     :       FLOAT
 597                         { write_exp_elt_opcode (OP_DOUBLE);
 598                           write_exp_elt_type ($1.type);
 599                           write_exp_elt_dblcst ($1.dval);
 600                           write_exp_elt_opcode (OP_DOUBLE); }
 601         ;
 602
 603 exp     :       DECFLOAT
 604                         { write_exp_elt_opcode (OP_DECFLOAT);
 605                           write_exp_elt_type ($1.type);
 606                           write_exp_elt_decfloatcst ($1.val);
 607                           write_exp_elt_opcode (OP_DECFLOAT); }
 608         ;
 609
 610 exp     :       variable
 611         ;
 612
 613 exp     :       VARIABLE
 614                         {
 615                           write_dollar_variable ($1);
 616                         }
 617         ;
 618
 619 exp     :       SIZEOF '(' type ')'     %prec UNARY
 620                         { write_exp_elt_opcode (OP_LONG);
 621                           write_exp_elt_type (lookup_signed_typename
 622                                               (parse_language, parse_gdbarch,
 623                                                "int"));
 624                           CHECK_TYPEDEF ($3);
 625                           write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
 626                           write_exp_elt_opcode (OP_LONG); }
 627         ;
 628
 629 exp     :       REINTERPRET_CAST '<' type '>' '(' exp ')' %prec UNARY
 630                         { write_exp_elt_opcode (UNOP_REINTERPRET_CAST);
 631                           write_exp_elt_type ($3);
 632                           write_exp_elt_opcode (UNOP_REINTERPRET_CAST); }
 633         ;
 634
 635 exp     :       STATIC_CAST '<' type '>' '(' exp ')' %prec UNARY
 636                         { write_exp_elt_opcode (UNOP_CAST);
 637                           write_exp_elt_type ($3);
 638                           write_exp_elt_opcode (UNOP_CAST); }
 639         ;
 640
 641 exp     :       DYNAMIC_CAST '<' type '>' '(' exp ')' %prec UNARY
 642                         { write_exp_elt_opcode (UNOP_DYNAMIC_CAST);
 643                           write_exp_elt_type ($3);
 644                           write_exp_elt_opcode (UNOP_DYNAMIC_CAST); }
 645         ;
 646
 647 exp     :       CONST_CAST '<' type '>' '(' exp ')' %prec UNARY
 648                         { /* We could do more error checking here, but
 649                              it doesn't seem worthwhile.  */
 650                           write_exp_elt_opcode (UNOP_CAST);
 651                           write_exp_elt_type ($3);
 652                           write_exp_elt_opcode (UNOP_CAST); }
 653         ;
 654
 655 string_exp:
 656                 STRING
 657                         {
 658                           /* We copy the string here, and not in the
 659                              lexer, to guarantee that we do not leak a
 660                              string.  Note that we follow the
 661                              NUL-termination convention of the
 662                              lexer.  */
 663                           struct typed_stoken *vec = XNEW (struct typed_stoken);
 664                           $$.len = 1;
 665                           $$.tokens = vec;
 666
 667                           vec->type = $1.type;
 668                           vec->length = $1.length;
 669                           vec->ptr = malloc ($1.length + 1);
 670                           memcpy (vec->ptr, $1.ptr, $1.length + 1);
 671                         }
 672
 673         |       string_exp STRING
 674                         {
 675                           /* Note that we NUL-terminate here, but just
 676                              for convenience.  */
 677                           char *p;
 678                           ++$$.len;
 679                           $$.tokens = realloc ($$.tokens,
 680                                                $$.len * sizeof (struct typed_stoken));
 681
 682                           p = malloc ($2.length + 1);
 683                           memcpy (p, $2.ptr, $2.length + 1);
 684
 685                           $$.tokens[$$.len - 1].type = $2.type;
 686                           $$.tokens[$$.len - 1].length = $2.length;
 687                           $$.tokens[$$.len - 1].ptr = p;
 688                         }
 689                 ;
 690
 691 exp     :       string_exp
 692                         {
 693                           int i;
 694                           enum c_string_type type = C_STRING;
 695
 696                           for (i = 0; i < $1.len; ++i)
 697                             {
 698                               switch ($1.tokens[i].type)
 699                                 {
 700                                 case C_STRING:
 701                                   break;
 702                                 case C_WIDE_STRING:
 703                                 case C_STRING_16:
 704                                 case C_STRING_32:
 705                                   if (type != C_STRING
 706                                       && type != $1.tokens[i].type)
 707                                     error (_("Undefined string concatenation."));
 708                                   type = $1.tokens[i].type;
 709                                   break;
 710                                 default:
 711                                   /* internal error */
 712                                   internal_error (__FILE__, __LINE__,
 713                                                   "unrecognized type in string concatenation");
 714                                 }
 715                             }
 716
 717                           write_exp_string_vector (type, &$1);
 718                           for (i = 0; i < $1.len; ++i)
 719                             free ($1.tokens[i].ptr);
 720                           free ($1.tokens);
 721                         }
 722         ;
 723
 724 /* C++.  */
 725 exp     :       TRUEKEYWORD
 726                         { write_exp_elt_opcode (OP_LONG);
 727                           write_exp_elt_type (parse_type->builtin_bool);
 728                           write_exp_elt_longcst ((LONGEST) 1);
 729                           write_exp_elt_opcode (OP_LONG); }
 730         ;
 731
 732 exp     :       FALSEKEYWORD
 733                         { write_exp_elt_opcode (OP_LONG);
 734                           write_exp_elt_type (parse_type->builtin_bool);
 735                           write_exp_elt_longcst ((LONGEST) 0);
 736                           write_exp_elt_opcode (OP_LONG); }
 737         ;
 738
 739 /* end of C++.  */
 740
 741 block   :       BLOCKNAME
 742                         {
 743                           if ($1.sym)
 744                             $$ = SYMBOL_BLOCK_VALUE ($1.sym);
 745                           else
 746                             error (_("No file or function \"%s\"."),
 747                                    copy_name ($1.stoken));
 748                         }
 749         |       FILENAME
 750                         {
 751                           $$ = $1;
 752                         }
 753         ;
 754
 755 block   :       block COLONCOLON name
 756                         { struct symbol *tem
 757                             = lookup_symbol (copy_name ($3), $1,
 758                                              VAR_DOMAIN, (int *) NULL);
 759                           if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
 760                             error (_("No function \"%s\" in specified context."),
 761                                    copy_name ($3));
 762                           $$ = SYMBOL_BLOCK_VALUE (tem); }
 763         ;
 764
 765 variable:       name_not_typename ENTRY
 766                         { struct symbol *sym = $1.sym;
 767
 768                           if (sym == NULL || !SYMBOL_IS_ARGUMENT (sym)
 769                               || !symbol_read_needs_frame (sym))
 770                             error (_("@entry can be used only for function "
 771                                      "parameters, not for \"%s\""),
 772                                    copy_name ($1.stoken));
 773
 774                           write_exp_elt_opcode (OP_VAR_ENTRY_VALUE);
 775                           write_exp_elt_sym (sym);
 776                           write_exp_elt_opcode (OP_VAR_ENTRY_VALUE);
 777                         }
 778         ;
 779
 780 variable:       block COLONCOLON name
 781                         { struct symbol *sym;
 782                           sym = lookup_symbol (copy_name ($3), $1,
 783                                                VAR_DOMAIN, (int *) NULL);
 784                           if (sym == 0)
 785                             error (_("No symbol \"%s\" in specified context."),
 786                                    copy_name ($3));
 787                           if (symbol_read_needs_frame (sym))
 788                             {
 789                               if (innermost_block == 0
 790                                   || contained_in (block_found,
 791                                                    innermost_block))
 792                                 innermost_block = block_found;
 793                             }
 794
 795                           write_exp_elt_opcode (OP_VAR_VALUE);
 796                           /* block_found is set by lookup_symbol.  */
 797                           write_exp_elt_block (block_found);
 798                           write_exp_elt_sym (sym);
 799                           write_exp_elt_opcode (OP_VAR_VALUE); }
 800         ;
 801
 802 qualified_name: TYPENAME COLONCOLON name
 803                         {
 804                           struct type *type = $1.type;
 805                           CHECK_TYPEDEF (type);
 806                           if (TYPE_CODE (type) != TYPE_CODE_STRUCT
 807                               && TYPE_CODE (type) != TYPE_CODE_UNION
 808                               && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
 809                             error (_("`%s' is not defined as an aggregate type."),
 810                                    TYPE_NAME (type));
 811
 812                           write_exp_elt_opcode (OP_SCOPE);
 813                           write_exp_elt_type (type);
 814                           write_exp_string ($3);
 815                           write_exp_elt_opcode (OP_SCOPE);
 816                         }
 817         |       TYPENAME COLONCOLON '~' name
 818                         {
 819                           struct type *type = $1.type;
 820                           struct stoken tmp_token;
 821                           CHECK_TYPEDEF (type);
 822                           if (TYPE_CODE (type) != TYPE_CODE_STRUCT
 823                               && TYPE_CODE (type) != TYPE_CODE_UNION
 824                               && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
 825                             error (_("`%s' is not defined as an aggregate type."),
 826                                    TYPE_NAME (type));
 827
 828                           tmp_token.ptr = (char*) alloca ($4.length + 2);
 829                           tmp_token.length = $4.length + 1;
 830                           tmp_token.ptr[0] = '~';
 831                           memcpy (tmp_token.ptr+1, $4.ptr, $4.length);
 832                           tmp_token.ptr[tmp_token.length] = 0;
 833
 834                           /* Check for valid destructor name.  */
 835                           destructor_name_p (tmp_token.ptr, $1.type);
 836                           write_exp_elt_opcode (OP_SCOPE);
 837                           write_exp_elt_type (type);
 838                           write_exp_string (tmp_token);
 839                           write_exp_elt_opcode (OP_SCOPE);
 840                         }
 841         |       TYPENAME COLONCOLON name COLONCOLON name
 842                         {
 843                           char *copy = copy_name ($3);
 844                           error (_("No type \"%s\" within class "
 845                                    "or namespace \"%s\"."),
 846                                  copy, TYPE_NAME ($1.type));
 847                         }
 848         ;
 849
 850 variable:       qualified_name
 851         |       COLONCOLON name_not_typename
 852                         {
 853                           char *name = copy_name ($2.stoken);
 854                           struct symbol *sym;
 855                           struct minimal_symbol *msymbol;
 856
 857                           sym =
 858                             lookup_symbol (name, (const struct block *) NULL,
 859                                            VAR_DOMAIN, (int *) NULL);
 860                           if (sym)
 861                             {
 862                               write_exp_elt_opcode (OP_VAR_VALUE);
 863                               write_exp_elt_block (NULL);
 864                               write_exp_elt_sym (sym);
 865                               write_exp_elt_opcode (OP_VAR_VALUE);
 866                               break;
 867                             }
 868
 869                           msymbol = lookup_minimal_symbol (name, NULL, NULL);
 870                           if (msymbol != NULL)
 871                             write_exp_msymbol (msymbol);
 872                           else if (!have_full_symbols () && !have_partial_symbols ())
 873                             error (_("No symbol table is loaded.  Use the \"file\" command."));
 874                           else
 875                             error (_("No symbol \"%s\" in current context."), name);
 876                         }
 877         ;
 878
 879 variable:       name_not_typename
 880                         { struct symbol *sym = $1.sym;
 881
 882                           if (sym)
 883                             {
 884                               if (symbol_read_needs_frame (sym))
 885                                 {
 886                                   if (innermost_block == 0
 887                                       || contained_in (block_found,
 888                                                        innermost_block))
 889                                     innermost_block = block_found;
 890                                 }
 891
 892                               write_exp_elt_opcode (OP_VAR_VALUE);
 893                               /* We want to use the selected frame, not
 894                                  another more inner frame which happens to
 895                                  be in the same block.  */
 896                               write_exp_elt_block (NULL);
 897                               write_exp_elt_sym (sym);
 898                               write_exp_elt_opcode (OP_VAR_VALUE);
 899                             }
 900                           else if ($1.is_a_field_of_this)
 901                             {
 902                               /* C++: it hangs off of `this'.  Must
 903                                  not inadvertently convert from a method call
 904                                  to data ref.  */
 905                               if (innermost_block == 0
 906                                   || contained_in (block_found,
 907                                                    innermost_block))
 908                                 innermost_block = block_found;
 909                               write_exp_elt_opcode (OP_THIS);
 910                               write_exp_elt_opcode (OP_THIS);
 911                               write_exp_elt_opcode (STRUCTOP_PTR);
 912                               write_exp_string ($1.stoken);
 913                               write_exp_elt_opcode (STRUCTOP_PTR);
 914                             }
 915                           else
 916                             {
 917                               struct minimal_symbol *msymbol;
 918                               char *arg = copy_name ($1.stoken);
 919
 920                               msymbol =
 921                                 lookup_minimal_symbol (arg, NULL, NULL);
 922                               if (msymbol != NULL)
 923                                 write_exp_msymbol (msymbol);
 924                               else if (!have_full_symbols () && !have_partial_symbols ())
 925                                 error (_("No symbol table is loaded.  Use the \"file\" command."));
 926                               else
 927                                 error (_("No symbol \"%s\" in current context."),
 928                                        copy_name ($1.stoken));
 929                             }
 930                         }
 931         ;
 932
 933 space_identifier : '@' NAME
 934                 { push_type_address_space (copy_name ($2.stoken));
 935                   push_type (tp_space_identifier);
 936                 }
 937         ;
 938
 939 const_or_volatile: const_or_volatile_noopt
 940         |
 941         ;
 942
 943 cv_with_space_id : const_or_volatile space_identifier const_or_volatile
 944         ;
 945
 946 const_or_volatile_or_space_identifier_noopt: cv_with_space_id
 947         | const_or_volatile_noopt
 948         ;
 949
 950 const_or_volatile_or_space_identifier:
 951                 const_or_volatile_or_space_identifier_noopt
 952         |
 953         ;
 954
 955 abs_decl:       '*'
 956                         { push_type (tp_pointer); $$ = 0; }
 957         |       '*' abs_decl
 958                         { push_type (tp_pointer); $$ = $2; }
 959         |       '&'
 960                         { push_type (tp_reference); $$ = 0; }
 961         |       '&' abs_decl
 962                         { push_type (tp_reference); $$ = $2; }
 963         |       direct_abs_decl
 964         ;
 965
 966 direct_abs_decl: '(' abs_decl ')'
 967                         { $$ = $2; }
 968         |       direct_abs_decl array_mod
 969                         {
 970                           push_type_int ($2);
 971                           push_type (tp_array);
 972                         }
 973         |       array_mod
 974                         {
 975                           push_type_int ($1);
 976                           push_type (tp_array);
 977                           $$ = 0;
 978                         }
 979
 980         |       direct_abs_decl func_mod
 981                         { push_type (tp_function); }
 982         |       func_mod
 983                         { push_type (tp_function); }
 984         ;
 985
 986 array_mod:      '[' ']'
 987                         { $$ = -1; }
 988         |       '[' INT ']'
 989                         { $$ = $2.val; }
 990         ;
 991
 992 func_mod:       '(' ')'
 993                         { $$ = 0; }
 994         |       '(' nonempty_typelist ')'
 995                         { free ($2); $$ = 0; }
 996         ;
 997
 998 /* We used to try to recognize pointer to member types here, but
 999    that didn't work (shift/reduce conflicts meant that these rules never
1000    got executed).  The problem is that
1001      int (foo::bar::baz::bizzle)
1002    is a function type but
1003      int (foo::bar::baz::bizzle::*)
1004    is a pointer to member type.  Stroustrup loses again!  */
1005
1006 type    :       ptype
1007         ;
1008
1009 typebase  /* Implements (approximately): (type-qualifier)* type-specifier */
1010         :       TYPENAME
1011                         { $$ = $1.type; }
1012         |       INT_KEYWORD
1013                         { $$ = lookup_signed_typename (parse_language,
1014                                                        parse_gdbarch,
1015                                                        "int"); }
1016         |       LONG
1017                         { $$ = lookup_signed_typename (parse_language,
1018                                                        parse_gdbarch,
1019                                                        "long"); }
1020         |       SHORT
1021                         { $$ = lookup_signed_typename (parse_language,
1022                                                        parse_gdbarch,
1023                                                        "short"); }
1024         |       LONG INT_KEYWORD
1025                         { $$ = lookup_signed_typename (parse_language,
1026                                                        parse_gdbarch,
1027                                                        "long"); }
1028         |       LONG SIGNED_KEYWORD INT_KEYWORD
1029                         { $$ = lookup_signed_typename (parse_language,
1030                                                        parse_gdbarch,
1031                                                        "long"); }
1032         |       LONG SIGNED_KEYWORD
1033                         { $$ = lookup_signed_typename (parse_language,
1034                                                        parse_gdbarch,
1035                                                        "long"); }
1036         |       SIGNED_KEYWORD LONG INT_KEYWORD
1037                         { $$ = lookup_signed_typename (parse_language,
1038                                                        parse_gdbarch,
1039                                                        "long"); }
1040         |       UNSIGNED LONG INT_KEYWORD
1041                         { $$ = lookup_unsigned_typename (parse_language,
1042                                                          parse_gdbarch,
1043                                                          "long"); }
1044         |       LONG UNSIGNED INT_KEYWORD
1045                         { $$ = lookup_unsigned_typename (parse_language,
1046                                                          parse_gdbarch,
1047                                                          "long"); }
1048         |       LONG UNSIGNED
1049                         { $$ = lookup_unsigned_typename (parse_language,
1050                                                          parse_gdbarch,
1051                                                          "long"); }
1052         |       LONG LONG
1053                         { $$ = lookup_signed_typename (parse_language,
1054                                                        parse_gdbarch,
1055                                                        "long long"); }
1056         |       LONG LONG INT_KEYWORD
1057                         { $$ = lookup_signed_typename (parse_language,
1058                                                        parse_gdbarch,
1059                                                        "long long"); }
1060         |       LONG LONG SIGNED_KEYWORD INT_KEYWORD
1061                         { $$ = lookup_signed_typename (parse_language,
1062                                                        parse_gdbarch,
1063                                                        "long long"); }
1064         |       LONG LONG SIGNED_KEYWORD
1065                         { $$ = lookup_signed_typename (parse_language,
1066                                                        parse_gdbarch,
1067                                                        "long long"); }
1068         |       SIGNED_KEYWORD LONG LONG
1069                         { $$ = lookup_signed_typename (parse_language,
1070                                                        parse_gdbarch,
1071                                                        "long long"); }
1072         |       SIGNED_KEYWORD LONG LONG INT_KEYWORD
1073                         { $$ = lookup_signed_typename (parse_language,
1074                                                        parse_gdbarch,
1075                                                        "long long"); }
1076         |       UNSIGNED LONG LONG
1077                         { $$ = lookup_unsigned_typename (parse_language,
1078                                                          parse_gdbarch,
1079                                                          "long long"); }
1080         |       UNSIGNED LONG LONG INT_KEYWORD
1081                         { $$ = lookup_unsigned_typename (parse_language,
1082                                                          parse_gdbarch,
1083                                                          "long long"); }
1084         |       LONG LONG UNSIGNED
1085                         { $$ = lookup_unsigned_typename (parse_language,
1086                                                          parse_gdbarch,
1087                                                          "long long"); }
1088         |       LONG LONG UNSIGNED INT_KEYWORD
1089                         { $$ = lookup_unsigned_typename (parse_language,
1090                                                          parse_gdbarch,
1091                                                          "long long"); }
1092         |       SHORT INT_KEYWORD
1093                         { $$ = lookup_signed_typename (parse_language,
1094                                                        parse_gdbarch,
1095                                                        "short"); }
1096         |       SHORT SIGNED_KEYWORD INT_KEYWORD
1097                         { $$ = lookup_signed_typename (parse_language,
1098                                                        parse_gdbarch,
1099                                                        "short"); }
1100         |       SHORT SIGNED_KEYWORD
1101                         { $$ = lookup_signed_typename (parse_language,
1102                                                        parse_gdbarch,
1103                                                        "short"); }
1104         |       UNSIGNED SHORT INT_KEYWORD
1105                         { $$ = lookup_unsigned_typename (parse_language,
1106                                                          parse_gdbarch,
1107                                                          "short"); }
1108         |       SHORT UNSIGNED
1109                         { $$ = lookup_unsigned_typename (parse_language,
1110                                                          parse_gdbarch,
1111                                                          "short"); }
1112         |       SHORT UNSIGNED INT_KEYWORD
1113                         { $$ = lookup_unsigned_typename (parse_language,
1114                                                          parse_gdbarch,
1115                                                          "short"); }
1116         |       DOUBLE_KEYWORD
1117                         { $$ = lookup_typename (parse_language, parse_gdbarch,
1118                                                 "double", (struct block *) NULL,
1119                                                 0); }
1120         |       LONG DOUBLE_KEYWORD
1121                         { $$ = lookup_typename (parse_language, parse_gdbarch,
1122                                                 "long double",
1123                                                 (struct block *) NULL, 0); }
1124         |       STRUCT name
1125                         { $$ = lookup_struct (copy_name ($2),
1126                                               expression_context_block); }
1127         |       CLASS name
1128                         { $$ = lookup_struct (copy_name ($2),
1129                                               expression_context_block); }
1130         |       UNION name
1131                         { $$ = lookup_union (copy_name ($2),
1132                                              expression_context_block); }
1133         |       ENUM name
1134                         { $$ = lookup_enum (copy_name ($2),
1135                                             expression_context_block); }
1136         |       UNSIGNED typename
1137                         { $$ = lookup_unsigned_typename (parse_language,
1138                                                          parse_gdbarch,
1139                                                          TYPE_NAME($2.type)); }
1140         |       UNSIGNED
1141                         { $$ = lookup_unsigned_typename (parse_language,
1142                                                          parse_gdbarch,
1143                                                          "int"); }
1144         |       SIGNED_KEYWORD typename
1145                         { $$ = lookup_signed_typename (parse_language,
1146                                                        parse_gdbarch,
1147                                                        TYPE_NAME($2.type)); }
1148         |       SIGNED_KEYWORD
1149                         { $$ = lookup_signed_typename (parse_language,
1150                                                        parse_gdbarch,
1151                                                        "int"); }
1152                 /* It appears that this rule for templates is never
1153                    reduced; template recognition happens by lookahead
1154                    in the token processing code in yylex. */
1155         |       TEMPLATE name '<' type '>'
1156                         { $$ = lookup_template_type(copy_name($2), $4,
1157                                                     expression_context_block);
1158                         }
1159         | const_or_volatile_or_space_identifier_noopt typebase
1160                         { $$ = follow_types ($2); }
1161         | typebase const_or_volatile_or_space_identifier_noopt
1162                         { $$ = follow_types ($1); }
1163         ;
1164
1165 typename:       TYPENAME
1166         |       INT_KEYWORD
1167                 {
1168                   $$.stoken.ptr = "int";
1169                   $$.stoken.length = 3;
1170                   $$.type = lookup_signed_typename (parse_language,
1171                                                     parse_gdbarch,
1172                                                     "int");
1173                 }
1174         |       LONG
1175                 {
1176                   $$.stoken.ptr = "long";
1177                   $$.stoken.length = 4;
1178                   $$.type = lookup_signed_typename (parse_language,
1179                                                     parse_gdbarch,
1180                                                     "long");
1181                 }
1182         |       SHORT
1183                 {
1184                   $$.stoken.ptr = "short";
1185                   $$.stoken.length = 5;
1186                   $$.type = lookup_signed_typename (parse_language,
1187                                                     parse_gdbarch,
1188                                                     "short");
1189                 }
1190         ;
1191
1192 nonempty_typelist
1193         :       type
1194                 { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
1195                   $<ivec>$[0] = 1;      /* Number of types in vector */
1196                   $$[1] = $1;
1197                 }
1198         |       nonempty_typelist ',' type
1199                 { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
1200                   $$ = (struct type **) realloc ((char *) $1, len);
1201                   $$[$<ivec>$[0]] = $3;
1202                 }
1203         ;
1204
1205 ptype   :       typebase
1206         |       ptype const_or_volatile_or_space_identifier abs_decl const_or_volatile_or_space_identifier
1207                 { $$ = follow_types ($1); }
1208         ;
1209
1210 const_and_volatile:     CONST_KEYWORD VOLATILE_KEYWORD
1211         |               VOLATILE_KEYWORD CONST_KEYWORD
1212         ;
1213
1214 const_or_volatile_noopt:        const_and_volatile
1215                         { push_type (tp_const);
1216                           push_type (tp_volatile);
1217                         }
1218         |               CONST_KEYWORD
1219                         { push_type (tp_const); }
1220         |               VOLATILE_KEYWORD
1221                         { push_type (tp_volatile); }
1222         ;
1223
1224 operator:       OPERATOR NEW
1225                         { $$ = operator_stoken (" new"); }
1226         |       OPERATOR DELETE
1227                         { $$ = operator_stoken (" delete "); }
1228         |       OPERATOR NEW '[' ']'
1229                         { $$ = operator_stoken (" new[]"); }
1230         |       OPERATOR DELETE '[' ']'
1231                         { $$ = operator_stoken (" delete[] "); }
1232         |       OPERATOR '+'
1233                         { $$ = operator_stoken ("+"); }
1234         |       OPERATOR '-'
1235                         { $$ = operator_stoken ("-"); }
1236         |       OPERATOR '*'
1237                         { $$ = operator_stoken ("*"); }
1238         |       OPERATOR '/'
1239                         { $$ = operator_stoken ("/"); }
1240         |       OPERATOR '%'
1241                         { $$ = operator_stoken ("%"); }
1242         |       OPERATOR '^'
1243                         { $$ = operator_stoken ("^"); }
1244         |       OPERATOR '&'
1245                         { $$ = operator_stoken ("&"); }
1246         |       OPERATOR '|'
1247                         { $$ = operator_stoken ("|"); }
1248         |       OPERATOR '~'
1249                         { $$ = operator_stoken ("~"); }
1250         |       OPERATOR '!'
1251                         { $$ = operator_stoken ("!"); }
1252         |       OPERATOR '='
1253                         { $$ = operator_stoken ("="); }
1254         |       OPERATOR '<'
1255                         { $$ = operator_stoken ("<"); }
1256         |       OPERATOR '>'
1257                         { $$ = operator_stoken (">"); }
1258         |       OPERATOR ASSIGN_MODIFY
1259                         { const char *op = "unknown";
1260                           switch ($2)
1261                             {
1262                             case BINOP_RSH:
1263                               op = ">>=";
1264                               break;
1265                             case BINOP_LSH:
1266                               op = "<<=";
1267                               break;
1268                             case BINOP_ADD:
1269                               op = "+=";
1270                               break;
1271                             case BINOP_SUB:
1272                               op = "-=";
1273                               break;
1274                             case BINOP_MUL:
1275                               op = "*=";
1276                               break;
1277                             case BINOP_DIV:
1278                               op = "/=";
1279                               break;
1280                             case BINOP_REM:
1281                               op = "%=";
1282                               break;
1283                             case BINOP_BITWISE_IOR:
1284                               op = "|=";
1285                               break;
1286                             case BINOP_BITWISE_AND:
1287                               op = "&=";
1288                               break;
1289                             case BINOP_BITWISE_XOR:
1290                               op = "^=";
1291                               break;
1292                             default:
1293                               break;
1294                             }
1295
1296                           $$ = operator_stoken (op);
1297                         }
1298         |       OPERATOR LSH
1299                         { $$ = operator_stoken ("<<"); }
1300         |       OPERATOR RSH
1301                         { $$ = operator_stoken (">>"); }
1302         |       OPERATOR EQUAL
1303                         { $$ = operator_stoken ("=="); }
1304         |       OPERATOR NOTEQUAL
1305                         { $$ = operator_stoken ("!="); }
1306         |       OPERATOR LEQ
1307                         { $$ = operator_stoken ("<="); }
1308         |       OPERATOR GEQ
1309                         { $$ = operator_stoken (">="); }
1310         |       OPERATOR ANDAND
1311                         { $$ = operator_stoken ("&&"); }
1312         |       OPERATOR OROR
1313                         { $$ = operator_stoken ("||"); }
1314         |       OPERATOR INCREMENT
1315                         { $$ = operator_stoken ("++"); }
1316         |       OPERATOR DECREMENT
1317                         { $$ = operator_stoken ("--"); }
1318         |       OPERATOR ','
1319                         { $$ = operator_stoken (","); }
1320         |       OPERATOR ARROW_STAR
1321                         { $$ = operator_stoken ("->*"); }
1322         |       OPERATOR ARROW
1323                         { $$ = operator_stoken ("->"); }
1324         |       OPERATOR '(' ')'
1325                         { $$ = operator_stoken ("()"); }
1326         |       OPERATOR '[' ']'
1327                         { $$ = operator_stoken ("[]"); }
1328         |       OPERATOR ptype
1329                         { char *name;
1330                           long length;
1331                           struct ui_file *buf = mem_fileopen ();
1332
1333                           c_print_type ($2, NULL, buf, -1, 0);
1334                           name = ui_file_xstrdup (buf, &length);
1335                           ui_file_delete (buf);
1336                           $$ = operator_stoken (name);
1337                           free (name);
1338                         }
1339         ;
1340
1341
1342
1343 name    :       NAME { $$ = $1.stoken; }
1344         |       BLOCKNAME { $$ = $1.stoken; }
1345         |       TYPENAME { $$ = $1.stoken; }
1346         |       NAME_OR_INT  { $$ = $1.stoken; }
1347         |       UNKNOWN_CPP_NAME  { $$ = $1.stoken; }
1348         |       operator { $$ = $1; }
1349         ;
1350
1351 name_not_typename :     NAME
1352         |       BLOCKNAME
1353 /* These would be useful if name_not_typename was useful, but it is just
1354    a fake for "variable", so these cause reduce/reduce conflicts because
1355    the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
1356    =exp) or just an exp.  If name_not_typename was ever used in an lvalue
1357    context where only a name could occur, this might be useful.
1358         |       NAME_OR_INT
1359  */
1360         |       operator
1361                         {
1362                           $$.stoken = $1;
1363                           $$.sym = lookup_symbol ($1.ptr,
1364                                                   expression_context_block,
1365                                                   VAR_DOMAIN,
1366                                                   &$$.is_a_field_of_this);
1367                         }
1368         |       UNKNOWN_CPP_NAME
1369         ;
1370
1371 %%
1372
1373 /* Returns a stoken of the operator name given by OP (which does not
1374    include the string "operator").  */
1375 static struct stoken
1376 operator_stoken (const char *op)
1377 {
1378   static const char *operator_string = "operator";
1379   struct stoken st = { NULL, 0 };
1380   st.length = strlen (operator_string) + strlen (op);
1381   st.ptr = malloc (st.length + 1);
1382   strcpy (st.ptr, operator_string);
1383   strcat (st.ptr, op);
1384
1385   /* The toplevel (c_parse) will free the memory allocated here.  */
1386   make_cleanup (free, st.ptr);
1387   return st;
1388 };
1389
1390 /* Take care of parsing a number (anything that starts with a digit).
1391    Set yylval and return the token type; update lexptr.
1392    LEN is the number of characters in it.  */
1393
1394 /*** Needs some error checking for the float case ***/
1395
1396 static int
1397 parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere)
1398 {
1399   /* FIXME: Shouldn't these be unsigned?  We don't deal with negative values
1400      here, and we do kind of silly things like cast to unsigned.  */
1401   LONGEST n = 0;
1402   LONGEST prevn = 0;
1403   ULONGEST un;
1404
1405   int i = 0;
1406   int c;
1407   int base = input_radix;
1408   int unsigned_p = 0;
1409
1410   /* Number of "L" suffixes encountered.  */
1411   int long_p = 0;
1412
1413   /* We have found a "L" or "U" suffix.  */
1414   int found_suffix = 0;
1415
1416   ULONGEST high_bit;
1417   struct type *signed_type;
1418   struct type *unsigned_type;
1419
1420   if (parsed_float)
1421     {
1422       /* If it ends at "df", "dd" or "dl", take it as type of decimal floating
1423          point.  Return DECFLOAT.  */
1424
1425       if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'f')
1426         {
1427           p[len - 2] = '\0';
1428           putithere->typed_val_decfloat.type
1429             = parse_type->builtin_decfloat;
1430           decimal_from_string (putithere->typed_val_decfloat.val, 4,
1431                                gdbarch_byte_order (parse_gdbarch), p);
1432           p[len - 2] = 'd';
1433           return DECFLOAT;
1434         }
1435
1436       if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'd')
1437         {
1438           p[len - 2] = '\0';
1439           putithere->typed_val_decfloat.type
1440             = parse_type->builtin_decdouble;
1441           decimal_from_string (putithere->typed_val_decfloat.val, 8,
1442                                gdbarch_byte_order (parse_gdbarch), p);
1443           p[len - 2] = 'd';
1444           return DECFLOAT;
1445         }
1446
1447       if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'l')
1448         {
1449           p[len - 2] = '\0';
1450           putithere->typed_val_decfloat.type
1451             = parse_type->builtin_declong;
1452           decimal_from_string (putithere->typed_val_decfloat.val, 16,
1453                                gdbarch_byte_order (parse_gdbarch), p);
1454           p[len - 2] = 'd';
1455           return DECFLOAT;
1456         }
1457
1458       if (! parse_c_float (parse_gdbarch, p, len,
1459                            &putithere->typed_val_float.dval,
1460                            &putithere->typed_val_float.type))
1461         return ERROR;
1462       return FLOAT;
1463     }
1464
1465   /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
1466   if (p[0] == '0')
1467     switch (p[1])
1468       {
1469       case 'x':
1470       case 'X':
1471         if (len >= 3)
1472           {
1473             p += 2;
1474             base = 16;
1475             len -= 2;
1476           }
1477         break;
1478
1479       case 'b':
1480       case 'B':
1481         if (len >= 3)
1482           {
1483             p += 2;
1484             base = 2;
1485             len -= 2;
1486           }
1487         break;
1488
1489       case 't':
1490       case 'T':
1491       case 'd':
1492       case 'D':
1493         if (len >= 3)
1494           {
1495             p += 2;
1496             base = 10;
1497             len -= 2;
1498           }
1499         break;
1500
1501       default:
1502         base = 8;
1503         break;
1504       }
1505
1506   while (len-- > 0)
1507     {
1508       c = *p++;
1509       if (c >= 'A' && c <= 'Z')
1510         c += 'a' - 'A';
1511       if (c != 'l' && c != 'u')
1512         n *= base;
1513       if (c >= '0' && c <= '9')
1514         {
1515           if (found_suffix)
1516             return ERROR;
1517           n += i = c - '0';
1518         }
1519       else
1520         {
1521           if (base > 10 && c >= 'a' && c <= 'f')
1522             {
1523               if (found_suffix)
1524                 return ERROR;
1525               n += i = c - 'a' + 10;
1526             }
1527           else if (c == 'l')
1528             {
1529               ++long_p;
1530               found_suffix = 1;
1531             }
1532           else if (c == 'u')
1533             {
1534               unsigned_p = 1;
1535               found_suffix = 1;
1536             }
1537           else
1538             return ERROR;       /* Char not a digit */
1539         }
1540       if (i >= base)
1541         return ERROR;           /* Invalid digit in this base */
1542
1543       /* Portably test for overflow (only works for nonzero values, so make
1544          a second check for zero).  FIXME: Can't we just make n and prevn
1545          unsigned and avoid this?  */
1546       if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
1547         unsigned_p = 1;         /* Try something unsigned */
1548
1549       /* Portably test for unsigned overflow.
1550          FIXME: This check is wrong; for example it doesn't find overflow
1551          on 0x123456789 when LONGEST is 32 bits.  */
1552       if (c != 'l' && c != 'u' && n != 0)
1553         {
1554           if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n))
1555             error (_("Numeric constant too large."));
1556         }
1557       prevn = n;
1558     }
1559
1560   /* An integer constant is an int, a long, or a long long.  An L
1561      suffix forces it to be long; an LL suffix forces it to be long
1562      long.  If not forced to a larger size, it gets the first type of
1563      the above that it fits in.  To figure out whether it fits, we
1564      shift it right and see whether anything remains.  Note that we
1565      can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
1566      operation, because many compilers will warn about such a shift
1567      (which always produces a zero result).  Sometimes gdbarch_int_bit
1568      or gdbarch_long_bit will be that big, sometimes not.  To deal with
1569      the case where it is we just always shift the value more than
1570      once, with fewer bits each time.  */
1571
1572   un = (ULONGEST)n >> 2;
1573   if (long_p == 0
1574       && (un >> (gdbarch_int_bit (parse_gdbarch) - 2)) == 0)
1575     {
1576       high_bit = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch) - 1);
1577
1578       /* A large decimal (not hex or octal) constant (between INT_MAX
1579          and UINT_MAX) is a long or unsigned long, according to ANSI,
1580          never an unsigned int, but this code treats it as unsigned
1581          int.  This probably should be fixed.  GCC gives a warning on
1582          such constants.  */
1583
1584       unsigned_type = parse_type->builtin_unsigned_int;
1585       signed_type = parse_type->builtin_int;
1586     }
1587   else if (long_p <= 1
1588            && (un >> (gdbarch_long_bit (parse_gdbarch) - 2)) == 0)
1589     {
1590       high_bit = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch) - 1);
1591       unsigned_type = parse_type->builtin_unsigned_long;
1592       signed_type = parse_type->builtin_long;
1593     }
1594   else
1595     {
1596       int shift;
1597       if (sizeof (ULONGEST) * HOST_CHAR_BIT
1598           < gdbarch_long_long_bit (parse_gdbarch))
1599         /* A long long does not fit in a LONGEST.  */
1600         shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
1601       else
1602         shift = (gdbarch_long_long_bit (parse_gdbarch) - 1);
1603       high_bit = (ULONGEST) 1 << shift;
1604       unsigned_type = parse_type->builtin_unsigned_long_long;
1605       signed_type = parse_type->builtin_long_long;
1606     }
1607
1608    putithere->typed_val_int.val = n;
1609
1610    /* If the high bit of the worked out type is set then this number
1611       has to be unsigned. */
1612
1613    if (unsigned_p || (n & high_bit))
1614      {
1615        putithere->typed_val_int.type = unsigned_type;
1616      }
1617    else
1618      {
1619        putithere->typed_val_int.type = signed_type;
1620      }
1621
1622    return INT;
1623 }
1624
1625 /* Temporary obstack used for holding strings.  */
1626 static struct obstack tempbuf;
1627 static int tempbuf_init;
1628
1629 /* Parse a C escape sequence.  The initial backslash of the sequence
1630    is at (*PTR)[-1].  *PTR will be updated to point to just after the
1631    last character of the sequence.  If OUTPUT is not NULL, the
1632    translated form of the escape sequence will be written there.  If
1633    OUTPUT is NULL, no output is written and the call will only affect
1634    *PTR.  If an escape sequence is expressed in target bytes, then the
1635    entire sequence will simply be copied to OUTPUT.  Return 1 if any
1636    character was emitted, 0 otherwise.  */
1637
1638 int
1639 c_parse_escape (char **ptr, struct obstack *output)
1640 {
1641   char *tokptr = *ptr;
1642   int result = 1;
1643
1644   /* Some escape sequences undergo character set conversion.  Those we
1645      translate here.  */
1646   switch (*tokptr)
1647     {
1648       /* Hex escapes do not undergo character set conversion, so keep
1649          the escape sequence for later.  */
1650     case 'x':
1651       if (output)
1652         obstack_grow_str (output, "\\x");
1653       ++tokptr;
1654       if (!isxdigit (*tokptr))
1655         error (_("\\x escape without a following hex digit"));
1656       while (isxdigit (*tokptr))
1657         {
1658           if (output)
1659             obstack_1grow (output, *tokptr);
1660           ++tokptr;
1661         }
1662       break;
1663
1664       /* Octal escapes do not undergo character set conversion, so
1665          keep the escape sequence for later.  */
1666     case '0':
1667     case '1':
1668     case '2':
1669     case '3':
1670     case '4':
1671     case '5':
1672     case '6':
1673     case '7':
1674       {
1675         int i;
1676         if (output)
1677           obstack_grow_str (output, "\\");
1678         for (i = 0;
1679              i < 3 && isdigit (*tokptr) && *tokptr != '8' && *tokptr != '9';
1680              ++i)
1681           {
1682             if (output)
1683               obstack_1grow (output, *tokptr);
1684             ++tokptr;
1685           }
1686       }
1687       break;
1688
1689       /* We handle UCNs later.  We could handle them here, but that
1690          would mean a spurious error in the case where the UCN could
1691          be converted to the target charset but not the host
1692          charset.  */
1693     case 'u':
1694     case 'U':
1695       {
1696         char c = *tokptr;
1697         int i, len = c == 'U' ? 8 : 4;
1698         if (output)
1699           {
1700             obstack_1grow (output, '\\');
1701             obstack_1grow (output, *tokptr);
1702           }
1703         ++tokptr;
1704         if (!isxdigit (*tokptr))
1705           error (_("\\%c escape without a following hex digit"), c);
1706         for (i = 0; i < len && isxdigit (*tokptr); ++i)
1707           {
1708             if (output)
1709               obstack_1grow (output, *tokptr);
1710             ++tokptr;
1711           }
1712       }
1713       break;
1714
1715       /* We must pass backslash through so that it does not
1716          cause quoting during the second expansion.  */
1717     case '\\':
1718       if (output)
1719         obstack_grow_str (output, "\\\\");
1720       ++tokptr;
1721       break;
1722
1723       /* Escapes which undergo conversion.  */
1724     case 'a':
1725       if (output)
1726         obstack_1grow (output, '\a');
1727       ++tokptr;
1728       break;
1729     case 'b':
1730       if (output)
1731         obstack_1grow (output, '\b');
1732       ++tokptr;
1733       break;
1734     case 'f':
1735       if (output)
1736         obstack_1grow (output, '\f');
1737       ++tokptr;
1738       break;
1739     case 'n':
1740       if (output)
1741         obstack_1grow (output, '\n');
1742       ++tokptr;
1743       break;
1744     case 'r':
1745       if (output)
1746         obstack_1grow (output, '\r');
1747       ++tokptr;
1748       break;
1749     case 't':
1750       if (output)
1751         obstack_1grow (output, '\t');
1752       ++tokptr;
1753       break;
1754     case 'v':
1755       if (output)
1756         obstack_1grow (output, '\v');
1757       ++tokptr;
1758       break;
1759
1760       /* GCC extension.  */
1761     case 'e':
1762       if (output)
1763         obstack_1grow (output, HOST_ESCAPE_CHAR);
1764       ++tokptr;
1765       break;
1766
1767       /* Backslash-newline expands to nothing at all.  */
1768     case '\n':
1769       ++tokptr;
1770       result = 0;
1771       break;
1772
1773       /* A few escapes just expand to the character itself.  */
1774     case '\'':
1775     case '\"':
1776     case '?':
1777       /* GCC extensions.  */
1778     case '(':
1779     case '{':
1780     case '[':
1781     case '%':
1782       /* Unrecognized escapes turn into the character itself.  */
1783     default:
1784       if (output)
1785         obstack_1grow (output, *tokptr);
1786       ++tokptr;
1787       break;
1788     }
1789   *ptr = tokptr;
1790   return result;
1791 }
1792
1793 /* Parse a string or character literal from TOKPTR.  The string or
1794    character may be wide or unicode.  *OUTPTR is set to just after the
1795    end of the literal in the input string.  The resulting token is
1796    stored in VALUE.  This returns a token value, either STRING or
1797    CHAR, depending on what was parsed.  *HOST_CHARS is set to the
1798    number of host characters in the literal.  */
1799 static int
1800 parse_string_or_char (char *tokptr, char **outptr, struct typed_stoken *value,
1801                       int *host_chars)
1802 {
1803   int quote;
1804   enum c_string_type type;
1805
1806   /* Build the gdb internal form of the input string in tempbuf.  Note
1807      that the buffer is null byte terminated *only* for the
1808      convenience of debugging gdb itself and printing the buffer
1809      contents when the buffer contains no embedded nulls.  Gdb does
1810      not depend upon the buffer being null byte terminated, it uses
1811      the length string instead.  This allows gdb to handle C strings
1812      (as well as strings in other languages) with embedded null
1813      bytes */
1814
1815   if (!tempbuf_init)
1816     tempbuf_init = 1;
1817   else
1818     obstack_free (&tempbuf, NULL);
1819   obstack_init (&tempbuf);
1820
1821   /* Record the string type.  */
1822   if (*tokptr == 'L')
1823     {
1824       type = C_WIDE_STRING;
1825       ++tokptr;
1826     }
1827   else if (*tokptr == 'u')
1828     {
1829       type = C_STRING_16;
1830       ++tokptr;
1831     }
1832   else if (*tokptr == 'U')
1833     {
1834       type = C_STRING_32;
1835       ++tokptr;
1836     }
1837   else
1838     type = C_STRING;
1839
1840   /* Skip the quote.  */
1841   quote = *tokptr;
1842   if (quote == '\'')
1843     type |= C_CHAR;
1844   ++tokptr;
1845
1846   *host_chars = 0;
1847
1848   while (*tokptr)
1849     {
1850       char c = *tokptr;
1851       if (c == '\\')
1852         {
1853           ++tokptr;
1854           *host_chars += c_parse_escape (&tokptr, &tempbuf);
1855         }
1856       else if (c == quote)
1857         break;
1858       else
1859         {
1860           obstack_1grow (&tempbuf, c);
1861           ++tokptr;
1862           /* FIXME: this does the wrong thing with multi-byte host
1863              characters.  We could use mbrlen here, but that would
1864              make "set host-charset" a bit less useful.  */
1865           ++*host_chars;
1866         }
1867     }
1868
1869   if (*tokptr != quote)
1870     {
1871       if (quote == '"')
1872         error (_("Unterminated string in expression."));
1873       else
1874         error (_("Unmatched single quote."));
1875     }
1876   ++tokptr;
1877
1878   value->type = type;
1879   value->ptr = obstack_base (&tempbuf);
1880   value->length = obstack_object_size (&tempbuf);
1881
1882   *outptr = tokptr;
1883
1884   return quote == '"' ? STRING : CHAR;
1885 }
1886
1887 struct token
1888 {
1889   char *operator;
1890   int token;
1891   enum exp_opcode opcode;
1892   int cxx_only;
1893 };
1894
1895 static const struct token tokentab3[] =
1896   {
1897     {">>=", ASSIGN_MODIFY, BINOP_RSH, 0},
1898     {"<<=", ASSIGN_MODIFY, BINOP_LSH, 0},
1899     {"->*", ARROW_STAR, BINOP_END, 1}
1900   };
1901
1902 static const struct token tokentab2[] =
1903   {
1904     {"+=", ASSIGN_MODIFY, BINOP_ADD, 0},
1905     {"-=", ASSIGN_MODIFY, BINOP_SUB, 0},
1906     {"*=", ASSIGN_MODIFY, BINOP_MUL, 0},
1907     {"/=", ASSIGN_MODIFY, BINOP_DIV, 0},
1908     {"%=", ASSIGN_MODIFY, BINOP_REM, 0},
1909     {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR, 0},
1910     {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND, 0},
1911     {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR, 0},
1912     {"++", INCREMENT, BINOP_END, 0},
1913     {"--", DECREMENT, BINOP_END, 0},
1914     {"->", ARROW, BINOP_END, 0},
1915     {"&&", ANDAND, BINOP_END, 0},
1916     {"||", OROR, BINOP_END, 0},
1917     /* "::" is *not* only C++: gdb overrides its meaning in several
1918        different ways, e.g., 'filename'::func, function::variable.  */
1919     {"::", COLONCOLON, BINOP_END, 0},
1920     {"<<", LSH, BINOP_END, 0},
1921     {">>", RSH, BINOP_END, 0},
1922     {"==", EQUAL, BINOP_END, 0},
1923     {"!=", NOTEQUAL, BINOP_END, 0},
1924     {"<=", LEQ, BINOP_END, 0},
1925     {">=", GEQ, BINOP_END, 0},
1926     {".*", DOT_STAR, BINOP_END, 1}
1927   };
1928
1929 /* Identifier-like tokens.  */
1930 static const struct token ident_tokens[] =
1931   {
1932     {"unsigned", UNSIGNED, OP_NULL, 0},
1933     {"template", TEMPLATE, OP_NULL, 1},
1934     {"volatile", VOLATILE_KEYWORD, OP_NULL, 0},
1935     {"struct", STRUCT, OP_NULL, 0},
1936     {"signed", SIGNED_KEYWORD, OP_NULL, 0},
1937     {"sizeof", SIZEOF, OP_NULL, 0},
1938     {"double", DOUBLE_KEYWORD, OP_NULL, 0},
1939     {"false", FALSEKEYWORD, OP_NULL, 1},
1940     {"class", CLASS, OP_NULL, 1},
1941     {"union", UNION, OP_NULL, 0},
1942     {"short", SHORT, OP_NULL, 0},
1943     {"const", CONST_KEYWORD, OP_NULL, 0},
1944     {"enum", ENUM, OP_NULL, 0},
1945     {"long", LONG, OP_NULL, 0},
1946     {"true", TRUEKEYWORD, OP_NULL, 1},
1947     {"int", INT_KEYWORD, OP_NULL, 0},
1948     {"new", NEW, OP_NULL, 1},
1949     {"delete", DELETE, OP_NULL, 1},
1950     {"operator", OPERATOR, OP_NULL, 1},
1951
1952     {"and", ANDAND, BINOP_END, 1},
1953     {"and_eq", ASSIGN_MODIFY, BINOP_BITWISE_AND, 1},
1954     {"bitand", '&', OP_NULL, 1},
1955     {"bitor", '|', OP_NULL, 1},
1956     {"compl", '~', OP_NULL, 1},
1957     {"not", '!', OP_NULL, 1},
1958     {"not_eq", NOTEQUAL, BINOP_END, 1},
1959     {"or", OROR, BINOP_END, 1},
1960     {"or_eq", ASSIGN_MODIFY, BINOP_BITWISE_IOR, 1},
1961     {"xor", '^', OP_NULL, 1},
1962     {"xor_eq", ASSIGN_MODIFY, BINOP_BITWISE_XOR, 1},
1963
1964     {"const_cast", CONST_CAST, OP_NULL, 1 },
1965     {"dynamic_cast", DYNAMIC_CAST, OP_NULL, 1 },
1966     {"static_cast", STATIC_CAST, OP_NULL, 1 },
1967     {"reinterpret_cast", REINTERPRET_CAST, OP_NULL, 1 }
1968   };
1969
1970 /* When we find that lexptr (the global var defined in parse.c) is
1971    pointing at a macro invocation, we expand the invocation, and call
1972    scan_macro_expansion to save the old lexptr here and point lexptr
1973    into the expanded text.  When we reach the end of that, we call
1974    end_macro_expansion to pop back to the value we saved here.  The
1975    macro expansion code promises to return only fully-expanded text,
1976    so we don't need to "push" more than one level.
1977
1978    This is disgusting, of course.  It would be cleaner to do all macro
1979    expansion beforehand, and then hand that to lexptr.  But we don't
1980    really know where the expression ends.  Remember, in a command like
1981
1982      (gdb) break *ADDRESS if CONDITION
1983
1984    we evaluate ADDRESS in the scope of the current frame, but we
1985    evaluate CONDITION in the scope of the breakpoint's location.  So
1986    it's simply wrong to try to macro-expand the whole thing at once.  */
1987 static char *macro_original_text;
1988
1989 /* We save all intermediate macro expansions on this obstack for the
1990    duration of a single parse.  The expansion text may sometimes have
1991    to live past the end of the expansion, due to yacc lookahead.
1992    Rather than try to be clever about saving the data for a single
1993    token, we simply keep it all and delete it after parsing has
1994    completed.  */
1995 static struct obstack expansion_obstack;
1996
1997 static void
1998 scan_macro_expansion (char *expansion)
1999 {
2000   char *copy;
2001
2002   /* We'd better not be trying to push the stack twice.  */
2003   gdb_assert (! macro_original_text);
2004
2005   /* Copy to the obstack, and then free the intermediate
2006      expansion.  */
2007   copy = obstack_copy0 (&expansion_obstack, expansion, strlen (expansion));
2008   xfree (expansion);
2009
2010   /* Save the old lexptr value, so we can return to it when we're done
2011      parsing the expanded text.  */
2012   macro_original_text = lexptr;
2013   lexptr = copy;
2014 }
2015
2016
2017 static int
2018 scanning_macro_expansion (void)
2019 {
2020   return macro_original_text != 0;
2021 }
2022
2023
2024 static void
2025 finished_macro_expansion (void)
2026 {
2027   /* There'd better be something to pop back to.  */
2028   gdb_assert (macro_original_text);
2029
2030   /* Pop back to the original text.  */
2031   lexptr = macro_original_text;
2032   macro_original_text = 0;
2033 }
2034
2035
2036 static void
2037 scan_macro_cleanup (void *dummy)
2038 {
2039   if (macro_original_text)
2040     finished_macro_expansion ();
2041
2042   obstack_free (&expansion_obstack, NULL);
2043 }
2044
2045 /* Return true iff the token represents a C++ cast operator.  */
2046
2047 static int
2048 is_cast_operator (const char *token, int len)
2049 {
2050   return (! strncmp (token, "dynamic_cast", len)
2051           || ! strncmp (token, "static_cast", len)
2052           || ! strncmp (token, "reinterpret_cast", len)
2053           || ! strncmp (token, "const_cast", len));
2054 }
2055
2056 /* The scope used for macro expansion.  */
2057 static struct macro_scope *expression_macro_scope;
2058
2059 /* This is set if a NAME token appeared at the very end of the input
2060    string, with no whitespace separating the name from the EOF.  This
2061    is used only when parsing to do field name completion.  */
2062 static int saw_name_at_eof;
2063
2064 /* This is set if the previously-returned token was a structure
2065    operator -- either '.' or ARROW.  This is used only when parsing to
2066    do field name completion.  */
2067 static int last_was_structop;
2068
2069 /* Read one token, getting characters through lexptr.  */
2070
2071 static int
2072 lex_one_token (void)
2073 {
2074   int c;
2075   int namelen;
2076   unsigned int i;
2077   char *tokstart;
2078   int saw_structop = last_was_structop;
2079   char *copy;
2080
2081   last_was_structop = 0;
2082
2083  retry:
2084
2085   /* Check if this is a macro invocation that we need to expand.  */
2086   if (! scanning_macro_expansion ())
2087     {
2088       char *expanded = macro_expand_next (&lexptr,
2089                                           standard_macro_lookup,
2090                                           expression_macro_scope);
2091
2092       if (expanded)
2093         scan_macro_expansion (expanded);
2094     }
2095
2096   prev_lexptr = lexptr;
2097
2098   tokstart = lexptr;
2099   /* See if it is a special token of length 3.  */
2100   for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
2101     if (strncmp (tokstart, tokentab3[i].operator, 3) == 0)
2102       {
2103         if (tokentab3[i].cxx_only
2104             && parse_language->la_language != language_cplus)
2105           break;
2106
2107         lexptr += 3;
2108         yylval.opcode = tokentab3[i].opcode;
2109         return tokentab3[i].token;
2110       }
2111
2112   /* See if it is a special token of length 2.  */
2113   for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
2114     if (strncmp (tokstart, tokentab2[i].operator, 2) == 0)
2115       {
2116         if (tokentab2[i].cxx_only
2117             && parse_language->la_language != language_cplus)
2118           break;
2119
2120         lexptr += 2;
2121         yylval.opcode = tokentab2[i].opcode;
2122         if (in_parse_field && tokentab2[i].token == ARROW)
2123           last_was_structop = 1;
2124         return tokentab2[i].token;
2125       }
2126
2127   switch (c = *tokstart)
2128     {
2129     case 0:
2130       /* If we were just scanning the result of a macro expansion,
2131          then we need to resume scanning the original text.
2132          If we're parsing for field name completion, and the previous
2133          token allows such completion, return a COMPLETE token.
2134          Otherwise, we were already scanning the original text, and
2135          we're really done.  */
2136       if (scanning_macro_expansion ())
2137         {
2138           finished_macro_expansion ();
2139           goto retry;
2140         }
2141       else if (saw_name_at_eof)
2142         {
2143           saw_name_at_eof = 0;
2144           return COMPLETE;
2145         }
2146       else if (saw_structop)
2147         return COMPLETE;
2148       else
2149         return 0;
2150
2151     case ' ':
2152     case '\t':
2153     case '\n':
2154       lexptr++;
2155       goto retry;
2156
2157     case '[':
2158     case '(':
2159       paren_depth++;
2160       lexptr++;
2161       return c;
2162
2163     case ']':
2164     case ')':
2165       if (paren_depth == 0)
2166         return 0;
2167       paren_depth--;
2168       lexptr++;
2169       return c;
2170
2171     case ',':
2172       if (comma_terminates
2173           && paren_depth == 0
2174           && ! scanning_macro_expansion ())
2175         return 0;
2176       lexptr++;
2177       return c;
2178
2179     case '.':
2180       /* Might be a floating point number.  */
2181       if (lexptr[1] < '0' || lexptr[1] > '9')
2182         {
2183           if (in_parse_field)
2184             last_was_structop = 1;
2185           goto symbol;          /* Nope, must be a symbol. */
2186         }
2187       /* FALL THRU into number case.  */
2188
2189     case '0':
2190     case '1':
2191     case '2':
2192     case '3':
2193     case '4':
2194     case '5':
2195     case '6':
2196     case '7':
2197     case '8':
2198     case '9':
2199       {
2200         /* It's a number.  */
2201         int got_dot = 0, got_e = 0, toktype;
2202         char *p = tokstart;
2203         int hex = input_radix > 10;
2204
2205         if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
2206           {
2207             p += 2;
2208             hex = 1;
2209           }
2210         else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
2211           {
2212             p += 2;
2213             hex = 0;
2214           }
2215
2216         for (;; ++p)
2217           {
2218             /* This test includes !hex because 'e' is a valid hex digit
2219                and thus does not indicate a floating point number when
2220                the radix is hex.  */
2221             if (!hex && !got_e && (*p == 'e' || *p == 'E'))
2222               got_dot = got_e = 1;
2223             /* This test does not include !hex, because a '.' always indicates
2224                a decimal floating point number regardless of the radix.  */
2225             else if (!got_dot && *p == '.')
2226               got_dot = 1;
2227             else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
2228                      && (*p == '-' || *p == '+'))
2229               /* This is the sign of the exponent, not the end of the
2230                  number.  */
2231               continue;
2232             /* We will take any letters or digits.  parse_number will
2233                complain if past the radix, or if L or U are not final.  */
2234             else if ((*p < '0' || *p > '9')
2235                      && ((*p < 'a' || *p > 'z')
2236                                   && (*p < 'A' || *p > 'Z')))
2237               break;
2238           }
2239         toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
2240         if (toktype == ERROR)
2241           {
2242             char *err_copy = (char *) alloca (p - tokstart + 1);
2243
2244             memcpy (err_copy, tokstart, p - tokstart);
2245             err_copy[p - tokstart] = 0;
2246             error (_("Invalid number \"%s\"."), err_copy);
2247           }
2248         lexptr = p;
2249         return toktype;
2250       }
2251
2252     case '@':
2253       {
2254         char *p = &tokstart[1];
2255         size_t len = strlen ("entry");
2256
2257         while (isspace (*p))
2258           p++;
2259         if (strncmp (p, "entry", len) == 0 && !isalnum (p[len])
2260             && p[len] != '_')
2261           {
2262             lexptr = &p[len];
2263             return ENTRY;
2264           }
2265       }
2266       /* FALLTHRU */
2267     case '+':
2268     case '-':
2269     case '*':
2270     case '/':
2271     case '%':
2272     case '|':
2273     case '&':
2274     case '^':
2275     case '~':
2276     case '!':
2277     case '<':
2278     case '>':
2279     case '?':
2280     case ':':
2281     case '=':
2282     case '{':
2283     case '}':
2284     symbol:
2285       lexptr++;
2286       return c;
2287
2288     case 'L':
2289     case 'u':
2290     case 'U':
2291       if (tokstart[1] != '"' && tokstart[1] != '\'')
2292         break;
2293       /* Fall through.  */
2294     case '\'':
2295     case '"':
2296       {
2297         int host_len;
2298         int result = parse_string_or_char (tokstart, &lexptr, &yylval.tsval,
2299                                            &host_len);
2300         if (result == CHAR)
2301           {
2302             if (host_len == 0)
2303               error (_("Empty character constant."));
2304             else if (host_len > 2 && c == '\'')
2305               {
2306                 ++tokstart;
2307                 namelen = lexptr - tokstart - 1;
2308                 goto tryname;
2309               }
2310             else if (host_len > 1)
2311               error (_("Invalid character constant."));
2312           }
2313         return result;
2314       }
2315     }
2316
2317   if (!(c == '_' || c == '$'
2318         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
2319     /* We must have come across a bad character (e.g. ';').  */
2320     error (_("Invalid character '%c' in expression."), c);
2321
2322   /* It's a name.  See how long it is.  */
2323   namelen = 0;
2324   for (c = tokstart[namelen];
2325        (c == '_' || c == '$' || (c >= '0' && c <= '9')
2326         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
2327     {
2328       /* Template parameter lists are part of the name.
2329          FIXME: This mishandles `print $a<4&&$a>3'.  */
2330
2331       if (c == '<')
2332         {
2333           if (! is_cast_operator (tokstart, namelen))
2334             {
2335               /* Scan ahead to get rest of the template specification.  Note
2336                  that we look ahead only when the '<' adjoins non-whitespace
2337                  characters; for comparison expressions, e.g. "a < b > c",
2338                  there must be spaces before the '<', etc. */
2339
2340               char * p = find_template_name_end (tokstart + namelen);
2341               if (p)
2342                 namelen = p - tokstart;
2343             }
2344           break;
2345         }
2346       c = tokstart[++namelen];
2347     }
2348
2349   /* The token "if" terminates the expression and is NOT removed from
2350      the input stream.  It doesn't count if it appears in the
2351      expansion of a macro.  */
2352   if (namelen == 2
2353       && tokstart[0] == 'i'
2354       && tokstart[1] == 'f'
2355       && ! scanning_macro_expansion ())
2356     {
2357       return 0;
2358     }
2359
2360   /* For the same reason (breakpoint conditions), "thread N"
2361      terminates the expression.  "thread" could be an identifier, but
2362      an identifier is never followed by a number without intervening
2363      punctuation.  "task" is similar.  Handle abbreviations of these,
2364      similarly to breakpoint.c:find_condition_and_thread.  */
2365   if (namelen >= 1
2366       && (strncmp (tokstart, "thread", namelen) == 0
2367           || strncmp (tokstart, "task", namelen) == 0)
2368       && (tokstart[namelen] == ' ' || tokstart[namelen] == '\t')
2369       && ! scanning_macro_expansion ())
2370     {
2371       char *p = tokstart + namelen + 1;
2372       while (*p == ' ' || *p == '\t')
2373         p++;
2374       if (*p >= '0' && *p <= '9')
2375         return 0;
2376     }
2377
2378   lexptr += namelen;
2379
2380   tryname:
2381
2382   yylval.sval.ptr = tokstart;
2383   yylval.sval.length = namelen;
2384
2385   /* Catch specific keywords.  */
2386   copy = copy_name (yylval.sval);
2387   for (i = 0; i < sizeof ident_tokens / sizeof ident_tokens[0]; i++)
2388     if (strcmp (copy, ident_tokens[i].operator) == 0)
2389       {
2390         if (ident_tokens[i].cxx_only
2391             && parse_language->la_language != language_cplus)
2392           break;
2393
2394         /* It is ok to always set this, even though we don't always
2395            strictly need to.  */
2396         yylval.opcode = ident_tokens[i].opcode;
2397         return ident_tokens[i].token;
2398       }
2399
2400   if (*tokstart == '$')
2401     return VARIABLE;
2402
2403   if (in_parse_field && *lexptr == '\0')
2404     saw_name_at_eof = 1;
2405   return NAME;
2406 }
2407
2408 /* An object of this type is pushed on a FIFO by the "outer" lexer.  */
2409 typedef struct
2410 {
2411   int token;
2412   YYSTYPE value;
2413 } token_and_value;
2414
2415 DEF_VEC_O (token_and_value);
2416
2417 /* A FIFO of tokens that have been read but not yet returned to the
2418    parser.  */
2419 static VEC (token_and_value) *token_fifo;
2420
2421 /* Non-zero if the lexer should return tokens from the FIFO.  */
2422 static int popping;
2423
2424 /* Temporary storage for c_lex; this holds symbol names as they are
2425    built up.  */
2426 static struct obstack name_obstack;
2427
2428 /* Classify a NAME token.  The contents of the token are in `yylval'.
2429    Updates yylval and returns the new token type.  BLOCK is the block
2430    in which lookups start; this can be NULL to mean the global
2431    scope.  */
2432 static int
2433 classify_name (struct block *block)
2434 {
2435   struct symbol *sym;
2436   char *copy;
2437   int is_a_field_of_this = 0;
2438
2439   copy = copy_name (yylval.sval);
2440
2441   sym = lookup_symbol (copy, block, VAR_DOMAIN,
2442                        parse_language->la_language == language_cplus
2443                        ? &is_a_field_of_this : (int *) NULL);
2444
2445   if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
2446     {
2447       yylval.ssym.sym = sym;
2448       yylval.ssym.is_a_field_of_this = is_a_field_of_this;
2449       return BLOCKNAME;
2450     }
2451   else if (!sym)
2452     {
2453       /* See if it's a file name. */
2454       struct symtab *symtab;
2455
2456       symtab = lookup_symtab (copy);
2457       if (symtab)
2458         {
2459           yylval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
2460           return FILENAME;
2461         }
2462     }
2463
2464   if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
2465     {
2466       yylval.tsym.type = SYMBOL_TYPE (sym);
2467       return TYPENAME;
2468     }
2469
2470   yylval.tsym.type
2471     = language_lookup_primitive_type_by_name (parse_language,
2472                                               parse_gdbarch, copy);
2473   if (yylval.tsym.type != NULL)
2474     return TYPENAME;
2475
2476   /* Input names that aren't symbols but ARE valid hex numbers, when
2477      the input radix permits them, can be names or numbers depending
2478      on the parse.  Note we support radixes > 16 here.  */
2479   if (!sym
2480       && ((copy[0] >= 'a' && copy[0] < 'a' + input_radix - 10)
2481           || (copy[0] >= 'A' && copy[0] < 'A' + input_radix - 10)))
2482     {
2483       YYSTYPE newlval;  /* Its value is ignored.  */
2484       int hextype = parse_number (copy, yylval.sval.length, 0, &newlval);
2485       if (hextype == INT)
2486         {
2487           yylval.ssym.sym = sym;
2488           yylval.ssym.is_a_field_of_this = is_a_field_of_this;
2489           return NAME_OR_INT;
2490         }
2491     }
2492
2493   /* Any other kind of symbol */
2494   yylval.ssym.sym = sym;
2495   yylval.ssym.is_a_field_of_this = is_a_field_of_this;
2496
2497   if (sym == NULL
2498       && parse_language->la_language == language_cplus
2499       && !is_a_field_of_this
2500       && !lookup_minimal_symbol (copy, NULL, NULL))
2501     return UNKNOWN_CPP_NAME;
2502
2503   return NAME;
2504 }
2505
2506 /* Like classify_name, but used by the inner loop of the lexer, when a
2507    name might have already been seen.  FIRST_NAME is true if the token
2508    in `yylval' is the first component of a name, false otherwise.  If
2509    this function returns NAME, it might not have updated `yylval'.
2510    This is ok because the caller only cares about TYPENAME.  */
2511 static int
2512 classify_inner_name (struct block *block, int first_name)
2513 {
2514   struct type *type, *new_type;
2515   char *copy;
2516
2517   if (first_name)
2518     return classify_name (block);
2519
2520   type = check_typedef (yylval.tsym.type);
2521   if (TYPE_CODE (type) != TYPE_CODE_STRUCT
2522       && TYPE_CODE (type) != TYPE_CODE_UNION
2523       && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
2524     /* We know the caller won't expect us to update yylval.  */
2525     return NAME;
2526
2527   copy = copy_name (yylval.tsym.stoken);
2528   new_type = cp_lookup_nested_type (yylval.tsym.type, copy, block);
2529
2530   if (new_type == NULL)
2531     /* We know the caller won't expect us to update yylval.  */
2532     return NAME;
2533
2534   yylval.tsym.type = new_type;
2535   return TYPENAME;
2536 }
2537
2538 /* The outer level of a two-level lexer.  This calls the inner lexer
2539    to return tokens.  It then either returns these tokens, or
2540    aggregates them into a larger token.  This lets us work around a
2541    problem in our parsing approach, where the parser could not
2542    distinguish between qualified names and qualified types at the
2543    right point.
2544
2545    This approach is still not ideal, because it mishandles template
2546    types.  See the comment in lex_one_token for an example.  However,
2547    this is still an improvement over the earlier approach, and will
2548    suffice until we move to better parsing technology.  */
2549 static int
2550 yylex (void)
2551 {
2552   token_and_value current;
2553   int first_was_coloncolon, last_was_coloncolon, first_iter;
2554
2555   if (popping && !VEC_empty (token_and_value, token_fifo))
2556     {
2557       token_and_value tv = *VEC_index (token_and_value, token_fifo, 0);
2558       VEC_ordered_remove (token_and_value, token_fifo, 0);
2559       yylval = tv.value;
2560       return tv.token;
2561     }
2562   popping = 0;
2563
2564   current.token = lex_one_token ();
2565   if (current.token == NAME)
2566     current.token = classify_name (expression_context_block);
2567   if (parse_language->la_language != language_cplus
2568       || (current.token != TYPENAME && current.token != COLONCOLON))
2569     return current.token;
2570
2571   first_was_coloncolon = current.token == COLONCOLON;
2572   last_was_coloncolon = first_was_coloncolon;
2573   obstack_free (&name_obstack, obstack_base (&name_obstack));
2574   if (!last_was_coloncolon)
2575     obstack_grow (&name_obstack, yylval.sval.ptr, yylval.sval.length);
2576   current.value = yylval;
2577   first_iter = 1;
2578   while (1)
2579     {
2580       token_and_value next;
2581
2582       next.token = lex_one_token ();
2583       next.value = yylval;
2584
2585       if (next.token == NAME && last_was_coloncolon)
2586         {
2587           int classification;
2588
2589           classification = classify_inner_name (first_was_coloncolon
2590                                                 ? NULL
2591                                                 : expression_context_block,
2592                                                 first_iter);
2593           /* We keep going until we either run out of names, or until
2594              we have a qualified name which is not a type.  */
2595           if (classification != TYPENAME)
2596             {
2597               /* Push the final component and leave the loop.  */
2598               VEC_safe_push (token_and_value, token_fifo, &next);
2599               break;
2600             }
2601
2602           /* Update the partial name we are constructing.  */
2603           if (!first_iter)
2604             {
2605               /* We don't want to put a leading "::" into the name.  */
2606               obstack_grow_str (&name_obstack, "::");
2607             }
2608           obstack_grow (&name_obstack, next.value.sval.ptr,
2609                         next.value.sval.length);
2610
2611           yylval.sval.ptr = obstack_base (&name_obstack);
2612           yylval.sval.length = obstack_object_size (&name_obstack);
2613           current.value = yylval;
2614           current.token = classification;
2615
2616           last_was_coloncolon = 0;
2617         }
2618       else if (next.token == COLONCOLON && !last_was_coloncolon)
2619         last_was_coloncolon = 1;
2620       else
2621         {
2622           /* We've reached the end of the name.  */
2623           VEC_safe_push (token_and_value, token_fifo, &next);
2624           break;
2625         }
2626
2627       first_iter = 0;
2628     }
2629
2630   popping = 1;
2631
2632   /* If we ended with a "::", insert it too.  */
2633   if (last_was_coloncolon)
2634     {
2635       token_and_value cc;
2636       memset (&cc, 0, sizeof (token_and_value));
2637       if (first_was_coloncolon && first_iter)
2638         {
2639           yylval = cc.value;
2640           return COLONCOLON;
2641         }
2642       cc.token = COLONCOLON;
2643       VEC_safe_insert (token_and_value, token_fifo, 0, &cc);
2644     }
2645
2646   yylval = current.value;
2647   yylval.sval.ptr = obstack_copy0 (&expansion_obstack,
2648                                    yylval.sval.ptr,
2649                                    yylval.sval.length);
2650   return current.token;
2651 }
2652
2653 int
2654 c_parse (void)
2655 {
2656   int result;
2657   struct cleanup *back_to = make_cleanup (free_current_contents,
2658                                           &expression_macro_scope);
2659
2660   /* Set up the scope for macro expansion.  */
2661   expression_macro_scope = NULL;
2662
2663   if (expression_context_block)
2664     expression_macro_scope
2665       = sal_macro_scope (find_pc_line (expression_context_pc, 0));
2666   else
2667     expression_macro_scope = default_macro_scope ();
2668   if (! expression_macro_scope)
2669     expression_macro_scope = user_macro_scope ();
2670
2671   /* Initialize macro expansion code.  */
2672   obstack_init (&expansion_obstack);
2673   gdb_assert (! macro_original_text);
2674   make_cleanup (scan_macro_cleanup, 0);
2675
2676   make_cleanup_restore_integer (&yydebug);
2677   yydebug = parser_debug;
2678
2679   /* Initialize some state used by the lexer.  */
2680   last_was_structop = 0;
2681   saw_name_at_eof = 0;
2682
2683   VEC_free (token_and_value, token_fifo);
2684   popping = 0;
2685   obstack_init (&name_obstack);
2686   make_cleanup_obstack_free (&name_obstack);
2687
2688   result = yyparse ();
2689   do_cleanups (back_to);
2690   return result;
2691 }
2692
2693
2694 void
2695 yyerror (char *msg)
2696 {
2697   if (prev_lexptr)
2698     lexptr = prev_lexptr;
2699
2700   error (_("A %s in expression, near `%s'."), (msg ? msg : "error"), lexptr);
2701 }