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