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         ;
 835
 836 typename:       TYPENAME
 837         |       INT_KEYWORD
 838                 {
 839                   $$.stoken.ptr = "int";
 840                   $$.stoken.length = 3;
 841                   $$.type = builtin_type_int;
 842                 }
 843         |       LONG
 844                 {
 845                   $$.stoken.ptr = "long";
 846                   $$.stoken.length = 4;
 847                   $$.type = builtin_type_long;
 848                 }
 849         |       SHORT
 850                 {
 851                   $$.stoken.ptr = "short";
 852                   $$.stoken.length = 5;
 853                   $$.type = builtin_type_short;
 854                 }
 855         ;
 856
 857 nonempty_typelist
 858         :       type
 859                 { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
 860                   $<ivec>$[0] = 1;      /* Number of types in vector */
 861                   $$[1] = $1;
 862                 }
 863         |       nonempty_typelist ',' type
 864                 { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
 865                   $$ = (struct type **) realloc ((char *) $1, len);
 866                   $$[$<ivec>$[0]] = $3;
 867                 }
 868         ;
 869
 870 name    :       NAME { $$ = $1.stoken; }
 871         |       BLOCKNAME { $$ = $1.stoken; }
 872         |       TYPENAME { $$ = $1.stoken; }
 873         |       NAME_OR_INT  { $$ = $1.stoken; }
 874         ;
 875
 876 name_not_typename :     NAME
 877         |       BLOCKNAME
 878 /* These would be useful if name_not_typename was useful, but it is just
 879    a fake for "variable", so these cause reduce/reduce conflicts because
 880    the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
 881    =exp) or just an exp.  If name_not_typename was ever used in an lvalue
 882    context where only a name could occur, this might be useful.
 883         |       NAME_OR_INT
 884  */
 885         ;
 886
 887 %%
 888
 889 /* Take care of parsing a number (anything that starts with a digit).
 890    Set yylval and return the token type; update lexptr.
 891    LEN is the number of characters in it.  */
 892
 893 /*** Needs some error checking for the float case ***/
 894
 895 static int
 896 parse_number (p, len, parsed_float, putithere)
 897      register char *p;
 898      register int len;
 899      int parsed_float;
 900      YYSTYPE *putithere;
 901 {
 902   /* FIXME: Shouldn't these be unsigned?  We don't deal with negative values
 903      here, and we do kind of silly things like cast to unsigned.  */
 904   register LONGEST n = 0;
 905   register LONGEST prevn = 0;
 906
 907   register int i = 0;
 908   register int c;
 909   register int base = input_radix;
 910   int unsigned_p = 0;
 911
 912   /* Number of "L" suffixes encountered.  */
 913   int long_p = 0;
 914
 915   /* We have found a "L" or "U" suffix.  */
 916   int found_suffix = 0;
 917
 918   unsigned LONGEST high_bit;
 919   struct type *signed_type;
 920   struct type *unsigned_type;
 921
 922   if (parsed_float)
 923     {
 924       /* It's a float since it contains a point or an exponent.  */
 925       putithere->dval = atof (p);
 926       return FLOAT;
 927     }
 928
 929   /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
 930   if (p[0] == '0')
 931     switch (p[1])
 932       {
 933       case 'x':
 934       case 'X':
 935         if (len >= 3)
 936           {
 937             p += 2;
 938             base = 16;
 939             len -= 2;
 940           }
 941         break;
 942
 943       case 't':
 944       case 'T':
 945       case 'd':
 946       case 'D':
 947         if (len >= 3)
 948           {
 949             p += 2;
 950             base = 10;
 951             len -= 2;
 952           }
 953         break;
 954
 955       default:
 956         base = 8;
 957         break;
 958       }
 959
 960   while (len-- > 0)
 961     {
 962       c = *p++;
 963       if (c >= 'A' && c <= 'Z')
 964         c += 'a' - 'A';
 965       if (c != 'l' && c != 'u')
 966         n *= base;
 967       if (c >= '0' && c <= '9')
 968         {
 969           if (found_suffix)
 970             return ERROR;
 971           n += i = c - '0';
 972         }
 973       else
 974         {
 975           if (base > 10 && c >= 'a' && c <= 'f')
 976             {
 977               if (found_suffix)
 978                 return ERROR;
 979               n += i = c - 'a' + 10;
 980             }
 981           else if (c == 'l')
 982             {
 983               ++long_p;
 984               found_suffix = 1;
 985             }
 986           else if (c == 'u')
 987             {
 988               unsigned_p = 1;
 989               found_suffix = 1;
 990             }
 991           else
 992             return ERROR;       /* Char not a digit */
 993         }
 994       if (i >= base)
 995         return ERROR;           /* Invalid digit in this base */
 996
 997       /* Portably test for overflow (only works for nonzero values, so make
 998          a second check for zero).  FIXME: Can't we just make n and prevn
 999          unsigned and avoid this?  */
1000       if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
1001         unsigned_p = 1;         /* Try something unsigned */
1002
1003       /* Portably test for unsigned overflow.
1004          FIXME: This check is wrong; for example it doesn't find overflow
1005          on 0x123456789 when LONGEST is 32 bits.  */
1006       if (c != 'l' && c != 'u' && n != 0)
1007         {
1008           if ((unsigned_p && (unsigned LONGEST) prevn >= (unsigned LONGEST) n))
1009             error ("Numeric constant too large.");
1010         }
1011       prevn = n;
1012     }
1013
1014   /* An integer constant is an int, a long, or a long long.  An L
1015      suffix forces it to be long; an LL suffix forces it to be long
1016      long.  If not forced to a larger size, it gets the first type of
1017      the above that it fits in.  To figure out whether it fits, we
1018      shift it right and see whether anything remains.  Note that we
1019      can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
1020      operation, because many compilers will warn about such a shift
1021      (which always produces a zero result).  Sometimes TARGET_INT_BIT
1022      or TARGET_LONG_BIT will be that big, sometimes not.  To deal with
1023      the case where it is we just always shift the value more than
1024      once, with fewer bits each time.  */
1025
1026   if (long_p == 0
1027       && (((unsigned LONGEST)n >> 2) >> (TARGET_INT_BIT - 2)) == 0)
1028     {
1029       high_bit = ((unsigned LONGEST)1) << (TARGET_INT_BIT-1);
1030
1031       /* A large decimal (not hex or octal) constant (between INT_MAX
1032          and UINT_MAX) is a long or unsigned long, according to ANSI,
1033          never an unsigned int, but this code treats it as unsigned
1034          int.  This probably should be fixed.  GCC gives a warning on
1035          such constants.  */
1036
1037       unsigned_type = builtin_type_unsigned_int;
1038       signed_type = builtin_type_int;
1039     }
1040   else if (long_p <= 1
1041            && (((unsigned LONGEST)n >> 2) >> (TARGET_LONG_BIT - 2)) == 0)
1042     {
1043       high_bit = ((unsigned LONGEST)1) << (TARGET_LONG_BIT-1);
1044       unsigned_type = builtin_type_unsigned_long;
1045       signed_type = builtin_type_long;
1046     }
1047   else
1048     {
1049       high_bit = ((unsigned LONGEST)1) << (TARGET_LONG_LONG_BIT - 1);
1050       unsigned_type = builtin_type_unsigned_long_long;
1051       signed_type = builtin_type_long_long;
1052     }
1053
1054    putithere->typed_val.val = n;
1055
1056    /* If the high bit of the worked out type is set then this number
1057       has to be unsigned. */
1058
1059    if (unsigned_p || (n & high_bit))
1060      {
1061        putithere->typed_val.type = unsigned_type;
1062      }
1063    else
1064      {
1065        putithere->typed_val.type = signed_type;
1066      }
1067
1068    return INT;
1069 }
1070
1071 struct token
1072 {
1073   char *operator;
1074   int token;
1075   enum exp_opcode opcode;
1076 };
1077
1078 static const struct token tokentab3[] =
1079   {
1080     {">>=", ASSIGN_MODIFY, BINOP_RSH},
1081     {"<<=", ASSIGN_MODIFY, BINOP_LSH}
1082   };
1083
1084 static const struct token tokentab2[] =
1085   {
1086     {"+=", ASSIGN_MODIFY, BINOP_ADD},
1087     {"-=", ASSIGN_MODIFY, BINOP_SUB},
1088     {"*=", ASSIGN_MODIFY, BINOP_MUL},
1089     {"/=", ASSIGN_MODIFY, BINOP_DIV},
1090     {"%=", ASSIGN_MODIFY, BINOP_REM},
1091     {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
1092     {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
1093     {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
1094     {"++", INCREMENT, BINOP_END},
1095     {"--", DECREMENT, BINOP_END},
1096     {"->", ARROW, BINOP_END},
1097     {"&&", ANDAND, BINOP_END},
1098     {"||", OROR, BINOP_END},
1099     {"::", COLONCOLON, BINOP_END},
1100     {"<<", LSH, BINOP_END},
1101     {">>", RSH, BINOP_END},
1102     {"==", EQUAL, BINOP_END},
1103     {"!=", NOTEQUAL, BINOP_END},
1104     {"<=", LEQ, BINOP_END},
1105     {">=", GEQ, BINOP_END}
1106   };
1107
1108 /* Read one token, getting characters through lexptr.  */
1109
1110 static int
1111 yylex ()
1112 {
1113   int c;
1114   int namelen;
1115   unsigned int i;
1116   char *tokstart;
1117   char *tokptr;
1118   int tempbufindex;
1119   static char *tempbuf;
1120   static int tempbufsize;
1121
1122  retry:
1123
1124   tokstart = lexptr;
1125   /* See if it is a special token of length 3.  */
1126   for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1127     if (STREQN (tokstart, tokentab3[i].operator, 3))
1128       {
1129         lexptr += 3;
1130         yylval.opcode = tokentab3[i].opcode;
1131         return tokentab3[i].token;
1132       }
1133
1134   /* See if it is a special token of length 2.  */
1135   for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1136     if (STREQN (tokstart, tokentab2[i].operator, 2))
1137       {
1138         lexptr += 2;
1139         yylval.opcode = tokentab2[i].opcode;
1140         return tokentab2[i].token;
1141       }
1142
1143   switch (c = *tokstart)
1144     {
1145     case 0:
1146       return 0;
1147
1148     case ' ':
1149     case '\t':
1150     case '\n':
1151       lexptr++;
1152       goto retry;
1153
1154     case '\'':
1155       /* We either have a character constant ('0' or '\177' for example)
1156          or we have a quoted symbol reference ('foo(int,int)' in C++
1157          for example). */
1158       lexptr++;
1159       c = *lexptr++;
1160       if (c == '\\')
1161         c = parse_escape (&lexptr);
1162
1163       yylval.typed_val.val = c;
1164       yylval.typed_val.type = builtin_type_char;
1165
1166       c = *lexptr++;
1167       if (c != '\'')
1168         {
1169           namelen = skip_quoted (tokstart) - tokstart;
1170           if (namelen > 2)
1171             {
1172               lexptr = tokstart + namelen;
1173               if (lexptr[-1] != '\'')
1174                 error ("Unmatched single quote.");
1175               namelen -= 2;
1176               tokstart++;
1177               goto tryname;
1178             }
1179           error ("Invalid character constant.");
1180         }
1181       return INT;
1182
1183     case '(':
1184       paren_depth++;
1185       lexptr++;
1186       return c;
1187
1188     case ')':
1189       if (paren_depth == 0)
1190         return 0;
1191       paren_depth--;
1192       lexptr++;
1193       return c;
1194
1195     case ',':
1196       if (comma_terminates && paren_depth == 0)
1197         return 0;
1198       lexptr++;
1199       return c;
1200
1201     case '.':
1202       /* Might be a floating point number.  */
1203       if (lexptr[1] < '0' || lexptr[1] > '9')
1204         goto symbol;            /* Nope, must be a symbol. */
1205       /* FALL THRU into number case.  */
1206
1207     case '0':
1208     case '1':
1209     case '2':
1210     case '3':
1211     case '4':
1212     case '5':
1213     case '6':
1214     case '7':
1215     case '8':
1216     case '9':
1217       {
1218         /* It's a number.  */
1219         int got_dot = 0, got_e = 0, toktype;
1220         register char *p = tokstart;
1221         int hex = input_radix > 10;
1222
1223         if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1224           {
1225             p += 2;
1226             hex = 1;
1227           }
1228         else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1229           {
1230             p += 2;
1231             hex = 0;
1232           }
1233
1234         for (;; ++p)
1235           {
1236             /* This test includes !hex because 'e' is a valid hex digit
1237                and thus does not indicate a floating point number when
1238                the radix is hex.  */
1239             if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1240               got_dot = got_e = 1;
1241             /* This test does not include !hex, because a '.' always indicates
1242                a decimal floating point number regardless of the radix.  */
1243             else if (!got_dot && *p == '.')
1244               got_dot = 1;
1245             else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1246                      && (*p == '-' || *p == '+'))
1247               /* This is the sign of the exponent, not the end of the
1248                  number.  */
1249               continue;
1250             /* We will take any letters or digits.  parse_number will
1251                complain if past the radix, or if L or U are not final.  */
1252             else if ((*p < '0' || *p > '9')
1253                      && ((*p < 'a' || *p > 'z')
1254                                   && (*p < 'A' || *p > 'Z')))
1255               break;
1256           }
1257         toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1258         if (toktype == ERROR)
1259           {
1260             char *err_copy = (char *) alloca (p - tokstart + 1);
1261
1262             memcpy (err_copy, tokstart, p - tokstart);
1263             err_copy[p - tokstart] = 0;
1264             error ("Invalid number \"%s\".", err_copy);
1265           }
1266         lexptr = p;
1267         return toktype;
1268       }
1269
1270     case '+':
1271     case '-':
1272     case '*':
1273     case '/':
1274     case '%':
1275     case '|':
1276     case '&':
1277     case '^':
1278     case '~':
1279     case '!':
1280     case '@':
1281     case '<':
1282     case '>':
1283     case '[':
1284     case ']':
1285     case '?':
1286     case ':':
1287     case '=':
1288     case '{':
1289     case '}':
1290     symbol:
1291       lexptr++;
1292       return c;
1293
1294     case '"':
1295
1296       /* Build the gdb internal form of the input string in tempbuf,
1297          translating any standard C escape forms seen.  Note that the
1298          buffer is null byte terminated *only* for the convenience of
1299          debugging gdb itself and printing the buffer contents when
1300          the buffer contains no embedded nulls.  Gdb does not depend
1301          upon the buffer being null byte terminated, it uses the length
1302          string instead.  This allows gdb to handle C strings (as well
1303          as strings in other languages) with embedded null bytes */
1304
1305       tokptr = ++tokstart;
1306       tempbufindex = 0;
1307
1308       do {
1309         /* Grow the static temp buffer if necessary, including allocating
1310            the first one on demand. */
1311         if (tempbufindex + 1 >= tempbufsize)
1312           {
1313             tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1314           }
1315         switch (*tokptr)
1316           {
1317           case '\0':
1318           case '"':
1319             /* Do nothing, loop will terminate. */
1320             break;
1321           case '\\':
1322             tokptr++;
1323             c = parse_escape (&tokptr);
1324             if (c == -1)
1325               {
1326                 continue;
1327               }
1328             tempbuf[tempbufindex++] = c;
1329             break;
1330           default:
1331             tempbuf[tempbufindex++] = *tokptr++;
1332             break;
1333           }
1334       } while ((*tokptr != '"') && (*tokptr != '\0'));
1335       if (*tokptr++ != '"')
1336         {
1337           error ("Unterminated string in expression.");
1338         }
1339       tempbuf[tempbufindex] = '\0';     /* See note above */
1340       yylval.sval.ptr = tempbuf;
1341       yylval.sval.length = tempbufindex;
1342       lexptr = tokptr;
1343       return (STRING);
1344     }
1345
1346   if (!(c == '_' || c == '$'
1347         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1348     /* We must have come across a bad character (e.g. ';').  */
1349     error ("Invalid character '%c' in expression.", c);
1350
1351   /* It's a name.  See how long it is.  */
1352   namelen = 0;
1353   for (c = tokstart[namelen];
1354        (c == '_' || c == '$' || (c >= '0' && c <= '9')
1355         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
1356        c = tokstart[++namelen])
1357     ;
1358
1359   /* The token "if" terminates the expression and is NOT
1360      removed from the input stream.  */
1361   if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1362     {
1363       return 0;
1364     }
1365
1366   lexptr += namelen;
1367
1368   /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
1369      and $$digits (equivalent to $<-digits> if you could type that).
1370      Make token type LAST, and put the number (the digits) in yylval.  */
1371
1372   tryname:
1373   if (*tokstart == '$')
1374     {
1375       register int negate = 0;
1376       c = 1;
1377       /* Double dollar means negate the number and add -1 as well.
1378          Thus $$ alone means -1.  */
1379       if (namelen >= 2 && tokstart[1] == '$')
1380         {
1381           negate = 1;
1382           c = 2;
1383         }
1384       if (c == namelen)
1385         {
1386           /* Just dollars (one or two) */
1387           yylval.lval = - negate;
1388           return LAST;
1389         }
1390       /* Is the rest of the token digits?  */
1391       for (; c < namelen; c++)
1392         if (!(tokstart[c] >= '0' && tokstart[c] <= '9'))
1393           break;
1394       if (c == namelen)
1395         {
1396           yylval.lval = atoi (tokstart + 1 + negate);
1397           if (negate)
1398             yylval.lval = - yylval.lval;
1399           return LAST;
1400         }
1401     }
1402
1403   /* Handle tokens that refer to machine registers:
1404      $ followed by a register name.  */
1405
1406   if (*tokstart == '$') {
1407     for (c = 0; c < NUM_REGS; c++)
1408       if (namelen - 1 == strlen (reg_names[c])
1409           && STREQN (tokstart + 1, reg_names[c], namelen - 1))
1410         {
1411           yylval.lval = c;
1412           return REGNAME;
1413         }
1414     for (c = 0; c < num_std_regs; c++)
1415      if (namelen - 1 == strlen (std_regs[c].name)
1416          && STREQN (tokstart + 1, std_regs[c].name, namelen - 1))
1417        {
1418          yylval.lval = std_regs[c].regnum;
1419          return REGNAME;
1420        }
1421   }
1422   /* Catch specific keywords.  Should be done with a data structure.  */
1423   switch (namelen)
1424     {
1425     case 8:
1426       if (STREQN (tokstart, "unsigned", 8))
1427         return UNSIGNED;
1428       if (current_language->la_language == language_cplus
1429           && STREQN (tokstart, "template", 8))
1430         return TEMPLATE;
1431       if (STREQN (tokstart, "volatile", 8))
1432         return VOLATILE_KEYWORD;
1433       break;
1434     case 6:
1435       if (STREQN (tokstart, "struct", 6))
1436         return STRUCT;
1437       if (STREQN (tokstart, "signed", 6))
1438         return SIGNED_KEYWORD;
1439       if (STREQN (tokstart, "sizeof", 6))
1440         return SIZEOF;
1441       break;
1442     case 5:
1443       if (current_language->la_language == language_cplus
1444           && STREQN (tokstart, "class", 5))
1445         return CLASS;
1446       if (STREQN (tokstart, "union", 5))
1447         return UNION;
1448       if (STREQN (tokstart, "short", 5))
1449         return SHORT;
1450       if (STREQN (tokstart, "const", 5))
1451         return CONST_KEYWORD;
1452       break;
1453     case 4:
1454       if (STREQN (tokstart, "enum", 4))
1455         return ENUM;
1456       if (STREQN (tokstart, "long", 4))
1457         return LONG;
1458       if (current_language->la_language == language_cplus
1459           && STREQN (tokstart, "this", 4))
1460         {
1461           static const char this_name[] =
1462                                  { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' };
1463
1464           if (lookup_symbol (this_name, expression_context_block,
1465                              VAR_NAMESPACE, (int *) NULL,
1466                              (struct symtab **) NULL))
1467             return THIS;
1468         }
1469       break;
1470     case 3:
1471       if (STREQN (tokstart, "int", 3))
1472         return INT_KEYWORD;
1473       break;
1474     default:
1475       break;
1476     }
1477
1478   yylval.sval.ptr = tokstart;
1479   yylval.sval.length = namelen;
1480
1481   /* Any other names starting in $ are debugger internal variables.  */
1482
1483   if (*tokstart == '$')
1484     {
1485       yylval.ivar =  lookup_internalvar (copy_name (yylval.sval) + 1);
1486       return VARIABLE;
1487     }
1488
1489   /* Use token-type BLOCKNAME for symbols that happen to be defined as
1490      functions or symtabs.  If this is not so, then ...
1491      Use token-type TYPENAME for symbols that happen to be defined
1492      currently as names of types; NAME for other symbols.
1493      The caller is not constrained to care about the distinction.  */
1494   {
1495     char *tmp = copy_name (yylval.sval);
1496     struct symbol *sym;
1497     int is_a_field_of_this = 0;
1498     int hextype;
1499
1500     sym = lookup_symbol (tmp, expression_context_block,
1501                          VAR_NAMESPACE,
1502                          current_language->la_language == language_cplus
1503                          ? &is_a_field_of_this : (int *) NULL,
1504                          (struct symtab **) NULL);
1505     /* Call lookup_symtab, not lookup_partial_symtab, in case there are
1506        no psymtabs (coff, xcoff, or some future change to blow away the
1507        psymtabs once once symbols are read).  */
1508     if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) ||
1509         lookup_symtab (tmp))
1510       {
1511         yylval.ssym.sym = sym;
1512         yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1513         return BLOCKNAME;
1514       }
1515     if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1516         {
1517 #if 0
1518           /* In "A::x", if x is a member function of A and there happens
1519              to be a type (nested or not, since the stabs don't make that
1520              distinction) named x, then this code incorrectly thinks we
1521              are dealing with nested types rather than a member function.  */
1522
1523           char *p;
1524           char *namestart;
1525           struct symbol *best_sym;
1526
1527           /* Look ahead to detect nested types.  This probably should be
1528              done in the grammar, but trying seemed to introduce a lot
1529              of shift/reduce and reduce/reduce conflicts.  It's possible
1530              that it could be done, though.  Or perhaps a non-grammar, but
1531              less ad hoc, approach would work well.  */
1532
1533           /* Since we do not currently have any way of distinguishing
1534              a nested type from a non-nested one (the stabs don't tell
1535              us whether a type is nested), we just ignore the
1536              containing type.  */
1537
1538           p = lexptr;
1539           best_sym = sym;
1540           while (1)
1541             {
1542               /* Skip whitespace.  */
1543               while (*p == ' ' || *p == '\t' || *p == '\n')
1544                 ++p;
1545               if (*p == ':' && p[1] == ':')
1546                 {
1547                   /* Skip the `::'.  */
1548                   p += 2;
1549                   /* Skip whitespace.  */
1550                   while (*p == ' ' || *p == '\t' || *p == '\n')
1551                     ++p;
1552                   namestart = p;
1553                   while (*p == '_' || *p == '$' || (*p >= '0' && *p <= '9')
1554                          || (*p >= 'a' && *p <= 'z')
1555                          || (*p >= 'A' && *p <= 'Z'))
1556                     ++p;
1557                   if (p != namestart)
1558                     {
1559                       struct symbol *cur_sym;
1560                       /* As big as the whole rest of the expression, which is
1561                          at least big enough.  */
1562                       char *tmp = alloca (strlen (namestart));
1563
1564                       memcpy (tmp, namestart, p - namestart);
1565                       tmp[p - namestart] = '\0';
1566                       cur_sym = lookup_symbol (tmp, expression_context_block,
1567                                                VAR_NAMESPACE, (int *) NULL,
1568                                                (struct symtab **) NULL);
1569                       if (cur_sym)
1570                         {
1571                           if (SYMBOL_CLASS (cur_sym) == LOC_TYPEDEF)
1572                             {
1573                               best_sym = cur_sym;
1574                               lexptr = p;
1575                             }
1576                           else
1577                             break;
1578                         }
1579                       else
1580                         break;
1581                     }
1582                   else
1583                     break;
1584                 }
1585               else
1586                 break;
1587             }
1588
1589           yylval.tsym.type = SYMBOL_TYPE (best_sym);
1590 #else /* not 0 */
1591           yylval.tsym.type = SYMBOL_TYPE (sym);
1592 #endif /* not 0 */
1593           return TYPENAME;
1594         }
1595     if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0)
1596         return TYPENAME;
1597
1598     /* Input names that aren't symbols but ARE valid hex numbers,
1599        when the input radix permits them, can be names or numbers
1600        depending on the parse.  Note we support radixes > 16 here.  */
1601     if (!sym &&
1602         ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1603          (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1604       {
1605         YYSTYPE newlval;        /* Its value is ignored.  */
1606         hextype = parse_number (tokstart, namelen, 0, &newlval);
1607         if (hextype == INT)
1608           {
1609             yylval.ssym.sym = sym;
1610             yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1611             return NAME_OR_INT;
1612           }
1613       }
1614
1615     /* Any other kind of symbol */
1616     yylval.ssym.sym = sym;
1617     yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1618     return NAME;
1619   }
1620 }
1621
1622 void
1623 yyerror (msg)
1624      char *msg;
1625 {
1626   error (msg ? msg : "Invalid syntax in expression.");
1627 }