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                   struct type *range_type;
 709
 710                   while (!done)
 711                     switch (pop_type ())
 712                       {
 713                       case tp_end:
 714                         done = 1;
 715                         break;
 716                       case tp_pointer:
 717                         follow_type = lookup_pointer_type (follow_type);
 718                         break;
 719                       case tp_reference:
 720                         follow_type = lookup_reference_type (follow_type);
 721                         break;
 722                       case tp_array:
 723                         array_size = pop_type_int ();
 724                         if (array_size != -1)
 725                           {
 726                             range_type =
 727                               create_range_type ((struct type *) NULL,
 728                                                  builtin_type_int, 0,
 729                                                  array_size - 1);
 730                             follow_type =
 731                               create_array_type ((struct type *) NULL,
 732                                                  follow_type, range_type);
 733                           }
 734                         else
 735                           follow_type = lookup_pointer_type (follow_type);
 736                         break;
 737                       case tp_function:
 738                         follow_type = lookup_function_type (follow_type);
 739                         break;
 740                       }
 741                   $$ = follow_type;
 742                 }
 743         ;
 744
 745 abs_decl:       '*'
 746                         { push_type (tp_pointer); $$ = 0; }
 747         |       '*' abs_decl
 748                         { push_type (tp_pointer); $$ = $2; }
 749         |       '&'
 750                         { push_type (tp_reference); $$ = 0; }
 751         |       '&' abs_decl
 752                         { push_type (tp_reference); $$ = $2; }
 753         |       direct_abs_decl
 754         ;
 755
 756 direct_abs_decl: '(' abs_decl ')'
 757                         { $$ = $2; }
 758         |       direct_abs_decl array_mod
 759                         {
 760                           push_type_int ($2);
 761                           push_type (tp_array);
 762                         }
 763         |       array_mod
 764                         {
 765                           push_type_int ($1);
 766                           push_type (tp_array);
 767                           $$ = 0;
 768                         }
 769         |       direct_abs_decl func_mod
 770                         { push_type (tp_function); }
 771         |       func_mod
 772                         { push_type (tp_function); }
 773         ;
 774
 775 array_mod:      '[' ']'
 776                         { $$ = -1; }
 777         |       '[' INT ']'
 778                         { $$ = $2.val; }
 779         ;
 780
 781 func_mod:       '(' ')'
 782                         { $$ = 0; }
 783         |       '(' nonempty_typelist ')'
 784                         { free ((PTR)$2); $$ = 0; }
 785         ;
 786
 787 type    :       ptype
 788         |       typebase COLONCOLON '*'
 789                         { $$ = lookup_member_type (builtin_type_int, $1); }
 790         |       type '(' typebase COLONCOLON '*' ')'
 791                         { $$ = lookup_member_type ($1, $3); }
 792         |       type '(' typebase COLONCOLON '*' ')' '(' ')'
 793                         { $$ = lookup_member_type
 794                             (lookup_function_type ($1), $3); }
 795         |       type '(' typebase COLONCOLON '*' ')' '(' nonempty_typelist ')'
 796                         { $$ = lookup_member_type
 797                             (lookup_function_type ($1), $3);
 798                           free ((PTR)$8); }
 799         ;
 800
 801 typebase  /* Implements (approximately): (type-qualifier)* type-specifier */
 802         :       TYPENAME
 803                         { $$ = $1.type; }
 804         |       INT_KEYWORD
 805                         { $$ = builtin_type_int; }
 806         |       LONG
 807                         { $$ = builtin_type_long; }
 808         |       SHORT
 809                         { $$ = builtin_type_short; }
 810         |       LONG INT_KEYWORD
 811                         { $$ = builtin_type_long; }
 812         |       UNSIGNED LONG INT_KEYWORD
 813                         { $$ = builtin_type_unsigned_long; }
 814         |       LONG LONG
 815                         { $$ = builtin_type_long_long; }
 816         |       LONG LONG INT_KEYWORD
 817                         { $$ = builtin_type_long_long; }
 818         |       UNSIGNED LONG LONG
 819                         { $$ = builtin_type_unsigned_long_long; }
 820         |       UNSIGNED LONG LONG INT_KEYWORD
 821                         { $$ = builtin_type_unsigned_long_long; }
 822         |       SHORT INT_KEYWORD
 823                         { $$ = builtin_type_short; }
 824         |       UNSIGNED SHORT INT_KEYWORD
 825                         { $$ = builtin_type_unsigned_short; }
 826         |       STRUCT name
 827                         { $$ = lookup_struct (copy_name ($2),
 828                                               expression_context_block); }
 829         |       CLASS name
 830                         { $$ = lookup_struct (copy_name ($2),
 831                                               expression_context_block); }
 832         |       UNION name
 833                         { $$ = lookup_union (copy_name ($2),
 834                                              expression_context_block); }
 835         |       ENUM name
 836                         { $$ = lookup_enum (copy_name ($2),
 837                                             expression_context_block); }
 838         |       UNSIGNED typename
 839                         { $$ = lookup_unsigned_typename (TYPE_NAME($2.type)); }
 840         |       UNSIGNED
 841                         { $$ = builtin_type_unsigned_int; }
 842         |       SIGNED_KEYWORD typename
 843                         { $$ = lookup_signed_typename (TYPE_NAME($2.type)); }
 844         |       SIGNED_KEYWORD
 845                         { $$ = builtin_type_int; }
 846         |       TEMPLATE name '<' type '>'
 847                         { $$ = lookup_template_type(copy_name($2), $4,
 848                                                     expression_context_block);
 849                         }
 850         /* "const" and "volatile" are curently ignored. */
 851         |       CONST_KEYWORD typebase { $$ = $2; }
 852         |       VOLATILE_KEYWORD typebase { $$ = $2; }
 853         ;
 854
 855 typename:       TYPENAME
 856         |       INT_KEYWORD
 857                 {
 858                   $$.stoken.ptr = "int";
 859                   $$.stoken.length = 3;
 860                   $$.type = builtin_type_int;
 861                 }
 862         |       LONG
 863                 {
 864                   $$.stoken.ptr = "long";
 865                   $$.stoken.length = 4;
 866                   $$.type = builtin_type_long;
 867                 }
 868         |       SHORT
 869                 {
 870                   $$.stoken.ptr = "short";
 871                   $$.stoken.length = 5;
 872                   $$.type = builtin_type_short;
 873                 }
 874         ;
 875
 876 nonempty_typelist
 877         :       type
 878                 { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
 879                   $<ivec>$[0] = 1;      /* Number of types in vector */
 880                   $$[1] = $1;
 881                 }
 882         |       nonempty_typelist ',' type
 883                 { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
 884                   $$ = (struct type **) realloc ((char *) $1, len);
 885                   $$[$<ivec>$[0]] = $3;
 886                 }
 887         ;
 888
 889 name    :       NAME { $$ = $1.stoken; }
 890         |       BLOCKNAME { $$ = $1.stoken; }
 891         |       TYPENAME { $$ = $1.stoken; }
 892         |       NAME_OR_INT  { $$ = $1.stoken; }
 893         ;
 894
 895 name_not_typename :     NAME
 896         |       BLOCKNAME
 897 /* These would be useful if name_not_typename was useful, but it is just
 898    a fake for "variable", so these cause reduce/reduce conflicts because
 899    the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
 900    =exp) or just an exp.  If name_not_typename was ever used in an lvalue
 901    context where only a name could occur, this might be useful.
 902         |       NAME_OR_INT
 903  */
 904         ;
 905
 906 %%
 907
 908 /* Take care of parsing a number (anything that starts with a digit).
 909    Set yylval and return the token type; update lexptr.
 910    LEN is the number of characters in it.  */
 911
 912 /*** Needs some error checking for the float case ***/
 913
 914 static int
 915 parse_number (p, len, parsed_float, putithere)
 916      register char *p;
 917      register int len;
 918      int parsed_float;
 919      YYSTYPE *putithere;
 920 {
 921   register LONGEST n = 0;
 922   register LONGEST prevn = 0;
 923   register int i;
 924   register int c;
 925   register int base = input_radix;
 926   int unsigned_p = 0;
 927   int long_p = 0;
 928   LONGEST high_bit;
 929   struct type *signed_type;
 930   struct type *unsigned_type;
 931
 932   if (parsed_float)
 933     {
 934       /* It's a float since it contains a point or an exponent.  */
 935       putithere->dval = atof (p);
 936       return FLOAT;
 937     }
 938
 939   /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
 940   if (p[0] == '0')
 941     switch (p[1])
 942       {
 943       case 'x':
 944       case 'X':
 945         if (len >= 3)
 946           {
 947             p += 2;
 948             base = 16;
 949             len -= 2;
 950           }
 951         break;
 952
 953       case 't':
 954       case 'T':
 955       case 'd':
 956       case 'D':
 957         if (len >= 3)
 958           {
 959             p += 2;
 960             base = 10;
 961             len -= 2;
 962           }
 963         break;
 964
 965       default:
 966         base = 8;
 967         break;
 968       }
 969
 970   while (len-- > 0)
 971     {
 972       c = *p++;
 973       if (c >= 'A' && c <= 'Z')
 974         c += 'a' - 'A';
 975       if (c != 'l' && c != 'u')
 976         n *= base;
 977       if (c >= '0' && c <= '9')
 978         n += i = c - '0';
 979       else
 980         {
 981           if (base > 10 && c >= 'a' && c <= 'f')
 982             n += i = c - 'a' + 10;
 983           else if (len == 0 && c == 'l')
 984             long_p = 1;
 985           else if (len == 0 && c == 'u')
 986             unsigned_p = 1;
 987           else
 988             return ERROR;       /* Char not a digit */
 989         }
 990       if (i >= base)
 991         return ERROR;           /* Invalid digit in this base */
 992
 993       /* Portably test for overflow (only works for nonzero values, so make
 994          a second check for zero).  */
 995       if((prevn >= n) && n != 0)
 996          unsigned_p=1;          /* Try something unsigned */
 997       /* If range checking enabled, portably test for unsigned overflow.  */
 998       if(RANGE_CHECK && n!=0)
 999       {
1000          if((unsigned_p && (unsigned)prevn >= (unsigned)n))
1001             range_error("Overflow on numeric constant.");
1002       }
1003       prevn=n;
1004     }
1005
1006      /* If the number is too big to be an int, or it's got an l suffix
1007         then it's a long.  Work out if this has to be a long by
1008         shifting right and and seeing if anything remains, and the
1009         target int size is different to the target long size. */
1010
1011     if ((TARGET_INT_BIT != TARGET_LONG_BIT && (n >> TARGET_INT_BIT)) || long_p)
1012       {
1013          high_bit = ((LONGEST)1) << (TARGET_LONG_BIT-1);
1014          unsigned_type = builtin_type_unsigned_long;
1015          signed_type = builtin_type_long;
1016       }
1017     else
1018       {
1019          high_bit = ((LONGEST)1) << (TARGET_INT_BIT-1);
1020          unsigned_type = builtin_type_unsigned_int;
1021          signed_type = builtin_type_int;
1022       }
1023
1024    putithere->typed_val.val = n;
1025
1026    /* If the high bit of the worked out type is set then this number
1027       has to be unsigned. */
1028
1029    if (unsigned_p || (n & high_bit))
1030      {
1031         putithere->typed_val.type = unsigned_type;
1032      }
1033    else
1034      {
1035         putithere->typed_val.type = signed_type;
1036      }
1037
1038    return INT;
1039 }
1040
1041 struct token
1042 {
1043   char *operator;
1044   int token;
1045   enum exp_opcode opcode;
1046 };
1047
1048 static const struct token tokentab3[] =
1049   {
1050     {">>=", ASSIGN_MODIFY, BINOP_RSH},
1051     {"<<=", ASSIGN_MODIFY, BINOP_LSH}
1052   };
1053
1054 static const struct token tokentab2[] =
1055   {
1056     {"+=", ASSIGN_MODIFY, BINOP_ADD},
1057     {"-=", ASSIGN_MODIFY, BINOP_SUB},
1058     {"*=", ASSIGN_MODIFY, BINOP_MUL},
1059     {"/=", ASSIGN_MODIFY, BINOP_DIV},
1060     {"%=", ASSIGN_MODIFY, BINOP_REM},
1061     {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
1062     {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
1063     {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
1064     {"++", INCREMENT, BINOP_END},
1065     {"--", DECREMENT, BINOP_END},
1066     {"->", ARROW, BINOP_END},
1067     {"&&", ANDAND, BINOP_END},
1068     {"||", OROR, BINOP_END},
1069     {"::", COLONCOLON, BINOP_END},
1070     {"<<", LSH, BINOP_END},
1071     {">>", RSH, BINOP_END},
1072     {"==", EQUAL, BINOP_END},
1073     {"!=", NOTEQUAL, BINOP_END},
1074     {"<=", LEQ, BINOP_END},
1075     {">=", GEQ, BINOP_END}
1076   };
1077
1078 /* Read one token, getting characters through lexptr.  */
1079
1080 int
1081 yylex ()
1082 {
1083   int c;
1084   int namelen;
1085   unsigned int i;
1086   char *tokstart;
1087   char *tokptr;
1088   int tempbufindex;
1089   static char *tempbuf;
1090   static int tempbufsize;
1091
1092  retry:
1093
1094   tokstart = lexptr;
1095   /* See if it is a special token of length 3.  */
1096   for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1097     if (!strncmp (tokstart, tokentab3[i].operator, 3))
1098       {
1099         lexptr += 3;
1100         yylval.opcode = tokentab3[i].opcode;
1101         return tokentab3[i].token;
1102       }
1103
1104   /* See if it is a special token of length 2.  */
1105   for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1106     if (!strncmp (tokstart, tokentab2[i].operator, 2))
1107       {
1108         lexptr += 2;
1109         yylval.opcode = tokentab2[i].opcode;
1110         return tokentab2[i].token;
1111       }
1112
1113   switch (c = *tokstart)
1114     {
1115     case 0:
1116       return 0;
1117
1118     case ' ':
1119     case '\t':
1120     case '\n':
1121       lexptr++;
1122       goto retry;
1123
1124     case '\'':
1125       /* We either have a character constant ('0' or '\177' for example)
1126          or we have a quoted symbol reference ('foo(int,int)' in C++
1127          for example). */
1128       lexptr++;
1129       c = *lexptr++;
1130       if (c == '\\')
1131         c = parse_escape (&lexptr);
1132
1133       yylval.typed_val.val = c;
1134       yylval.typed_val.type = builtin_type_char;
1135
1136       c = *lexptr++;
1137       if (c != '\'')
1138         {
1139           namelen = skip_quoted (tokstart) - tokstart;
1140           if (namelen > 2)
1141             {
1142               lexptr = tokstart + namelen;
1143               namelen -= 2;
1144               tokstart++;
1145               goto tryname;
1146             }
1147           error ("Invalid character constant.");
1148         }
1149       return INT;
1150
1151     case '(':
1152       paren_depth++;
1153       lexptr++;
1154       return c;
1155
1156     case ')':
1157       if (paren_depth == 0)
1158         return 0;
1159       paren_depth--;
1160       lexptr++;
1161       return c;
1162
1163     case ',':
1164       if (comma_terminates && paren_depth == 0)
1165         return 0;
1166       lexptr++;
1167       return c;
1168
1169     case '.':
1170       /* Might be a floating point number.  */
1171       if (lexptr[1] < '0' || lexptr[1] > '9')
1172         goto symbol;            /* Nope, must be a symbol. */
1173       /* FALL THRU into number case.  */
1174
1175     case '0':
1176     case '1':
1177     case '2':
1178     case '3':
1179     case '4':
1180     case '5':
1181     case '6':
1182     case '7':
1183     case '8':
1184     case '9':
1185       {
1186         /* It's a number.  */
1187         int got_dot = 0, got_e = 0, toktype;
1188         register char *p = tokstart;
1189         int hex = input_radix > 10;
1190
1191         if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1192           {
1193             p += 2;
1194             hex = 1;
1195           }
1196         else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1197           {
1198             p += 2;
1199             hex = 0;
1200           }
1201
1202         for (;; ++p)
1203           {
1204             if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1205               got_dot = got_e = 1;
1206             else if (!hex && !got_dot && *p == '.')
1207               got_dot = 1;
1208             else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1209                      && (*p == '-' || *p == '+'))
1210               /* This is the sign of the exponent, not the end of the
1211                  number.  */
1212               continue;
1213             /* We will take any letters or digits.  parse_number will
1214                complain if past the radix, or if L or U are not final.  */
1215             else if ((*p < '0' || *p > '9')
1216                      && ((*p < 'a' || *p > 'z')
1217                                   && (*p < 'A' || *p > 'Z')))
1218               break;
1219           }
1220         toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1221         if (toktype == ERROR)
1222           {
1223             char *err_copy = (char *) alloca (p - tokstart + 1);
1224
1225             memcpy (err_copy, tokstart, p - tokstart);
1226             err_copy[p - tokstart] = 0;
1227             error ("Invalid number \"%s\".", err_copy);
1228           }
1229         lexptr = p;
1230         return toktype;
1231       }
1232
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     case '>':
1246     case '[':
1247     case ']':
1248     case '?':
1249     case ':':
1250     case '=':
1251     case '{':
1252     case '}':
1253     symbol:
1254       lexptr++;
1255       return c;
1256
1257     case '"':
1258
1259       /* Build the gdb internal form of the input string in tempbuf,
1260          translating any standard C escape forms seen.  Note that the
1261          buffer is null byte terminated *only* for the convenience of
1262          debugging gdb itself and printing the buffer contents when
1263          the buffer contains no embedded nulls.  Gdb does not depend
1264          upon the buffer being null byte terminated, it uses the length
1265          string instead.  This allows gdb to handle C strings (as well
1266          as strings in other languages) with embedded null bytes */
1267
1268       tokptr = ++tokstart;
1269       tempbufindex = 0;
1270
1271       do {
1272         /* Grow the static temp buffer if necessary, including allocating
1273            the first one on demand. */
1274         if (tempbufindex + 1 >= tempbufsize)
1275           {
1276             tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1277           }
1278         switch (*tokptr)
1279           {
1280           case '\0':
1281           case '"':
1282             /* Do nothing, loop will terminate. */
1283             break;
1284           case '\\':
1285             tokptr++;
1286             c = parse_escape (&tokptr);
1287             if (c == -1)
1288               {
1289                 continue;
1290               }
1291             tempbuf[tempbufindex++] = c;
1292             break;
1293           default:
1294             tempbuf[tempbufindex++] = *tokptr++;
1295             break;
1296           }
1297       } while ((*tokptr != '"') && (*tokptr != '\0'));
1298       if (*tokptr++ != '"')
1299         {
1300           error ("Unterminated string in expression.");
1301         }
1302       tempbuf[tempbufindex] = '\0';     /* See note above */
1303       yylval.sval.ptr = tempbuf;
1304       yylval.sval.length = tempbufindex;
1305       lexptr = tokptr;
1306       return (STRING);
1307     }
1308
1309   if (!(c == '_' || c == '$'
1310         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1311     /* We must have come across a bad character (e.g. ';').  */
1312     error ("Invalid character '%c' in expression.", c);
1313
1314   /* It's a name.  See how long it is.  */
1315   namelen = 0;
1316   for (c = tokstart[namelen];
1317        (c == '_' || c == '$' || (c >= '0' && c <= '9')
1318         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
1319        c = tokstart[++namelen])
1320     ;
1321
1322   /* The token "if" terminates the expression and is NOT
1323      removed from the input stream.  */
1324   if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1325     {
1326       return 0;
1327     }
1328
1329   lexptr += namelen;
1330
1331   /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
1332      and $$digits (equivalent to $<-digits> if you could type that).
1333      Make token type LAST, and put the number (the digits) in yylval.  */
1334
1335   tryname:
1336   if (*tokstart == '$')
1337     {
1338       register int negate = 0;
1339       c = 1;
1340       /* Double dollar means negate the number and add -1 as well.
1341          Thus $$ alone means -1.  */
1342       if (namelen >= 2 && tokstart[1] == '$')
1343         {
1344           negate = 1;
1345           c = 2;
1346         }
1347       if (c == namelen)
1348         {
1349           /* Just dollars (one or two) */
1350           yylval.lval = - negate;
1351           return LAST;
1352         }
1353       /* Is the rest of the token digits?  */
1354       for (; c < namelen; c++)
1355         if (!(tokstart[c] >= '0' && tokstart[c] <= '9'))
1356           break;
1357       if (c == namelen)
1358         {
1359           yylval.lval = atoi (tokstart + 1 + negate);
1360           if (negate)
1361             yylval.lval = - yylval.lval;
1362           return LAST;
1363         }
1364     }
1365
1366   /* Handle tokens that refer to machine registers:
1367      $ followed by a register name.  */
1368
1369   if (*tokstart == '$') {
1370     for (c = 0; c < NUM_REGS; c++)
1371       if (namelen - 1 == strlen (reg_names[c])
1372           && !strncmp (tokstart + 1, reg_names[c], namelen - 1))
1373         {
1374           yylval.lval = c;
1375           return REGNAME;
1376         }
1377     for (c = 0; c < num_std_regs; c++)
1378      if (namelen - 1 == strlen (std_regs[c].name)
1379          && !strncmp (tokstart + 1, std_regs[c].name, namelen - 1))
1380        {
1381          yylval.lval = std_regs[c].regnum;
1382          return REGNAME;
1383        }
1384   }
1385   /* Catch specific keywords.  Should be done with a data structure.  */
1386   switch (namelen)
1387     {
1388     case 8:
1389       if (!strncmp (tokstart, "unsigned", 8))
1390         return UNSIGNED;
1391       if (current_language->la_language == language_cplus
1392           && !strncmp (tokstart, "template", 8))
1393         return TEMPLATE;
1394       if (!strncmp (tokstart, "volatile", 8))
1395         return VOLATILE_KEYWORD;
1396       break;
1397     case 6:
1398       if (!strncmp (tokstart, "struct", 6))
1399         return STRUCT;
1400       if (!strncmp (tokstart, "signed", 6))
1401         return SIGNED_KEYWORD;
1402       if (!strncmp (tokstart, "sizeof", 6))
1403         return SIZEOF;
1404       break;
1405     case 5:
1406       if (current_language->la_language == language_cplus
1407           && !strncmp (tokstart, "class", 5))
1408         return CLASS;
1409       if (!strncmp (tokstart, "union", 5))
1410         return UNION;
1411       if (!strncmp (tokstart, "short", 5))
1412         return SHORT;
1413       if (!strncmp (tokstart, "const", 5))
1414         return CONST_KEYWORD;
1415       break;
1416     case 4:
1417       if (!strncmp (tokstart, "enum", 4))
1418         return ENUM;
1419       if (!strncmp (tokstart, "long", 4))
1420         return LONG;
1421       if (current_language->la_language == language_cplus
1422           && !strncmp (tokstart, "this", 4))
1423         {
1424           static const char this_name[] =
1425                                  { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' };
1426
1427           if (lookup_symbol (this_name, expression_context_block,
1428                              VAR_NAMESPACE, 0, NULL))
1429             return THIS;
1430         }
1431       break;
1432     case 3:
1433       if (!strncmp (tokstart, "int", 3))
1434         return INT_KEYWORD;
1435       break;
1436     default:
1437       break;
1438     }
1439
1440   yylval.sval.ptr = tokstart;
1441   yylval.sval.length = namelen;
1442
1443   /* Any other names starting in $ are debugger internal variables.  */
1444
1445   if (*tokstart == '$')
1446     {
1447       yylval.ivar =  lookup_internalvar (copy_name (yylval.sval) + 1);
1448       return VARIABLE;
1449     }
1450
1451   /* Use token-type BLOCKNAME for symbols that happen to be defined as
1452      functions or symtabs.  If this is not so, then ...
1453      Use token-type TYPENAME for symbols that happen to be defined
1454      currently as names of types; NAME for other symbols.
1455      The caller is not constrained to care about the distinction.  */
1456   {
1457     char *tmp = copy_name (yylval.sval);
1458     struct symbol *sym;
1459     int is_a_field_of_this = 0;
1460     int hextype;
1461
1462     sym = lookup_symbol (tmp, expression_context_block,
1463                          VAR_NAMESPACE,
1464                          current_language->la_language == language_cplus
1465                          ? &is_a_field_of_this : NULL,
1466                          NULL);
1467     if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) ||
1468         lookup_partial_symtab (tmp))
1469       {
1470         yylval.ssym.sym = sym;
1471         yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1472         return BLOCKNAME;
1473       }
1474     if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1475         {
1476           yylval.tsym.type = SYMBOL_TYPE (sym);
1477           return TYPENAME;
1478         }
1479     if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0)
1480         return TYPENAME;
1481
1482     /* Input names that aren't symbols but ARE valid hex numbers,
1483        when the input radix permits them, can be names or numbers
1484        depending on the parse.  Note we support radixes > 16 here.  */
1485     if (!sym &&
1486         ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1487          (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1488       {
1489         YYSTYPE newlval;        /* Its value is ignored.  */
1490         hextype = parse_number (tokstart, namelen, 0, &newlval);
1491         if (hextype == INT)
1492           {
1493             yylval.ssym.sym = sym;
1494             yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1495             return NAME_OR_INT;
1496           }
1497       }
1498
1499     /* Any other kind of symbol */
1500     yylval.ssym.sym = sym;
1501     yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1502     return NAME;
1503   }
1504 }
1505
1506 void
1507 yyerror (msg)
1508      char *msg;
1509 {
1510   error (msg ? msg : "Invalid syntax in expression.");
1511 }