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