gdb/objc-exp.y

   1 /* YACC parser for C expressions, for GDB.
   2
   3    Copyright (C) 1986, 1989-1991, 1993-1994, 2002, 2006-2012 Free
   4    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                           if (symbol_read_needs_frame (sym))
 652                             {
 653                               if (innermost_block == 0
 654                                   || contained_in (block_found,
 655                                                    innermost_block))
 656                                 innermost_block = block_found;
 657                             }
 658
 659                           write_exp_elt_opcode (OP_VAR_VALUE);
 660                           /* block_found is set by lookup_symbol.  */
 661                           write_exp_elt_block (block_found);
 662                           write_exp_elt_sym (sym);
 663                           write_exp_elt_opcode (OP_VAR_VALUE); }
 664         ;
 665
 666 qualified_name: typebase COLONCOLON name
 667                         {
 668                           struct type *type = $1;
 669                           if (TYPE_CODE (type) != TYPE_CODE_STRUCT
 670                               && TYPE_CODE (type) != TYPE_CODE_UNION)
 671                             error (_("`%s' is not defined as an aggregate type."),
 672                                    TYPE_NAME (type));
 673
 674                           write_exp_elt_opcode (OP_SCOPE);
 675                           write_exp_elt_type (type);
 676                           write_exp_string ($3);
 677                           write_exp_elt_opcode (OP_SCOPE);
 678                         }
 679         |       typebase COLONCOLON '~' name
 680                         {
 681                           struct type *type = $1;
 682                           struct stoken tmp_token;
 683                           if (TYPE_CODE (type) != TYPE_CODE_STRUCT
 684                               && TYPE_CODE (type) != TYPE_CODE_UNION)
 685                             error (_("`%s' is not defined as an aggregate type."),
 686                                    TYPE_NAME (type));
 687
 688                           if (strcmp (type_name_no_tag (type), $4.ptr) != 0)
 689                             error (_("invalid destructor `%s::~%s'"),
 690                                    type_name_no_tag (type), $4.ptr);
 691
 692                           tmp_token.ptr = (char*) alloca ($4.length + 2);
 693                           tmp_token.length = $4.length + 1;
 694                           tmp_token.ptr[0] = '~';
 695                           memcpy (tmp_token.ptr+1, $4.ptr, $4.length);
 696                           tmp_token.ptr[tmp_token.length] = 0;
 697                           write_exp_elt_opcode (OP_SCOPE);
 698                           write_exp_elt_type (type);
 699                           write_exp_string (tmp_token);
 700                           write_exp_elt_opcode (OP_SCOPE);
 701                         }
 702         ;
 703
 704 variable:       qualified_name
 705         |       COLONCOLON name
 706                         {
 707                           char *name = copy_name ($2);
 708                           struct symbol *sym;
 709                           struct minimal_symbol *msymbol;
 710
 711                           sym =
 712                             lookup_symbol (name, (const struct block *) NULL,
 713                                            VAR_DOMAIN, (int *) NULL);
 714                           if (sym)
 715                             {
 716                               write_exp_elt_opcode (OP_VAR_VALUE);
 717                               write_exp_elt_block (NULL);
 718                               write_exp_elt_sym (sym);
 719                               write_exp_elt_opcode (OP_VAR_VALUE);
 720                               break;
 721                             }
 722
 723                           msymbol = lookup_minimal_symbol (name, NULL, NULL);
 724                           if (msymbol != NULL)
 725                             write_exp_msymbol (msymbol);
 726                           else if (!have_full_symbols ()
 727                                    && !have_partial_symbols ())
 728                             error (_("No symbol table is loaded.  "
 729                                    "Use the \"file\" command."));
 730                           else
 731                             error (_("No symbol \"%s\" in current context."),
 732                                    name);
 733                         }
 734         ;
 735
 736 variable:       name_not_typename
 737                         { struct symbol *sym = $1.sym;
 738
 739                           if (sym)
 740                             {
 741                               if (symbol_read_needs_frame (sym))
 742                                 {
 743                                   if (innermost_block == 0 ||
 744                                       contained_in (block_found,
 745                                                     innermost_block))
 746                                     innermost_block = block_found;
 747                                 }
 748
 749                               write_exp_elt_opcode (OP_VAR_VALUE);
 750                               /* We want to use the selected frame, not
 751                                  another more inner frame which happens to
 752                                  be in the same block.  */
 753                               write_exp_elt_block (NULL);
 754                               write_exp_elt_sym (sym);
 755                               write_exp_elt_opcode (OP_VAR_VALUE);
 756                             }
 757                           else if ($1.is_a_field_of_this)
 758                             {
 759                               /* C++/ObjC: it hangs off of `this'/'self'.
 760                                  Must not inadvertently convert from a
 761                                  method call to data ref.  */
 762                               if (innermost_block == 0 ||
 763                                   contained_in (block_found, innermost_block))
 764                                 innermost_block = block_found;
 765                               write_exp_elt_opcode (OP_THIS);
 766                               write_exp_elt_opcode (OP_THIS);
 767                               write_exp_elt_opcode (STRUCTOP_PTR);
 768                               write_exp_string ($1.stoken);
 769                               write_exp_elt_opcode (STRUCTOP_PTR);
 770                             }
 771                           else
 772                             {
 773                               struct minimal_symbol *msymbol;
 774                               char *arg = copy_name ($1.stoken);
 775
 776                               msymbol =
 777                                 lookup_minimal_symbol (arg, NULL, NULL);
 778                               if (msymbol != NULL)
 779                                 write_exp_msymbol (msymbol);
 780                               else if (!have_full_symbols () &&
 781                                        !have_partial_symbols ())
 782                                 error (_("No symbol table is loaded.  "
 783                                        "Use the \"file\" command."));
 784                               else
 785                                 error (_("No symbol \"%s\" in current context."),
 786                                        copy_name ($1.stoken));
 787                             }
 788                         }
 789         ;
 790
 791
 792 ptype   :       typebase
 793         /* "const" and "volatile" are curently ignored.  A type
 794            qualifier before the type is currently handled in the
 795            typebase rule.  The reason for recognizing these here
 796            (shift/reduce conflicts) might be obsolete now that some
 797            pointer to member rules have been deleted.  */
 798         |       typebase CONST_KEYWORD
 799         |       typebase VOLATILE_KEYWORD
 800         |       typebase abs_decl
 801                 { $$ = follow_types ($1); }
 802         |       typebase CONST_KEYWORD abs_decl
 803                 { $$ = follow_types ($1); }
 804         |       typebase VOLATILE_KEYWORD abs_decl
 805                 { $$ = follow_types ($1); }
 806         ;
 807
 808 abs_decl:       '*'
 809                         { push_type (tp_pointer); $$ = 0; }
 810         |       '*' abs_decl
 811                         { push_type (tp_pointer); $$ = $2; }
 812         |       '&'
 813                         { push_type (tp_reference); $$ = 0; }
 814         |       '&' abs_decl
 815                         { push_type (tp_reference); $$ = $2; }
 816         |       direct_abs_decl
 817         ;
 818
 819 direct_abs_decl: '(' abs_decl ')'
 820                         { $$ = $2; }
 821         |       direct_abs_decl array_mod
 822                         {
 823                           push_type_int ($2);
 824                           push_type (tp_array);
 825                         }
 826         |       array_mod
 827                         {
 828                           push_type_int ($1);
 829                           push_type (tp_array);
 830                           $$ = 0;
 831                         }
 832
 833         |       direct_abs_decl func_mod
 834                         { push_type (tp_function); }
 835         |       func_mod
 836                         { push_type (tp_function); }
 837         ;
 838
 839 array_mod:      '[' ']'
 840                         { $$ = -1; }
 841         |       '[' INT ']'
 842                         { $$ = $2.val; }
 843         ;
 844
 845 func_mod:       '(' ')'
 846                         { $$ = 0; }
 847         |       '(' nonempty_typelist ')'
 848                         { free ($2); $$ = 0; }
 849         ;
 850
 851 /* We used to try to recognize more pointer to member types here, but
 852    that didn't work (shift/reduce conflicts meant that these rules
 853    never got executed).  The problem is that
 854      int (foo::bar::baz::bizzle)
 855    is a function type but
 856      int (foo::bar::baz::bizzle::*)
 857    is a pointer to member type.  Stroustrup loses again!  */
 858
 859 type    :       ptype
 860         ;
 861
 862 typebase  /* Implements (approximately): (type-qualifier)* type-specifier.  */
 863         :       TYPENAME
 864                         { $$ = $1.type; }
 865         |       CLASSNAME
 866                         {
 867                           if ($1.type == NULL)
 868                             error (_("No symbol \"%s\" in current context."),
 869                                    copy_name($1.stoken));
 870                           else
 871                             $$ = $1.type;
 872                         }
 873         |       INT_KEYWORD
 874                         { $$ = parse_type->builtin_int; }
 875         |       LONG
 876                         { $$ = parse_type->builtin_long; }
 877         |       SHORT
 878                         { $$ = parse_type->builtin_short; }
 879         |       LONG INT_KEYWORD
 880                         { $$ = parse_type->builtin_long; }
 881         |       UNSIGNED LONG INT_KEYWORD
 882                         { $$ = parse_type->builtin_unsigned_long; }
 883         |       LONG LONG
 884                         { $$ = parse_type->builtin_long_long; }
 885         |       LONG LONG INT_KEYWORD
 886                         { $$ = parse_type->builtin_long_long; }
 887         |       UNSIGNED LONG LONG
 888                         { $$ = parse_type->builtin_unsigned_long_long; }
 889         |       UNSIGNED LONG LONG INT_KEYWORD
 890                         { $$ = parse_type->builtin_unsigned_long_long; }
 891         |       SHORT INT_KEYWORD
 892                         { $$ = parse_type->builtin_short; }
 893         |       UNSIGNED SHORT INT_KEYWORD
 894                         { $$ = parse_type->builtin_unsigned_short; }
 895         |       DOUBLE_KEYWORD
 896                         { $$ = parse_type->builtin_double; }
 897         |       LONG DOUBLE_KEYWORD
 898                         { $$ = parse_type->builtin_long_double; }
 899         |       STRUCT name
 900                         { $$ = lookup_struct (copy_name ($2),
 901                                               expression_context_block); }
 902         |       CLASS name
 903                         { $$ = lookup_struct (copy_name ($2),
 904                                               expression_context_block); }
 905         |       UNION name
 906                         { $$ = lookup_union (copy_name ($2),
 907                                              expression_context_block); }
 908         |       ENUM name
 909                         { $$ = lookup_enum (copy_name ($2),
 910                                             expression_context_block); }
 911         |       UNSIGNED typename
 912                         { $$ = lookup_unsigned_typename (parse_language,
 913                                                          parse_gdbarch,
 914                                                          TYPE_NAME($2.type)); }
 915         |       UNSIGNED
 916                         { $$ = parse_type->builtin_unsigned_int; }
 917         |       SIGNED_KEYWORD typename
 918                         { $$ = lookup_signed_typename (parse_language,
 919                                                        parse_gdbarch,
 920                                                        TYPE_NAME($2.type)); }
 921         |       SIGNED_KEYWORD
 922                         { $$ = parse_type->builtin_int; }
 923         |       TEMPLATE name '<' type '>'
 924                         { $$ = lookup_template_type(copy_name($2), $4,
 925                                                     expression_context_block);
 926                         }
 927         /* "const" and "volatile" are curently ignored.  A type
 928            qualifier after the type is handled in the ptype rule.  I
 929            think these could be too.  */
 930         |       CONST_KEYWORD typebase { $$ = $2; }
 931         |       VOLATILE_KEYWORD typebase { $$ = $2; }
 932         ;
 933
 934 typename:       TYPENAME
 935         |       INT_KEYWORD
 936                 {
 937                   $$.stoken.ptr = "int";
 938                   $$.stoken.length = 3;
 939                   $$.type = parse_type->builtin_int;
 940                 }
 941         |       LONG
 942                 {
 943                   $$.stoken.ptr = "long";
 944                   $$.stoken.length = 4;
 945                   $$.type = parse_type->builtin_long;
 946                 }
 947         |       SHORT
 948                 {
 949                   $$.stoken.ptr = "short";
 950                   $$.stoken.length = 5;
 951                   $$.type = parse_type->builtin_short;
 952                 }
 953         ;
 954
 955 nonempty_typelist
 956         :       type
 957                 { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
 958                   $<ivec>$[0] = 1;      /* Number of types in vector.  */
 959                   $$[1] = $1;
 960                 }
 961         |       nonempty_typelist ',' type
 962                 { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
 963                   $$ = (struct type **) realloc ((char *) $1, len);
 964                   $$[$<ivec>$[0]] = $3;
 965                 }
 966         ;
 967
 968 name    :       NAME        { $$ = $1.stoken; }
 969         |       BLOCKNAME   { $$ = $1.stoken; }
 970         |       TYPENAME    { $$ = $1.stoken; }
 971         |       CLASSNAME   { $$ = $1.stoken; }
 972         |       NAME_OR_INT { $$ = $1.stoken; }
 973         ;
 974
 975 name_not_typename :     NAME
 976         |       BLOCKNAME
 977 /* These would be useful if name_not_typename was useful, but it is
 978    just a fake for "variable", so these cause reduce/reduce conflicts
 979    because the parser can't tell whether NAME_OR_INT is a
 980    name_not_typename (=variable, =exp) or just an exp.  If
 981    name_not_typename was ever used in an lvalue context where only a
 982    name could occur, this might be useful.  */
 983 /*      | NAME_OR_INT */
 984         ;
 985
 986 %%
 987
 988 /* Take care of parsing a number (anything that starts with a digit).
 989    Set yylval and return the token type; update lexptr.  LEN is the
 990    number of characters in it.  */
 991
 992 /*** Needs some error checking for the float case.  ***/
 993
 994 static int
 995 parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere)
 996 {
 997   /* FIXME: Shouldn't these be unsigned?  We don't deal with negative
 998      values here, and we do kind of silly things like cast to
 999      unsigned.  */
1000   LONGEST n = 0;
1001   LONGEST prevn = 0;
1002   unsigned LONGEST un;
1003
1004   int i = 0;
1005   int c;
1006   int base = input_radix;
1007   int unsigned_p = 0;
1008
1009   /* Number of "L" suffixes encountered.  */
1010   int long_p = 0;
1011
1012   /* We have found a "L" or "U" suffix.  */
1013   int found_suffix = 0;
1014
1015   unsigned LONGEST high_bit;
1016   struct type *signed_type;
1017   struct type *unsigned_type;
1018
1019   if (parsed_float)
1020     {
1021       if (! parse_c_float (parse_gdbarch, p, len,
1022                            &putithere->typed_val_float.dval,
1023                            &putithere->typed_val_float.type))
1024         return ERROR;
1025       return FLOAT;
1026     }
1027
1028   /* Handle base-switching prefixes 0x, 0t, 0d, and 0.  */
1029   if (p[0] == '0')
1030     switch (p[1])
1031       {
1032       case 'x':
1033       case 'X':
1034         if (len >= 3)
1035           {
1036             p += 2;
1037             base = 16;
1038             len -= 2;
1039           }
1040         break;
1041
1042       case 't':
1043       case 'T':
1044       case 'd':
1045       case 'D':
1046         if (len >= 3)
1047           {
1048             p += 2;
1049             base = 10;
1050             len -= 2;
1051           }
1052         break;
1053
1054       default:
1055         base = 8;
1056         break;
1057       }
1058
1059   while (len-- > 0)
1060     {
1061       c = *p++;
1062       if (c >= 'A' && c <= 'Z')
1063         c += 'a' - 'A';
1064       if (c != 'l' && c != 'u')
1065         n *= base;
1066       if (c >= '0' && c <= '9')
1067         {
1068           if (found_suffix)
1069             return ERROR;
1070           n += i = c - '0';
1071         }
1072       else
1073         {
1074           if (base > 10 && c >= 'a' && c <= 'f')
1075             {
1076               if (found_suffix)
1077                 return ERROR;
1078               n += i = c - 'a' + 10;
1079             }
1080           else if (c == 'l')
1081             {
1082               ++long_p;
1083               found_suffix = 1;
1084             }
1085           else if (c == 'u')
1086             {
1087               unsigned_p = 1;
1088               found_suffix = 1;
1089             }
1090           else
1091             return ERROR;       /* Char not a digit.  */
1092         }
1093       if (i >= base)
1094         return ERROR;           /* Invalid digit in this base.  */
1095
1096       /* Portably test for overflow (only works for nonzero values, so
1097          make a second check for zero).  FIXME: Can't we just make n
1098          and prevn unsigned and avoid this?  */
1099       if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
1100         unsigned_p = 1;         /* Try something unsigned.  */
1101
1102       /* Portably test for unsigned overflow.
1103          FIXME: This check is wrong; for example it doesn't find
1104          overflow on 0x123456789 when LONGEST is 32 bits.  */
1105       if (c != 'l' && c != 'u' && n != 0)
1106         {
1107           if ((unsigned_p && (unsigned LONGEST) prevn >= (unsigned LONGEST) n))
1108             error (_("Numeric constant too large."));
1109         }
1110       prevn = n;
1111     }
1112
1113   /* An integer constant is an int, a long, or a long long.  An L
1114      suffix forces it to be long; an LL suffix forces it to be long
1115      long.  If not forced to a larger size, it gets the first type of
1116      the above that it fits in.  To figure out whether it fits, we
1117      shift it right and see whether anything remains.  Note that we
1118      can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
1119      operation, because many compilers will warn about such a shift
1120      (which always produces a zero result).  Sometimes gdbarch_int_bit
1121      or gdbarch_long_int will be that big, sometimes not.  To deal with
1122      the case where it is we just always shift the value more than
1123      once, with fewer bits each time.  */
1124
1125   un = (unsigned LONGEST)n >> 2;
1126   if (long_p == 0
1127       && (un >> (gdbarch_int_bit (parse_gdbarch) - 2)) == 0)
1128     {
1129       high_bit
1130         = ((unsigned LONGEST)1) << (gdbarch_int_bit (parse_gdbarch) - 1);
1131
1132       /* A large decimal (not hex or octal) constant (between INT_MAX
1133          and UINT_MAX) is a long or unsigned long, according to ANSI,
1134          never an unsigned int, but this code treats it as unsigned
1135          int.  This probably should be fixed.  GCC gives a warning on
1136          such constants.  */
1137
1138       unsigned_type = parse_type->builtin_unsigned_int;
1139       signed_type = parse_type->builtin_int;
1140     }
1141   else if (long_p <= 1
1142            && (un >> (gdbarch_long_bit (parse_gdbarch) - 2)) == 0)
1143     {
1144       high_bit
1145         = ((unsigned LONGEST)1) << (gdbarch_long_bit (parse_gdbarch) - 1);
1146       unsigned_type = parse_type->builtin_unsigned_long;
1147       signed_type = parse_type->builtin_long;
1148     }
1149   else
1150     {
1151       high_bit = (((unsigned LONGEST)1)
1152                   << (gdbarch_long_long_bit (parse_gdbarch) - 32 - 1)
1153                   << 16
1154                   << 16);
1155       if (high_bit == 0)
1156         /* A long long does not fit in a LONGEST.  */
1157         high_bit =
1158           (unsigned LONGEST)1 << (sizeof (LONGEST) * HOST_CHAR_BIT - 1);
1159       unsigned_type = parse_type->builtin_unsigned_long_long;
1160       signed_type = parse_type->builtin_long_long;
1161     }
1162
1163    putithere->typed_val_int.val = n;
1164
1165    /* If the high bit of the worked out type is set then this number
1166       has to be unsigned.  */
1167
1168    if (unsigned_p || (n & high_bit))
1169      {
1170        putithere->typed_val_int.type = unsigned_type;
1171      }
1172    else
1173      {
1174        putithere->typed_val_int.type = signed_type;
1175      }
1176
1177    return INT;
1178 }
1179
1180 struct token
1181 {
1182   char *operator;
1183   int token;
1184   enum exp_opcode opcode;
1185 };
1186
1187 static const struct token tokentab3[] =
1188   {
1189     {">>=", ASSIGN_MODIFY, BINOP_RSH},
1190     {"<<=", ASSIGN_MODIFY, BINOP_LSH}
1191   };
1192
1193 static const struct token tokentab2[] =
1194   {
1195     {"+=", ASSIGN_MODIFY, BINOP_ADD},
1196     {"-=", ASSIGN_MODIFY, BINOP_SUB},
1197     {"*=", ASSIGN_MODIFY, BINOP_MUL},
1198     {"/=", ASSIGN_MODIFY, BINOP_DIV},
1199     {"%=", ASSIGN_MODIFY, BINOP_REM},
1200     {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
1201     {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
1202     {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
1203     {"++", INCREMENT, BINOP_END},
1204     {"--", DECREMENT, BINOP_END},
1205     {"->", ARROW, BINOP_END},
1206     {"&&", ANDAND, BINOP_END},
1207     {"||", OROR, BINOP_END},
1208     {"::", COLONCOLON, BINOP_END},
1209     {"<<", LSH, BINOP_END},
1210     {">>", RSH, BINOP_END},
1211     {"==", EQUAL, BINOP_END},
1212     {"!=", NOTEQUAL, BINOP_END},
1213     {"<=", LEQ, BINOP_END},
1214     {">=", GEQ, BINOP_END}
1215   };
1216
1217 /* Read one token, getting characters through lexptr.  */
1218
1219 static int
1220 yylex (void)
1221 {
1222   int c, tokchr;
1223   int namelen;
1224   unsigned int i;
1225   char *tokstart;
1226   char *tokptr;
1227   int tempbufindex;
1228   static char *tempbuf;
1229   static int tempbufsize;
1230
1231  retry:
1232
1233   tokstart = lexptr;
1234   /* See if it is a special token of length 3.  */
1235   for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1236     if (strncmp (tokstart, tokentab3[i].operator, 3) == 0)
1237       {
1238         lexptr += 3;
1239         yylval.opcode = tokentab3[i].opcode;
1240         return tokentab3[i].token;
1241       }
1242
1243   /* See if it is a special token of length 2.  */
1244   for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1245     if (strncmp (tokstart, tokentab2[i].operator, 2) == 0)
1246       {
1247         lexptr += 2;
1248         yylval.opcode = tokentab2[i].opcode;
1249         return tokentab2[i].token;
1250       }
1251
1252   c = 0;
1253   switch (tokchr = *tokstart)
1254     {
1255     case 0:
1256       return 0;
1257
1258     case ' ':
1259     case '\t':
1260     case '\n':
1261       lexptr++;
1262       goto retry;
1263
1264     case '\'':
1265       /* We either have a character constant ('0' or '\177' for
1266          example) or we have a quoted symbol reference ('foo(int,int)'
1267          in C++ for example).  */
1268       lexptr++;
1269       c = *lexptr++;
1270       if (c == '\\')
1271         c = parse_escape (parse_gdbarch, &lexptr);
1272       else if (c == '\'')
1273         error (_("Empty character constant."));
1274
1275       yylval.typed_val_int.val = c;
1276       yylval.typed_val_int.type = parse_type->builtin_char;
1277
1278       c = *lexptr++;
1279       if (c != '\'')
1280         {
1281           namelen = skip_quoted (tokstart) - tokstart;
1282           if (namelen > 2)
1283             {
1284               lexptr = tokstart + namelen;
1285               if (lexptr[-1] != '\'')
1286                 error (_("Unmatched single quote."));
1287               namelen -= 2;
1288               tokstart++;
1289               goto tryname;
1290             }
1291           error (_("Invalid character constant."));
1292         }
1293       return INT;
1294
1295     case '(':
1296       paren_depth++;
1297       lexptr++;
1298       return '(';
1299
1300     case ')':
1301       if (paren_depth == 0)
1302         return 0;
1303       paren_depth--;
1304       lexptr++;
1305       return ')';
1306
1307     case ',':
1308       if (comma_terminates && paren_depth == 0)
1309         return 0;
1310       lexptr++;
1311       return ',';
1312
1313     case '.':
1314       /* Might be a floating point number.  */
1315       if (lexptr[1] < '0' || lexptr[1] > '9')
1316         goto symbol;            /* Nope, must be a symbol.  */
1317       /* FALL THRU into number case.  */
1318
1319     case '0':
1320     case '1':
1321     case '2':
1322     case '3':
1323     case '4':
1324     case '5':
1325     case '6':
1326     case '7':
1327     case '8':
1328     case '9':
1329       {
1330         /* It's a number.  */
1331         int got_dot = 0, got_e = 0, toktype = FLOAT;
1332         /* Initialize toktype to anything other than ERROR.  */
1333         char *p = tokstart;
1334         int hex = input_radix > 10;
1335         int local_radix = input_radix;
1336         if (tokchr == '0' && (p[1] == 'x' || p[1] == 'X'))
1337           {
1338             p += 2;
1339             hex = 1;
1340             local_radix = 16;
1341           }
1342         else if (tokchr == '0' && (p[1]=='t' || p[1]=='T'
1343                                    || p[1]=='d' || p[1]=='D'))
1344           {
1345             p += 2;
1346             hex = 0;
1347             local_radix = 10;
1348           }
1349
1350         for (;; ++p)
1351           {
1352             /* This test includes !hex because 'e' is a valid hex digit
1353                and thus does not indicate a floating point number when
1354                the radix is hex.  */
1355
1356             if (!hex && (*p == 'e' || *p == 'E'))
1357               if (got_e)
1358                 toktype = ERROR;        /* Only one 'e' in a float.  */
1359               else
1360                 got_e = 1;
1361             /* This test does not include !hex, because a '.' always
1362                indicates a decimal floating point number regardless of
1363                the radix.  */
1364             else if (*p == '.')
1365               if (got_dot)
1366                 toktype = ERROR;        /* Only one '.' in a float.  */
1367               else
1368                 got_dot = 1;
1369             else if (got_e && (p[-1] == 'e' || p[-1] == 'E') &&
1370                     (*p == '-' || *p == '+'))
1371               /* This is the sign of the exponent, not the end of the
1372                  number.  */
1373               continue;
1374             /* Always take decimal digits; parse_number handles radix
1375                error.  */
1376             else if (*p >= '0' && *p <= '9')
1377               continue;
1378             /* We will take letters only if hex is true, and only up
1379                to what the input radix would permit.  FSF was content
1380                to rely on parse_number to validate; but it leaks.  */
1381             else if (*p >= 'a' && *p <= 'z')
1382               {
1383                 if (!hex || *p >= ('a' + local_radix - 10))
1384                   toktype = ERROR;
1385               }
1386             else if (*p >= 'A' && *p <= 'Z')
1387               {
1388                 if (!hex || *p >= ('A' + local_radix - 10))
1389                   toktype = ERROR;
1390               }
1391             else break;
1392           }
1393         if (toktype != ERROR)
1394           toktype = parse_number (tokstart, p - tokstart,
1395                                   got_dot | got_e, &yylval);
1396         if (toktype == ERROR)
1397           {
1398             char *err_copy = (char *) alloca (p - tokstart + 1);
1399
1400             memcpy (err_copy, tokstart, p - tokstart);
1401             err_copy[p - tokstart] = 0;
1402             error (_("Invalid number \"%s\"."), err_copy);
1403           }
1404         lexptr = p;
1405         return toktype;
1406       }
1407
1408     case '+':
1409     case '-':
1410     case '*':
1411     case '/':
1412     case '%':
1413     case '|':
1414     case '&':
1415     case '^':
1416     case '~':
1417     case '!':
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 (char *msg)
1780 {
1781   if (*lexptr == '\0')
1782     error(_("A %s near end of expression."),  (msg ? msg : "error"));
1783   else
1784     error (_("A %s in expression, near `%s'."), (msg ? msg : "error"),
1785            lexptr);
1786 }