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 /* start-sanitize-gm
 298 Need to find a better way to do this...
 299 exp     :       exp '@' name
 300                         { write_exp_elt_opcode (STRUCTOP_FIELD);
 301                           write_exp_string ($3);
 302                           write_exp_elt_opcode (STRUCTOP_FIELD);
 303                         }
 304  end-sanitize-gm */
 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.type);
 477                           write_exp_elt_longcst ((LONGEST)val.typed_val.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 (builtin_type_double);
 486                           write_exp_elt_dblcst ($1);
 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 /* end of C++.  */
 536
 537 block   :       BLOCKNAME
 538                         {
 539                           if ($1.sym != 0)
 540                               $$ = SYMBOL_BLOCK_VALUE ($1.sym);
 541                           else
 542                             {
 543                               struct symtab *tem =
 544                                   lookup_symtab (copy_name ($1.stoken));
 545                               if (tem)
 546                                 $$ = BLOCKVECTOR_BLOCK (BLOCKVECTOR (tem), STATIC_BLOCK);
 547                               else
 548                                 error ("No file or function \"%s\".",
 549                                        copy_name ($1.stoken));
 550                             }
 551                         }
 552         ;
 553
 554 block   :       block COLONCOLON name
 555                         { struct symbol *tem
 556                             = lookup_symbol (copy_name ($3), $1,
 557                                              VAR_NAMESPACE, (int *) NULL,
 558                                              (struct symtab **) NULL);
 559                           if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
 560                             error ("No function \"%s\" in specified context.",
 561                                    copy_name ($3));
 562                           $$ = SYMBOL_BLOCK_VALUE (tem); }
 563         ;
 564
 565 variable:       block COLONCOLON name
 566                         { struct symbol *sym;
 567                           sym = lookup_symbol (copy_name ($3), $1,
 568                                                VAR_NAMESPACE, (int *) NULL,
 569                                                (struct symtab **) NULL);
 570                           if (sym == 0)
 571                             error ("No symbol \"%s\" in specified context.",
 572                                    copy_name ($3));
 573
 574                           write_exp_elt_opcode (OP_VAR_VALUE);
 575                           /* block_found is set by lookup_symbol.  */
 576                           write_exp_elt_block (block_found);
 577                           write_exp_elt_sym (sym);
 578                           write_exp_elt_opcode (OP_VAR_VALUE); }
 579         ;
 580
 581 qualified_name: typebase COLONCOLON name
 582                         {
 583                           struct type *type = $1;
 584                           if (TYPE_CODE (type) != TYPE_CODE_STRUCT
 585                               && TYPE_CODE (type) != TYPE_CODE_UNION)
 586                             error ("`%s' is not defined as an aggregate type.",
 587                                    TYPE_NAME (type));
 588
 589                           write_exp_elt_opcode (OP_SCOPE);
 590                           write_exp_elt_type (type);
 591                           write_exp_string ($3);
 592                           write_exp_elt_opcode (OP_SCOPE);
 593                         }
 594         |       typebase COLONCOLON '~' name
 595                         {
 596                           struct type *type = $1;
 597                           struct stoken tmp_token;
 598                           if (TYPE_CODE (type) != TYPE_CODE_STRUCT
 599                               && TYPE_CODE (type) != TYPE_CODE_UNION)
 600                             error ("`%s' is not defined as an aggregate type.",
 601                                    TYPE_NAME (type));
 602
 603                           if (!STREQ (type_name_no_tag (type), $4.ptr))
 604                             error ("invalid destructor `%s::~%s'",
 605                                    type_name_no_tag (type), $4.ptr);
 606
 607                           tmp_token.ptr = (char*) alloca ($4.length + 2);
 608                           tmp_token.length = $4.length + 1;
 609                           tmp_token.ptr[0] = '~';
 610                           memcpy (tmp_token.ptr+1, $4.ptr, $4.length);
 611                           tmp_token.ptr[tmp_token.length] = 0;
 612                           write_exp_elt_opcode (OP_SCOPE);
 613                           write_exp_elt_type (type);
 614                           write_exp_string (tmp_token);
 615                           write_exp_elt_opcode (OP_SCOPE);
 616                         }
 617         ;
 618
 619 variable:       qualified_name
 620         |       COLONCOLON name
 621                         {
 622                           char *name = copy_name ($2);
 623                           struct symbol *sym;
 624                           struct minimal_symbol *msymbol;
 625
 626                           sym =
 627                             lookup_symbol (name, (const struct block *) NULL,
 628                                            VAR_NAMESPACE, (int *) NULL,
 629                                            (struct symtab **) NULL);
 630                           if (sym)
 631                             {
 632                               write_exp_elt_opcode (OP_VAR_VALUE);
 633                               write_exp_elt_block (NULL);
 634                               write_exp_elt_sym (sym);
 635                               write_exp_elt_opcode (OP_VAR_VALUE);
 636                               break;
 637                             }
 638
 639                           msymbol = lookup_minimal_symbol (name, NULL, NULL);
 640                           if (msymbol != NULL)
 641                             {
 642                               write_exp_msymbol (msymbol,
 643                                                  lookup_function_type (builtin_type_int),
 644                                                  builtin_type_int);
 645                             }
 646                           else
 647                             if (!have_full_symbols () && !have_partial_symbols ())
 648                               error ("No symbol table is loaded.  Use the \"file\" command.");
 649                             else
 650                               error ("No symbol \"%s\" in current context.", name);
 651                         }
 652         ;
 653
 654 variable:       name_not_typename
 655                         { struct symbol *sym = $1.sym;
 656
 657                           if (sym)
 658                             {
 659                               if (symbol_read_needs_frame (sym))
 660                                 {
 661                                   if (innermost_block == 0 ||
 662                                       contained_in (block_found,
 663                                                     innermost_block))
 664                                     innermost_block = block_found;
 665                                 }
 666
 667                               write_exp_elt_opcode (OP_VAR_VALUE);
 668                               /* We want to use the selected frame, not
 669                                  another more inner frame which happens to
 670                                  be in the same block.  */
 671                               write_exp_elt_block (NULL);
 672                               write_exp_elt_sym (sym);
 673                               write_exp_elt_opcode (OP_VAR_VALUE);
 674                             }
 675                           else if ($1.is_a_field_of_this)
 676                             {
 677                               /* C++: it hangs off of `this'.  Must
 678                                  not inadvertently convert from a method call
 679                                  to data ref.  */
 680                               if (innermost_block == 0 ||
 681                                   contained_in (block_found, innermost_block))
 682                                 innermost_block = block_found;
 683                               write_exp_elt_opcode (OP_THIS);
 684                               write_exp_elt_opcode (OP_THIS);
 685                               write_exp_elt_opcode (STRUCTOP_PTR);
 686                               write_exp_string ($1.stoken);
 687                               write_exp_elt_opcode (STRUCTOP_PTR);
 688                             }
 689                           else
 690                             {
 691                               struct minimal_symbol *msymbol;
 692                               register char *arg = copy_name ($1.stoken);
 693
 694                               msymbol =
 695                                 lookup_minimal_symbol (arg, NULL, NULL);
 696                               if (msymbol != NULL)
 697                                 {
 698                                   write_exp_msymbol (msymbol,
 699                                                      lookup_function_type (builtin_type_int),
 700                                                      builtin_type_int);
 701                                 }
 702                               else if (!have_full_symbols () && !have_partial_symbols ())
 703                                 error ("No symbol table is loaded.  Use the \"file\" command.");
 704                               else
 705                                 error ("No symbol \"%s\" in current context.",
 706                                        copy_name ($1.stoken));
 707                             }
 708                         }
 709         ;
 710
 711
 712 ptype   :       typebase
 713         /* "const" and "volatile" are curently ignored.  A type qualifier
 714            before the type is currently handled in the typebase rule.
 715            The reason for recognizing these here (shift/reduce conflicts)
 716            might be obsolete now that some pointer to member rules have
 717            been deleted.  */
 718         |       typebase CONST_KEYWORD
 719         |       typebase VOLATILE_KEYWORD
 720         |       typebase abs_decl
 721                 { $$ = follow_types ($1); }
 722         |       typebase CONST_KEYWORD abs_decl
 723                 { $$ = follow_types ($1); }
 724         |       typebase VOLATILE_KEYWORD abs_decl
 725                 { $$ = follow_types ($1); }
 726         ;
 727
 728 abs_decl:       '*'
 729                         { push_type (tp_pointer); $$ = 0; }
 730         |       '*' abs_decl
 731                         { push_type (tp_pointer); $$ = $2; }
 732         |       '&'
 733                         { push_type (tp_reference); $$ = 0; }
 734         |       '&' abs_decl
 735                         { push_type (tp_reference); $$ = $2; }
 736         |       direct_abs_decl
 737         ;
 738
 739 direct_abs_decl: '(' abs_decl ')'
 740                         { $$ = $2; }
 741         |       direct_abs_decl array_mod
 742                         {
 743                           push_type_int ($2);
 744                           push_type (tp_array);
 745                         }
 746         |       array_mod
 747                         {
 748                           push_type_int ($1);
 749                           push_type (tp_array);
 750                           $$ = 0;
 751                         }
 752
 753         |       direct_abs_decl func_mod
 754                         { push_type (tp_function); }
 755         |       func_mod
 756                         { push_type (tp_function); }
 757         ;
 758
 759 array_mod:      '[' ']'
 760                         { $$ = -1; }
 761         |       '[' INT ']'
 762                         { $$ = $2.val; }
 763         ;
 764
 765 func_mod:       '(' ')'
 766                         { $$ = 0; }
 767         |       '(' nonempty_typelist ')'
 768                         { free ((PTR)$2); $$ = 0; }
 769         ;
 770
 771 /* We used to try to recognize more pointer to member types here, but
 772    that didn't work (shift/reduce conflicts meant that these rules never
 773    got executed).  The problem is that
 774      int (foo::bar::baz::bizzle)
 775    is a function type but
 776      int (foo::bar::baz::bizzle::*)
 777    is a pointer to member type.  Stroustrup loses again!  */
 778
 779 type    :       ptype
 780         |       typebase COLONCOLON '*'
 781                         { $$ = lookup_member_type (builtin_type_int, $1); }
 782         ;
 783
 784 typebase  /* Implements (approximately): (type-qualifier)* type-specifier */
 785         :       TYPENAME
 786                         { $$ = $1.type; }
 787         |       INT_KEYWORD
 788                         { $$ = builtin_type_int; }
 789         |       LONG
 790                         { $$ = builtin_type_long; }
 791         |       SHORT
 792                         { $$ = builtin_type_short; }
 793         |       LONG INT_KEYWORD
 794                         { $$ = builtin_type_long; }
 795         |       UNSIGNED LONG INT_KEYWORD
 796                         { $$ = builtin_type_unsigned_long; }
 797         |       LONG LONG
 798                         { $$ = builtin_type_long_long; }
 799         |       LONG LONG INT_KEYWORD
 800                         { $$ = builtin_type_long_long; }
 801         |       UNSIGNED LONG LONG
 802                         { $$ = builtin_type_unsigned_long_long; }
 803         |       UNSIGNED LONG LONG INT_KEYWORD
 804                         { $$ = builtin_type_unsigned_long_long; }
 805         |       SHORT INT_KEYWORD
 806                         { $$ = builtin_type_short; }
 807         |       UNSIGNED SHORT INT_KEYWORD
 808                         { $$ = builtin_type_unsigned_short; }
 809         |       STRUCT name
 810                         { $$ = lookup_struct (copy_name ($2),
 811                                               expression_context_block); }
 812         |       CLASS name
 813                         { $$ = lookup_struct (copy_name ($2),
 814                                               expression_context_block); }
 815         |       UNION name
 816                         { $$ = lookup_union (copy_name ($2),
 817                                              expression_context_block); }
 818         |       ENUM name
 819                         { $$ = lookup_enum (copy_name ($2),
 820                                             expression_context_block); }
 821         |       UNSIGNED typename
 822                         { $$ = lookup_unsigned_typename (TYPE_NAME($2.type)); }
 823         |       UNSIGNED
 824                         { $$ = builtin_type_unsigned_int; }
 825         |       SIGNED_KEYWORD typename
 826                         { $$ = lookup_signed_typename (TYPE_NAME($2.type)); }
 827         |       SIGNED_KEYWORD
 828                         { $$ = builtin_type_int; }
 829         |       TEMPLATE name '<' type '>'
 830                         { $$ = lookup_template_type(copy_name($2), $4,
 831                                                     expression_context_block);
 832                         }
 833         /* "const" and "volatile" are curently ignored.  A type qualifier
 834            after the type is handled in the ptype rule.  I think these could
 835            be too.  */
 836         |       CONST_KEYWORD typebase { $$ = $2; }
 837         |       VOLATILE_KEYWORD typebase { $$ = $2; }
 838         ;
 839
 840 typename:       TYPENAME
 841         |       INT_KEYWORD
 842                 {
 843                   $$.stoken.ptr = "int";
 844                   $$.stoken.length = 3;
 845                   $$.type = builtin_type_int;
 846                 }
 847         |       LONG
 848                 {
 849                   $$.stoken.ptr = "long";
 850                   $$.stoken.length = 4;
 851                   $$.type = builtin_type_long;
 852                 }
 853         |       SHORT
 854                 {
 855                   $$.stoken.ptr = "short";
 856                   $$.stoken.length = 5;
 857                   $$.type = builtin_type_short;
 858                 }
 859         ;
 860
 861 nonempty_typelist
 862         :       type
 863                 { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
 864                   $<ivec>$[0] = 1;      /* Number of types in vector */
 865                   $$[1] = $1;
 866                 }
 867         |       nonempty_typelist ',' type
 868                 { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
 869                   $$ = (struct type **) realloc ((char *) $1, len);
 870                   $$[$<ivec>$[0]] = $3;
 871                 }
 872         ;
 873
 874 name    :       NAME { $$ = $1.stoken; }
 875         |       BLOCKNAME { $$ = $1.stoken; }
 876         |       TYPENAME { $$ = $1.stoken; }
 877         |       NAME_OR_INT  { $$ = $1.stoken; }
 878         ;
 879
 880 name_not_typename :     NAME
 881         |       BLOCKNAME
 882 /* These would be useful if name_not_typename was useful, but it is just
 883    a fake for "variable", so these cause reduce/reduce conflicts because
 884    the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
 885    =exp) or just an exp.  If name_not_typename was ever used in an lvalue
 886    context where only a name could occur, this might be useful.
 887         |       NAME_OR_INT
 888  */
 889         ;
 890
 891 %%
 892
 893 /* Take care of parsing a number (anything that starts with a digit).
 894    Set yylval and return the token type; update lexptr.
 895    LEN is the number of characters in it.  */
 896
 897 /*** Needs some error checking for the float case ***/
 898
 899 static int
 900 parse_number (p, len, parsed_float, putithere)
 901      register char *p;
 902      register int len;
 903      int parsed_float;
 904      YYSTYPE *putithere;
 905 {
 906   /* FIXME: Shouldn't these be unsigned?  We don't deal with negative values
 907      here, and we do kind of silly things like cast to unsigned.  */
 908   register LONGEST n = 0;
 909   register LONGEST prevn = 0;
 910   unsigned LONGEST un;
 911
 912   register int i = 0;
 913   register int c;
 914   register int base = input_radix;
 915   int unsigned_p = 0;
 916
 917   /* Number of "L" suffixes encountered.  */
 918   int long_p = 0;
 919
 920   /* We have found a "L" or "U" suffix.  */
 921   int found_suffix = 0;
 922
 923   unsigned LONGEST high_bit;
 924   struct type *signed_type;
 925   struct type *unsigned_type;
 926
 927   if (parsed_float)
 928     {
 929       /* It's a float since it contains a point or an exponent.  */
 930       putithere->dval = atof (p);
 931       return FLOAT;
 932     }
 933
 934   /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
 935   if (p[0] == '0')
 936     switch (p[1])
 937       {
 938       case 'x':
 939       case 'X':
 940         if (len >= 3)
 941           {
 942             p += 2;
 943             base = 16;
 944             len -= 2;
 945           }
 946         break;
 947
 948       case 't':
 949       case 'T':
 950       case 'd':
 951       case 'D':
 952         if (len >= 3)
 953           {
 954             p += 2;
 955             base = 10;
 956             len -= 2;
 957           }
 958         break;
 959
 960       default:
 961         base = 8;
 962         break;
 963       }
 964
 965   while (len-- > 0)
 966     {
 967       c = *p++;
 968       if (c >= 'A' && c <= 'Z')
 969         c += 'a' - 'A';
 970       if (c != 'l' && c != 'u')
 971         n *= base;
 972       if (c >= '0' && c <= '9')
 973         {
 974           if (found_suffix)
 975             return ERROR;
 976           n += i = c - '0';
 977         }
 978       else
 979         {
 980           if (base > 10 && c >= 'a' && c <= 'f')
 981             {
 982               if (found_suffix)
 983                 return ERROR;
 984               n += i = c - 'a' + 10;
 985             }
 986           else if (c == 'l')
 987             {
 988               ++long_p;
 989               found_suffix = 1;
 990             }
 991           else if (c == 'u')
 992             {
 993               unsigned_p = 1;
 994               found_suffix = 1;
 995             }
 996           else
 997             return ERROR;       /* Char not a digit */
 998         }
 999       if (i >= base)
1000         return ERROR;           /* Invalid digit in this base */
1001
1002       /* Portably test for overflow (only works for nonzero values, so make
1003          a second check for zero).  FIXME: Can't we just make n and prevn
1004          unsigned and avoid this?  */
1005       if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
1006         unsigned_p = 1;         /* Try something unsigned */
1007
1008       /* Portably test for unsigned overflow.
1009          FIXME: This check is wrong; for example it doesn't find overflow
1010          on 0x123456789 when LONGEST is 32 bits.  */
1011       if (c != 'l' && c != 'u' && n != 0)
1012         {
1013           if ((unsigned_p && (unsigned LONGEST) prevn >= (unsigned LONGEST) n))
1014             error ("Numeric constant too large.");
1015         }
1016       prevn = n;
1017     }
1018
1019   /* An integer constant is an int, a long, or a long long.  An L
1020      suffix forces it to be long; an LL suffix forces it to be long
1021      long.  If not forced to a larger size, it gets the first type of
1022      the above that it fits in.  To figure out whether it fits, we
1023      shift it right and see whether anything remains.  Note that we
1024      can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
1025      operation, because many compilers will warn about such a shift
1026      (which always produces a zero result).  Sometimes TARGET_INT_BIT
1027      or TARGET_LONG_BIT will be that big, sometimes not.  To deal with
1028      the case where it is we just always shift the value more than
1029      once, with fewer bits each time.  */
1030
1031   un = (unsigned LONGEST)n >> 2;
1032   if (long_p == 0
1033       && (un >> (TARGET_INT_BIT - 2)) == 0)
1034     {
1035       high_bit = ((unsigned LONGEST)1) << (TARGET_INT_BIT-1);
1036
1037       /* A large decimal (not hex or octal) constant (between INT_MAX
1038          and UINT_MAX) is a long or unsigned long, according to ANSI,
1039          never an unsigned int, but this code treats it as unsigned
1040          int.  This probably should be fixed.  GCC gives a warning on
1041          such constants.  */
1042
1043       unsigned_type = builtin_type_unsigned_int;
1044       signed_type = builtin_type_int;
1045     }
1046   else if (long_p <= 1
1047            && (un >> (TARGET_LONG_BIT - 2)) == 0)
1048     {
1049       high_bit = ((unsigned LONGEST)1) << (TARGET_LONG_BIT-1);
1050       unsigned_type = builtin_type_unsigned_long;
1051       signed_type = builtin_type_long;
1052     }
1053   else
1054     {
1055       high_bit = (((unsigned LONGEST)1)
1056                   << (TARGET_LONG_LONG_BIT - 32 - 1)
1057                   << 16
1058                   << 16);
1059       if (high_bit == 0)
1060         /* A long long does not fit in a LONGEST.  */
1061         high_bit =
1062           (unsigned LONGEST)1 << (sizeof (LONGEST) * HOST_CHAR_BIT - 1);
1063       unsigned_type = builtin_type_unsigned_long_long;
1064       signed_type = builtin_type_long_long;
1065     }
1066
1067    putithere->typed_val.val = n;
1068
1069    /* If the high bit of the worked out type is set then this number
1070       has to be unsigned. */
1071
1072    if (unsigned_p || (n & high_bit))
1073      {
1074        putithere->typed_val.type = unsigned_type;
1075      }
1076    else
1077      {
1078        putithere->typed_val.type = signed_type;
1079      }
1080
1081    return INT;
1082 }
1083
1084 struct token
1085 {
1086   char *operator;
1087   int token;
1088   enum exp_opcode opcode;
1089 };
1090
1091 static const struct token tokentab3[] =
1092   {
1093     {">>=", ASSIGN_MODIFY, BINOP_RSH},
1094     {"<<=", ASSIGN_MODIFY, BINOP_LSH}
1095   };
1096
1097 static const struct token tokentab2[] =
1098   {
1099     {"+=", ASSIGN_MODIFY, BINOP_ADD},
1100     {"-=", ASSIGN_MODIFY, BINOP_SUB},
1101     {"*=", ASSIGN_MODIFY, BINOP_MUL},
1102     {"/=", ASSIGN_MODIFY, BINOP_DIV},
1103     {"%=", ASSIGN_MODIFY, BINOP_REM},
1104     {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
1105     {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
1106     {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
1107     {"++", INCREMENT, BINOP_END},
1108     {"--", DECREMENT, BINOP_END},
1109     {"->", ARROW, BINOP_END},
1110     {"&&", ANDAND, BINOP_END},
1111     {"||", OROR, BINOP_END},
1112     {"::", COLONCOLON, BINOP_END},
1113     {"<<", LSH, BINOP_END},
1114     {">>", RSH, BINOP_END},
1115     {"==", EQUAL, BINOP_END},
1116     {"!=", NOTEQUAL, BINOP_END},
1117     {"<=", LEQ, BINOP_END},
1118     {">=", GEQ, BINOP_END}
1119   };
1120
1121 /* Read one token, getting characters through lexptr.  */
1122
1123 static int
1124 yylex ()
1125 {
1126   int c;
1127   int namelen;
1128   unsigned int i;
1129   char *tokstart;
1130   char *tokptr;
1131   int tempbufindex;
1132   static char *tempbuf;
1133   static int tempbufsize;
1134
1135  retry:
1136
1137   tokstart = lexptr;
1138   /* See if it is a special token of length 3.  */
1139   for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1140     if (STREQN (tokstart, tokentab3[i].operator, 3))
1141       {
1142         lexptr += 3;
1143         yylval.opcode = tokentab3[i].opcode;
1144         return tokentab3[i].token;
1145       }
1146
1147   /* See if it is a special token of length 2.  */
1148   for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1149     if (STREQN (tokstart, tokentab2[i].operator, 2))
1150       {
1151         lexptr += 2;
1152         yylval.opcode = tokentab2[i].opcode;
1153         return tokentab2[i].token;
1154       }
1155
1156   switch (c = *tokstart)
1157     {
1158     case 0:
1159       return 0;
1160
1161     case ' ':
1162     case '\t':
1163     case '\n':
1164       lexptr++;
1165       goto retry;
1166
1167     case '\'':
1168       /* We either have a character constant ('0' or '\177' for example)
1169          or we have a quoted symbol reference ('foo(int,int)' in C++
1170          for example). */
1171       lexptr++;
1172       c = *lexptr++;
1173       if (c == '\\')
1174         c = parse_escape (&lexptr);
1175       else if (c == '\'')
1176         error ("Empty character constant.");
1177
1178       yylval.typed_val.val = c;
1179       yylval.typed_val.type = builtin_type_char;
1180
1181       c = *lexptr++;
1182       if (c != '\'')
1183         {
1184           namelen = skip_quoted (tokstart) - tokstart;
1185           if (namelen > 2)
1186             {
1187               lexptr = tokstart + namelen;
1188               if (lexptr[-1] != '\'')
1189                 error ("Unmatched single quote.");
1190               namelen -= 2;
1191               tokstart++;
1192               goto tryname;
1193             }
1194           error ("Invalid character constant.");
1195         }
1196       return INT;
1197
1198     case '(':
1199       paren_depth++;
1200       lexptr++;
1201       return c;
1202
1203     case ')':
1204       if (paren_depth == 0)
1205         return 0;
1206       paren_depth--;
1207       lexptr++;
1208       return c;
1209
1210     case ',':
1211       if (comma_terminates && paren_depth == 0)
1212         return 0;
1213       lexptr++;
1214       return c;
1215
1216     case '.':
1217       /* Might be a floating point number.  */
1218       if (lexptr[1] < '0' || lexptr[1] > '9')
1219         goto symbol;            /* Nope, must be a symbol. */
1220       /* FALL THRU into number case.  */
1221
1222     case '0':
1223     case '1':
1224     case '2':
1225     case '3':
1226     case '4':
1227     case '5':
1228     case '6':
1229     case '7':
1230     case '8':
1231     case '9':
1232       {
1233         /* It's a number.  */
1234         int got_dot = 0, got_e = 0, toktype;
1235         register char *p = tokstart;
1236         int hex = input_radix > 10;
1237
1238         if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1239           {
1240             p += 2;
1241             hex = 1;
1242           }
1243         else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1244           {
1245             p += 2;
1246             hex = 0;
1247           }
1248
1249         for (;; ++p)
1250           {
1251             /* This test includes !hex because 'e' is a valid hex digit
1252                and thus does not indicate a floating point number when
1253                the radix is hex.  */
1254             if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1255               got_dot = got_e = 1;
1256             /* This test does not include !hex, because a '.' always indicates
1257                a decimal floating point number regardless of the radix.  */
1258             else if (!got_dot && *p == '.')
1259               got_dot = 1;
1260             else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1261                      && (*p == '-' || *p == '+'))
1262               /* This is the sign of the exponent, not the end of the
1263                  number.  */
1264               continue;
1265             /* We will take any letters or digits.  parse_number will
1266                complain if past the radix, or if L or U are not final.  */
1267             else if ((*p < '0' || *p > '9')
1268                      && ((*p < 'a' || *p > 'z')
1269                                   && (*p < 'A' || *p > 'Z')))
1270               break;
1271           }
1272         toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1273         if (toktype == ERROR)
1274           {
1275             char *err_copy = (char *) alloca (p - tokstart + 1);
1276
1277             memcpy (err_copy, tokstart, p - tokstart);
1278             err_copy[p - tokstart] = 0;
1279             error ("Invalid number \"%s\".", err_copy);
1280           }
1281         lexptr = p;
1282         return toktype;
1283       }
1284
1285     case '+':
1286     case '-':
1287     case '*':
1288     case '/':
1289     case '%':
1290     case '|':
1291     case '&':
1292     case '^':
1293     case '~':
1294     case '!':
1295     case '@':
1296     case '<':
1297     case '>':
1298     case '[':
1299     case ']':
1300     case '?':
1301     case ':':
1302     case '=':
1303     case '{':
1304     case '}':
1305     symbol:
1306       lexptr++;
1307       return c;
1308
1309     case '"':
1310
1311       /* Build the gdb internal form of the input string in tempbuf,
1312          translating any standard C escape forms seen.  Note that the
1313          buffer is null byte terminated *only* for the convenience of
1314          debugging gdb itself and printing the buffer contents when
1315          the buffer contains no embedded nulls.  Gdb does not depend
1316          upon the buffer being null byte terminated, it uses the length
1317          string instead.  This allows gdb to handle C strings (as well
1318          as strings in other languages) with embedded null bytes */
1319
1320       tokptr = ++tokstart;
1321       tempbufindex = 0;
1322
1323       do {
1324         /* Grow the static temp buffer if necessary, including allocating
1325            the first one on demand. */
1326         if (tempbufindex + 1 >= tempbufsize)
1327           {
1328             tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1329           }
1330         switch (*tokptr)
1331           {
1332           case '\0':
1333           case '"':
1334             /* Do nothing, loop will terminate. */
1335             break;
1336           case '\\':
1337             tokptr++;
1338             c = parse_escape (&tokptr);
1339             if (c == -1)
1340               {
1341                 continue;
1342               }
1343             tempbuf[tempbufindex++] = c;
1344             break;
1345           default:
1346             tempbuf[tempbufindex++] = *tokptr++;
1347             break;
1348           }
1349       } while ((*tokptr != '"') && (*tokptr != '\0'));
1350       if (*tokptr++ != '"')
1351         {
1352           error ("Unterminated string in expression.");
1353         }
1354       tempbuf[tempbufindex] = '\0';     /* See note above */
1355       yylval.sval.ptr = tempbuf;
1356       yylval.sval.length = tempbufindex;
1357       lexptr = tokptr;
1358       return (STRING);
1359     }
1360
1361   if (!(c == '_' || c == '$'
1362         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1363     /* We must have come across a bad character (e.g. ';').  */
1364     error ("Invalid character '%c' in expression.", c);
1365
1366   /* It's a name.  See how long it is.  */
1367   namelen = 0;
1368   for (c = tokstart[namelen];
1369        (c == '_' || c == '$' || (c >= '0' && c <= '9')
1370         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
1371     {
1372        if (c == '<')
1373          {
1374            int i = namelen;
1375            while (tokstart[++i] && tokstart[i] != '>');
1376            if (tokstart[i] == '>')
1377              namelen = i;
1378           }
1379        c = tokstart[++namelen];
1380      }
1381
1382   /* The token "if" terminates the expression and is NOT
1383      removed from the input stream.  */
1384   if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1385     {
1386       return 0;
1387     }
1388
1389   lexptr += namelen;
1390
1391   tryname:
1392
1393   /* Catch specific keywords.  Should be done with a data structure.  */
1394   switch (namelen)
1395     {
1396     case 8:
1397       if (STREQN (tokstart, "unsigned", 8))
1398         return UNSIGNED;
1399       if (current_language->la_language == language_cplus
1400           && STREQN (tokstart, "template", 8))
1401         return TEMPLATE;
1402       if (STREQN (tokstart, "volatile", 8))
1403         return VOLATILE_KEYWORD;
1404       break;
1405     case 6:
1406       if (STREQN (tokstart, "struct", 6))
1407         return STRUCT;
1408       if (STREQN (tokstart, "signed", 6))
1409         return SIGNED_KEYWORD;
1410       if (STREQN (tokstart, "sizeof", 6))
1411         return SIZEOF;
1412       break;
1413     case 5:
1414       if (current_language->la_language == language_cplus
1415           && STREQN (tokstart, "class", 5))
1416         return CLASS;
1417       if (STREQN (tokstart, "union", 5))
1418         return UNION;
1419       if (STREQN (tokstart, "short", 5))
1420         return SHORT;
1421       if (STREQN (tokstart, "const", 5))
1422         return CONST_KEYWORD;
1423       break;
1424     case 4:
1425       if (STREQN (tokstart, "enum", 4))
1426         return ENUM;
1427       if (STREQN (tokstart, "long", 4))
1428         return LONG;
1429       if (current_language->la_language == language_cplus
1430           && STREQN (tokstart, "this", 4))
1431         {
1432           static const char this_name[] =
1433                                  { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' };
1434
1435           if (lookup_symbol (this_name, expression_context_block,
1436                              VAR_NAMESPACE, (int *) NULL,
1437                              (struct symtab **) NULL))
1438             return THIS;
1439         }
1440       break;
1441     case 3:
1442       if (STREQN (tokstart, "int", 3))
1443         return INT_KEYWORD;
1444       break;
1445     default:
1446       break;
1447     }
1448
1449   yylval.sval.ptr = tokstart;
1450   yylval.sval.length = namelen;
1451
1452   if (*tokstart == '$')
1453     {
1454       write_dollar_variable (yylval.sval);
1455       return VARIABLE;
1456     }
1457
1458   /* Use token-type BLOCKNAME for symbols that happen to be defined as
1459      functions or symtabs.  If this is not so, then ...
1460      Use token-type TYPENAME for symbols that happen to be defined
1461      currently as names of types; NAME for other symbols.
1462      The caller is not constrained to care about the distinction.  */
1463   {
1464     char *tmp = copy_name (yylval.sval);
1465     struct symbol *sym;
1466     int is_a_field_of_this = 0;
1467     int hextype;
1468
1469     sym = lookup_symbol (tmp, expression_context_block,
1470                          VAR_NAMESPACE,
1471                          current_language->la_language == language_cplus
1472                          ? &is_a_field_of_this : (int *) NULL,
1473                          (struct symtab **) NULL);
1474     /* Call lookup_symtab, not lookup_partial_symtab, in case there are
1475        no psymtabs (coff, xcoff, or some future change to blow away the
1476        psymtabs once once symbols are read).  */
1477     if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) ||
1478         lookup_symtab (tmp))
1479       {
1480         yylval.ssym.sym = sym;
1481         yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1482         return BLOCKNAME;
1483       }
1484     if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1485         {
1486 #if 1
1487           /* Despite the following flaw, we need to keep this code enabled.
1488              Because we can get called from check_stub_method, if we don't
1489              handle nested types then it screws many operations in any
1490              program which uses nested types.  */
1491           /* In "A::x", if x is a member function of A and there happens
1492              to be a type (nested or not, since the stabs don't make that
1493              distinction) named x, then this code incorrectly thinks we
1494              are dealing with nested types rather than a member function.  */
1495
1496           char *p;
1497           char *namestart;
1498           struct symbol *best_sym;
1499
1500           /* Look ahead to detect nested types.  This probably should be
1501              done in the grammar, but trying seemed to introduce a lot
1502              of shift/reduce and reduce/reduce conflicts.  It's possible
1503              that it could be done, though.  Or perhaps a non-grammar, but
1504              less ad hoc, approach would work well.  */
1505
1506           /* Since we do not currently have any way of distinguishing
1507              a nested type from a non-nested one (the stabs don't tell
1508              us whether a type is nested), we just ignore the
1509              containing type.  */
1510
1511           p = lexptr;
1512           best_sym = sym;
1513           while (1)
1514             {
1515               /* Skip whitespace.  */
1516               while (*p == ' ' || *p == '\t' || *p == '\n')
1517                 ++p;
1518               if (*p == ':' && p[1] == ':')
1519                 {
1520                   /* Skip the `::'.  */
1521                   p += 2;
1522                   /* Skip whitespace.  */
1523                   while (*p == ' ' || *p == '\t' || *p == '\n')
1524                     ++p;
1525                   namestart = p;
1526                   while (*p == '_' || *p == '$' || (*p >= '0' && *p <= '9')
1527                          || (*p >= 'a' && *p <= 'z')
1528                          || (*p >= 'A' && *p <= 'Z'))
1529                     ++p;
1530                   if (p != namestart)
1531                     {
1532                       struct symbol *cur_sym;
1533                       /* As big as the whole rest of the expression, which is
1534                          at least big enough.  */
1535                       char *ncopy = alloca (strlen (tmp)+strlen (namestart)+3);
1536                       char *tmp1;
1537
1538                       tmp1 = ncopy;
1539                       memcpy (tmp1, tmp, strlen (tmp));
1540                       tmp1 += strlen (tmp);
1541                       memcpy (tmp1, "::", 2);
1542                       tmp1 += 2;
1543                       memcpy (tmp1, namestart, p - namestart);
1544                       tmp1[p - namestart] = '\0';
1545                       cur_sym = lookup_symbol (ncopy, expression_context_block,
1546                                                VAR_NAMESPACE, (int *) NULL,
1547                                                (struct symtab **) NULL);
1548                       if (cur_sym)
1549                         {
1550                           if (SYMBOL_CLASS (cur_sym) == LOC_TYPEDEF)
1551                             {
1552                               best_sym = cur_sym;
1553                               lexptr = p;
1554                             }
1555                           else
1556                             break;
1557                         }
1558                       else
1559                         break;
1560                     }
1561                   else
1562                     break;
1563                 }
1564               else
1565                 break;
1566             }
1567
1568           yylval.tsym.type = SYMBOL_TYPE (best_sym);
1569 #else /* not 0 */
1570           yylval.tsym.type = SYMBOL_TYPE (sym);
1571 #endif /* not 0 */
1572           return TYPENAME;
1573         }
1574     if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0)
1575         return TYPENAME;
1576
1577     /* Input names that aren't symbols but ARE valid hex numbers,
1578        when the input radix permits them, can be names or numbers
1579        depending on the parse.  Note we support radixes > 16 here.  */
1580     if (!sym &&
1581         ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1582          (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1583       {
1584         YYSTYPE newlval;        /* Its value is ignored.  */
1585         hextype = parse_number (tokstart, namelen, 0, &newlval);
1586         if (hextype == INT)
1587           {
1588             yylval.ssym.sym = sym;
1589             yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1590             return NAME_OR_INT;
1591           }
1592       }
1593
1594     /* Any other kind of symbol */
1595     yylval.ssym.sym = sym;
1596     yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1597     return NAME;
1598   }
1599 }
1600
1601 void
1602 yyerror (msg)
1603      char *msg;
1604 {
1605   error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);
1606 }