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