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