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