gdb/c-exp.y

   1 /* YACC parser for C expressions, for GDB.
   2    Copyright 1986, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
   3    1998, 1999, 2000, 2003
   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 2 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, write to the Free Software
  20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22 /* Parse a C expression from text in a string,
  23    and return the result as a  struct expression  pointer.
  24    That structure contains arithmetic operations in reverse polish,
  25    with constants represented by operations that are followed by special data.
  26    See expression.h for the details of the format.
  27    What is important here is that it can be built up sequentially
  28    during the process of parsing; the lower levels of the tree always
  29    come first in the result.
  30
  31    Note that malloc's and realloc's in this file are transformed to
  32    xmalloc and xrealloc respectively by the same sed command in the
  33    makefile that remaps any other malloc/realloc inserted by the parser
  34    generator.  Doing this with #defines and trying to control the interaction
  35    with include files (<malloc.h> and <stdlib.h> for example) just became
  36    too messy, particularly when such includes can be inserted at random
  37    times by the parser generator.  */
  38
  39 %{
  40
  41 #include "defs.h"
  42 #include "gdb_string.h"
  43 #include <ctype.h>
  44 #include "expression.h"
  45 #include "value.h"
  46 #include "parser-defs.h"
  47 #include "language.h"
  48 #include "c-lang.h"
  49 #include "bfd.h" /* Required by objfiles.h.  */
  50 #include "symfile.h" /* Required by objfiles.h.  */
  51 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
  52 #include "charset.h"
  53 #include "block.h"
  54 #include "cp-support.h"
  55
  56 /* Flag indicating we're dealing with HP-compiled objects */
  57 extern int hp_som_som_object_present;
  58
  59 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
  60    as well as gratuitiously global symbol names, so we can have multiple
  61    yacc generated parsers in gdb.  Note that these are only the variables
  62    produced by yacc.  If other parser generators (bison, byacc, etc) produce
  63    additional global names that conflict at link time, then those parser
  64    generators need to be fixed instead of adding those names to this list. */
  65
  66 #define yymaxdepth c_maxdepth
  67 #define yyparse c_parse
  68 #define yylex   c_lex
  69 #define yyerror c_error
  70 #define yylval  c_lval
  71 #define yychar  c_char
  72 #define yydebug c_debug
  73 #define yypact  c_pact
  74 #define yyr1    c_r1
  75 #define yyr2    c_r2
  76 #define yydef   c_def
  77 #define yychk   c_chk
  78 #define yypgo   c_pgo
  79 #define yyact   c_act
  80 #define yyexca  c_exca
  81 #define yyerrflag c_errflag
  82 #define yynerrs c_nerrs
  83 #define yyps    c_ps
  84 #define yypv    c_pv
  85 #define yys     c_s
  86 #define yy_yys  c_yys
  87 #define yystate c_state
  88 #define yytmp   c_tmp
  89 #define yyv     c_v
  90 #define yy_yyv  c_yyv
  91 #define yyval   c_val
  92 #define yylloc  c_lloc
  93 #define yyreds  c_reds          /* With YYDEBUG defined */
  94 #define yytoks  c_toks          /* With YYDEBUG defined */
  95 #define yyname  c_name          /* With YYDEBUG defined */
  96 #define yyrule  c_rule          /* With YYDEBUG defined */
  97 #define yylhs   c_yylhs
  98 #define yylen   c_yylen
  99 #define yydefred c_yydefred
 100 #define yydgoto c_yydgoto
 101 #define yysindex c_yysindex
 102 #define yyrindex c_yyrindex
 103 #define yygindex c_yygindex
 104 #define yytable  c_yytable
 105 #define yycheck  c_yycheck
 106
 107 #ifndef YYDEBUG
 108 #define YYDEBUG 1               /* Default to yydebug support */
 109 #endif
 110
 111 #define YYFPRINTF parser_fprintf
 112
 113 int yyparse (void);
 114
 115 static int yylex (void);
 116
 117 void yyerror (char *);
 118
 119 %}
 120
 121 /* Although the yacc "value" of an expression is not used,
 122    since the result is stored in the structure being created,
 123    other node types do have values.  */
 124
 125 %union
 126   {
 127     LONGEST lval;
 128     struct {
 129       LONGEST val;
 130       struct type *type;
 131     } typed_val_int;
 132     struct {
 133       DOUBLEST dval;
 134       struct type *type;
 135     } typed_val_float;
 136     struct symbol *sym;
 137     struct type *tval;
 138     struct stoken sval;
 139     struct ttype tsym;
 140     struct symtoken ssym;
 141     int voidval;
 142     struct block *bval;
 143     enum exp_opcode opcode;
 144     struct internalvar *ivar;
 145
 146     struct type **tvec;
 147     int *ivec;
 148   }
 149
 150 %{
 151 /* YYSTYPE gets defined by %union */
 152 static int parse_number (char *, int, int, YYSTYPE *);
 153 %}
 154
 155 %type <voidval> exp exp1 type_exp start variable qualified_name lcurly
 156 %type <lval> rcurly
 157 %type <tval> type typebase qualified_type
 158 %type <tvec> nonempty_typelist
 159 /* %type <bval> block */
 160
 161 /* Fancy type parsing.  */
 162 %type <voidval> func_mod direct_abs_decl abs_decl
 163 %type <tval> ptype
 164 %type <lval> array_mod
 165
 166 %token <typed_val_int> INT
 167 %token <typed_val_float> FLOAT
 168
 169 /* Both NAME and TYPENAME tokens represent symbols in the input,
 170    and both convey their data as strings.
 171    But a TYPENAME is a string that happens to be defined as a typedef
 172    or builtin type name (such as int or char)
 173    and a NAME is any other symbol.
 174    Contexts where this distinction is not important can use the
 175    nonterminal "name", which matches either NAME or TYPENAME.  */
 176
 177 %token <sval> STRING
 178 %token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */
 179 %token <tsym> TYPENAME
 180 %type <sval> name
 181 %type <ssym> name_not_typename
 182 %type <tsym> typename
 183
 184 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
 185    but which would parse as a valid number in the current input radix.
 186    E.g. "c" when input_radix==16.  Depending on the parse, it will be
 187    turned into a name or into a number.  */
 188
 189 %token <ssym> NAME_OR_INT
 190
 191 %token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
 192 %token TEMPLATE
 193 %token ERROR
 194
 195 /* Special type cases, put in to allow the parser to distinguish different
 196    legal basetypes.  */
 197 %token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD DOUBLE_KEYWORD
 198
 199 %token <voidval> VARIABLE
 200
 201 %token <opcode> ASSIGN_MODIFY
 202
 203 /* C++ */
 204 %token TRUEKEYWORD
 205 %token FALSEKEYWORD
 206
 207
 208 %left ','
 209 %left ABOVE_COMMA
 210 %right '=' ASSIGN_MODIFY
 211 %right '?'
 212 %left OROR
 213 %left ANDAND
 214 %left '|'
 215 %left '^'
 216 %left '&'
 217 %left EQUAL NOTEQUAL
 218 %left '<' '>' LEQ GEQ
 219 %left LSH RSH
 220 %left '@'
 221 %left '+' '-'
 222 %left '*' '/' '%'
 223 %right UNARY INCREMENT DECREMENT
 224 %right ARROW '.' '[' '('
 225 %token <ssym> BLOCKNAME
 226 %token <bval> FILENAME
 227 %type <bval> block
 228 %left COLONCOLON
 229
 230 \f
 231 %%
 232
 233 start   :       exp1
 234         |       type_exp
 235         ;
 236
 237 type_exp:       type
 238                         { write_exp_elt_opcode(OP_TYPE);
 239                           write_exp_elt_type($1);
 240                           write_exp_elt_opcode(OP_TYPE);}
 241         ;
 242
 243 /* Expressions, including the comma operator.  */
 244 exp1    :       exp
 245         |       exp1 ',' exp
 246                         { write_exp_elt_opcode (BINOP_COMMA); }
 247         ;
 248
 249 /* Expressions, not including the comma operator.  */
 250 exp     :       '*' exp    %prec UNARY
 251                         { write_exp_elt_opcode (UNOP_IND); }
 252         ;
 253
 254 exp     :       '&' exp    %prec UNARY
 255                         { write_exp_elt_opcode (UNOP_ADDR); }
 256         ;
 257
 258 exp     :       '-' exp    %prec UNARY
 259                         { write_exp_elt_opcode (UNOP_NEG); }
 260         ;
 261
 262 exp     :       '!' exp    %prec UNARY
 263                         { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
 264         ;
 265
 266 exp     :       '~' exp    %prec UNARY
 267                         { write_exp_elt_opcode (UNOP_COMPLEMENT); }
 268         ;
 269
 270 exp     :       INCREMENT exp    %prec UNARY
 271                         { write_exp_elt_opcode (UNOP_PREINCREMENT); }
 272         ;
 273
 274 exp     :       DECREMENT exp    %prec UNARY
 275                         { write_exp_elt_opcode (UNOP_PREDECREMENT); }
 276         ;
 277
 278 exp     :       exp INCREMENT    %prec UNARY
 279                         { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
 280         ;
 281
 282 exp     :       exp DECREMENT    %prec UNARY
 283                         { write_exp_elt_opcode (UNOP_POSTDECREMENT); }
 284         ;
 285
 286 exp     :       SIZEOF exp       %prec UNARY
 287                         { write_exp_elt_opcode (UNOP_SIZEOF); }
 288         ;
 289
 290 exp     :       exp ARROW name
 291                         { write_exp_elt_opcode (STRUCTOP_PTR);
 292                           write_exp_string ($3);
 293                           write_exp_elt_opcode (STRUCTOP_PTR); }
 294         ;
 295
 296 exp     :       exp ARROW qualified_name
 297                         { /* exp->type::name becomes exp->*(&type::name) */
 298                           /* Note: this doesn't work if name is a
 299                              static member!  FIXME */
 300                           write_exp_elt_opcode (UNOP_ADDR);
 301                           write_exp_elt_opcode (STRUCTOP_MPTR); }
 302         ;
 303
 304 exp     :       exp ARROW '*' exp
 305                         { write_exp_elt_opcode (STRUCTOP_MPTR); }
 306         ;
 307
 308 exp     :       exp '.' name
 309                         { write_exp_elt_opcode (STRUCTOP_STRUCT);
 310                           write_exp_string ($3);
 311                           write_exp_elt_opcode (STRUCTOP_STRUCT); }
 312         ;
 313
 314 exp     :       exp '.' qualified_name
 315                         { /* exp.type::name becomes exp.*(&type::name) */
 316                           /* Note: this doesn't work if name is a
 317                              static member!  FIXME */
 318                           write_exp_elt_opcode (UNOP_ADDR);
 319                           write_exp_elt_opcode (STRUCTOP_MEMBER); }
 320         ;
 321
 322 exp     :       exp '.' '*' exp
 323                         { write_exp_elt_opcode (STRUCTOP_MEMBER); }
 324         ;
 325
 326 exp     :       exp '[' exp1 ']'
 327                         { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
 328         ;
 329
 330 exp     :       exp '('
 331                         /* This is to save the value of arglist_len
 332                            being accumulated by an outer function call.  */
 333                         { start_arglist (); }
 334                 arglist ')'     %prec ARROW
 335                         { write_exp_elt_opcode (OP_FUNCALL);
 336                           write_exp_elt_longcst ((LONGEST) end_arglist ());
 337                           write_exp_elt_opcode (OP_FUNCALL); }
 338         ;
 339
 340 lcurly  :       '{'
 341                         { start_arglist (); }
 342         ;
 343
 344 arglist :
 345         ;
 346
 347 arglist :       exp
 348                         { arglist_len = 1; }
 349         ;
 350
 351 arglist :       arglist ',' exp   %prec ABOVE_COMMA
 352                         { arglist_len++; }
 353         ;
 354
 355 rcurly  :       '}'
 356                         { $$ = end_arglist () - 1; }
 357         ;
 358 exp     :       lcurly arglist rcurly   %prec ARROW
 359                         { write_exp_elt_opcode (OP_ARRAY);
 360                           write_exp_elt_longcst ((LONGEST) 0);
 361                           write_exp_elt_longcst ((LONGEST) $3);
 362                           write_exp_elt_opcode (OP_ARRAY); }
 363         ;
 364
 365 exp     :       lcurly type rcurly exp  %prec UNARY
 366                         { write_exp_elt_opcode (UNOP_MEMVAL);
 367                           write_exp_elt_type ($2);
 368                           write_exp_elt_opcode (UNOP_MEMVAL); }
 369         ;
 370
 371 exp     :       '(' type ')' exp  %prec UNARY
 372                         { write_exp_elt_opcode (UNOP_CAST);
 373                           write_exp_elt_type ($2);
 374                           write_exp_elt_opcode (UNOP_CAST); }
 375         ;
 376
 377 exp     :       '(' exp1 ')'
 378                         { }
 379         ;
 380
 381 /* Binary operators in order of decreasing precedence.  */
 382
 383 exp     :       exp '@' exp
 384                         { write_exp_elt_opcode (BINOP_REPEAT); }
 385         ;
 386
 387 exp     :       exp '*' exp
 388                         { write_exp_elt_opcode (BINOP_MUL); }
 389         ;
 390
 391 exp     :       exp '/' exp
 392                         { write_exp_elt_opcode (BINOP_DIV); }
 393         ;
 394
 395 exp     :       exp '%' exp
 396                         { write_exp_elt_opcode (BINOP_REM); }
 397         ;
 398
 399 exp     :       exp '+' exp
 400                         { write_exp_elt_opcode (BINOP_ADD); }
 401         ;
 402
 403 exp     :       exp '-' exp
 404                         { write_exp_elt_opcode (BINOP_SUB); }
 405         ;
 406
 407 exp     :       exp LSH exp
 408                         { write_exp_elt_opcode (BINOP_LSH); }
 409         ;
 410
 411 exp     :       exp RSH exp
 412                         { write_exp_elt_opcode (BINOP_RSH); }
 413         ;
 414
 415 exp     :       exp EQUAL exp
 416                         { write_exp_elt_opcode (BINOP_EQUAL); }
 417         ;
 418
 419 exp     :       exp NOTEQUAL exp
 420                         { write_exp_elt_opcode (BINOP_NOTEQUAL); }
 421         ;
 422
 423 exp     :       exp LEQ exp
 424                         { write_exp_elt_opcode (BINOP_LEQ); }
 425         ;
 426
 427 exp     :       exp GEQ exp
 428                         { write_exp_elt_opcode (BINOP_GEQ); }
 429         ;
 430
 431 exp     :       exp '<' exp
 432                         { write_exp_elt_opcode (BINOP_LESS); }
 433         ;
 434
 435 exp     :       exp '>' exp
 436                         { write_exp_elt_opcode (BINOP_GTR); }
 437         ;
 438
 439 exp     :       exp '&' exp
 440                         { write_exp_elt_opcode (BINOP_BITWISE_AND); }
 441         ;
 442
 443 exp     :       exp '^' exp
 444                         { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
 445         ;
 446
 447 exp     :       exp '|' exp
 448                         { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
 449         ;
 450
 451 exp     :       exp ANDAND exp
 452                         { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
 453         ;
 454
 455 exp     :       exp OROR exp
 456                         { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
 457         ;
 458
 459 exp     :       exp '?' exp ':' exp     %prec '?'
 460                         { write_exp_elt_opcode (TERNOP_COND); }
 461         ;
 462
 463 exp     :       exp '=' exp
 464                         { write_exp_elt_opcode (BINOP_ASSIGN); }
 465         ;
 466
 467 exp     :       exp ASSIGN_MODIFY exp
 468                         { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
 469                           write_exp_elt_opcode ($2);
 470                           write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
 471         ;
 472
 473 exp     :       INT
 474                         { write_exp_elt_opcode (OP_LONG);
 475                           write_exp_elt_type ($1.type);
 476                           write_exp_elt_longcst ((LONGEST)($1.val));
 477                           write_exp_elt_opcode (OP_LONG); }
 478         ;
 479
 480 exp     :       NAME_OR_INT
 481                         { YYSTYPE val;
 482                           parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
 483                           write_exp_elt_opcode (OP_LONG);
 484                           write_exp_elt_type (val.typed_val_int.type);
 485                           write_exp_elt_longcst ((LONGEST)val.typed_val_int.val);
 486                           write_exp_elt_opcode (OP_LONG);
 487                         }
 488         ;
 489
 490
 491 exp     :       FLOAT
 492                         { write_exp_elt_opcode (OP_DOUBLE);
 493                           write_exp_elt_type ($1.type);
 494                           write_exp_elt_dblcst ($1.dval);
 495                           write_exp_elt_opcode (OP_DOUBLE); }
 496         ;
 497
 498 exp     :       variable
 499         ;
 500
 501 exp     :       VARIABLE
 502                         /* Already written by write_dollar_variable. */
 503         ;
 504
 505 exp     :       SIZEOF '(' type ')'     %prec UNARY
 506                         { write_exp_elt_opcode (OP_LONG);
 507                           write_exp_elt_type (builtin_type_int);
 508                           CHECK_TYPEDEF ($3);
 509                           write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
 510                           write_exp_elt_opcode (OP_LONG); }
 511         ;
 512
 513 exp     :       STRING
 514                         { /* C strings are converted into array constants with
 515                              an explicit null byte added at the end.  Thus
 516                              the array upper bound is the string length.
 517                              There is no such thing in C as a completely empty
 518                              string. */
 519                           char *sp = $1.ptr; int count = $1.length;
 520                           while (count-- > 0)
 521                             {
 522                               write_exp_elt_opcode (OP_LONG);
 523                               write_exp_elt_type (builtin_type_char);
 524                               write_exp_elt_longcst ((LONGEST)(*sp++));
 525                               write_exp_elt_opcode (OP_LONG);
 526                             }
 527                           write_exp_elt_opcode (OP_LONG);
 528                           write_exp_elt_type (builtin_type_char);
 529                           write_exp_elt_longcst ((LONGEST)'\0');
 530                           write_exp_elt_opcode (OP_LONG);
 531                           write_exp_elt_opcode (OP_ARRAY);
 532                           write_exp_elt_longcst ((LONGEST) 0);
 533                           write_exp_elt_longcst ((LONGEST) ($1.length));
 534                           write_exp_elt_opcode (OP_ARRAY); }
 535         ;
 536
 537 /* C++.  */
 538 exp     :       TRUEKEYWORD
 539                         { write_exp_elt_opcode (OP_LONG);
 540                           write_exp_elt_type (builtin_type_bool);
 541                           write_exp_elt_longcst ((LONGEST) 1);
 542                           write_exp_elt_opcode (OP_LONG); }
 543         ;
 544
 545 exp     :       FALSEKEYWORD
 546                         { write_exp_elt_opcode (OP_LONG);
 547                           write_exp_elt_type (builtin_type_bool);
 548                           write_exp_elt_longcst ((LONGEST) 0);
 549                           write_exp_elt_opcode (OP_LONG); }
 550         ;
 551
 552 /* end of C++.  */
 553
 554 block   :       BLOCKNAME
 555                         {
 556                           if ($1.sym)
 557                             $$ = SYMBOL_BLOCK_VALUE ($1.sym);
 558                           else
 559                             error ("No file or function \"%s\".",
 560                                    copy_name ($1.stoken));
 561                         }
 562         |       FILENAME
 563                         {
 564                           $$ = $1;
 565                         }
 566         ;
 567
 568 block   :       block COLONCOLON name
 569                         { struct symbol *tem
 570                             = lookup_symbol (copy_name ($3), $1,
 571                                              VAR_DOMAIN, (int *) NULL,
 572                                              (struct symtab **) NULL);
 573                           if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
 574                             error ("No function \"%s\" in specified context.",
 575                                    copy_name ($3));
 576                           $$ = SYMBOL_BLOCK_VALUE (tem); }
 577         ;
 578
 579 variable:       block COLONCOLON name
 580                         { struct symbol *sym;
 581                           sym = lookup_symbol (copy_name ($3), $1,
 582                                                VAR_DOMAIN, (int *) NULL,
 583                                                (struct symtab **) NULL);
 584                           if (sym == 0)
 585                             error ("No symbol \"%s\" in specified context.",
 586                                    copy_name ($3));
 587
 588                           write_exp_elt_opcode (OP_VAR_VALUE);
 589                           /* block_found is set by lookup_symbol.  */
 590                           write_exp_elt_block (block_found);
 591                           write_exp_elt_sym (sym);
 592                           write_exp_elt_opcode (OP_VAR_VALUE); }
 593         ;
 594
 595 qualified_name: typebase COLONCOLON name
 596                         {
 597                           struct type *type = $1;
 598                           if (TYPE_CODE (type) != TYPE_CODE_STRUCT
 599                               && TYPE_CODE (type) != TYPE_CODE_UNION
 600                               && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
 601                             error ("`%s' is not defined as an aggregate type.",
 602                                    TYPE_NAME (type));
 603
 604                           write_exp_elt_opcode (OP_SCOPE);
 605                           write_exp_elt_type (type);
 606                           write_exp_string ($3);
 607                           write_exp_elt_opcode (OP_SCOPE);
 608                         }
 609         |       typebase COLONCOLON '~' name
 610                         {
 611                           struct type *type = $1;
 612                           struct stoken tmp_token;
 613                           if (TYPE_CODE (type) != TYPE_CODE_STRUCT
 614                               && TYPE_CODE (type) != TYPE_CODE_UNION
 615                               && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
 616                             error ("`%s' is not defined as an aggregate type.",
 617                                    TYPE_NAME (type));
 618
 619                           tmp_token.ptr = (char*) alloca ($4.length + 2);
 620                           tmp_token.length = $4.length + 1;
 621                           tmp_token.ptr[0] = '~';
 622                           memcpy (tmp_token.ptr+1, $4.ptr, $4.length);
 623                           tmp_token.ptr[tmp_token.length] = 0;
 624
 625                           /* Check for valid destructor name.  */
 626                           destructor_name_p (tmp_token.ptr, type);
 627                           write_exp_elt_opcode (OP_SCOPE);
 628                           write_exp_elt_type (type);
 629                           write_exp_string (tmp_token);
 630                           write_exp_elt_opcode (OP_SCOPE);
 631                         }
 632         ;
 633
 634 variable:       qualified_name
 635         |       COLONCOLON name
 636                         {
 637                           char *name = copy_name ($2);
 638                           struct symbol *sym;
 639                           struct minimal_symbol *msymbol;
 640
 641                           sym =
 642                             lookup_symbol (name, (const struct block *) NULL,
 643                                            VAR_DOMAIN, (int *) NULL,
 644                                            (struct symtab **) NULL);
 645                           if (sym)
 646                             {
 647                               write_exp_elt_opcode (OP_VAR_VALUE);
 648                               write_exp_elt_block (NULL);
 649                               write_exp_elt_sym (sym);
 650                               write_exp_elt_opcode (OP_VAR_VALUE);
 651                               break;
 652                             }
 653
 654                           msymbol = lookup_minimal_symbol (name, NULL, NULL);
 655                           if (msymbol != NULL)
 656                             {
 657                               write_exp_msymbol (msymbol,
 658                                                  lookup_function_type (builtin_type_int),
 659                                                  builtin_type_int);
 660                             }
 661                           else
 662                             if (!have_full_symbols () && !have_partial_symbols ())
 663                               error ("No symbol table is loaded.  Use the \"file\" command.");
 664                             else
 665                               error ("No symbol \"%s\" in current context.", name);
 666                         }
 667         ;
 668
 669 variable:       name_not_typename
 670                         { struct symbol *sym = $1.sym;
 671
 672                           if (sym)
 673                             {
 674                               if (symbol_read_needs_frame (sym))
 675                                 {
 676                                   if (innermost_block == 0 ||
 677                                       contained_in (block_found,
 678                                                     innermost_block))
 679                                     innermost_block = block_found;
 680                                 }
 681
 682                               write_exp_elt_opcode (OP_VAR_VALUE);
 683                               /* We want to use the selected frame, not
 684                                  another more inner frame which happens to
 685                                  be in the same block.  */
 686                               write_exp_elt_block (NULL);
 687                               write_exp_elt_sym (sym);
 688                               write_exp_elt_opcode (OP_VAR_VALUE);
 689                             }
 690                           else if ($1.is_a_field_of_this)
 691                             {
 692                               /* C++: it hangs off of `this'.  Must
 693                                  not inadvertently convert from a method call
 694                                  to data ref.  */
 695                               if (innermost_block == 0 ||
 696                                   contained_in (block_found, innermost_block))
 697                                 innermost_block = block_found;
 698                               write_exp_elt_opcode (OP_THIS);
 699                               write_exp_elt_opcode (OP_THIS);
 700                               write_exp_elt_opcode (STRUCTOP_PTR);
 701                               write_exp_string ($1.stoken);
 702                               write_exp_elt_opcode (STRUCTOP_PTR);
 703                             }
 704                           else
 705                             {
 706                               struct minimal_symbol *msymbol;
 707                               register char *arg = copy_name ($1.stoken);
 708
 709                               msymbol =
 710                                 lookup_minimal_symbol (arg, NULL, NULL);
 711                               if (msymbol != NULL)
 712                                 {
 713                                   write_exp_msymbol (msymbol,
 714                                                      lookup_function_type (builtin_type_int),
 715                                                      builtin_type_int);
 716                                 }
 717                               else if (!have_full_symbols () && !have_partial_symbols ())
 718                                 error ("No symbol table is loaded.  Use the \"file\" command.");
 719                               else
 720                                 error ("No symbol \"%s\" in current context.",
 721                                        copy_name ($1.stoken));
 722                             }
 723                         }
 724         ;
 725
 726 space_identifier : '@' NAME
 727                 { push_type_address_space (copy_name ($2.stoken));
 728                   push_type (tp_space_identifier);
 729                 }
 730         ;
 731
 732 const_or_volatile: const_or_volatile_noopt
 733         |
 734         ;
 735
 736 cv_with_space_id : const_or_volatile space_identifier const_or_volatile
 737         ;
 738
 739 const_or_volatile_or_space_identifier_noopt: cv_with_space_id
 740         | const_or_volatile_noopt
 741         ;
 742
 743 const_or_volatile_or_space_identifier:
 744                 const_or_volatile_or_space_identifier_noopt
 745         |
 746         ;
 747
 748 abs_decl:       '*'
 749                         { push_type (tp_pointer); $$ = 0; }
 750         |       '*' abs_decl
 751                         { push_type (tp_pointer); $$ = $2; }
 752         |       '&'
 753                         { push_type (tp_reference); $$ = 0; }
 754         |       '&' abs_decl
 755                         { push_type (tp_reference); $$ = $2; }
 756         |       direct_abs_decl
 757         ;
 758
 759 direct_abs_decl: '(' abs_decl ')'
 760                         { $$ = $2; }
 761         |       direct_abs_decl array_mod
 762                         {
 763                           push_type_int ($2);
 764                           push_type (tp_array);
 765                         }
 766         |       array_mod
 767                         {
 768                           push_type_int ($1);
 769                           push_type (tp_array);
 770                           $$ = 0;
 771                         }
 772
 773         |       direct_abs_decl func_mod
 774                         { push_type (tp_function); }
 775         |       func_mod
 776                         { push_type (tp_function); }
 777         ;
 778
 779 array_mod:      '[' ']'
 780                         { $$ = -1; }
 781         |       '[' INT ']'
 782                         { $$ = $2.val; }
 783         ;
 784
 785 func_mod:       '(' ')'
 786                         { $$ = 0; }
 787         |       '(' nonempty_typelist ')'
 788                         { free ($2); $$ = 0; }
 789         ;
 790
 791 /* We used to try to recognize more pointer to member types here, but
 792    that didn't work (shift/reduce conflicts meant that these rules never
 793    got executed).  The problem is that
 794      int (foo::bar::baz::bizzle)
 795    is a function type but
 796      int (foo::bar::baz::bizzle::*)
 797    is a pointer to member type.  Stroustrup loses again!  */
 798
 799 type    :       ptype
 800         |       typebase COLONCOLON '*'
 801                         { $$ = lookup_member_type (builtin_type_int, $1); }
 802         ;
 803
 804 typebase  /* Implements (approximately): (type-qualifier)* type-specifier */
 805         :       TYPENAME
 806                         { $$ = $1.type; }
 807         |       INT_KEYWORD
 808                         { $$ = builtin_type_int; }
 809         |       LONG
 810                         { $$ = builtin_type_long; }
 811         |       SHORT
 812                         { $$ = builtin_type_short; }
 813         |       LONG INT_KEYWORD
 814                         { $$ = builtin_type_long; }
 815         |       LONG SIGNED_KEYWORD INT_KEYWORD
 816                         { $$ = builtin_type_long; }
 817         |       LONG SIGNED_KEYWORD
 818                         { $$ = builtin_type_long; }
 819         |       SIGNED_KEYWORD LONG INT_KEYWORD
 820                         { $$ = builtin_type_long; }
 821         |       UNSIGNED LONG INT_KEYWORD
 822                         { $$ = builtin_type_unsigned_long; }
 823         |       LONG UNSIGNED INT_KEYWORD
 824                         { $$ = builtin_type_unsigned_long; }
 825         |       LONG UNSIGNED
 826                         { $$ = builtin_type_unsigned_long; }
 827         |       LONG LONG
 828                         { $$ = builtin_type_long_long; }
 829         |       LONG LONG INT_KEYWORD
 830                         { $$ = builtin_type_long_long; }
 831         |       LONG LONG SIGNED_KEYWORD INT_KEYWORD
 832                         { $$ = builtin_type_long_long; }
 833         |       LONG LONG SIGNED_KEYWORD
 834                         { $$ = builtin_type_long_long; }
 835         |       SIGNED_KEYWORD LONG LONG
 836                         { $$ = builtin_type_long_long; }
 837         |       SIGNED_KEYWORD LONG LONG INT_KEYWORD
 838                         { $$ = builtin_type_long_long; }
 839         |       UNSIGNED LONG LONG
 840                         { $$ = builtin_type_unsigned_long_long; }
 841         |       UNSIGNED LONG LONG INT_KEYWORD
 842                         { $$ = builtin_type_unsigned_long_long; }
 843         |       LONG LONG UNSIGNED
 844                         { $$ = builtin_type_unsigned_long_long; }
 845         |       LONG LONG UNSIGNED INT_KEYWORD
 846                         { $$ = builtin_type_unsigned_long_long; }
 847         |       SHORT INT_KEYWORD
 848                         { $$ = builtin_type_short; }
 849         |       SHORT SIGNED_KEYWORD INT_KEYWORD
 850                         { $$ = builtin_type_short; }
 851         |       SHORT SIGNED_KEYWORD
 852                         { $$ = builtin_type_short; }
 853         |       UNSIGNED SHORT INT_KEYWORD
 854                         { $$ = builtin_type_unsigned_short; }
 855         |       SHORT UNSIGNED
 856                         { $$ = builtin_type_unsigned_short; }
 857         |       SHORT UNSIGNED INT_KEYWORD
 858                         { $$ = builtin_type_unsigned_short; }
 859         |       DOUBLE_KEYWORD
 860                         { $$ = builtin_type_double; }
 861         |       LONG DOUBLE_KEYWORD
 862                         { $$ = builtin_type_long_double; }
 863         |       STRUCT name
 864                         { $$ = lookup_struct (copy_name ($2),
 865                                               expression_context_block); }
 866         |       CLASS name
 867                         { $$ = lookup_struct (copy_name ($2),
 868                                               expression_context_block); }
 869         |       UNION name
 870                         { $$ = lookup_union (copy_name ($2),
 871                                              expression_context_block); }
 872         |       ENUM name
 873                         { $$ = lookup_enum (copy_name ($2),
 874                                             expression_context_block); }
 875         |       UNSIGNED typename
 876                         { $$ = lookup_unsigned_typename (TYPE_NAME($2.type)); }
 877         |       UNSIGNED
 878                         { $$ = builtin_type_unsigned_int; }
 879         |       SIGNED_KEYWORD typename
 880                         { $$ = lookup_signed_typename (TYPE_NAME($2.type)); }
 881         |       SIGNED_KEYWORD
 882                         { $$ = builtin_type_int; }
 883                 /* It appears that this rule for templates is never
 884                    reduced; template recognition happens by lookahead
 885                    in the token processing code in yylex. */
 886         |       TEMPLATE name '<' type '>'
 887                         { $$ = lookup_template_type(copy_name($2), $4,
 888                                                     expression_context_block);
 889                         }
 890         | const_or_volatile_or_space_identifier_noopt typebase
 891                         { $$ = follow_types ($2); }
 892         | typebase const_or_volatile_or_space_identifier_noopt
 893                         { $$ = follow_types ($1); }
 894         | qualified_type
 895         ;
 896
 897 /* FIXME: carlton/2003-09-25: This next bit leads to lots of
 898    reduce-reduce conflicts, because the parser doesn't know whether or
 899    not to use qualified_name or qualified_type: the rules are
 900    identical.  If the parser is parsing 'A::B::x', then, when it sees
 901    the second '::', it knows that the expression to the left of it has
 902    to be a type, so it uses qualified_type.  But if it is parsing just
 903    'A::B', then it doesn't have any way of knowing which rule to use,
 904    so there's a reduce-reduce conflict; it picks qualified_name, since
 905    that occurs earlier in this file than qualified_type.
 906
 907    There's no good way to fix this with the grammar as it stands; as
 908    far as I can tell, some of the problems arise from ambiguities that
 909    GDB introduces ('start' can be either an expression or a type), but
 910    some of it is inherent to the nature of C++ (you want to treat the
 911    input "(FOO)" fairly differently depending on whether FOO is an
 912    expression or a type, and if FOO is a complex expression, this can
 913    be hard to determine at the right time).  Fortunately, it works
 914    pretty well in most cases.  For example, if you do 'ptype A::B',
 915    where A::B is a nested type, then the parser will mistakenly
 916    misidentify it as an expression; but evaluate_subexp will get
 917    called with 'noside' set to EVAL_AVOID_SIDE_EFFECTS, and everything
 918    will work out anyways.  But there are situations where the parser
 919    will get confused: the most common one that I've run into is when
 920    you want to do
 921
 922      print *((A::B *) x)"
 923
 924    where the parser doesn't realize that A::B has to be a type until
 925    it hits the first right paren, at which point it's too late.  (The
 926    workaround is to type "print *(('A::B' *) x)" instead.)  (And
 927    another solution is to fix our symbol-handling code so that the
 928    user never wants to type something like that in the first place,
 929    because we get all the types right without the user's help!)
 930
 931    Perhaps we could fix this by making the lexer smarter.  Some of
 932    this functionality used to be in the lexer, but in a way that
 933    worked even less well than the current solution: that attempt
 934    involved having the parser sometimes handle '::' and having the
 935    lexer sometimes handle it, and without a clear division of
 936    responsibility, it quickly degenerated into a big mess.  Probably
 937    the eventual correct solution will give more of a role to the lexer
 938    (ideally via code that is shared between the lexer and
 939    decode_line_1), but I'm not holding my breath waiting for somebody
 940    to get around to cleaning this up...  */
 941
 942 /* FIXME: carlton/2003-09-25: Currently, the only qualified type
 943    symbols that we generate are nested namespaces.  Next on my TODO
 944    list is to generate all nested type names properly (or at least as
 945    well as possible, assuming that we're using DWARF-2).  */
 946
 947 qualified_type: typebase COLONCOLON name
 948                 {
 949                   struct type *type = $1;
 950                   struct type *new_type;
 951                   char *ncopy = alloca ($3.length + 1);
 952
 953                   memcpy (ncopy, $3.ptr, $3.length);
 954                   ncopy[$3.length] = '\0';
 955
 956                   if (TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
 957                     error ("`%s' is not defined as a namespace.",
 958                            TYPE_NAME (type));
 959
 960                   new_type = cp_lookup_nested_type (type, ncopy,
 961                                                     expression_context_block);
 962                   if (new_type == NULL)
 963                     error ("No type \"%s\" in namespace \"%s\".",
 964                            ncopy, TYPE_NAME (type));
 965
 966                   $$ = new_type;
 967                 }
 968         ;
 969
 970 typename:       TYPENAME
 971         |       INT_KEYWORD
 972                 {
 973                   $$.stoken.ptr = "int";
 974                   $$.stoken.length = 3;
 975                   $$.type = builtin_type_int;
 976                 }
 977         |       LONG
 978                 {
 979                   $$.stoken.ptr = "long";
 980                   $$.stoken.length = 4;
 981                   $$.type = builtin_type_long;
 982                 }
 983         |       SHORT
 984                 {
 985                   $$.stoken.ptr = "short";
 986                   $$.stoken.length = 5;
 987                   $$.type = builtin_type_short;
 988                 }
 989         ;
 990
 991 nonempty_typelist
 992         :       type
 993                 { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
 994                   $<ivec>$[0] = 1;      /* Number of types in vector */
 995                   $$[1] = $1;
 996                 }
 997         |       nonempty_typelist ',' type
 998                 { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
 999                   $$ = (struct type **) realloc ((char *) $1, len);
1000                   $$[$<ivec>$[0]] = $3;
1001                 }
1002         ;
1003
1004 ptype   :       typebase
1005         |       ptype const_or_volatile_or_space_identifier abs_decl const_or_volatile_or_space_identifier
1006                 { $$ = follow_types ($1); }
1007         ;
1008
1009 const_and_volatile:     CONST_KEYWORD VOLATILE_KEYWORD
1010         |               VOLATILE_KEYWORD CONST_KEYWORD
1011         ;
1012
1013 const_or_volatile_noopt:        const_and_volatile
1014                         { push_type (tp_const);
1015                           push_type (tp_volatile);
1016                         }
1017         |               CONST_KEYWORD
1018                         { push_type (tp_const); }
1019         |               VOLATILE_KEYWORD
1020                         { push_type (tp_volatile); }
1021         ;
1022
1023 name    :       NAME { $$ = $1.stoken; }
1024         |       BLOCKNAME { $$ = $1.stoken; }
1025         |       TYPENAME { $$ = $1.stoken; }
1026         |       NAME_OR_INT  { $$ = $1.stoken; }
1027         ;
1028
1029 name_not_typename :     NAME
1030         |       BLOCKNAME
1031 /* These would be useful if name_not_typename was useful, but it is just
1032    a fake for "variable", so these cause reduce/reduce conflicts because
1033    the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
1034    =exp) or just an exp.  If name_not_typename was ever used in an lvalue
1035    context where only a name could occur, this might be useful.
1036         |       NAME_OR_INT
1037  */
1038         ;
1039
1040 %%
1041
1042 /* Take care of parsing a number (anything that starts with a digit).
1043    Set yylval and return the token type; update lexptr.
1044    LEN is the number of characters in it.  */
1045
1046 /*** Needs some error checking for the float case ***/
1047
1048 static int
1049 parse_number (p, len, parsed_float, putithere)
1050      register char *p;
1051      register int len;
1052      int parsed_float;
1053      YYSTYPE *putithere;
1054 {
1055   /* FIXME: Shouldn't these be unsigned?  We don't deal with negative values
1056      here, and we do kind of silly things like cast to unsigned.  */
1057   register LONGEST n = 0;
1058   register LONGEST prevn = 0;
1059   ULONGEST un;
1060
1061   register int i = 0;
1062   register int c;
1063   register int base = input_radix;
1064   int unsigned_p = 0;
1065
1066   /* Number of "L" suffixes encountered.  */
1067   int long_p = 0;
1068
1069   /* We have found a "L" or "U" suffix.  */
1070   int found_suffix = 0;
1071
1072   ULONGEST high_bit;
1073   struct type *signed_type;
1074   struct type *unsigned_type;
1075
1076   if (parsed_float)
1077     {
1078       /* It's a float since it contains a point or an exponent.  */
1079       char c;
1080       int num = 0;      /* number of tokens scanned by scanf */
1081       char saved_char = p[len];
1082
1083       p[len] = 0;       /* null-terminate the token */
1084       if (sizeof (putithere->typed_val_float.dval) <= sizeof (float))
1085         num = sscanf (p, "%g%c", (float *) &putithere->typed_val_float.dval,&c);
1086       else if (sizeof (putithere->typed_val_float.dval) <= sizeof (double))
1087         num = sscanf (p, "%lg%c", (double *) &putithere->typed_val_float.dval,&c);
1088       else
1089         {
1090 #ifdef SCANF_HAS_LONG_DOUBLE
1091           num = sscanf (p, "%Lg%c", &putithere->typed_val_float.dval,&c);
1092 #else
1093           /* Scan it into a double, then assign it to the long double.
1094              This at least wins with values representable in the range
1095              of doubles. */
1096           double temp;
1097           num = sscanf (p, "%lg%c", &temp,&c);
1098           putithere->typed_val_float.dval = temp;
1099 #endif
1100         }
1101       p[len] = saved_char;      /* restore the input stream */
1102       if (num != 1)             /* check scanf found ONLY a float ... */
1103         return ERROR;
1104       /* See if it has `f' or `l' suffix (float or long double).  */
1105
1106       c = tolower (p[len - 1]);
1107
1108       if (c == 'f')
1109         putithere->typed_val_float.type = builtin_type_float;
1110       else if (c == 'l')
1111         putithere->typed_val_float.type = builtin_type_long_double;
1112       else if (isdigit (c) || c == '.')
1113         putithere->typed_val_float.type = builtin_type_double;
1114       else
1115         return ERROR;
1116
1117       return FLOAT;
1118     }
1119
1120   /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
1121   if (p[0] == '0')
1122     switch (p[1])
1123       {
1124       case 'x':
1125       case 'X':
1126         if (len >= 3)
1127           {
1128             p += 2;
1129             base = 16;
1130             len -= 2;
1131           }
1132         break;
1133
1134       case 't':
1135       case 'T':
1136       case 'd':
1137       case 'D':
1138         if (len >= 3)
1139           {
1140             p += 2;
1141             base = 10;
1142             len -= 2;
1143           }
1144         break;
1145
1146       default:
1147         base = 8;
1148         break;
1149       }
1150
1151   while (len-- > 0)
1152     {
1153       c = *p++;
1154       if (c >= 'A' && c <= 'Z')
1155         c += 'a' - 'A';
1156       if (c != 'l' && c != 'u')
1157         n *= base;
1158       if (c >= '0' && c <= '9')
1159         {
1160           if (found_suffix)
1161             return ERROR;
1162           n += i = c - '0';
1163         }
1164       else
1165         {
1166           if (base > 10 && c >= 'a' && c <= 'f')
1167             {
1168               if (found_suffix)
1169                 return ERROR;
1170               n += i = c - 'a' + 10;
1171             }
1172           else if (c == 'l')
1173             {
1174               ++long_p;
1175               found_suffix = 1;
1176             }
1177           else if (c == 'u')
1178             {
1179               unsigned_p = 1;
1180               found_suffix = 1;
1181             }
1182           else
1183             return ERROR;       /* Char not a digit */
1184         }
1185       if (i >= base)
1186         return ERROR;           /* Invalid digit in this base */
1187
1188       /* Portably test for overflow (only works for nonzero values, so make
1189          a second check for zero).  FIXME: Can't we just make n and prevn
1190          unsigned and avoid this?  */
1191       if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
1192         unsigned_p = 1;         /* Try something unsigned */
1193
1194       /* Portably test for unsigned overflow.
1195          FIXME: This check is wrong; for example it doesn't find overflow
1196          on 0x123456789 when LONGEST is 32 bits.  */
1197       if (c != 'l' && c != 'u' && n != 0)
1198         {
1199           if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n))
1200             error ("Numeric constant too large.");
1201         }
1202       prevn = n;
1203     }
1204
1205   /* An integer constant is an int, a long, or a long long.  An L
1206      suffix forces it to be long; an LL suffix forces it to be long
1207      long.  If not forced to a larger size, it gets the first type of
1208      the above that it fits in.  To figure out whether it fits, we
1209      shift it right and see whether anything remains.  Note that we
1210      can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
1211      operation, because many compilers will warn about such a shift
1212      (which always produces a zero result).  Sometimes TARGET_INT_BIT
1213      or TARGET_LONG_BIT will be that big, sometimes not.  To deal with
1214      the case where it is we just always shift the value more than
1215      once, with fewer bits each time.  */
1216
1217   un = (ULONGEST)n >> 2;
1218   if (long_p == 0
1219       && (un >> (TARGET_INT_BIT - 2)) == 0)
1220     {
1221       high_bit = ((ULONGEST)1) << (TARGET_INT_BIT-1);
1222
1223       /* A large decimal (not hex or octal) constant (between INT_MAX
1224          and UINT_MAX) is a long or unsigned long, according to ANSI,
1225          never an unsigned int, but this code treats it as unsigned
1226          int.  This probably should be fixed.  GCC gives a warning on
1227          such constants.  */
1228
1229       unsigned_type = builtin_type_unsigned_int;
1230       signed_type = builtin_type_int;
1231     }
1232   else if (long_p <= 1
1233            && (un >> (TARGET_LONG_BIT - 2)) == 0)
1234     {
1235       high_bit = ((ULONGEST)1) << (TARGET_LONG_BIT-1);
1236       unsigned_type = builtin_type_unsigned_long;
1237       signed_type = builtin_type_long;
1238     }
1239   else
1240     {
1241       int shift;
1242       if (sizeof (ULONGEST) * HOST_CHAR_BIT < TARGET_LONG_LONG_BIT)
1243         /* A long long does not fit in a LONGEST.  */
1244         shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
1245       else
1246         shift = (TARGET_LONG_LONG_BIT - 1);
1247       high_bit = (ULONGEST) 1 << shift;
1248       unsigned_type = builtin_type_unsigned_long_long;
1249       signed_type = builtin_type_long_long;
1250     }
1251
1252    putithere->typed_val_int.val = n;
1253
1254    /* If the high bit of the worked out type is set then this number
1255       has to be unsigned. */
1256
1257    if (unsigned_p || (n & high_bit))
1258      {
1259        putithere->typed_val_int.type = unsigned_type;
1260      }
1261    else
1262      {
1263        putithere->typed_val_int.type = signed_type;
1264      }
1265
1266    return INT;
1267 }
1268
1269 struct token
1270 {
1271   char *operator;
1272   int token;
1273   enum exp_opcode opcode;
1274 };
1275
1276 static const struct token tokentab3[] =
1277   {
1278     {">>=", ASSIGN_MODIFY, BINOP_RSH},
1279     {"<<=", ASSIGN_MODIFY, BINOP_LSH}
1280   };
1281
1282 static const struct token tokentab2[] =
1283   {
1284     {"+=", ASSIGN_MODIFY, BINOP_ADD},
1285     {"-=", ASSIGN_MODIFY, BINOP_SUB},
1286     {"*=", ASSIGN_MODIFY, BINOP_MUL},
1287     {"/=", ASSIGN_MODIFY, BINOP_DIV},
1288     {"%=", ASSIGN_MODIFY, BINOP_REM},
1289     {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
1290     {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
1291     {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
1292     {"++", INCREMENT, BINOP_END},
1293     {"--", DECREMENT, BINOP_END},
1294     {"->", ARROW, BINOP_END},
1295     {"&&", ANDAND, BINOP_END},
1296     {"||", OROR, BINOP_END},
1297     {"::", COLONCOLON, BINOP_END},
1298     {"<<", LSH, BINOP_END},
1299     {">>", RSH, BINOP_END},
1300     {"==", EQUAL, BINOP_END},
1301     {"!=", NOTEQUAL, BINOP_END},
1302     {"<=", LEQ, BINOP_END},
1303     {">=", GEQ, BINOP_END}
1304   };
1305
1306 /* Read one token, getting characters through lexptr.  */
1307
1308 static int
1309 yylex ()
1310 {
1311   int c;
1312   int namelen;
1313   unsigned int i;
1314   char *tokstart;
1315   char *tokptr;
1316   int tempbufindex;
1317   static char *tempbuf;
1318   static int tempbufsize;
1319   struct symbol * sym_class = NULL;
1320   char * token_string = NULL;
1321   int class_prefix = 0;
1322   int unquoted_expr;
1323
1324  retry:
1325
1326   /* Check if this is a macro invocation that we need to expand.  */
1327   if (! scanning_macro_expansion ())
1328     {
1329       char *expanded = macro_expand_next (&lexptr,
1330                                           expression_macro_lookup_func,
1331                                           expression_macro_lookup_baton);
1332
1333       if (expanded)
1334         scan_macro_expansion (expanded);
1335     }
1336
1337   prev_lexptr = lexptr;
1338   unquoted_expr = 1;
1339
1340   tokstart = lexptr;
1341   /* See if it is a special token of length 3.  */
1342   for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1343     if (STREQN (tokstart, tokentab3[i].operator, 3))
1344       {
1345         lexptr += 3;
1346         yylval.opcode = tokentab3[i].opcode;
1347         return tokentab3[i].token;
1348       }
1349
1350   /* See if it is a special token of length 2.  */
1351   for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1352     if (STREQN (tokstart, tokentab2[i].operator, 2))
1353       {
1354         lexptr += 2;
1355         yylval.opcode = tokentab2[i].opcode;
1356         return tokentab2[i].token;
1357       }
1358
1359   switch (c = *tokstart)
1360     {
1361     case 0:
1362       /* If we were just scanning the result of a macro expansion,
1363          then we need to resume scanning the original text.
1364          Otherwise, we were already scanning the original text, and
1365          we're really done.  */
1366       if (scanning_macro_expansion ())
1367         {
1368           finished_macro_expansion ();
1369           goto retry;
1370         }
1371       else
1372         return 0;
1373
1374     case ' ':
1375     case '\t':
1376     case '\n':
1377       lexptr++;
1378       goto retry;
1379
1380     case '\'':
1381       /* We either have a character constant ('0' or '\177' for example)
1382          or we have a quoted symbol reference ('foo(int,int)' in C++
1383          for example). */
1384       lexptr++;
1385       c = *lexptr++;
1386       if (c == '\\')
1387         c = parse_escape (&lexptr);
1388       else if (c == '\'')
1389         error ("Empty character constant.");
1390       else if (! host_char_to_target (c, &c))
1391         {
1392           int toklen = lexptr - tokstart + 1;
1393           char *tok = alloca (toklen + 1);
1394           memcpy (tok, tokstart, toklen);
1395           tok[toklen] = '\0';
1396           error ("There is no character corresponding to %s in the target "
1397                  "character set `%s'.", tok, target_charset ());
1398         }
1399
1400       yylval.typed_val_int.val = c;
1401       yylval.typed_val_int.type = builtin_type_char;
1402
1403       c = *lexptr++;
1404       if (c != '\'')
1405         {
1406           namelen = skip_quoted (tokstart) - tokstart;
1407           if (namelen > 2)
1408             {
1409               lexptr = tokstart + namelen;
1410               unquoted_expr = 0;
1411               if (lexptr[-1] != '\'')
1412                 error ("Unmatched single quote.");
1413               namelen -= 2;
1414               tokstart++;
1415               goto tryname;
1416             }
1417           error ("Invalid character constant.");
1418         }
1419       return INT;
1420
1421     case '(':
1422       paren_depth++;
1423       lexptr++;
1424       return c;
1425
1426     case ')':
1427       if (paren_depth == 0)
1428         return 0;
1429       paren_depth--;
1430       lexptr++;
1431       return c;
1432
1433     case ',':
1434       if (comma_terminates
1435           && paren_depth == 0
1436           && ! scanning_macro_expansion ())
1437         return 0;
1438       lexptr++;
1439       return c;
1440
1441     case '.':
1442       /* Might be a floating point number.  */
1443       if (lexptr[1] < '0' || lexptr[1] > '9')
1444         goto symbol;            /* Nope, must be a symbol. */
1445       /* FALL THRU into number case.  */
1446
1447     case '0':
1448     case '1':
1449     case '2':
1450     case '3':
1451     case '4':
1452     case '5':
1453     case '6':
1454     case '7':
1455     case '8':
1456     case '9':
1457       {
1458         /* It's a number.  */
1459         int got_dot = 0, got_e = 0, toktype;
1460         register char *p = tokstart;
1461         int hex = input_radix > 10;
1462
1463         if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1464           {
1465             p += 2;
1466             hex = 1;
1467           }
1468         else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1469           {
1470             p += 2;
1471             hex = 0;
1472           }
1473
1474         for (;; ++p)
1475           {
1476             /* This test includes !hex because 'e' is a valid hex digit
1477                and thus does not indicate a floating point number when
1478                the radix is hex.  */
1479             if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1480               got_dot = got_e = 1;
1481             /* This test does not include !hex, because a '.' always indicates
1482                a decimal floating point number regardless of the radix.  */
1483             else if (!got_dot && *p == '.')
1484               got_dot = 1;
1485             else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1486                      && (*p == '-' || *p == '+'))
1487               /* This is the sign of the exponent, not the end of the
1488                  number.  */
1489               continue;
1490             /* We will take any letters or digits.  parse_number will
1491                complain if past the radix, or if L or U are not final.  */
1492             else if ((*p < '0' || *p > '9')
1493                      && ((*p < 'a' || *p > 'z')
1494                                   && (*p < 'A' || *p > 'Z')))
1495               break;
1496           }
1497         toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1498         if (toktype == ERROR)
1499           {
1500             char *err_copy = (char *) alloca (p - tokstart + 1);
1501
1502             memcpy (err_copy, tokstart, p - tokstart);
1503             err_copy[p - tokstart] = 0;
1504             error ("Invalid number \"%s\".", err_copy);
1505           }
1506         lexptr = p;
1507         return toktype;
1508       }
1509
1510     case '+':
1511     case '-':
1512     case '*':
1513     case '/':
1514     case '%':
1515     case '|':
1516     case '&':
1517     case '^':
1518     case '~':
1519     case '!':
1520     case '@':
1521     case '<':
1522     case '>':
1523     case '[':
1524     case ']':
1525     case '?':
1526     case ':':
1527     case '=':
1528     case '{':
1529     case '}':
1530     symbol:
1531       lexptr++;
1532       return c;
1533
1534     case '"':
1535
1536       /* Build the gdb internal form of the input string in tempbuf,
1537          translating any standard C escape forms seen.  Note that the
1538          buffer is null byte terminated *only* for the convenience of
1539          debugging gdb itself and printing the buffer contents when
1540          the buffer contains no embedded nulls.  Gdb does not depend
1541          upon the buffer being null byte terminated, it uses the length
1542          string instead.  This allows gdb to handle C strings (as well
1543          as strings in other languages) with embedded null bytes */
1544
1545       tokptr = ++tokstart;
1546       tempbufindex = 0;
1547
1548       do {
1549         char *char_start_pos = tokptr;
1550
1551         /* Grow the static temp buffer if necessary, including allocating
1552            the first one on demand. */
1553         if (tempbufindex + 1 >= tempbufsize)
1554           {
1555             tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1556           }
1557         switch (*tokptr)
1558           {
1559           case '\0':
1560           case '"':
1561             /* Do nothing, loop will terminate. */
1562             break;
1563           case '\\':
1564             tokptr++;
1565             c = parse_escape (&tokptr);
1566             if (c == -1)
1567               {
1568                 continue;
1569               }
1570             tempbuf[tempbufindex++] = c;
1571             break;
1572           default:
1573             c = *tokptr++;
1574             if (! host_char_to_target (c, &c))
1575               {
1576                 int len = tokptr - char_start_pos;
1577                 char *copy = alloca (len + 1);
1578                 memcpy (copy, char_start_pos, len);
1579                 copy[len] = '\0';
1580
1581                 error ("There is no character corresponding to `%s' "
1582                        "in the target character set `%s'.",
1583                        copy, target_charset ());
1584               }
1585             tempbuf[tempbufindex++] = c;
1586             break;
1587           }
1588       } while ((*tokptr != '"') && (*tokptr != '\0'));
1589       if (*tokptr++ != '"')
1590         {
1591           error ("Unterminated string in expression.");
1592         }
1593       tempbuf[tempbufindex] = '\0';     /* See note above */
1594       yylval.sval.ptr = tempbuf;
1595       yylval.sval.length = tempbufindex;
1596       lexptr = tokptr;
1597       return (STRING);
1598     }
1599
1600   if (!(c == '_' || c == '$'
1601         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1602     /* We must have come across a bad character (e.g. ';').  */
1603     error ("Invalid character '%c' in expression.", c);
1604
1605   /* It's a name.  See how long it is.  */
1606   namelen = 0;
1607   for (c = tokstart[namelen];
1608        (c == '_' || c == '$' || (c >= '0' && c <= '9')
1609         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
1610     {
1611       /* Template parameter lists are part of the name.
1612          FIXME: This mishandles `print $a<4&&$a>3'.  */
1613
1614       if (c == '<')
1615         {
1616                /* Scan ahead to get rest of the template specification.  Note
1617                   that we look ahead only when the '<' adjoins non-whitespace
1618                   characters; for comparison expressions, e.g. "a < b > c",
1619                   there must be spaces before the '<', etc. */
1620
1621                char * p = find_template_name_end (tokstart + namelen);
1622                if (p)
1623                  namelen = p - tokstart;
1624                break;
1625         }
1626       c = tokstart[++namelen];
1627     }
1628
1629   /* The token "if" terminates the expression and is NOT removed from
1630      the input stream.  It doesn't count if it appears in the
1631      expansion of a macro.  */
1632   if (namelen == 2
1633       && tokstart[0] == 'i'
1634       && tokstart[1] == 'f'
1635       && ! scanning_macro_expansion ())
1636     {
1637       return 0;
1638     }
1639
1640   lexptr += namelen;
1641
1642   tryname:
1643
1644   /* Catch specific keywords.  Should be done with a data structure.  */
1645   switch (namelen)
1646     {
1647     case 8:
1648       if (STREQN (tokstart, "unsigned", 8))
1649         return UNSIGNED;
1650       if (current_language->la_language == language_cplus
1651           && STREQN (tokstart, "template", 8))
1652         return TEMPLATE;
1653       if (STREQN (tokstart, "volatile", 8))
1654         return VOLATILE_KEYWORD;
1655       break;
1656     case 6:
1657       if (STREQN (tokstart, "struct", 6))
1658         return STRUCT;
1659       if (STREQN (tokstart, "signed", 6))
1660         return SIGNED_KEYWORD;
1661       if (STREQN (tokstart, "sizeof", 6))
1662         return SIZEOF;
1663       if (STREQN (tokstart, "double", 6))
1664         return DOUBLE_KEYWORD;
1665       break;
1666     case 5:
1667       if (current_language->la_language == language_cplus)
1668         {
1669           if (STREQN (tokstart, "false", 5))
1670             return FALSEKEYWORD;
1671           if (STREQN (tokstart, "class", 5))
1672             return CLASS;
1673         }
1674       if (STREQN (tokstart, "union", 5))
1675         return UNION;
1676       if (STREQN (tokstart, "short", 5))
1677         return SHORT;
1678       if (STREQN (tokstart, "const", 5))
1679         return CONST_KEYWORD;
1680       break;
1681     case 4:
1682       if (STREQN (tokstart, "enum", 4))
1683         return ENUM;
1684       if (STREQN (tokstart, "long", 4))
1685         return LONG;
1686       if (current_language->la_language == language_cplus)
1687           {
1688             if (STREQN (tokstart, "true", 4))
1689               return TRUEKEYWORD;
1690           }
1691       break;
1692     case 3:
1693       if (STREQN (tokstart, "int", 3))
1694         return INT_KEYWORD;
1695       break;
1696     default:
1697       break;
1698     }
1699
1700   yylval.sval.ptr = tokstart;
1701   yylval.sval.length = namelen;
1702
1703   if (*tokstart == '$')
1704     {
1705       write_dollar_variable (yylval.sval);
1706       return VARIABLE;
1707     }
1708
1709   /* Look ahead and see if we can consume more of the input
1710      string to get a reasonable class/namespace spec or a
1711      fully-qualified name.  This is a kludge to get around the
1712      HP aCC compiler's generation of symbol names with embedded
1713      colons for namespace and nested classes. */
1714
1715   /* NOTE: carlton/2003-09-24: I don't entirely understand the
1716      HP-specific code, either here or in linespec.  Having said that,
1717      I suspect that we're actually moving towards their model: we want
1718      symbols whose names are fully qualified, which matches the
1719      description above.  */
1720   if (unquoted_expr)
1721     {
1722       /* Only do it if not inside single quotes */
1723       sym_class = parse_nested_classes_for_hpacc (yylval.sval.ptr, yylval.sval.length,
1724                                                   &token_string, &class_prefix, &lexptr);
1725       if (sym_class)
1726         {
1727           /* Replace the current token with the bigger one we found */
1728           yylval.sval.ptr = token_string;
1729           yylval.sval.length = strlen (token_string);
1730         }
1731     }
1732
1733   /* Use token-type BLOCKNAME for symbols that happen to be defined as
1734      functions or symtabs.  If this is not so, then ...
1735      Use token-type TYPENAME for symbols that happen to be defined
1736      currently as names of types; NAME for other symbols.
1737      The caller is not constrained to care about the distinction.  */
1738   {
1739     char *tmp = copy_name (yylval.sval);
1740     struct symbol *sym;
1741     int is_a_field_of_this = 0;
1742     int hextype;
1743
1744     sym = lookup_symbol (tmp, expression_context_block,
1745                          VAR_DOMAIN,
1746                          current_language->la_language == language_cplus
1747                          ? &is_a_field_of_this : (int *) NULL,
1748                          (struct symtab **) NULL);
1749     /* Call lookup_symtab, not lookup_partial_symtab, in case there are
1750        no psymtabs (coff, xcoff, or some future change to blow away the
1751        psymtabs once once symbols are read).  */
1752     if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
1753       {
1754         yylval.ssym.sym = sym;
1755         yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1756         return BLOCKNAME;
1757       }
1758     else if (!sym)
1759       {                         /* See if it's a file name. */
1760         struct symtab *symtab;
1761
1762         symtab = lookup_symtab (tmp);
1763
1764         if (symtab)
1765           {
1766             yylval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
1767             return FILENAME;
1768           }
1769       }
1770
1771     if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1772         {
1773           /* NOTE: carlton/2003-09-25: There used to be code here to
1774              handle nested types.  It didn't work very well.  See the
1775              comment before qualified_type for more info.  */
1776           yylval.tsym.type = SYMBOL_TYPE (sym);
1777           return TYPENAME;
1778         }
1779     if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0)
1780       return TYPENAME;
1781
1782     /* Input names that aren't symbols but ARE valid hex numbers,
1783        when the input radix permits them, can be names or numbers
1784        depending on the parse.  Note we support radixes > 16 here.  */
1785     if (!sym &&
1786         ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1787          (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1788       {
1789         YYSTYPE newlval;        /* Its value is ignored.  */
1790         hextype = parse_number (tokstart, namelen, 0, &newlval);
1791         if (hextype == INT)
1792           {
1793             yylval.ssym.sym = sym;
1794             yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1795             return NAME_OR_INT;
1796           }
1797       }
1798
1799     /* Any other kind of symbol */
1800     yylval.ssym.sym = sym;
1801     yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1802     return NAME;
1803   }
1804 }
1805
1806 void
1807 yyerror (msg)
1808      char *msg;
1809 {
1810   if (prev_lexptr)
1811     lexptr = prev_lexptr;
1812
1813   error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);
1814 }