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