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