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         |       typebase abs_decl
 727                 {
 728                   /* This is where the interesting stuff happens.  */
 729                   int done = 0;
 730                   int array_size;
 731                   struct type *follow_type = $1;
 732                   struct type *range_type;
 733
 734                   while (!done)
 735                     switch (pop_type ())
 736                       {
 737                       case tp_end:
 738                         done = 1;
 739                         break;
 740                       case tp_pointer:
 741                         follow_type = lookup_pointer_type (follow_type);
 742                         break;
 743                       case tp_reference:
 744                         follow_type = lookup_reference_type (follow_type);
 745                         break;
 746                       case tp_array:
 747                         array_size = pop_type_int ();
 748                         if (array_size != -1)
 749                           {
 750                             range_type =
 751                               create_range_type ((struct type *) NULL,
 752                                                  builtin_type_int, 0,
 753                                                  array_size - 1);
 754                             follow_type =
 755                               create_array_type ((struct type *) NULL,
 756                                                  follow_type, range_type);
 757                           }
 758                         else
 759                           follow_type = lookup_pointer_type (follow_type);
 760                         break;
 761                       case tp_function:
 762                         follow_type = lookup_function_type (follow_type);
 763                         break;
 764                       }
 765                   $$ = follow_type;
 766                 }
 767         ;
 768
 769 abs_decl:       '*'
 770                         { push_type (tp_pointer); $$ = 0; }
 771         |       '*' abs_decl
 772                         { push_type (tp_pointer); $$ = $2; }
 773         |       '&'
 774                         { push_type (tp_reference); $$ = 0; }
 775         |       '&' abs_decl
 776                         { push_type (tp_reference); $$ = $2; }
 777         |       direct_abs_decl
 778         ;
 779
 780 direct_abs_decl: '(' abs_decl ')'
 781                         { $$ = $2; }
 782         |       direct_abs_decl array_mod
 783                         {
 784                           push_type_int ($2);
 785                           push_type (tp_array);
 786                         }
 787         |       array_mod
 788                         {
 789                           push_type_int ($1);
 790                           push_type (tp_array);
 791                           $$ = 0;
 792                         }
 793         |       direct_abs_decl func_mod
 794                         { push_type (tp_function); }
 795         |       func_mod
 796                         { push_type (tp_function); }
 797         ;
 798
 799 array_mod:      '[' ']'
 800                         { $$ = -1; }
 801         |       '[' INT ']'
 802                         { $$ = $2.val; }
 803         ;
 804
 805 func_mod:       '(' ')'
 806                         { $$ = 0; }
 807         |       '(' nonempty_typelist ')'
 808                         { free ((PTR)$2); $$ = 0; }
 809         ;
 810
 811 type    :       ptype
 812         |       typebase COLONCOLON '*'
 813                         { $$ = lookup_member_type (builtin_type_int, $1); }
 814         |       type '(' typebase COLONCOLON '*' ')'
 815                         { $$ = lookup_member_type ($1, $3); }
 816         |       type '(' typebase COLONCOLON '*' ')' '(' ')'
 817                         { $$ = lookup_member_type
 818                             (lookup_function_type ($1), $3); }
 819         |       type '(' typebase COLONCOLON '*' ')' '(' nonempty_typelist ')'
 820                         { $$ = lookup_member_type
 821                             (lookup_function_type ($1), $3);
 822                           free ((PTR)$8); }
 823         ;
 824
 825 typebase  /* Implements (approximately): (type-qualifier)* type-specifier */
 826         :       TYPENAME
 827                         { $$ = $1.type; }
 828         |       INT_KEYWORD
 829                         { $$ = builtin_type_int; }
 830         |       LONG
 831                         { $$ = builtin_type_long; }
 832         |       SHORT
 833                         { $$ = builtin_type_short; }
 834         |       LONG INT_KEYWORD
 835                         { $$ = builtin_type_long; }
 836         |       UNSIGNED LONG INT_KEYWORD
 837                         { $$ = builtin_type_unsigned_long; }
 838         |       LONG LONG
 839                         { $$ = builtin_type_long_long; }
 840         |       LONG LONG INT_KEYWORD
 841                         { $$ = builtin_type_long_long; }
 842         |       UNSIGNED LONG LONG
 843                         { $$ = builtin_type_unsigned_long_long; }
 844         |       UNSIGNED LONG LONG INT_KEYWORD
 845                         { $$ = builtin_type_unsigned_long_long; }
 846         |       SHORT INT_KEYWORD
 847                         { $$ = builtin_type_short; }
 848         |       UNSIGNED SHORT INT_KEYWORD
 849                         { $$ = builtin_type_unsigned_short; }
 850         |       STRUCT name
 851                         { $$ = lookup_struct (copy_name ($2),
 852                                               expression_context_block); }
 853         |       CLASS name
 854                         { $$ = lookup_struct (copy_name ($2),
 855                                               expression_context_block); }
 856         |       UNION name
 857                         { $$ = lookup_union (copy_name ($2),
 858                                              expression_context_block); }
 859         |       ENUM name
 860                         { $$ = lookup_enum (copy_name ($2),
 861                                             expression_context_block); }
 862         |       UNSIGNED typename
 863                         { $$ = lookup_unsigned_typename (TYPE_NAME($2.type)); }
 864         |       UNSIGNED
 865                         { $$ = builtin_type_unsigned_int; }
 866         |       SIGNED_KEYWORD typename
 867                         { $$ = lookup_signed_typename (TYPE_NAME($2.type)); }
 868         |       SIGNED_KEYWORD
 869                         { $$ = builtin_type_int; }
 870         |       TEMPLATE name '<' type '>'
 871                         { $$ = lookup_template_type(copy_name($2), $4,
 872                                                     expression_context_block);
 873                         }
 874         /* "const" and "volatile" are curently ignored. */
 875         |       CONST_KEYWORD typebase { $$ = $2; }
 876         |       VOLATILE_KEYWORD typebase { $$ = $2; }
 877         ;
 878
 879 typename:       TYPENAME
 880         |       INT_KEYWORD
 881                 {
 882                   $$.stoken.ptr = "int";
 883                   $$.stoken.length = 3;
 884                   $$.type = builtin_type_int;
 885                 }
 886         |       LONG
 887                 {
 888                   $$.stoken.ptr = "long";
 889                   $$.stoken.length = 4;
 890                   $$.type = builtin_type_long;
 891                 }
 892         |       SHORT
 893                 {
 894                   $$.stoken.ptr = "short";
 895                   $$.stoken.length = 5;
 896                   $$.type = builtin_type_short;
 897                 }
 898         ;
 899
 900 nonempty_typelist
 901         :       type
 902                 { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
 903                   $<ivec>$[0] = 1;      /* Number of types in vector */
 904                   $$[1] = $1;
 905                 }
 906         |       nonempty_typelist ',' type
 907                 { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
 908                   $$ = (struct type **) realloc ((char *) $1, len);
 909                   $$[$<ivec>$[0]] = $3;
 910                 }
 911         ;
 912
 913 name    :       NAME { $$ = $1.stoken; }
 914         |       BLOCKNAME { $$ = $1.stoken; }
 915         |       TYPENAME { $$ = $1.stoken; }
 916         |       NAME_OR_INT  { $$ = $1.stoken; }
 917         ;
 918
 919 name_not_typename :     NAME
 920         |       BLOCKNAME
 921 /* These would be useful if name_not_typename was useful, but it is just
 922    a fake for "variable", so these cause reduce/reduce conflicts because
 923    the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
 924    =exp) or just an exp.  If name_not_typename was ever used in an lvalue
 925    context where only a name could occur, this might be useful.
 926         |       NAME_OR_INT
 927  */
 928         ;
 929
 930 %%
 931
 932 /* Take care of parsing a number (anything that starts with a digit).
 933    Set yylval and return the token type; update lexptr.
 934    LEN is the number of characters in it.  */
 935
 936 /*** Needs some error checking for the float case ***/
 937
 938 static int
 939 parse_number (p, len, parsed_float, putithere)
 940      register char *p;
 941      register int len;
 942      int parsed_float;
 943      YYSTYPE *putithere;
 944 {
 945   register LONGEST n = 0;
 946   register LONGEST prevn = 0;
 947   register int i = 0;
 948   register int c;
 949   register int base = input_radix;
 950   int unsigned_p = 0;
 951   int long_p = 0;
 952   unsigned LONGEST high_bit;
 953   struct type *signed_type;
 954   struct type *unsigned_type;
 955
 956   if (parsed_float)
 957     {
 958       /* It's a float since it contains a point or an exponent.  */
 959       putithere->dval = atof (p);
 960       return FLOAT;
 961     }
 962
 963   /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
 964   if (p[0] == '0')
 965     switch (p[1])
 966       {
 967       case 'x':
 968       case 'X':
 969         if (len >= 3)
 970           {
 971             p += 2;
 972             base = 16;
 973             len -= 2;
 974           }
 975         break;
 976
 977       case 't':
 978       case 'T':
 979       case 'd':
 980       case 'D':
 981         if (len >= 3)
 982           {
 983             p += 2;
 984             base = 10;
 985             len -= 2;
 986           }
 987         break;
 988
 989       default:
 990         base = 8;
 991         break;
 992       }
 993
 994   while (len-- > 0)
 995     {
 996       c = *p++;
 997       if (c >= 'A' && c <= 'Z')
 998         c += 'a' - 'A';
 999       if (c != 'l' && c != 'u')
1000         n *= base;
1001       if (c >= '0' && c <= '9')
1002         n += i = c - '0';
1003       else
1004         {
1005           if (base > 10 && c >= 'a' && c <= 'f')
1006             n += i = c - 'a' + 10;
1007           else if (len == 0 && c == 'l')
1008             long_p = 1;
1009           else if (len == 0 && c == 'u')
1010             unsigned_p = 1;
1011           else
1012             return ERROR;       /* Char not a digit */
1013         }
1014       if (i >= base)
1015         return ERROR;           /* Invalid digit in this base */
1016
1017       /* Portably test for overflow (only works for nonzero values, so make
1018          a second check for zero).  */
1019       if((prevn >= n) && n != 0)
1020          unsigned_p=1;          /* Try something unsigned */
1021       /* If range checking enabled, portably test for unsigned overflow.  */
1022       if(RANGE_CHECK && n!=0)
1023       {
1024          if((unsigned_p && (unsigned)prevn >= (unsigned)n))
1025             range_error("Overflow on numeric constant.");
1026       }
1027       prevn=n;
1028     }
1029
1030      /* If the number is too big to be an int, or it's got an l suffix
1031         then it's a long.  Work out if this has to be a long by
1032         shifting right and and seeing if anything remains, and the
1033         target int size is different to the target long size.
1034
1035         In the expression below, we could have tested
1036                 (n >> TARGET_INT_BIT)
1037         to see if it was zero,
1038         but too many compilers warn about that, when ints and longs
1039         are the same size.  So we shift it twice, with fewer bits
1040         each time, for the same result.  */
1041
1042     if (   (TARGET_INT_BIT != TARGET_LONG_BIT
1043             && ((n >> 2) >> (TARGET_INT_BIT-2)))   /* Avoid shift warning */
1044         || long_p)
1045       {
1046          high_bit = ((unsigned 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 = ((unsigned 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               if (lexptr[-1] != '\'')
1177                 error ("Unmatched single quote.");
1178               namelen -= 2;
1179               tokstart++;
1180               goto tryname;
1181             }
1182           error ("Invalid character constant.");
1183         }
1184       return INT;
1185
1186     case '(':
1187       paren_depth++;
1188       lexptr++;
1189       return c;
1190
1191     case ')':
1192       if (paren_depth == 0)
1193         return 0;
1194       paren_depth--;
1195       lexptr++;
1196       return c;
1197
1198     case ',':
1199       if (comma_terminates && paren_depth == 0)
1200         return 0;
1201       lexptr++;
1202       return c;
1203
1204     case '.':
1205       /* Might be a floating point number.  */
1206       if (lexptr[1] < '0' || lexptr[1] > '9')
1207         goto symbol;            /* Nope, must be a symbol. */
1208       /* FALL THRU into number case.  */
1209
1210     case '0':
1211     case '1':
1212     case '2':
1213     case '3':
1214     case '4':
1215     case '5':
1216     case '6':
1217     case '7':
1218     case '8':
1219     case '9':
1220       {
1221         /* It's a number.  */
1222         int got_dot = 0, got_e = 0, toktype;
1223         register char *p = tokstart;
1224         int hex = input_radix > 10;
1225
1226         if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1227           {
1228             p += 2;
1229             hex = 1;
1230           }
1231         else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1232           {
1233             p += 2;
1234             hex = 0;
1235           }
1236
1237         for (;; ++p)
1238           {
1239             /* This test includes !hex because 'e' is a valid hex digit
1240                and thus does not indicate a floating point number when
1241                the radix is hex.  */
1242             if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1243               got_dot = got_e = 1;
1244             /* This test does not include !hex, because a '.' always indicates
1245                a decimal floating point number regardless of the radix.  */
1246             else if (!got_dot && *p == '.')
1247               got_dot = 1;
1248             else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1249                      && (*p == '-' || *p == '+'))
1250               /* This is the sign of the exponent, not the end of the
1251                  number.  */
1252               continue;
1253             /* We will take any letters or digits.  parse_number will
1254                complain if past the radix, or if L or U are not final.  */
1255             else if ((*p < '0' || *p > '9')
1256                      && ((*p < 'a' || *p > 'z')
1257                                   && (*p < 'A' || *p > 'Z')))
1258               break;
1259           }
1260         toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1261         if (toktype == ERROR)
1262           {
1263             char *err_copy = (char *) alloca (p - tokstart + 1);
1264
1265             memcpy (err_copy, tokstart, p - tokstart);
1266             err_copy[p - tokstart] = 0;
1267             error ("Invalid number \"%s\".", err_copy);
1268           }
1269         lexptr = p;
1270         return toktype;
1271       }
1272
1273     case '+':
1274     case '-':
1275     case '*':
1276     case '/':
1277     case '%':
1278     case '|':
1279     case '&':
1280     case '^':
1281     case '~':
1282     case '!':
1283     case '@':
1284     case '<':
1285     case '>':
1286     case '[':
1287     case ']':
1288     case '?':
1289     case ':':
1290     case '=':
1291     case '{':
1292     case '}':
1293     symbol:
1294       lexptr++;
1295       return c;
1296
1297     case '"':
1298
1299       /* Build the gdb internal form of the input string in tempbuf,
1300          translating any standard C escape forms seen.  Note that the
1301          buffer is null byte terminated *only* for the convenience of
1302          debugging gdb itself and printing the buffer contents when
1303          the buffer contains no embedded nulls.  Gdb does not depend
1304          upon the buffer being null byte terminated, it uses the length
1305          string instead.  This allows gdb to handle C strings (as well
1306          as strings in other languages) with embedded null bytes */
1307
1308       tokptr = ++tokstart;
1309       tempbufindex = 0;
1310
1311       do {
1312         /* Grow the static temp buffer if necessary, including allocating
1313            the first one on demand. */
1314         if (tempbufindex + 1 >= tempbufsize)
1315           {
1316             tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1317           }
1318         switch (*tokptr)
1319           {
1320           case '\0':
1321           case '"':
1322             /* Do nothing, loop will terminate. */
1323             break;
1324           case '\\':
1325             tokptr++;
1326             c = parse_escape (&tokptr);
1327             if (c == -1)
1328               {
1329                 continue;
1330               }
1331             tempbuf[tempbufindex++] = c;
1332             break;
1333           default:
1334             tempbuf[tempbufindex++] = *tokptr++;
1335             break;
1336           }
1337       } while ((*tokptr != '"') && (*tokptr != '\0'));
1338       if (*tokptr++ != '"')
1339         {
1340           error ("Unterminated string in expression.");
1341         }
1342       tempbuf[tempbufindex] = '\0';     /* See note above */
1343       yylval.sval.ptr = tempbuf;
1344       yylval.sval.length = tempbufindex;
1345       lexptr = tokptr;
1346       return (STRING);
1347     }
1348
1349   if (!(c == '_' || c == '$'
1350         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1351     /* We must have come across a bad character (e.g. ';').  */
1352     error ("Invalid character '%c' in expression.", c);
1353
1354   /* It's a name.  See how long it is.  */
1355   namelen = 0;
1356   for (c = tokstart[namelen];
1357        (c == '_' || c == '$' || (c >= '0' && c <= '9')
1358         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
1359        c = tokstart[++namelen])
1360     ;
1361
1362   /* The token "if" terminates the expression and is NOT
1363      removed from the input stream.  */
1364   if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1365     {
1366       return 0;
1367     }
1368
1369   lexptr += namelen;
1370
1371   /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
1372      and $$digits (equivalent to $<-digits> if you could type that).
1373      Make token type LAST, and put the number (the digits) in yylval.  */
1374
1375   tryname:
1376   if (*tokstart == '$')
1377     {
1378       register int negate = 0;
1379       c = 1;
1380       /* Double dollar means negate the number and add -1 as well.
1381          Thus $$ alone means -1.  */
1382       if (namelen >= 2 && tokstart[1] == '$')
1383         {
1384           negate = 1;
1385           c = 2;
1386         }
1387       if (c == namelen)
1388         {
1389           /* Just dollars (one or two) */
1390           yylval.lval = - negate;
1391           return LAST;
1392         }
1393       /* Is the rest of the token digits?  */
1394       for (; c < namelen; c++)
1395         if (!(tokstart[c] >= '0' && tokstart[c] <= '9'))
1396           break;
1397       if (c == namelen)
1398         {
1399           yylval.lval = atoi (tokstart + 1 + negate);
1400           if (negate)
1401             yylval.lval = - yylval.lval;
1402           return LAST;
1403         }
1404     }
1405
1406   /* Handle tokens that refer to machine registers:
1407      $ followed by a register name.  */
1408
1409   if (*tokstart == '$') {
1410     for (c = 0; c < NUM_REGS; c++)
1411       if (namelen - 1 == strlen (reg_names[c])
1412           && STREQN (tokstart + 1, reg_names[c], namelen - 1))
1413         {
1414           yylval.lval = c;
1415           return REGNAME;
1416         }
1417     for (c = 0; c < num_std_regs; c++)
1418      if (namelen - 1 == strlen (std_regs[c].name)
1419          && STREQN (tokstart + 1, std_regs[c].name, namelen - 1))
1420        {
1421          yylval.lval = std_regs[c].regnum;
1422          return REGNAME;
1423        }
1424   }
1425   /* Catch specific keywords.  Should be done with a data structure.  */
1426   switch (namelen)
1427     {
1428     case 8:
1429       if (STREQN (tokstart, "unsigned", 8))
1430         return UNSIGNED;
1431       if (current_language->la_language == language_cplus
1432           && STREQN (tokstart, "template", 8))
1433         return TEMPLATE;
1434       if (STREQN (tokstart, "volatile", 8))
1435         return VOLATILE_KEYWORD;
1436       break;
1437     case 6:
1438       if (STREQN (tokstart, "struct", 6))
1439         return STRUCT;
1440       if (STREQN (tokstart, "signed", 6))
1441         return SIGNED_KEYWORD;
1442       if (STREQN (tokstart, "sizeof", 6))
1443         return SIZEOF;
1444       break;
1445     case 5:
1446       if (current_language->la_language == language_cplus
1447           && STREQN (tokstart, "class", 5))
1448         return CLASS;
1449       if (STREQN (tokstart, "union", 5))
1450         return UNION;
1451       if (STREQN (tokstart, "short", 5))
1452         return SHORT;
1453       if (STREQN (tokstart, "const", 5))
1454         return CONST_KEYWORD;
1455       break;
1456     case 4:
1457       if (STREQN (tokstart, "enum", 4))
1458         return ENUM;
1459       if (STREQN (tokstart, "long", 4))
1460         return LONG;
1461       if (current_language->la_language == language_cplus
1462           && STREQN (tokstart, "this", 4))
1463         {
1464           static const char this_name[] =
1465                                  { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' };
1466
1467           if (lookup_symbol (this_name, expression_context_block,
1468                              VAR_NAMESPACE, (int *) NULL,
1469                              (struct symtab **) NULL))
1470             return THIS;
1471         }
1472       break;
1473     case 3:
1474       if (STREQN (tokstart, "int", 3))
1475         return INT_KEYWORD;
1476       break;
1477     default:
1478       break;
1479     }
1480
1481   yylval.sval.ptr = tokstart;
1482   yylval.sval.length = namelen;
1483
1484   /* Any other names starting in $ are debugger internal variables.  */
1485
1486   if (*tokstart == '$')
1487     {
1488       yylval.ivar =  lookup_internalvar (copy_name (yylval.sval) + 1);
1489       return VARIABLE;
1490     }
1491
1492   /* Use token-type BLOCKNAME for symbols that happen to be defined as
1493      functions or symtabs.  If this is not so, then ...
1494      Use token-type TYPENAME for symbols that happen to be defined
1495      currently as names of types; NAME for other symbols.
1496      The caller is not constrained to care about the distinction.  */
1497   {
1498     char *tmp = copy_name (yylval.sval);
1499     struct symbol *sym;
1500     int is_a_field_of_this = 0;
1501     int hextype;
1502
1503     sym = lookup_symbol (tmp, expression_context_block,
1504                          VAR_NAMESPACE,
1505                          current_language->la_language == language_cplus
1506                          ? &is_a_field_of_this : (int *) NULL,
1507                          (struct symtab **) NULL);
1508     if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) ||
1509         lookup_partial_symtab (tmp))
1510       {
1511         yylval.ssym.sym = sym;
1512         yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1513         return BLOCKNAME;
1514       }
1515     if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1516         {
1517           char *p;
1518           char *namestart;
1519           struct symbol *best_sym;
1520
1521           /* Look ahead to detect nested types.  This probably should be
1522              done in the grammar, but trying seemed to introduce a lot
1523              of shift/reduce and reduce/reduce conflicts.  It's possible
1524              that it could be done, though.  Or perhaps a non-grammar, but
1525              less ad hoc, approach would work well.  */
1526
1527           /* Since we do not currently have any way of distinguishing
1528              a nested type from a non-nested one (the stabs don't tell
1529              us whether a type is nested), we just ignore the
1530              containing type.  */
1531
1532           p = lexptr;
1533           best_sym = sym;
1534           while (1)
1535             {
1536               /* Skip whitespace.  */
1537               while (*p == ' ' || *p == '\t' || *p == '\n')
1538                 ++p;
1539               if (*p == ':' && p[1] == ':')
1540                 {
1541                   /* Skip the `::'.  */
1542                   p += 2;
1543                   /* Skip whitespace.  */
1544                   while (*p == ' ' || *p == '\t' || *p == '\n')
1545                     ++p;
1546                   namestart = p;
1547                   while (*p == '_' || *p == '$' || (*p >= '0' && *p <= '9')
1548                          || (*p >= 'a' && *p <= 'z')
1549                          || (*p >= 'A' && *p <= 'Z'))
1550                     ++p;
1551                   if (p != namestart)
1552                     {
1553                       struct symbol *cur_sym;
1554                       /* As big as the whole rest of the expression, which is
1555                          at least big enough.  */
1556                       char *tmp = alloca (strlen (namestart));
1557
1558                       memcpy (tmp, namestart, p - namestart);
1559                       tmp[p - namestart] = '\0';
1560                       cur_sym = lookup_symbol (tmp, expression_context_block,
1561                                                VAR_NAMESPACE, (int *) NULL,
1562                                                (struct symtab **) NULL);
1563                       if (cur_sym)
1564                         {
1565                           if (SYMBOL_CLASS (cur_sym) == LOC_TYPEDEF)
1566                             {
1567                               best_sym = cur_sym;
1568                               lexptr = p;
1569                             }
1570                           else
1571                             break;
1572                         }
1573                       else
1574                         break;
1575                     }
1576                   else
1577                     break;
1578                 }
1579               else
1580                 break;
1581             }
1582
1583           yylval.tsym.type = SYMBOL_TYPE (best_sym);
1584           return TYPENAME;
1585         }
1586     if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0)
1587         return TYPENAME;
1588
1589     /* Input names that aren't symbols but ARE valid hex numbers,
1590        when the input radix permits them, can be names or numbers
1591        depending on the parse.  Note we support radixes > 16 here.  */
1592     if (!sym &&
1593         ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1594          (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1595       {
1596         YYSTYPE newlval;        /* Its value is ignored.  */
1597         hextype = parse_number (tokstart, namelen, 0, &newlval);
1598         if (hextype == INT)
1599           {
1600             yylval.ssym.sym = sym;
1601             yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1602             return NAME_OR_INT;
1603           }
1604       }
1605
1606     /* Any other kind of symbol */
1607     yylval.ssym.sym = sym;
1608     yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1609     return NAME;
1610   }
1611 }
1612
1613 void
1614 yyerror (msg)
1615      char *msg;
1616 {
1617   error (msg ? msg : "Invalid syntax in expression.");
1618 }