gdb/objc-exp.y

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