gdb/c-exp.y

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