gdb/c-exp.y

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