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     unsigned LONGEST ulval;
 106     struct {
 107       LONGEST val;
 108       struct type *type;
 109     } typed_val;
 110     double dval;
 111     struct symbol *sym;
 112     struct type *tval;
 113     struct stoken sval;
 114     struct ttype tsym;
 115     struct symtoken ssym;
 116     int voidval;
 117     struct block *bval;
 118     enum exp_opcode opcode;
 119     struct internalvar *ivar;
 120
 121     struct type **tvec;
 122     int *ivec;
 123   }
 124
 125 %{
 126 /* YYSTYPE gets defined by %union */
 127 static int
 128 parse_number PARAMS ((char *, int, int, YYSTYPE *));
 129 %}
 130
 131 %type <voidval> exp exp1 type_exp start variable qualified_name
 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 arglist :
 311         ;
 312
 313 arglist :       exp
 314                         { arglist_len = 1; }
 315         ;
 316
 317 arglist :       arglist ',' exp   %prec ABOVE_COMMA
 318                         { arglist_len++; }
 319         ;
 320
 321 exp     :       '{'
 322                         /* This is to save the value of arglist_len
 323                            being accumulated by an outer function call.  */
 324                         { start_arglist (); }
 325                 arglist '}'     %prec ARROW
 326                         { write_exp_elt_opcode (OP_ARRAY);
 327                           write_exp_elt_longcst ((LONGEST) 0);
 328                           write_exp_elt_longcst ((LONGEST) end_arglist () - 1);
 329                           write_exp_elt_opcode (OP_ARRAY); }
 330         ;
 331
 332 exp     :       '{' type '}' exp  %prec UNARY
 333                         { write_exp_elt_opcode (UNOP_MEMVAL);
 334                           write_exp_elt_type ($2);
 335                           write_exp_elt_opcode (UNOP_MEMVAL); }
 336         ;
 337
 338 exp     :       '(' type ')' exp  %prec UNARY
 339                         { write_exp_elt_opcode (UNOP_CAST);
 340                           write_exp_elt_type ($2);
 341                           write_exp_elt_opcode (UNOP_CAST); }
 342         ;
 343
 344 exp     :       '(' exp1 ')'
 345                         { }
 346         ;
 347
 348 /* Binary operators in order of decreasing precedence.  */
 349
 350 exp     :       exp '@' exp
 351                         { write_exp_elt_opcode (BINOP_REPEAT); }
 352         ;
 353
 354 exp     :       exp '*' exp
 355                         { write_exp_elt_opcode (BINOP_MUL); }
 356         ;
 357
 358 exp     :       exp '/' exp
 359                         { write_exp_elt_opcode (BINOP_DIV); }
 360         ;
 361
 362 exp     :       exp '%' exp
 363                         { write_exp_elt_opcode (BINOP_REM); }
 364         ;
 365
 366 exp     :       exp '+' exp
 367                         { write_exp_elt_opcode (BINOP_ADD); }
 368         ;
 369
 370 exp     :       exp '-' exp
 371                         { write_exp_elt_opcode (BINOP_SUB); }
 372         ;
 373
 374 exp     :       exp LSH exp
 375                         { write_exp_elt_opcode (BINOP_LSH); }
 376         ;
 377
 378 exp     :       exp RSH exp
 379                         { write_exp_elt_opcode (BINOP_RSH); }
 380         ;
 381
 382 exp     :       exp EQUAL exp
 383                         { write_exp_elt_opcode (BINOP_EQUAL); }
 384         ;
 385
 386 exp     :       exp NOTEQUAL exp
 387                         { write_exp_elt_opcode (BINOP_NOTEQUAL); }
 388         ;
 389
 390 exp     :       exp LEQ exp
 391                         { write_exp_elt_opcode (BINOP_LEQ); }
 392         ;
 393
 394 exp     :       exp GEQ exp
 395                         { write_exp_elt_opcode (BINOP_GEQ); }
 396         ;
 397
 398 exp     :       exp '<' exp
 399                         { write_exp_elt_opcode (BINOP_LESS); }
 400         ;
 401
 402 exp     :       exp '>' exp
 403                         { write_exp_elt_opcode (BINOP_GTR); }
 404         ;
 405
 406 exp     :       exp '&' exp
 407                         { write_exp_elt_opcode (BINOP_BITWISE_AND); }
 408         ;
 409
 410 exp     :       exp '^' exp
 411                         { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
 412         ;
 413
 414 exp     :       exp '|' exp
 415                         { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
 416         ;
 417
 418 exp     :       exp ANDAND exp
 419                         { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
 420         ;
 421
 422 exp     :       exp OROR exp
 423                         { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
 424         ;
 425
 426 exp     :       exp '?' exp ':' exp     %prec '?'
 427                         { write_exp_elt_opcode (TERNOP_COND); }
 428         ;
 429
 430 exp     :       exp '=' exp
 431                         { write_exp_elt_opcode (BINOP_ASSIGN); }
 432         ;
 433
 434 exp     :       exp ASSIGN_MODIFY exp
 435                         { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
 436                           write_exp_elt_opcode ($2);
 437                           write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
 438         ;
 439
 440 exp     :       INT
 441                         { write_exp_elt_opcode (OP_LONG);
 442                           write_exp_elt_type ($1.type);
 443                           write_exp_elt_longcst ((LONGEST)($1.val));
 444                           write_exp_elt_opcode (OP_LONG); }
 445         ;
 446
 447 exp     :       NAME_OR_INT
 448                         { YYSTYPE val;
 449                           parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
 450                           write_exp_elt_opcode (OP_LONG);
 451                           write_exp_elt_type (val.typed_val.type);
 452                           write_exp_elt_longcst ((LONGEST)val.typed_val.val);
 453                           write_exp_elt_opcode (OP_LONG);
 454                         }
 455         ;
 456
 457
 458 exp     :       FLOAT
 459                         { write_exp_elt_opcode (OP_DOUBLE);
 460                           write_exp_elt_type (builtin_type_double);
 461                           write_exp_elt_dblcst ($1);
 462                           write_exp_elt_opcode (OP_DOUBLE); }
 463         ;
 464
 465 exp     :       variable
 466         ;
 467
 468 exp     :       LAST
 469                         { write_exp_elt_opcode (OP_LAST);
 470                           write_exp_elt_longcst ((LONGEST) $1);
 471                           write_exp_elt_opcode (OP_LAST); }
 472         ;
 473
 474 exp     :       REGNAME
 475                         { write_exp_elt_opcode (OP_REGISTER);
 476                           write_exp_elt_longcst ((LONGEST) $1);
 477                           write_exp_elt_opcode (OP_REGISTER); }
 478         ;
 479
 480 exp     :       VARIABLE
 481                         { write_exp_elt_opcode (OP_INTERNALVAR);
 482                           write_exp_elt_intern ($1);
 483                           write_exp_elt_opcode (OP_INTERNALVAR); }
 484         ;
 485
 486 exp     :       SIZEOF '(' type ')'     %prec UNARY
 487                         { write_exp_elt_opcode (OP_LONG);
 488                           write_exp_elt_type (builtin_type_int);
 489                           write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
 490                           write_exp_elt_opcode (OP_LONG); }
 491         ;
 492
 493 exp     :       STRING
 494                         { /* C strings are converted into array constants with
 495                              an explicit null byte added at the end.  Thus
 496                              the array upper bound is the string length.
 497                              There is no such thing in C as a completely empty
 498                              string. */
 499                           char *sp = $1.ptr; int count = $1.length;
 500                           while (count-- > 0)
 501                             {
 502                               write_exp_elt_opcode (OP_LONG);
 503                               write_exp_elt_type (builtin_type_char);
 504                               write_exp_elt_longcst ((LONGEST)(*sp++));
 505                               write_exp_elt_opcode (OP_LONG);
 506                             }
 507                           write_exp_elt_opcode (OP_LONG);
 508                           write_exp_elt_type (builtin_type_char);
 509                           write_exp_elt_longcst ((LONGEST)'\0');
 510                           write_exp_elt_opcode (OP_LONG);
 511                           write_exp_elt_opcode (OP_ARRAY);
 512                           write_exp_elt_longcst ((LONGEST) 0);
 513                           write_exp_elt_longcst ((LONGEST) ($1.length));
 514                           write_exp_elt_opcode (OP_ARRAY); }
 515         ;
 516
 517 /* C++.  */
 518 exp     :       THIS
 519                         { write_exp_elt_opcode (OP_THIS);
 520                           write_exp_elt_opcode (OP_THIS); }
 521         ;
 522
 523 /* end of C++.  */
 524
 525 block   :       BLOCKNAME
 526                         {
 527                           if ($1.sym != 0)
 528                               $$ = SYMBOL_BLOCK_VALUE ($1.sym);
 529                           else
 530                             {
 531                               struct symtab *tem =
 532                                   lookup_symtab (copy_name ($1.stoken));
 533                               if (tem)
 534                                 $$ = BLOCKVECTOR_BLOCK
 535                                          (BLOCKVECTOR (tem), STATIC_BLOCK);
 536                               else
 537                                 error ("No file or function \"%s\".",
 538                                        copy_name ($1.stoken));
 539                             }
 540                         }
 541         ;
 542
 543 block   :       block COLONCOLON name
 544                         { struct symbol *tem
 545                             = lookup_symbol (copy_name ($3), $1,
 546                                              VAR_NAMESPACE, 0, NULL);
 547                           if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
 548                             error ("No function \"%s\" in specified context.",
 549                                    copy_name ($3));
 550                           $$ = SYMBOL_BLOCK_VALUE (tem); }
 551         ;
 552
 553 variable:       block COLONCOLON name
 554                         { struct symbol *sym;
 555                           sym = lookup_symbol (copy_name ($3), $1,
 556                                                VAR_NAMESPACE, 0, NULL);
 557                           if (sym == 0)
 558                             error ("No symbol \"%s\" in specified context.",
 559                                    copy_name ($3));
 560
 561                           write_exp_elt_opcode (OP_VAR_VALUE);
 562                           write_exp_elt_sym (sym);
 563                           write_exp_elt_opcode (OP_VAR_VALUE); }
 564         ;
 565
 566 qualified_name: typebase COLONCOLON name
 567                         {
 568                           struct type *type = $1;
 569                           if (TYPE_CODE (type) != TYPE_CODE_STRUCT
 570                               && TYPE_CODE (type) != TYPE_CODE_UNION)
 571                             error ("`%s' is not defined as an aggregate type.",
 572                                    TYPE_NAME (type));
 573
 574                           write_exp_elt_opcode (OP_SCOPE);
 575                           write_exp_elt_type (type);
 576                           write_exp_string ($3);
 577                           write_exp_elt_opcode (OP_SCOPE);
 578                         }
 579         |       typebase COLONCOLON '~' name
 580                         {
 581                           struct type *type = $1;
 582                           struct stoken tmp_token;
 583                           if (TYPE_CODE (type) != TYPE_CODE_STRUCT
 584                               && TYPE_CODE (type) != TYPE_CODE_UNION)
 585                             error ("`%s' is not defined as an aggregate type.",
 586                                    TYPE_NAME (type));
 587
 588                           if (!STREQ (type_name_no_tag (type), $4.ptr))
 589                             error ("invalid destructor `%s::~%s'",
 590                                    type_name_no_tag (type), $4.ptr);
 591
 592                           tmp_token.ptr = (char*) alloca ($4.length + 2);
 593                           tmp_token.length = $4.length + 1;
 594                           tmp_token.ptr[0] = '~';
 595                           memcpy (tmp_token.ptr+1, $4.ptr, $4.length);
 596                           tmp_token.ptr[tmp_token.length] = 0;
 597                           write_exp_elt_opcode (OP_SCOPE);
 598                           write_exp_elt_type (type);
 599                           write_exp_string (tmp_token);
 600                           write_exp_elt_opcode (OP_SCOPE);
 601                         }
 602         ;
 603
 604 variable:       qualified_name
 605         |       COLONCOLON name
 606                         {
 607                           char *name = copy_name ($2);
 608                           struct symbol *sym;
 609                           struct minimal_symbol *msymbol;
 610
 611                           sym =
 612                             lookup_symbol (name, 0, VAR_NAMESPACE, 0, NULL);
 613                           if (sym)
 614                             {
 615                               write_exp_elt_opcode (OP_VAR_VALUE);
 616                               write_exp_elt_sym (sym);
 617                               write_exp_elt_opcode (OP_VAR_VALUE);
 618                               break;
 619                             }
 620
 621                           msymbol = lookup_minimal_symbol (name,
 622                                       (struct objfile *) NULL);
 623                           if (msymbol != NULL)
 624                             {
 625                               write_exp_elt_opcode (OP_LONG);
 626                               write_exp_elt_type (builtin_type_int);
 627                               write_exp_elt_longcst ((LONGEST) SYMBOL_VALUE_ADDRESS (msymbol));
 628                               write_exp_elt_opcode (OP_LONG);
 629                               write_exp_elt_opcode (UNOP_MEMVAL);
 630                               if (msymbol -> type == mst_data ||
 631                                   msymbol -> type == mst_bss)
 632                                 write_exp_elt_type (builtin_type_int);
 633                               else if (msymbol -> type == mst_text)
 634                                 write_exp_elt_type (lookup_function_type (builtin_type_int));
 635                               else
 636                                 write_exp_elt_type (builtin_type_char);
 637                               write_exp_elt_opcode (UNOP_MEMVAL);
 638                             }
 639                           else
 640                             if (!have_full_symbols () && !have_partial_symbols ())
 641                               error ("No symbol table is loaded.  Use the \"file\" command.");
 642                             else
 643                               error ("No symbol \"%s\" in current context.", name);
 644                         }
 645         ;
 646
 647 variable:       name_not_typename
 648                         { struct symbol *sym = $1.sym;
 649
 650                           if (sym)
 651                             {
 652                               switch (SYMBOL_CLASS (sym))
 653                                 {
 654                                 case LOC_REGISTER:
 655                                 case LOC_ARG:
 656                                 case LOC_REF_ARG:
 657                                 case LOC_REGPARM:
 658                                 case LOC_LOCAL:
 659                                 case LOC_LOCAL_ARG:
 660                                   if (innermost_block == 0 ||
 661                                       contained_in (block_found,
 662                                                     innermost_block))
 663                                     innermost_block = block_found;
 664                                 case LOC_UNDEF:
 665                                 case LOC_CONST:
 666                                 case LOC_STATIC:
 667                                 case LOC_TYPEDEF:
 668                                 case LOC_LABEL:
 669                                 case LOC_BLOCK:
 670                                 case LOC_CONST_BYTES:
 671
 672                                   /* In this case the expression can
 673                                      be evaluated regardless of what
 674                                      frame we are in, so there is no
 675                                      need to check for the
 676                                      innermost_block.  These cases are
 677                                      listed so that gcc -Wall will
 678                                      report types that may not have
 679                                      been considered.  */
 680
 681                                   break;
 682                                 }
 683                               write_exp_elt_opcode (OP_VAR_VALUE);
 684                               write_exp_elt_sym (sym);
 685                               write_exp_elt_opcode (OP_VAR_VALUE);
 686                             }
 687                           else if ($1.is_a_field_of_this)
 688                             {
 689                               /* C++: it hangs off of `this'.  Must
 690                                  not inadvertently convert from a method call
 691                                  to data ref.  */
 692                               if (innermost_block == 0 ||
 693                                   contained_in (block_found, innermost_block))
 694                                 innermost_block = block_found;
 695                               write_exp_elt_opcode (OP_THIS);
 696                               write_exp_elt_opcode (OP_THIS);
 697                               write_exp_elt_opcode (STRUCTOP_PTR);
 698                               write_exp_string ($1.stoken);
 699                               write_exp_elt_opcode (STRUCTOP_PTR);
 700                             }
 701                           else
 702                             {
 703                               struct minimal_symbol *msymbol;
 704                               register char *arg = copy_name ($1.stoken);
 705
 706                               msymbol = lookup_minimal_symbol (arg,
 707                                           (struct objfile *) NULL);
 708                               if (msymbol != NULL)
 709                                 {
 710                                   write_exp_elt_opcode (OP_LONG);
 711                                   write_exp_elt_type (builtin_type_int);
 712                                   write_exp_elt_longcst ((LONGEST) SYMBOL_VALUE_ADDRESS (msymbol));
 713                                   write_exp_elt_opcode (OP_LONG);
 714                                   write_exp_elt_opcode (UNOP_MEMVAL);
 715                                   if (msymbol -> type == mst_data ||
 716                                       msymbol -> type == mst_bss)
 717                                     write_exp_elt_type (builtin_type_int);
 718                                   else if (msymbol -> type == mst_text)
 719                                     write_exp_elt_type (lookup_function_type (builtin_type_int));
 720                                   else
 721                                     write_exp_elt_type (builtin_type_char);
 722                                   write_exp_elt_opcode (UNOP_MEMVAL);
 723                                 }
 724                               else if (!have_full_symbols () && !have_partial_symbols ())
 725                                 error ("No symbol table is loaded.  Use the \"file\" command.");
 726                               else
 727                                 error ("No symbol \"%s\" in current context.",
 728                                        copy_name ($1.stoken));
 729                             }
 730                         }
 731         ;
 732
 733
 734 ptype   :       typebase
 735         |       typebase abs_decl
 736                 {
 737                   /* This is where the interesting stuff happens.  */
 738                   int done = 0;
 739                   int array_size;
 740                   struct type *follow_type = $1;
 741                   struct type *range_type;
 742
 743                   while (!done)
 744                     switch (pop_type ())
 745                       {
 746                       case tp_end:
 747                         done = 1;
 748                         break;
 749                       case tp_pointer:
 750                         follow_type = lookup_pointer_type (follow_type);
 751                         break;
 752                       case tp_reference:
 753                         follow_type = lookup_reference_type (follow_type);
 754                         break;
 755                       case tp_array:
 756                         array_size = pop_type_int ();
 757                         if (array_size != -1)
 758                           {
 759                             range_type =
 760                               create_range_type ((struct type *) NULL,
 761                                                  builtin_type_int, 0,
 762                                                  array_size - 1);
 763                             follow_type =
 764                               create_array_type ((struct type *) NULL,
 765                                                  follow_type, range_type);
 766                           }
 767                         else
 768                           follow_type = lookup_pointer_type (follow_type);
 769                         break;
 770                       case tp_function:
 771                         follow_type = lookup_function_type (follow_type);
 772                         break;
 773                       }
 774                   $$ = follow_type;
 775                 }
 776         ;
 777
 778 abs_decl:       '*'
 779                         { push_type (tp_pointer); $$ = 0; }
 780         |       '*' abs_decl
 781                         { push_type (tp_pointer); $$ = $2; }
 782         |       '&'
 783                         { push_type (tp_reference); $$ = 0; }
 784         |       '&' abs_decl
 785                         { push_type (tp_reference); $$ = $2; }
 786         |       direct_abs_decl
 787         ;
 788
 789 direct_abs_decl: '(' abs_decl ')'
 790                         { $$ = $2; }
 791         |       direct_abs_decl array_mod
 792                         {
 793                           push_type_int ($2);
 794                           push_type (tp_array);
 795                         }
 796         |       array_mod
 797                         {
 798                           push_type_int ($1);
 799                           push_type (tp_array);
 800                           $$ = 0;
 801                         }
 802         |       direct_abs_decl func_mod
 803                         { push_type (tp_function); }
 804         |       func_mod
 805                         { push_type (tp_function); }
 806         ;
 807
 808 array_mod:      '[' ']'
 809                         { $$ = -1; }
 810         |       '[' INT ']'
 811                         { $$ = $2.val; }
 812         ;
 813
 814 func_mod:       '(' ')'
 815                         { $$ = 0; }
 816         |       '(' nonempty_typelist ')'
 817                         { free ((PTR)$2); $$ = 0; }
 818         ;
 819
 820 type    :       ptype
 821         |       typebase COLONCOLON '*'
 822                         { $$ = lookup_member_type (builtin_type_int, $1); }
 823         |       type '(' typebase COLONCOLON '*' ')'
 824                         { $$ = lookup_member_type ($1, $3); }
 825         |       type '(' typebase COLONCOLON '*' ')' '(' ')'
 826                         { $$ = lookup_member_type
 827                             (lookup_function_type ($1), $3); }
 828         |       type '(' typebase COLONCOLON '*' ')' '(' nonempty_typelist ')'
 829                         { $$ = lookup_member_type
 830                             (lookup_function_type ($1), $3);
 831                           free ((PTR)$8); }
 832         ;
 833
 834 typebase  /* Implements (approximately): (type-qualifier)* type-specifier */
 835         :       TYPENAME
 836                         { $$ = $1.type; }
 837         |       INT_KEYWORD
 838                         { $$ = builtin_type_int; }
 839         |       LONG
 840                         { $$ = builtin_type_long; }
 841         |       SHORT
 842                         { $$ = builtin_type_short; }
 843         |       LONG INT_KEYWORD
 844                         { $$ = builtin_type_long; }
 845         |       UNSIGNED LONG INT_KEYWORD
 846                         { $$ = builtin_type_unsigned_long; }
 847         |       LONG LONG
 848                         { $$ = builtin_type_long_long; }
 849         |       LONG LONG INT_KEYWORD
 850                         { $$ = builtin_type_long_long; }
 851         |       UNSIGNED LONG LONG
 852                         { $$ = builtin_type_unsigned_long_long; }
 853         |       UNSIGNED LONG LONG INT_KEYWORD
 854                         { $$ = builtin_type_unsigned_long_long; }
 855         |       SHORT INT_KEYWORD
 856                         { $$ = builtin_type_short; }
 857         |       UNSIGNED SHORT INT_KEYWORD
 858                         { $$ = builtin_type_unsigned_short; }
 859         |       STRUCT name
 860                         { $$ = lookup_struct (copy_name ($2),
 861                                               expression_context_block); }
 862         |       CLASS name
 863                         { $$ = lookup_struct (copy_name ($2),
 864                                               expression_context_block); }
 865         |       UNION name
 866                         { $$ = lookup_union (copy_name ($2),
 867                                              expression_context_block); }
 868         |       ENUM name
 869                         { $$ = lookup_enum (copy_name ($2),
 870                                             expression_context_block); }
 871         |       UNSIGNED typename
 872                         { $$ = lookup_unsigned_typename (TYPE_NAME($2.type)); }
 873         |       UNSIGNED
 874                         { $$ = builtin_type_unsigned_int; }
 875         |       SIGNED_KEYWORD typename
 876                         { $$ = lookup_signed_typename (TYPE_NAME($2.type)); }
 877         |       SIGNED_KEYWORD
 878                         { $$ = builtin_type_int; }
 879         |       TEMPLATE name '<' type '>'
 880                         { $$ = lookup_template_type(copy_name($2), $4,
 881                                                     expression_context_block);
 882                         }
 883         /* "const" and "volatile" are curently ignored. */
 884         |       CONST_KEYWORD typebase { $$ = $2; }
 885         |       VOLATILE_KEYWORD typebase { $$ = $2; }
 886         ;
 887
 888 typename:       TYPENAME
 889         |       INT_KEYWORD
 890                 {
 891                   $$.stoken.ptr = "int";
 892                   $$.stoken.length = 3;
 893                   $$.type = builtin_type_int;
 894                 }
 895         |       LONG
 896                 {
 897                   $$.stoken.ptr = "long";
 898                   $$.stoken.length = 4;
 899                   $$.type = builtin_type_long;
 900                 }
 901         |       SHORT
 902                 {
 903                   $$.stoken.ptr = "short";
 904                   $$.stoken.length = 5;
 905                   $$.type = builtin_type_short;
 906                 }
 907         ;
 908
 909 nonempty_typelist
 910         :       type
 911                 { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
 912                   $<ivec>$[0] = 1;      /* Number of types in vector */
 913                   $$[1] = $1;
 914                 }
 915         |       nonempty_typelist ',' type
 916                 { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
 917                   $$ = (struct type **) realloc ((char *) $1, len);
 918                   $$[$<ivec>$[0]] = $3;
 919                 }
 920         ;
 921
 922 name    :       NAME { $$ = $1.stoken; }
 923         |       BLOCKNAME { $$ = $1.stoken; }
 924         |       TYPENAME { $$ = $1.stoken; }
 925         |       NAME_OR_INT  { $$ = $1.stoken; }
 926         ;
 927
 928 name_not_typename :     NAME
 929         |       BLOCKNAME
 930 /* These would be useful if name_not_typename was useful, but it is just
 931    a fake for "variable", so these cause reduce/reduce conflicts because
 932    the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
 933    =exp) or just an exp.  If name_not_typename was ever used in an lvalue
 934    context where only a name could occur, this might be useful.
 935         |       NAME_OR_INT
 936  */
 937         ;
 938
 939 %%
 940
 941 /* Take care of parsing a number (anything that starts with a digit).
 942    Set yylval and return the token type; update lexptr.
 943    LEN is the number of characters in it.  */
 944
 945 /*** Needs some error checking for the float case ***/
 946
 947 static int
 948 parse_number (p, len, parsed_float, putithere)
 949      register char *p;
 950      register int len;
 951      int parsed_float;
 952      YYSTYPE *putithere;
 953 {
 954   register LONGEST n = 0;
 955   register LONGEST prevn = 0;
 956   register int i;
 957   register int c;
 958   register int base = input_radix;
 959   int unsigned_p = 0;
 960   int long_p = 0;
 961   LONGEST high_bit;
 962   struct type *signed_type;
 963   struct type *unsigned_type;
 964
 965   if (parsed_float)
 966     {
 967       /* It's a float since it contains a point or an exponent.  */
 968       putithere->dval = atof (p);
 969       return FLOAT;
 970     }
 971
 972   /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
 973   if (p[0] == '0')
 974     switch (p[1])
 975       {
 976       case 'x':
 977       case 'X':
 978         if (len >= 3)
 979           {
 980             p += 2;
 981             base = 16;
 982             len -= 2;
 983           }
 984         break;
 985
 986       case 't':
 987       case 'T':
 988       case 'd':
 989       case 'D':
 990         if (len >= 3)
 991           {
 992             p += 2;
 993             base = 10;
 994             len -= 2;
 995           }
 996         break;
 997
 998       default:
 999         base = 8;
1000         break;
1001       }
1002
1003   while (len-- > 0)
1004     {
1005       c = *p++;
1006       if (c >= 'A' && c <= 'Z')
1007         c += 'a' - 'A';
1008       if (c != 'l' && c != 'u')
1009         n *= base;
1010       if (c >= '0' && c <= '9')
1011         n += i = c - '0';
1012       else
1013         {
1014           if (base > 10 && c >= 'a' && c <= 'f')
1015             n += i = c - 'a' + 10;
1016           else if (len == 0 && c == 'l')
1017             long_p = 1;
1018           else if (len == 0 && c == 'u')
1019             unsigned_p = 1;
1020           else
1021             return ERROR;       /* Char not a digit */
1022         }
1023       if (i >= base)
1024         return ERROR;           /* Invalid digit in this base */
1025
1026       /* Portably test for overflow (only works for nonzero values, so make
1027          a second check for zero).  */
1028       if((prevn >= n) && n != 0)
1029          unsigned_p=1;          /* Try something unsigned */
1030       /* If range checking enabled, portably test for unsigned overflow.  */
1031       if(RANGE_CHECK && n!=0)
1032       {
1033          if((unsigned_p && (unsigned)prevn >= (unsigned)n))
1034             range_error("Overflow on numeric constant.");
1035       }
1036       prevn=n;
1037     }
1038
1039      /* If the number is too big to be an int, or it's got an l suffix
1040         then it's a long.  Work out if this has to be a long by
1041         shifting right and and seeing if anything remains, and the
1042         target int size is different to the target long size. */
1043
1044     if ((TARGET_INT_BIT != TARGET_LONG_BIT && (n >> TARGET_INT_BIT)) || long_p)
1045       {
1046          high_bit = ((LONGEST)1) << (TARGET_LONG_BIT-1);
1047          unsigned_type = builtin_type_unsigned_long;
1048          signed_type = builtin_type_long;
1049       }
1050     else
1051       {
1052          high_bit = ((LONGEST)1) << (TARGET_INT_BIT-1);
1053          unsigned_type = builtin_type_unsigned_int;
1054          signed_type = builtin_type_int;
1055       }
1056
1057    putithere->typed_val.val = n;
1058
1059    /* If the high bit of the worked out type is set then this number
1060       has to be unsigned. */
1061
1062    if (unsigned_p || (n & high_bit))
1063      {
1064         putithere->typed_val.type = unsigned_type;
1065      }
1066    else
1067      {
1068         putithere->typed_val.type = signed_type;
1069      }
1070
1071    return INT;
1072 }
1073
1074 struct token
1075 {
1076   char *operator;
1077   int token;
1078   enum exp_opcode opcode;
1079 };
1080
1081 static const struct token tokentab3[] =
1082   {
1083     {">>=", ASSIGN_MODIFY, BINOP_RSH},
1084     {"<<=", ASSIGN_MODIFY, BINOP_LSH}
1085   };
1086
1087 static const struct token tokentab2[] =
1088   {
1089     {"+=", ASSIGN_MODIFY, BINOP_ADD},
1090     {"-=", ASSIGN_MODIFY, BINOP_SUB},
1091     {"*=", ASSIGN_MODIFY, BINOP_MUL},
1092     {"/=", ASSIGN_MODIFY, BINOP_DIV},
1093     {"%=", ASSIGN_MODIFY, BINOP_REM},
1094     {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
1095     {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
1096     {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
1097     {"++", INCREMENT, BINOP_END},
1098     {"--", DECREMENT, BINOP_END},
1099     {"->", ARROW, BINOP_END},
1100     {"&&", ANDAND, BINOP_END},
1101     {"||", OROR, BINOP_END},
1102     {"::", COLONCOLON, BINOP_END},
1103     {"<<", LSH, BINOP_END},
1104     {">>", RSH, BINOP_END},
1105     {"==", EQUAL, BINOP_END},
1106     {"!=", NOTEQUAL, BINOP_END},
1107     {"<=", LEQ, BINOP_END},
1108     {">=", GEQ, BINOP_END}
1109   };
1110
1111 /* Read one token, getting characters through lexptr.  */
1112
1113 static int
1114 yylex ()
1115 {
1116   int c;
1117   int namelen;
1118   unsigned int i;
1119   char *tokstart;
1120   char *tokptr;
1121   int tempbufindex;
1122   static char *tempbuf;
1123   static int tempbufsize;
1124
1125  retry:
1126
1127   tokstart = lexptr;
1128   /* See if it is a special token of length 3.  */
1129   for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1130     if (STREQN (tokstart, tokentab3[i].operator, 3))
1131       {
1132         lexptr += 3;
1133         yylval.opcode = tokentab3[i].opcode;
1134         return tokentab3[i].token;
1135       }
1136
1137   /* See if it is a special token of length 2.  */
1138   for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1139     if (STREQN (tokstart, tokentab2[i].operator, 2))
1140       {
1141         lexptr += 2;
1142         yylval.opcode = tokentab2[i].opcode;
1143         return tokentab2[i].token;
1144       }
1145
1146   switch (c = *tokstart)
1147     {
1148     case 0:
1149       return 0;
1150
1151     case ' ':
1152     case '\t':
1153     case '\n':
1154       lexptr++;
1155       goto retry;
1156
1157     case '\'':
1158       /* We either have a character constant ('0' or '\177' for example)
1159          or we have a quoted symbol reference ('foo(int,int)' in C++
1160          for example). */
1161       lexptr++;
1162       c = *lexptr++;
1163       if (c == '\\')
1164         c = parse_escape (&lexptr);
1165
1166       yylval.typed_val.val = c;
1167       yylval.typed_val.type = builtin_type_char;
1168
1169       c = *lexptr++;
1170       if (c != '\'')
1171         {
1172           namelen = skip_quoted (tokstart) - tokstart;
1173           if (namelen > 2)
1174             {
1175               lexptr = tokstart + namelen;
1176               namelen -= 2;
1177               tokstart++;
1178               goto tryname;
1179             }
1180           error ("Invalid character constant.");
1181         }
1182       return INT;
1183
1184     case '(':
1185       paren_depth++;
1186       lexptr++;
1187       return c;
1188
1189     case ')':
1190       if (paren_depth == 0)
1191         return 0;
1192       paren_depth--;
1193       lexptr++;
1194       return c;
1195
1196     case ',':
1197       if (comma_terminates && paren_depth == 0)
1198         return 0;
1199       lexptr++;
1200       return c;
1201
1202     case '.':
1203       /* Might be a floating point number.  */
1204       if (lexptr[1] < '0' || lexptr[1] > '9')
1205         goto symbol;            /* Nope, must be a symbol. */
1206       /* FALL THRU into number case.  */
1207
1208     case '0':
1209     case '1':
1210     case '2':
1211     case '3':
1212     case '4':
1213     case '5':
1214     case '6':
1215     case '7':
1216     case '8':
1217     case '9':
1218       {
1219         /* It's a number.  */
1220         int got_dot = 0, got_e = 0, toktype;
1221         register char *p = tokstart;
1222         int hex = input_radix > 10;
1223
1224         if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1225           {
1226             p += 2;
1227             hex = 1;
1228           }
1229         else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1230           {
1231             p += 2;
1232             hex = 0;
1233           }
1234
1235         for (;; ++p)
1236           {
1237             if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1238               got_dot = got_e = 1;
1239             else if (!hex && !got_dot && *p == '.')
1240               got_dot = 1;
1241             else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1242                      && (*p == '-' || *p == '+'))
1243               /* This is the sign of the exponent, not the end of the
1244                  number.  */
1245               continue;
1246             /* We will take any letters or digits.  parse_number will
1247                complain if past the radix, or if L or U are not final.  */
1248             else if ((*p < '0' || *p > '9')
1249                      && ((*p < 'a' || *p > 'z')
1250                                   && (*p < 'A' || *p > 'Z')))
1251               break;
1252           }
1253         toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1254         if (toktype == ERROR)
1255           {
1256             char *err_copy = (char *) alloca (p - tokstart + 1);
1257
1258             memcpy (err_copy, tokstart, p - tokstart);
1259             err_copy[p - tokstart] = 0;
1260             error ("Invalid number \"%s\".", err_copy);
1261           }
1262         lexptr = p;
1263         return toktype;
1264       }
1265
1266     case '+':
1267     case '-':
1268     case '*':
1269     case '/':
1270     case '%':
1271     case '|':
1272     case '&':
1273     case '^':
1274     case '~':
1275     case '!':
1276     case '@':
1277     case '<':
1278     case '>':
1279     case '[':
1280     case ']':
1281     case '?':
1282     case ':':
1283     case '=':
1284     case '{':
1285     case '}':
1286     symbol:
1287       lexptr++;
1288       return c;
1289
1290     case '"':
1291
1292       /* Build the gdb internal form of the input string in tempbuf,
1293          translating any standard C escape forms seen.  Note that the
1294          buffer is null byte terminated *only* for the convenience of
1295          debugging gdb itself and printing the buffer contents when
1296          the buffer contains no embedded nulls.  Gdb does not depend
1297          upon the buffer being null byte terminated, it uses the length
1298          string instead.  This allows gdb to handle C strings (as well
1299          as strings in other languages) with embedded null bytes */
1300
1301       tokptr = ++tokstart;
1302       tempbufindex = 0;
1303
1304       do {
1305         /* Grow the static temp buffer if necessary, including allocating
1306            the first one on demand. */
1307         if (tempbufindex + 1 >= tempbufsize)
1308           {
1309             tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1310           }
1311         switch (*tokptr)
1312           {
1313           case '\0':
1314           case '"':
1315             /* Do nothing, loop will terminate. */
1316             break;
1317           case '\\':
1318             tokptr++;
1319             c = parse_escape (&tokptr);
1320             if (c == -1)
1321               {
1322                 continue;
1323               }
1324             tempbuf[tempbufindex++] = c;
1325             break;
1326           default:
1327             tempbuf[tempbufindex++] = *tokptr++;
1328             break;
1329           }
1330       } while ((*tokptr != '"') && (*tokptr != '\0'));
1331       if (*tokptr++ != '"')
1332         {
1333           error ("Unterminated string in expression.");
1334         }
1335       tempbuf[tempbufindex] = '\0';     /* See note above */
1336       yylval.sval.ptr = tempbuf;
1337       yylval.sval.length = tempbufindex;
1338       lexptr = tokptr;
1339       return (STRING);
1340     }
1341
1342   if (!(c == '_' || c == '$'
1343         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1344     /* We must have come across a bad character (e.g. ';').  */
1345     error ("Invalid character '%c' in expression.", c);
1346
1347   /* It's a name.  See how long it is.  */
1348   namelen = 0;
1349   for (c = tokstart[namelen];
1350        (c == '_' || c == '$' || (c >= '0' && c <= '9')
1351         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
1352        c = tokstart[++namelen])
1353     ;
1354
1355   /* The token "if" terminates the expression and is NOT
1356      removed from the input stream.  */
1357   if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1358     {
1359       return 0;
1360     }
1361
1362   lexptr += namelen;
1363
1364   /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
1365      and $$digits (equivalent to $<-digits> if you could type that).
1366      Make token type LAST, and put the number (the digits) in yylval.  */
1367
1368   tryname:
1369   if (*tokstart == '$')
1370     {
1371       register int negate = 0;
1372       c = 1;
1373       /* Double dollar means negate the number and add -1 as well.
1374          Thus $$ alone means -1.  */
1375       if (namelen >= 2 && tokstart[1] == '$')
1376         {
1377           negate = 1;
1378           c = 2;
1379         }
1380       if (c == namelen)
1381         {
1382           /* Just dollars (one or two) */
1383           yylval.lval = - negate;
1384           return LAST;
1385         }
1386       /* Is the rest of the token digits?  */
1387       for (; c < namelen; c++)
1388         if (!(tokstart[c] >= '0' && tokstart[c] <= '9'))
1389           break;
1390       if (c == namelen)
1391         {
1392           yylval.lval = atoi (tokstart + 1 + negate);
1393           if (negate)
1394             yylval.lval = - yylval.lval;
1395           return LAST;
1396         }
1397     }
1398
1399   /* Handle tokens that refer to machine registers:
1400      $ followed by a register name.  */
1401
1402   if (*tokstart == '$') {
1403     for (c = 0; c < NUM_REGS; c++)
1404       if (namelen - 1 == strlen (reg_names[c])
1405           && STREQN (tokstart + 1, reg_names[c], namelen - 1))
1406         {
1407           yylval.lval = c;
1408           return REGNAME;
1409         }
1410     for (c = 0; c < num_std_regs; c++)
1411      if (namelen - 1 == strlen (std_regs[c].name)
1412          && STREQN (tokstart + 1, std_regs[c].name, namelen - 1))
1413        {
1414          yylval.lval = std_regs[c].regnum;
1415          return REGNAME;
1416        }
1417   }
1418   /* Catch specific keywords.  Should be done with a data structure.  */
1419   switch (namelen)
1420     {
1421     case 8:
1422       if (STREQN (tokstart, "unsigned", 8))
1423         return UNSIGNED;
1424       if (current_language->la_language == language_cplus
1425           && STREQN (tokstart, "template", 8))
1426         return TEMPLATE;
1427       if (STREQN (tokstart, "volatile", 8))
1428         return VOLATILE_KEYWORD;
1429       break;
1430     case 6:
1431       if (STREQN (tokstart, "struct", 6))
1432         return STRUCT;
1433       if (STREQN (tokstart, "signed", 6))
1434         return SIGNED_KEYWORD;
1435       if (STREQN (tokstart, "sizeof", 6))
1436         return SIZEOF;
1437       break;
1438     case 5:
1439       if (current_language->la_language == language_cplus
1440           && STREQN (tokstart, "class", 5))
1441         return CLASS;
1442       if (STREQN (tokstart, "union", 5))
1443         return UNION;
1444       if (STREQN (tokstart, "short", 5))
1445         return SHORT;
1446       if (STREQN (tokstart, "const", 5))
1447         return CONST_KEYWORD;
1448       break;
1449     case 4:
1450       if (STREQN (tokstart, "enum", 4))
1451         return ENUM;
1452       if (STREQN (tokstart, "long", 4))
1453         return LONG;
1454       if (current_language->la_language == language_cplus
1455           && STREQN (tokstart, "this", 4))
1456         {
1457           static const char this_name[] =
1458                                  { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' };
1459
1460           if (lookup_symbol (this_name, expression_context_block,
1461                              VAR_NAMESPACE, 0, NULL))
1462             return THIS;
1463         }
1464       break;
1465     case 3:
1466       if (STREQN (tokstart, "int", 3))
1467         return INT_KEYWORD;
1468       break;
1469     default:
1470       break;
1471     }
1472
1473   yylval.sval.ptr = tokstart;
1474   yylval.sval.length = namelen;
1475
1476   /* Any other names starting in $ are debugger internal variables.  */
1477
1478   if (*tokstart == '$')
1479     {
1480       yylval.ivar =  lookup_internalvar (copy_name (yylval.sval) + 1);
1481       return VARIABLE;
1482     }
1483
1484   /* Use token-type BLOCKNAME for symbols that happen to be defined as
1485      functions or symtabs.  If this is not so, then ...
1486      Use token-type TYPENAME for symbols that happen to be defined
1487      currently as names of types; NAME for other symbols.
1488      The caller is not constrained to care about the distinction.  */
1489   {
1490     char *tmp = copy_name (yylval.sval);
1491     struct symbol *sym;
1492     int is_a_field_of_this = 0;
1493     int hextype;
1494
1495     sym = lookup_symbol (tmp, expression_context_block,
1496                          VAR_NAMESPACE,
1497                          current_language->la_language == language_cplus
1498                          ? &is_a_field_of_this : NULL,
1499                          NULL);
1500     if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) ||
1501         lookup_partial_symtab (tmp))
1502       {
1503         yylval.ssym.sym = sym;
1504         yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1505         return BLOCKNAME;
1506       }
1507     if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1508         {
1509           yylval.tsym.type = SYMBOL_TYPE (sym);
1510           return TYPENAME;
1511         }
1512     if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0)
1513         return TYPENAME;
1514
1515     /* Input names that aren't symbols but ARE valid hex numbers,
1516        when the input radix permits them, can be names or numbers
1517        depending on the parse.  Note we support radixes > 16 here.  */
1518     if (!sym &&
1519         ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1520          (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1521       {
1522         YYSTYPE newlval;        /* Its value is ignored.  */
1523         hextype = parse_number (tokstart, namelen, 0, &newlval);
1524         if (hextype == INT)
1525           {
1526             yylval.ssym.sym = sym;
1527             yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1528             return NAME_OR_INT;
1529           }
1530       }
1531
1532     /* Any other kind of symbol */
1533     yylval.ssym.sym = sym;
1534     yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1535     return NAME;
1536   }
1537 }
1538
1539 void
1540 yyerror (msg)
1541      char *msg;
1542 {
1543   error (msg ? msg : "Invalid syntax in expression.");
1544 }