gdb/objc-exp.y

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