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