gdb/c-exp.y

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