gdb/p-exp.y

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