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