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