gdb/c-exp.y

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