gdb/p-exp.y

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