gdb/c-exp.y

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