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