gdb/c-exp.y

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