gdb/c-exp.y

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