gdb/c-exp.y

   1 /* YACC parser for C expressions, for GDB.
   2    Copyright (C) 1986, 1989, 1990, 1991 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 /* Parse a C expression from text in a string,
  21    and return the result as a  struct expression  pointer.
  22    That structure contains arithmetic operations in reverse polish,
  23    with constants represented by operations that are followed by special data.
  24    See expression.h for the details of the format.
  25    What is important here is that it can be built up sequentially
  26    during the process of parsing; the lower levels of the tree always
  27    come first in the result.
  28
  29    Note that malloc's and realloc's in this file are transformed to
  30    xmalloc and xrealloc respectively by the same sed command in the
  31    makefile that remaps any other malloc/realloc inserted by the parser
  32    generator.  Doing this with #defines and trying to control the interaction
  33    with include files (<malloc.h> and <stdlib.h> for example) just became
  34    too messy, particularly when such includes can be inserted at random
  35    times by the parser generator.  */
  36
  37 %{
  38
  39 #include "defs.h"
  40 #include "expression.h"
  41 #include "parser-defs.h"
  42 #include "value.h"
  43 #include "language.h"
  44 #include "c-lang.h"
  45 #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_elt_opcode (OP_LONG);
 639                               write_exp_elt_type (builtin_type_long);
 640                               write_exp_elt_longcst ((LONGEST) SYMBOL_VALUE_ADDRESS (msymbol));
 641                               write_exp_elt_opcode (OP_LONG);
 642                               write_exp_elt_opcode (UNOP_MEMVAL);
 643                               if (msymbol -> type == mst_data ||
 644                                   msymbol -> type == mst_bss)
 645                                 write_exp_elt_type (builtin_type_int);
 646                               else if (msymbol -> type == mst_text)
 647                                 write_exp_elt_type (lookup_function_type (builtin_type_int));
 648                               else
 649                                 write_exp_elt_type (builtin_type_char);
 650                               write_exp_elt_opcode (UNOP_MEMVAL);
 651                             }
 652                           else
 653                             if (!have_full_symbols () && !have_partial_symbols ())
 654                               error ("No symbol table is loaded.  Use the \"file\" command.");
 655                             else
 656                               error ("No symbol \"%s\" in current context.", name);
 657                         }
 658         ;
 659
 660 variable:       name_not_typename
 661                         { struct symbol *sym = $1.sym;
 662
 663                           if (sym)
 664                             {
 665                               if (symbol_read_needs_frame (sym))
 666                                 {
 667                                   if (innermost_block == 0 ||
 668                                       contained_in (block_found,
 669                                                     innermost_block))
 670                                     innermost_block = block_found;
 671                                 }
 672
 673                               write_exp_elt_opcode (OP_VAR_VALUE);
 674                               /* We want to use the selected frame, not
 675                                  another more inner frame which happens to
 676                                  be in the same block.  */
 677                               write_exp_elt_block (NULL);
 678                               write_exp_elt_sym (sym);
 679                               write_exp_elt_opcode (OP_VAR_VALUE);
 680                             }
 681                           else if ($1.is_a_field_of_this)
 682                             {
 683                               /* C++: it hangs off of `this'.  Must
 684                                  not inadvertently convert from a method call
 685                                  to data ref.  */
 686                               if (innermost_block == 0 ||
 687                                   contained_in (block_found, innermost_block))
 688                                 innermost_block = block_found;
 689                               write_exp_elt_opcode (OP_THIS);
 690                               write_exp_elt_opcode (OP_THIS);
 691                               write_exp_elt_opcode (STRUCTOP_PTR);
 692                               write_exp_string ($1.stoken);
 693                               write_exp_elt_opcode (STRUCTOP_PTR);
 694                             }
 695                           else
 696                             {
 697                               struct minimal_symbol *msymbol;
 698                               register char *arg = copy_name ($1.stoken);
 699
 700                               msymbol = lookup_minimal_symbol (arg,
 701                                           (struct objfile *) NULL);
 702                               if (msymbol != NULL)
 703                                 {
 704                                   write_exp_elt_opcode (OP_LONG);
 705                                   write_exp_elt_type (builtin_type_long);
 706                                   write_exp_elt_longcst ((LONGEST) SYMBOL_VALUE_ADDRESS (msymbol));
 707                                   write_exp_elt_opcode (OP_LONG);
 708                                   write_exp_elt_opcode (UNOP_MEMVAL);
 709                                   if (msymbol -> type == mst_data ||
 710                                       msymbol -> type == mst_bss)
 711                                     write_exp_elt_type (builtin_type_int);
 712                                   else if (msymbol -> type == mst_text)
 713                                     write_exp_elt_type (lookup_function_type (builtin_type_int));
 714                                   else
 715                                     write_exp_elt_type (builtin_type_char);
 716                                   write_exp_elt_opcode (UNOP_MEMVAL);
 717                                 }
 718                               else if (!have_full_symbols () && !have_partial_symbols ())
 719                                 error ("No symbol table is loaded.  Use the \"file\" command.");
 720                               else
 721                                 error ("No symbol \"%s\" in current context.",
 722                                        copy_name ($1.stoken));
 723                             }
 724                         }
 725         ;
 726
 727
 728 ptype   :       typebase
 729         /* "const" and "volatile" are curently ignored.  A type qualifier
 730            before the type is currently handled in the typebase rule.
 731            The reason for recognizing these here (shift/reduce conflicts)
 732            might be obsolete now that some pointer to member rules have
 733            been deleted.  */
 734         |       typebase CONST_KEYWORD
 735         |       typebase VOLATILE_KEYWORD
 736         |       typebase abs_decl
 737                 { $$ = follow_types ($1); }
 738         |       typebase CONST_KEYWORD abs_decl
 739                 { $$ = follow_types ($1); }
 740         |       typebase VOLATILE_KEYWORD abs_decl
 741                 { $$ = follow_types ($1); }
 742         ;
 743
 744 abs_decl:       '*'
 745                         { push_type (tp_pointer); $$ = 0; }
 746         |       '*' abs_decl
 747                         { push_type (tp_pointer); $$ = $2; }
 748         |       '&'
 749                         { push_type (tp_reference); $$ = 0; }
 750         |       '&' abs_decl
 751                         { push_type (tp_reference); $$ = $2; }
 752         |       direct_abs_decl
 753         ;
 754
 755 direct_abs_decl: '(' abs_decl ')'
 756                         { $$ = $2; }
 757         |       direct_abs_decl array_mod
 758                         {
 759                           push_type_int ($2);
 760                           push_type (tp_array);
 761                         }
 762         |       array_mod
 763                         {
 764                           push_type_int ($1);
 765                           push_type (tp_array);
 766                           $$ = 0;
 767                         }
 768
 769         |       direct_abs_decl func_mod
 770                         { push_type (tp_function); }
 771         |       func_mod
 772                         { push_type (tp_function); }
 773         ;
 774
 775 array_mod:      '[' ']'
 776                         { $$ = -1; }
 777         |       '[' INT ']'
 778                         { $$ = $2.val; }
 779         ;
 780
 781 func_mod:       '(' ')'
 782                         { $$ = 0; }
 783         |       '(' nonempty_typelist ')'
 784                         { free ((PTR)$2); $$ = 0; }
 785         ;
 786
 787 /* We used to try to recognize more pointer to member types here, but
 788    that didn't work (shift/reduce conflicts meant that these rules never
 789    got executed).  The problem is that
 790      int (foo::bar::baz::bizzle)
 791    is a function type but
 792      int (foo::bar::baz::bizzle::*)
 793    is a pointer to member type.  Stroustrup loses again!  */
 794
 795 type    :       ptype
 796         |       typebase COLONCOLON '*'
 797                         { $$ = lookup_member_type (builtin_type_int, $1); }
 798         ;
 799
 800 typebase  /* Implements (approximately): (type-qualifier)* type-specifier */
 801         :       TYPENAME
 802                         { $$ = $1.type; }
 803         |       INT_KEYWORD
 804                         { $$ = builtin_type_int; }
 805         |       LONG
 806                         { $$ = builtin_type_long; }
 807         |       SHORT
 808                         { $$ = builtin_type_short; }
 809         |       LONG INT_KEYWORD
 810                         { $$ = builtin_type_long; }
 811         |       UNSIGNED LONG INT_KEYWORD
 812                         { $$ = builtin_type_unsigned_long; }
 813         |       LONG LONG
 814                         { $$ = builtin_type_long_long; }
 815         |       LONG LONG INT_KEYWORD
 816                         { $$ = builtin_type_long_long; }
 817         |       UNSIGNED LONG LONG
 818                         { $$ = builtin_type_unsigned_long_long; }
 819         |       UNSIGNED LONG LONG INT_KEYWORD
 820                         { $$ = builtin_type_unsigned_long_long; }
 821         |       SHORT INT_KEYWORD
 822                         { $$ = builtin_type_short; }
 823         |       UNSIGNED SHORT INT_KEYWORD
 824                         { $$ = builtin_type_unsigned_short; }
 825         |       STRUCT name
 826                         { $$ = lookup_struct (copy_name ($2),
 827                                               expression_context_block); }
 828         |       CLASS name
 829                         { $$ = lookup_struct (copy_name ($2),
 830                                               expression_context_block); }
 831         |       UNION name
 832                         { $$ = lookup_union (copy_name ($2),
 833                                              expression_context_block); }
 834         |       ENUM name
 835                         { $$ = lookup_enum (copy_name ($2),
 836                                             expression_context_block); }
 837         |       UNSIGNED typename
 838                         { $$ = lookup_unsigned_typename (TYPE_NAME($2.type)); }
 839         |       UNSIGNED
 840                         { $$ = builtin_type_unsigned_int; }
 841         |       SIGNED_KEYWORD typename
 842                         { $$ = lookup_signed_typename (TYPE_NAME($2.type)); }
 843         |       SIGNED_KEYWORD
 844                         { $$ = builtin_type_int; }
 845         |       TEMPLATE name '<' type '>'
 846                         { $$ = lookup_template_type(copy_name($2), $4,
 847                                                     expression_context_block);
 848                         }
 849         /* "const" and "volatile" are curently ignored.  A type qualifier
 850            after the type is handled in the ptype rule.  I think these could
 851            be too.  */
 852         |       CONST_KEYWORD typebase { $$ = $2; }
 853         |       VOLATILE_KEYWORD typebase { $$ = $2; }
 854         ;
 855
 856 typename:       TYPENAME
 857         |       INT_KEYWORD
 858                 {
 859                   $$.stoken.ptr = "int";
 860                   $$.stoken.length = 3;
 861                   $$.type = builtin_type_int;
 862                 }
 863         |       LONG
 864                 {
 865                   $$.stoken.ptr = "long";
 866                   $$.stoken.length = 4;
 867                   $$.type = builtin_type_long;
 868                 }
 869         |       SHORT
 870                 {
 871                   $$.stoken.ptr = "short";
 872                   $$.stoken.length = 5;
 873                   $$.type = builtin_type_short;
 874                 }
 875         ;
 876
 877 nonempty_typelist
 878         :       type
 879                 { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
 880                   $<ivec>$[0] = 1;      /* Number of types in vector */
 881                   $$[1] = $1;
 882                 }
 883         |       nonempty_typelist ',' type
 884                 { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
 885                   $$ = (struct type **) realloc ((char *) $1, len);
 886                   $$[$<ivec>$[0]] = $3;
 887                 }
 888         ;
 889
 890 name    :       NAME { $$ = $1.stoken; }
 891         |       BLOCKNAME { $$ = $1.stoken; }
 892         |       TYPENAME { $$ = $1.stoken; }
 893         |       NAME_OR_INT  { $$ = $1.stoken; }
 894         ;
 895
 896 name_not_typename :     NAME
 897         |       BLOCKNAME
 898 /* These would be useful if name_not_typename was useful, but it is just
 899    a fake for "variable", so these cause reduce/reduce conflicts because
 900    the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
 901    =exp) or just an exp.  If name_not_typename was ever used in an lvalue
 902    context where only a name could occur, this might be useful.
 903         |       NAME_OR_INT
 904  */
 905         ;
 906
 907 %%
 908
 909 /* Take care of parsing a number (anything that starts with a digit).
 910    Set yylval and return the token type; update lexptr.
 911    LEN is the number of characters in it.  */
 912
 913 /*** Needs some error checking for the float case ***/
 914
 915 static int
 916 parse_number (p, len, parsed_float, putithere)
 917      register char *p;
 918      register int len;
 919      int parsed_float;
 920      YYSTYPE *putithere;
 921 {
 922   register LONGEST n = 0;
 923   register LONGEST prevn = 0;
 924   register int i = 0;
 925   register int c;
 926   register int base = input_radix;
 927   int unsigned_p = 0;
 928   int long_p = 0;
 929   unsigned LONGEST high_bit;
 930   struct type *signed_type;
 931   struct type *unsigned_type;
 932
 933   if (parsed_float)
 934     {
 935       /* It's a float since it contains a point or an exponent.  */
 936       putithere->dval = atof (p);
 937       return FLOAT;
 938     }
 939
 940   /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
 941   if (p[0] == '0')
 942     switch (p[1])
 943       {
 944       case 'x':
 945       case 'X':
 946         if (len >= 3)
 947           {
 948             p += 2;
 949             base = 16;
 950             len -= 2;
 951           }
 952         break;
 953
 954       case 't':
 955       case 'T':
 956       case 'd':
 957       case 'D':
 958         if (len >= 3)
 959           {
 960             p += 2;
 961             base = 10;
 962             len -= 2;
 963           }
 964         break;
 965
 966       default:
 967         base = 8;
 968         break;
 969       }
 970
 971   while (len-- > 0)
 972     {
 973       c = *p++;
 974       if (c >= 'A' && c <= 'Z')
 975         c += 'a' - 'A';
 976       if (c != 'l' && c != 'u')
 977         n *= base;
 978       if (c >= '0' && c <= '9')
 979         n += i = c - '0';
 980       else
 981         {
 982           if (base > 10 && c >= 'a' && c <= 'f')
 983             n += i = c - 'a' + 10;
 984           else if (len == 0 && c == 'l')
 985             long_p = 1;
 986           else if (len == 0 && c == 'u')
 987             unsigned_p = 1;
 988           else
 989             return ERROR;       /* Char not a digit */
 990         }
 991       if (i >= base)
 992         return ERROR;           /* Invalid digit in this base */
 993
 994       /* Portably test for overflow (only works for nonzero values, so make
 995          a second check for zero).  */
 996       if((prevn >= n) && n != 0)
 997          unsigned_p=1;          /* Try something unsigned */
 998       /* If range checking enabled, portably test for unsigned overflow.  */
 999       if(RANGE_CHECK && n!=0)
1000       {
1001          if((unsigned_p && (unsigned)prevn >= (unsigned)n))
1002             range_error("Overflow on numeric constant.");
1003       }
1004       prevn=n;
1005     }
1006
1007      /* If the number is too big to be an int, or it's got an l suffix
1008         then it's a long.  Work out if this has to be a long by
1009         shifting right and and seeing if anything remains, and the
1010         target int size is different to the target long size.
1011
1012         In the expression below, we could have tested
1013                 (n >> TARGET_INT_BIT)
1014         to see if it was zero,
1015         but too many compilers warn about that, when ints and longs
1016         are the same size.  So we shift it twice, with fewer bits
1017         each time, for the same result.  */
1018
1019     if (   (TARGET_INT_BIT != TARGET_LONG_BIT
1020             && ((n >> 2) >> (TARGET_INT_BIT-2)))   /* Avoid shift warning */
1021         || long_p)
1022       {
1023          high_bit = ((unsigned LONGEST)1) << (TARGET_LONG_BIT-1);
1024          unsigned_type = builtin_type_unsigned_long;
1025          signed_type = builtin_type_long;
1026       }
1027     else
1028       {
1029          high_bit = ((unsigned LONGEST)1) << (TARGET_INT_BIT-1);
1030          unsigned_type = builtin_type_unsigned_int;
1031          signed_type = builtin_type_int;
1032       }
1033
1034    putithere->typed_val.val = n;
1035
1036    /* If the high bit of the worked out type is set then this number
1037       has to be unsigned. */
1038
1039    if (unsigned_p || (n & high_bit))
1040      {
1041         putithere->typed_val.type = unsigned_type;
1042      }
1043    else
1044      {
1045         putithere->typed_val.type = signed_type;
1046      }
1047
1048    return INT;
1049 }
1050
1051 struct token
1052 {
1053   char *operator;
1054   int token;
1055   enum exp_opcode opcode;
1056 };
1057
1058 static const struct token tokentab3[] =
1059   {
1060     {">>=", ASSIGN_MODIFY, BINOP_RSH},
1061     {"<<=", ASSIGN_MODIFY, BINOP_LSH}
1062   };
1063
1064 static const struct token tokentab2[] =
1065   {
1066     {"+=", ASSIGN_MODIFY, BINOP_ADD},
1067     {"-=", ASSIGN_MODIFY, BINOP_SUB},
1068     {"*=", ASSIGN_MODIFY, BINOP_MUL},
1069     {"/=", ASSIGN_MODIFY, BINOP_DIV},
1070     {"%=", ASSIGN_MODIFY, BINOP_REM},
1071     {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
1072     {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
1073     {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
1074     {"++", INCREMENT, BINOP_END},
1075     {"--", DECREMENT, BINOP_END},
1076     {"->", ARROW, BINOP_END},
1077     {"&&", ANDAND, BINOP_END},
1078     {"||", OROR, BINOP_END},
1079     {"::", COLONCOLON, BINOP_END},
1080     {"<<", LSH, BINOP_END},
1081     {">>", RSH, BINOP_END},
1082     {"==", EQUAL, BINOP_END},
1083     {"!=", NOTEQUAL, BINOP_END},
1084     {"<=", LEQ, BINOP_END},
1085     {">=", GEQ, BINOP_END}
1086   };
1087
1088 /* Read one token, getting characters through lexptr.  */
1089
1090 static int
1091 yylex ()
1092 {
1093   int c;
1094   int namelen;
1095   unsigned int i;
1096   char *tokstart;
1097   char *tokptr;
1098   int tempbufindex;
1099   static char *tempbuf;
1100   static int tempbufsize;
1101
1102  retry:
1103
1104   tokstart = lexptr;
1105   /* See if it is a special token of length 3.  */
1106   for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1107     if (STREQN (tokstart, tokentab3[i].operator, 3))
1108       {
1109         lexptr += 3;
1110         yylval.opcode = tokentab3[i].opcode;
1111         return tokentab3[i].token;
1112       }
1113
1114   /* See if it is a special token of length 2.  */
1115   for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1116     if (STREQN (tokstart, tokentab2[i].operator, 2))
1117       {
1118         lexptr += 2;
1119         yylval.opcode = tokentab2[i].opcode;
1120         return tokentab2[i].token;
1121       }
1122
1123   switch (c = *tokstart)
1124     {
1125     case 0:
1126       return 0;
1127
1128     case ' ':
1129     case '\t':
1130     case '\n':
1131       lexptr++;
1132       goto retry;
1133
1134     case '\'':
1135       /* We either have a character constant ('0' or '\177' for example)
1136          or we have a quoted symbol reference ('foo(int,int)' in C++
1137          for example). */
1138       lexptr++;
1139       c = *lexptr++;
1140       if (c == '\\')
1141         c = parse_escape (&lexptr);
1142
1143       yylval.typed_val.val = c;
1144       yylval.typed_val.type = builtin_type_char;
1145
1146       c = *lexptr++;
1147       if (c != '\'')
1148         {
1149           namelen = skip_quoted (tokstart) - tokstart;
1150           if (namelen > 2)
1151             {
1152               lexptr = tokstart + namelen;
1153               if (lexptr[-1] != '\'')
1154                 error ("Unmatched single quote.");
1155               namelen -= 2;
1156               tokstart++;
1157               goto tryname;
1158             }
1159           error ("Invalid character constant.");
1160         }
1161       return INT;
1162
1163     case '(':
1164       paren_depth++;
1165       lexptr++;
1166       return c;
1167
1168     case ')':
1169       if (paren_depth == 0)
1170         return 0;
1171       paren_depth--;
1172       lexptr++;
1173       return c;
1174
1175     case ',':
1176       if (comma_terminates && paren_depth == 0)
1177         return 0;
1178       lexptr++;
1179       return c;
1180
1181     case '.':
1182       /* Might be a floating point number.  */
1183       if (lexptr[1] < '0' || lexptr[1] > '9')
1184         goto symbol;            /* Nope, must be a symbol. */
1185       /* FALL THRU into number case.  */
1186
1187     case '0':
1188     case '1':
1189     case '2':
1190     case '3':
1191     case '4':
1192     case '5':
1193     case '6':
1194     case '7':
1195     case '8':
1196     case '9':
1197       {
1198         /* It's a number.  */
1199         int got_dot = 0, got_e = 0, toktype;
1200         register char *p = tokstart;
1201         int hex = input_radix > 10;
1202
1203         if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1204           {
1205             p += 2;
1206             hex = 1;
1207           }
1208         else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1209           {
1210             p += 2;
1211             hex = 0;
1212           }
1213
1214         for (;; ++p)
1215           {
1216             /* This test includes !hex because 'e' is a valid hex digit
1217                and thus does not indicate a floating point number when
1218                the radix is hex.  */
1219             if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1220               got_dot = got_e = 1;
1221             /* This test does not include !hex, because a '.' always indicates
1222                a decimal floating point number regardless of the radix.  */
1223             else if (!got_dot && *p == '.')
1224               got_dot = 1;
1225             else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1226                      && (*p == '-' || *p == '+'))
1227               /* This is the sign of the exponent, not the end of the
1228                  number.  */
1229               continue;
1230             /* We will take any letters or digits.  parse_number will
1231                complain if past the radix, or if L or U are not final.  */
1232             else if ((*p < '0' || *p > '9')
1233                      && ((*p < 'a' || *p > 'z')
1234                                   && (*p < 'A' || *p > 'Z')))
1235               break;
1236           }
1237         toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1238         if (toktype == ERROR)
1239           {
1240             char *err_copy = (char *) alloca (p - tokstart + 1);
1241
1242             memcpy (err_copy, tokstart, p - tokstart);
1243             err_copy[p - tokstart] = 0;
1244             error ("Invalid number \"%s\".", err_copy);
1245           }
1246         lexptr = p;
1247         return toktype;
1248       }
1249
1250     case '+':
1251     case '-':
1252     case '*':
1253     case '/':
1254     case '%':
1255     case '|':
1256     case '&':
1257     case '^':
1258     case '~':
1259     case '!':
1260     case '@':
1261     case '<':
1262     case '>':
1263     case '[':
1264     case ']':
1265     case '?':
1266     case ':':
1267     case '=':
1268     case '{':
1269     case '}':
1270     symbol:
1271       lexptr++;
1272       return c;
1273
1274     case '"':
1275
1276       /* Build the gdb internal form of the input string in tempbuf,
1277          translating any standard C escape forms seen.  Note that the
1278          buffer is null byte terminated *only* for the convenience of
1279          debugging gdb itself and printing the buffer contents when
1280          the buffer contains no embedded nulls.  Gdb does not depend
1281          upon the buffer being null byte terminated, it uses the length
1282          string instead.  This allows gdb to handle C strings (as well
1283          as strings in other languages) with embedded null bytes */
1284
1285       tokptr = ++tokstart;
1286       tempbufindex = 0;
1287
1288       do {
1289         /* Grow the static temp buffer if necessary, including allocating
1290            the first one on demand. */
1291         if (tempbufindex + 1 >= tempbufsize)
1292           {
1293             tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1294           }
1295         switch (*tokptr)
1296           {
1297           case '\0':
1298           case '"':
1299             /* Do nothing, loop will terminate. */
1300             break;
1301           case '\\':
1302             tokptr++;
1303             c = parse_escape (&tokptr);
1304             if (c == -1)
1305               {
1306                 continue;
1307               }
1308             tempbuf[tempbufindex++] = c;
1309             break;
1310           default:
1311             tempbuf[tempbufindex++] = *tokptr++;
1312             break;
1313           }
1314       } while ((*tokptr != '"') && (*tokptr != '\0'));
1315       if (*tokptr++ != '"')
1316         {
1317           error ("Unterminated string in expression.");
1318         }
1319       tempbuf[tempbufindex] = '\0';     /* See note above */
1320       yylval.sval.ptr = tempbuf;
1321       yylval.sval.length = tempbufindex;
1322       lexptr = tokptr;
1323       return (STRING);
1324     }
1325
1326   if (!(c == '_' || c == '$'
1327         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1328     /* We must have come across a bad character (e.g. ';').  */
1329     error ("Invalid character '%c' in expression.", c);
1330
1331   /* It's a name.  See how long it is.  */
1332   namelen = 0;
1333   for (c = tokstart[namelen];
1334        (c == '_' || c == '$' || (c >= '0' && c <= '9')
1335         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
1336        c = tokstart[++namelen])
1337     ;
1338
1339   /* The token "if" terminates the expression and is NOT
1340      removed from the input stream.  */
1341   if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1342     {
1343       return 0;
1344     }
1345
1346   lexptr += namelen;
1347
1348   /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
1349      and $$digits (equivalent to $<-digits> if you could type that).
1350      Make token type LAST, and put the number (the digits) in yylval.  */
1351
1352   tryname:
1353   if (*tokstart == '$')
1354     {
1355       register int negate = 0;
1356       c = 1;
1357       /* Double dollar means negate the number and add -1 as well.
1358          Thus $$ alone means -1.  */
1359       if (namelen >= 2 && tokstart[1] == '$')
1360         {
1361           negate = 1;
1362           c = 2;
1363         }
1364       if (c == namelen)
1365         {
1366           /* Just dollars (one or two) */
1367           yylval.lval = - negate;
1368           return LAST;
1369         }
1370       /* Is the rest of the token digits?  */
1371       for (; c < namelen; c++)
1372         if (!(tokstart[c] >= '0' && tokstart[c] <= '9'))
1373           break;
1374       if (c == namelen)
1375         {
1376           yylval.lval = atoi (tokstart + 1 + negate);
1377           if (negate)
1378             yylval.lval = - yylval.lval;
1379           return LAST;
1380         }
1381     }
1382
1383   /* Handle tokens that refer to machine registers:
1384      $ followed by a register name.  */
1385
1386   if (*tokstart == '$') {
1387     for (c = 0; c < NUM_REGS; c++)
1388       if (namelen - 1 == strlen (reg_names[c])
1389           && STREQN (tokstart + 1, reg_names[c], namelen - 1))
1390         {
1391           yylval.lval = c;
1392           return REGNAME;
1393         }
1394     for (c = 0; c < num_std_regs; c++)
1395      if (namelen - 1 == strlen (std_regs[c].name)
1396          && STREQN (tokstart + 1, std_regs[c].name, namelen - 1))
1397        {
1398          yylval.lval = std_regs[c].regnum;
1399          return REGNAME;
1400        }
1401   }
1402   /* Catch specific keywords.  Should be done with a data structure.  */
1403   switch (namelen)
1404     {
1405     case 8:
1406       if (STREQN (tokstart, "unsigned", 8))
1407         return UNSIGNED;
1408       if (current_language->la_language == language_cplus
1409           && STREQN (tokstart, "template", 8))
1410         return TEMPLATE;
1411       if (STREQN (tokstart, "volatile", 8))
1412         return VOLATILE_KEYWORD;
1413       break;
1414     case 6:
1415       if (STREQN (tokstart, "struct", 6))
1416         return STRUCT;
1417       if (STREQN (tokstart, "signed", 6))
1418         return SIGNED_KEYWORD;
1419       if (STREQN (tokstart, "sizeof", 6))
1420         return SIZEOF;
1421       break;
1422     case 5:
1423       if (current_language->la_language == language_cplus
1424           && STREQN (tokstart, "class", 5))
1425         return CLASS;
1426       if (STREQN (tokstart, "union", 5))
1427         return UNION;
1428       if (STREQN (tokstart, "short", 5))
1429         return SHORT;
1430       if (STREQN (tokstart, "const", 5))
1431         return CONST_KEYWORD;
1432       break;
1433     case 4:
1434       if (STREQN (tokstart, "enum", 4))
1435         return ENUM;
1436       if (STREQN (tokstart, "long", 4))
1437         return LONG;
1438       if (current_language->la_language == language_cplus
1439           && STREQN (tokstart, "this", 4))
1440         {
1441           static const char this_name[] =
1442                                  { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' };
1443
1444           if (lookup_symbol (this_name, expression_context_block,
1445                              VAR_NAMESPACE, (int *) NULL,
1446                              (struct symtab **) NULL))
1447             return THIS;
1448         }
1449       break;
1450     case 3:
1451       if (STREQN (tokstart, "int", 3))
1452         return INT_KEYWORD;
1453       break;
1454     default:
1455       break;
1456     }
1457
1458   yylval.sval.ptr = tokstart;
1459   yylval.sval.length = namelen;
1460
1461   /* Any other names starting in $ are debugger internal variables.  */
1462
1463   if (*tokstart == '$')
1464     {
1465       yylval.ivar =  lookup_internalvar (copy_name (yylval.sval) + 1);
1466       return VARIABLE;
1467     }
1468
1469   /* Use token-type BLOCKNAME for symbols that happen to be defined as
1470      functions or symtabs.  If this is not so, then ...
1471      Use token-type TYPENAME for symbols that happen to be defined
1472      currently as names of types; NAME for other symbols.
1473      The caller is not constrained to care about the distinction.  */
1474   {
1475     char *tmp = copy_name (yylval.sval);
1476     struct symbol *sym;
1477     int is_a_field_of_this = 0;
1478     int hextype;
1479
1480     sym = lookup_symbol (tmp, expression_context_block,
1481                          VAR_NAMESPACE,
1482                          current_language->la_language == language_cplus
1483                          ? &is_a_field_of_this : (int *) NULL,
1484                          (struct symtab **) NULL);
1485     if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) ||
1486         lookup_partial_symtab (tmp))
1487       {
1488         yylval.ssym.sym = sym;
1489         yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1490         return BLOCKNAME;
1491       }
1492     if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1493         {
1494           char *p;
1495           char *namestart;
1496           struct symbol *best_sym;
1497
1498           /* Look ahead to detect nested types.  This probably should be
1499              done in the grammar, but trying seemed to introduce a lot
1500              of shift/reduce and reduce/reduce conflicts.  It's possible
1501              that it could be done, though.  Or perhaps a non-grammar, but
1502              less ad hoc, approach would work well.  */
1503
1504           /* Since we do not currently have any way of distinguishing
1505              a nested type from a non-nested one (the stabs don't tell
1506              us whether a type is nested), we just ignore the
1507              containing type.  */
1508
1509           p = lexptr;
1510           best_sym = sym;
1511           while (1)
1512             {
1513               /* Skip whitespace.  */
1514               while (*p == ' ' || *p == '\t' || *p == '\n')
1515                 ++p;
1516               if (*p == ':' && p[1] == ':')
1517                 {
1518                   /* Skip the `::'.  */
1519                   p += 2;
1520                   /* Skip whitespace.  */
1521                   while (*p == ' ' || *p == '\t' || *p == '\n')
1522                     ++p;
1523                   namestart = p;
1524                   while (*p == '_' || *p == '$' || (*p >= '0' && *p <= '9')
1525                          || (*p >= 'a' && *p <= 'z')
1526                          || (*p >= 'A' && *p <= 'Z'))
1527                     ++p;
1528                   if (p != namestart)
1529                     {
1530                       struct symbol *cur_sym;
1531                       /* As big as the whole rest of the expression, which is
1532                          at least big enough.  */
1533                       char *tmp = alloca (strlen (namestart));
1534
1535                       memcpy (tmp, namestart, p - namestart);
1536                       tmp[p - namestart] = '\0';
1537                       cur_sym = lookup_symbol (tmp, expression_context_block,
1538                                                VAR_NAMESPACE, (int *) NULL,
1539                                                (struct symtab **) NULL);
1540                       if (cur_sym)
1541                         {
1542                           if (SYMBOL_CLASS (cur_sym) == LOC_TYPEDEF)
1543                             {
1544                               best_sym = cur_sym;
1545                               lexptr = p;
1546                             }
1547                           else
1548                             break;
1549                         }
1550                       else
1551                         break;
1552                     }
1553                   else
1554                     break;
1555                 }
1556               else
1557                 break;
1558             }
1559
1560           yylval.tsym.type = SYMBOL_TYPE (best_sym);
1561           return TYPENAME;
1562         }
1563     if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0)
1564         return TYPENAME;
1565
1566     /* Input names that aren't symbols but ARE valid hex numbers,
1567        when the input radix permits them, can be names or numbers
1568        depending on the parse.  Note we support radixes > 16 here.  */
1569     if (!sym &&
1570         ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1571          (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1572       {
1573         YYSTYPE newlval;        /* Its value is ignored.  */
1574         hextype = parse_number (tokstart, namelen, 0, &newlval);
1575         if (hextype == INT)
1576           {
1577             yylval.ssym.sym = sym;
1578             yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1579             return NAME_OR_INT;
1580           }
1581       }
1582
1583     /* Any other kind of symbol */
1584     yylval.ssym.sym = sym;
1585     yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1586     return NAME;
1587   }
1588 }
1589
1590 void
1591 yyerror (msg)
1592      char *msg;
1593 {
1594   error (msg ? msg : "Invalid syntax in expression.");
1595 }