gdb/c-exp.y

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