gdb/c-exp.y

   1 /* YACC parser for C expressions, for GDB.
   2    Copyright (C) 1986, 1989-2000, 2003-2004, 2006-2012 Free Software
   3    Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 /* Parse a C expression from text in a string,
  21    and return the result as a  struct expression  pointer.
  22    That structure contains arithmetic operations in reverse polish,
  23    with constants represented by operations that are followed by special data.
  24    See expression.h for the details of the format.
  25    What is important here is that it can be built up sequentially
  26    during the process of parsing; the lower levels of the tree always
  27    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 parser
  32    generator.  Doing this with #defines and trying to control the interaction
  33    with include files (<malloc.h> and <stdlib.h> for example) just became
  34    too messy, particularly when such includes can be inserted at random
  35    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 #include "value.h"
  44 #include "parser-defs.h"
  45 #include "language.h"
  46 #include "c-lang.h"
  47 #include "bfd.h" /* Required by objfiles.h.  */
  48 #include "symfile.h" /* Required by objfiles.h.  */
  49 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
  50 #include "charset.h"
  51 #include "block.h"
  52 #include "cp-support.h"
  53 #include "dfp.h"
  54 #include "gdb_assert.h"
  55 #include "macroscope.h"
  56 #include "objc-lang.h"
  57 #include "typeprint.h"
  58
  59 #define parse_type builtin_type (parse_gdbarch)
  60
  61 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
  62    as well as gratuitiously global symbol names, so we can have multiple
  63    yacc generated parsers in gdb.  Note that these are only the variables
  64    produced by yacc.  If other parser generators (bison, byacc, etc) produce
  65    additional global names that conflict at link time, then those parser
  66    generators need to be fixed instead of adding those names to this list. */
  67
  68 #define yymaxdepth c_maxdepth
  69 #define yyparse c_parse_internal
  70 #define yylex   c_lex
  71 #define yyerror c_error
  72 #define yylval  c_lval
  73 #define yychar  c_char
  74 #define yydebug c_debug
  75 #define yypact  c_pact
  76 #define yyr1    c_r1
  77 #define yyr2    c_r2
  78 #define yydef   c_def
  79 #define yychk   c_chk
  80 #define yypgo   c_pgo
  81 #define yyact   c_act
  82 #define yyexca  c_exca
  83 #define yyerrflag c_errflag
  84 #define yynerrs c_nerrs
  85 #define yyps    c_ps
  86 #define yypv    c_pv
  87 #define yys     c_s
  88 #define yy_yys  c_yys
  89 #define yystate c_state
  90 #define yytmp   c_tmp
  91 #define yyv     c_v
  92 #define yy_yyv  c_yyv
  93 #define yyval   c_val
  94 #define yylloc  c_lloc
  95 #define yyreds  c_reds          /* With YYDEBUG defined */
  96 #define yytoks  c_toks          /* With YYDEBUG defined */
  97 #define yyname  c_name          /* With YYDEBUG defined */
  98 #define yyrule  c_rule          /* With YYDEBUG defined */
  99 #define yylhs   c_yylhs
 100 #define yylen   c_yylen
 101 #define yydefred c_yydefred
 102 #define yydgoto c_yydgoto
 103 #define yysindex c_yysindex
 104 #define yyrindex c_yyrindex
 105 #define yygindex c_yygindex
 106 #define yytable  c_yytable
 107 #define yycheck  c_yycheck
 108 #define yyss    c_yyss
 109 #define yysslim c_yysslim
 110 #define yyssp   c_yyssp
 111 #define yystacksize c_yystacksize
 112 #define yyvs    c_yyvs
 113 #define yyvsp   c_yyvsp
 114
 115 #ifndef YYDEBUG
 116 #define YYDEBUG 1               /* Default to yydebug support */
 117 #endif
 118
 119 #define YYFPRINTF parser_fprintf
 120
 121 int yyparse (void);
 122
 123 static int yylex (void);
 124
 125 void yyerror (char *);
 126
 127 %}
 128
 129 /* Although the yacc "value" of an expression is not used,
 130    since the result is stored in the structure being created,
 131    other node types do have values.  */
 132
 133 %union
 134   {
 135     LONGEST lval;
 136     struct {
 137       LONGEST val;
 138       struct type *type;
 139     } typed_val_int;
 140     struct {
 141       DOUBLEST dval;
 142       struct type *type;
 143     } typed_val_float;
 144     struct {
 145       gdb_byte val[16];
 146       struct type *type;
 147     } typed_val_decfloat;
 148     struct symbol *sym;
 149     struct type *tval;
 150     struct stoken sval;
 151     struct typed_stoken tsval;
 152     struct ttype tsym;
 153     struct symtoken ssym;
 154     int voidval;
 155     struct block *bval;
 156     enum exp_opcode opcode;
 157     struct internalvar *ivar;
 158
 159     struct stoken_vector svec;
 160     VEC (type_ptr) *tvec;
 161     int *ivec;
 162
 163     struct type_stack *type_stack;
 164
 165     struct objc_class_str class;
 166   }
 167
 168 %{
 169 /* YYSTYPE gets defined by %union */
 170 static int parse_number (char *, int, int, YYSTYPE *);
 171 static struct stoken operator_stoken (const char *);
 172 static void check_parameter_typelist (VEC (type_ptr) *);
 173 %}
 174
 175 %type <voidval> exp exp1 type_exp start variable qualified_name lcurly
 176 %type <lval> rcurly
 177 %type <tval> type typebase
 178 %type <tvec> nonempty_typelist func_mod parameter_typelist
 179 /* %type <bval> block */
 180
 181 /* Fancy type parsing.  */
 182 %type <tval> ptype
 183 %type <lval> array_mod
 184 %type <tval> conversion_type_id
 185
 186 %type <type_stack> ptr_operator_ts abs_decl direct_abs_decl
 187
 188 %token <typed_val_int> INT
 189 %token <typed_val_float> FLOAT
 190 %token <typed_val_decfloat> DECFLOAT
 191
 192 /* Both NAME and TYPENAME tokens represent symbols in the input,
 193    and both convey their data as strings.
 194    But a TYPENAME is a string that happens to be defined as a typedef
 195    or builtin type name (such as int or char)
 196    and a NAME is any other symbol.
 197    Contexts where this distinction is not important can use the
 198    nonterminal "name", which matches either NAME or TYPENAME.  */
 199
 200 %token <tsval> STRING
 201 %token <sval> NSSTRING          /* ObjC Foundation "NSString" literal */
 202 %token SELECTOR                 /* ObjC "@selector" pseudo-operator   */
 203 %token <tsval> CHAR
 204 %token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */
 205 %token <ssym> UNKNOWN_CPP_NAME
 206 %token <voidval> COMPLETE
 207 %token <tsym> TYPENAME
 208 %token <class> CLASSNAME        /* ObjC Class name */
 209 %type <sval> name
 210 %type <svec> string_exp
 211 %type <ssym> name_not_typename
 212 %type <tsym> typename
 213
 214  /* This is like a '[' token, but is only generated when parsing
 215     Objective C.  This lets us reuse the same parser without
 216     erroneously parsing ObjC-specific expressions in C.  */
 217 %token OBJC_LBRAC
 218
 219 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
 220    but which would parse as a valid number in the current input radix.
 221    E.g. "c" when input_radix==16.  Depending on the parse, it will be
 222    turned into a name or into a number.  */
 223
 224 %token <ssym> NAME_OR_INT
 225
 226 %token OPERATOR
 227 %token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
 228 %token TEMPLATE
 229 %token ERROR
 230 %token NEW DELETE
 231 %type <sval> operator
 232 %token REINTERPRET_CAST DYNAMIC_CAST STATIC_CAST CONST_CAST
 233 %token ENTRY
 234 %token TYPEOF
 235 %token DECLTYPE
 236
 237 /* Special type cases, put in to allow the parser to distinguish different
 238    legal basetypes.  */
 239 %token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD DOUBLE_KEYWORD
 240
 241 %token <sval> VARIABLE
 242
 243 %token <opcode> ASSIGN_MODIFY
 244
 245 /* C++ */
 246 %token TRUEKEYWORD
 247 %token FALSEKEYWORD
 248
 249
 250 %left ','
 251 %left ABOVE_COMMA
 252 %right '=' ASSIGN_MODIFY
 253 %right '?'
 254 %left OROR
 255 %left ANDAND
 256 %left '|'
 257 %left '^'
 258 %left '&'
 259 %left EQUAL NOTEQUAL
 260 %left '<' '>' LEQ GEQ
 261 %left LSH RSH
 262 %left '@'
 263 %left '+' '-'
 264 %left '*' '/' '%'
 265 %right UNARY INCREMENT DECREMENT
 266 %right ARROW ARROW_STAR '.' DOT_STAR '[' OBJC_LBRAC '('
 267 %token <ssym> BLOCKNAME
 268 %token <bval> FILENAME
 269 %type <bval> block
 270 %left COLONCOLON
 271
 272 %token DOTDOTDOT
 273
 274 \f
 275 %%
 276
 277 start   :       exp1
 278         |       type_exp
 279         ;
 280
 281 type_exp:       type
 282                         { write_exp_elt_opcode(OP_TYPE);
 283                           write_exp_elt_type($1);
 284                           write_exp_elt_opcode(OP_TYPE);}
 285         |       TYPEOF '(' exp ')'
 286                         {
 287                           write_exp_elt_opcode (OP_TYPEOF);
 288                         }
 289         |       TYPEOF '(' type ')'
 290                         {
 291                           write_exp_elt_opcode (OP_TYPE);
 292                           write_exp_elt_type ($3);
 293                           write_exp_elt_opcode (OP_TYPE);
 294                         }
 295         |       DECLTYPE '(' exp ')'
 296                         {
 297                           write_exp_elt_opcode (OP_DECLTYPE);
 298                         }
 299         ;
 300
 301 /* Expressions, including the comma operator.  */
 302 exp1    :       exp
 303         |       exp1 ',' exp
 304                         { write_exp_elt_opcode (BINOP_COMMA); }
 305         ;
 306
 307 /* Expressions, not including the comma operator.  */
 308 exp     :       '*' exp    %prec UNARY
 309                         { write_exp_elt_opcode (UNOP_IND); }
 310         ;
 311
 312 exp     :       '&' exp    %prec UNARY
 313                         { write_exp_elt_opcode (UNOP_ADDR); }
 314         ;
 315
 316 exp     :       '-' exp    %prec UNARY
 317                         { write_exp_elt_opcode (UNOP_NEG); }
 318         ;
 319
 320 exp     :       '+' exp    %prec UNARY
 321                         { write_exp_elt_opcode (UNOP_PLUS); }
 322         ;
 323
 324 exp     :       '!' exp    %prec UNARY
 325                         { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
 326         ;
 327
 328 exp     :       '~' exp    %prec UNARY
 329                         { write_exp_elt_opcode (UNOP_COMPLEMENT); }
 330         ;
 331
 332 exp     :       INCREMENT exp    %prec UNARY
 333                         { write_exp_elt_opcode (UNOP_PREINCREMENT); }
 334         ;
 335
 336 exp     :       DECREMENT exp    %prec UNARY
 337                         { write_exp_elt_opcode (UNOP_PREDECREMENT); }
 338         ;
 339
 340 exp     :       exp INCREMENT    %prec UNARY
 341                         { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
 342         ;
 343
 344 exp     :       exp DECREMENT    %prec UNARY
 345                         { write_exp_elt_opcode (UNOP_POSTDECREMENT); }
 346         ;
 347
 348 exp     :       SIZEOF exp       %prec UNARY
 349                         { write_exp_elt_opcode (UNOP_SIZEOF); }
 350         ;
 351
 352 exp     :       exp ARROW name
 353                         { write_exp_elt_opcode (STRUCTOP_PTR);
 354                           write_exp_string ($3);
 355                           write_exp_elt_opcode (STRUCTOP_PTR); }
 356         ;
 357
 358 exp     :       exp ARROW name COMPLETE
 359                         { mark_struct_expression ();
 360                           write_exp_elt_opcode (STRUCTOP_PTR);
 361                           write_exp_string ($3);
 362                           write_exp_elt_opcode (STRUCTOP_PTR); }
 363         ;
 364
 365 exp     :       exp ARROW COMPLETE
 366                         { struct stoken s;
 367                           mark_struct_expression ();
 368                           write_exp_elt_opcode (STRUCTOP_PTR);
 369                           s.ptr = "";
 370                           s.length = 0;
 371                           write_exp_string (s);
 372                           write_exp_elt_opcode (STRUCTOP_PTR); }
 373         ;
 374
 375 exp     :       exp ARROW qualified_name
 376                         { /* exp->type::name becomes exp->*(&type::name) */
 377                           /* Note: this doesn't work if name is a
 378                              static member!  FIXME */
 379                           write_exp_elt_opcode (UNOP_ADDR);
 380                           write_exp_elt_opcode (STRUCTOP_MPTR); }
 381         ;
 382
 383 exp     :       exp ARROW_STAR exp
 384                         { write_exp_elt_opcode (STRUCTOP_MPTR); }
 385         ;
 386
 387 exp     :       exp '.' name
 388                         { write_exp_elt_opcode (STRUCTOP_STRUCT);
 389                           write_exp_string ($3);
 390                           write_exp_elt_opcode (STRUCTOP_STRUCT); }
 391         ;
 392
 393 exp     :       exp '.' name COMPLETE
 394                         { mark_struct_expression ();
 395                           write_exp_elt_opcode (STRUCTOP_STRUCT);
 396                           write_exp_string ($3);
 397                           write_exp_elt_opcode (STRUCTOP_STRUCT); }
 398         ;
 399
 400 exp     :       exp '.' COMPLETE
 401                         { struct stoken s;
 402                           mark_struct_expression ();
 403                           write_exp_elt_opcode (STRUCTOP_STRUCT);
 404                           s.ptr = "";
 405                           s.length = 0;
 406                           write_exp_string (s);
 407                           write_exp_elt_opcode (STRUCTOP_STRUCT); }
 408         ;
 409
 410 exp     :       exp '.' qualified_name
 411                         { /* exp.type::name becomes exp.*(&type::name) */
 412                           /* Note: this doesn't work if name is a
 413                              static member!  FIXME */
 414                           write_exp_elt_opcode (UNOP_ADDR);
 415                           write_exp_elt_opcode (STRUCTOP_MEMBER); }
 416         ;
 417
 418 exp     :       exp DOT_STAR exp
 419                         { write_exp_elt_opcode (STRUCTOP_MEMBER); }
 420         ;
 421
 422 exp     :       exp '[' exp1 ']'
 423                         { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
 424         ;
 425
 426 exp     :       exp OBJC_LBRAC exp1 ']'
 427                         { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
 428         ;
 429
 430 /*
 431  * The rules below parse ObjC message calls of the form:
 432  *      '[' target selector {':' argument}* ']'
 433  */
 434
 435 exp     :       OBJC_LBRAC TYPENAME
 436                         {
 437                           CORE_ADDR class;
 438
 439                           class = lookup_objc_class (parse_gdbarch,
 440                                                      copy_name ($2.stoken));
 441                           if (class == 0)
 442                             error (_("%s is not an ObjC Class"),
 443                                    copy_name ($2.stoken));
 444                           write_exp_elt_opcode (OP_LONG);
 445                           write_exp_elt_type (parse_type->builtin_int);
 446                           write_exp_elt_longcst ((LONGEST) class);
 447                           write_exp_elt_opcode (OP_LONG);
 448                           start_msglist();
 449                         }
 450                 msglist ']'
 451                         { write_exp_elt_opcode (OP_OBJC_MSGCALL);
 452                           end_msglist();
 453                           write_exp_elt_opcode (OP_OBJC_MSGCALL);
 454                         }
 455         ;
 456
 457 exp     :       OBJC_LBRAC CLASSNAME
 458                         {
 459                           write_exp_elt_opcode (OP_LONG);
 460                           write_exp_elt_type (parse_type->builtin_int);
 461                           write_exp_elt_longcst ((LONGEST) $2.class);
 462                           write_exp_elt_opcode (OP_LONG);
 463                           start_msglist();
 464                         }
 465                 msglist ']'
 466                         { write_exp_elt_opcode (OP_OBJC_MSGCALL);
 467                           end_msglist();
 468                           write_exp_elt_opcode (OP_OBJC_MSGCALL);
 469                         }
 470         ;
 471
 472 exp     :       OBJC_LBRAC exp
 473                         { start_msglist(); }
 474                 msglist ']'
 475                         { write_exp_elt_opcode (OP_OBJC_MSGCALL);
 476                           end_msglist();
 477                           write_exp_elt_opcode (OP_OBJC_MSGCALL);
 478                         }
 479         ;
 480
 481 msglist :       name
 482                         { add_msglist(&$1, 0); }
 483         |       msgarglist
 484         ;
 485
 486 msgarglist :    msgarg
 487         |       msgarglist msgarg
 488         ;
 489
 490 msgarg  :       name ':' exp
 491                         { add_msglist(&$1, 1); }
 492         |       ':' exp /* Unnamed arg.  */
 493                         { add_msglist(0, 1);   }
 494         |       ',' exp /* Variable number of args.  */
 495                         { add_msglist(0, 0);   }
 496         ;
 497
 498 exp     :       exp '('
 499                         /* This is to save the value of arglist_len
 500                            being accumulated by an outer function call.  */
 501                         { start_arglist (); }
 502                 arglist ')'     %prec ARROW
 503                         { write_exp_elt_opcode (OP_FUNCALL);
 504                           write_exp_elt_longcst ((LONGEST) end_arglist ());
 505                           write_exp_elt_opcode (OP_FUNCALL); }
 506         ;
 507
 508 exp     :       UNKNOWN_CPP_NAME '('
 509                         {
 510                           /* This could potentially be a an argument defined
 511                              lookup function (Koenig).  */
 512                           write_exp_elt_opcode (OP_ADL_FUNC);
 513                           write_exp_elt_block (expression_context_block);
 514                           write_exp_elt_sym (NULL); /* Placeholder.  */
 515                           write_exp_string ($1.stoken);
 516                           write_exp_elt_opcode (OP_ADL_FUNC);
 517
 518                         /* This is to save the value of arglist_len
 519                            being accumulated by an outer function call.  */
 520
 521                           start_arglist ();
 522                         }
 523                 arglist ')'     %prec ARROW
 524                         {
 525                           write_exp_elt_opcode (OP_FUNCALL);
 526                           write_exp_elt_longcst ((LONGEST) end_arglist ());
 527                           write_exp_elt_opcode (OP_FUNCALL);
 528                         }
 529         ;
 530
 531 lcurly  :       '{'
 532                         { start_arglist (); }
 533         ;
 534
 535 arglist :
 536         ;
 537
 538 arglist :       exp
 539                         { arglist_len = 1; }
 540         ;
 541
 542 arglist :       arglist ',' exp   %prec ABOVE_COMMA
 543                         { arglist_len++; }
 544         ;
 545
 546 exp     :       exp '(' parameter_typelist ')' const_or_volatile
 547                         { int i;
 548                           VEC (type_ptr) *type_list = $3;
 549                           struct type *type_elt;
 550                           LONGEST len = VEC_length (type_ptr, type_list);
 551
 552                           write_exp_elt_opcode (TYPE_INSTANCE);
 553                           write_exp_elt_longcst (len);
 554                           for (i = 0;
 555                                VEC_iterate (type_ptr, type_list, i, type_elt);
 556                                ++i)
 557                             write_exp_elt_type (type_elt);
 558                           write_exp_elt_longcst(len);
 559                           write_exp_elt_opcode (TYPE_INSTANCE);
 560                           VEC_free (type_ptr, type_list);
 561                         }
 562         ;
 563
 564 rcurly  :       '}'
 565                         { $$ = end_arglist () - 1; }
 566         ;
 567 exp     :       lcurly arglist rcurly   %prec ARROW
 568                         { write_exp_elt_opcode (OP_ARRAY);
 569                           write_exp_elt_longcst ((LONGEST) 0);
 570                           write_exp_elt_longcst ((LONGEST) $3);
 571                           write_exp_elt_opcode (OP_ARRAY); }
 572         ;
 573
 574 exp     :       lcurly type_exp rcurly exp  %prec UNARY
 575                         { write_exp_elt_opcode (UNOP_MEMVAL_TYPE); }
 576         ;
 577
 578 exp     :       '(' type_exp ')' exp  %prec UNARY
 579                         { write_exp_elt_opcode (UNOP_CAST_TYPE); }
 580         ;
 581
 582 exp     :       '(' exp1 ')'
 583                         { }
 584         ;
 585
 586 /* Binary operators in order of decreasing precedence.  */
 587
 588 exp     :       exp '@' exp
 589                         { write_exp_elt_opcode (BINOP_REPEAT); }
 590         ;
 591
 592 exp     :       exp '*' exp
 593                         { write_exp_elt_opcode (BINOP_MUL); }
 594         ;
 595
 596 exp     :       exp '/' exp
 597                         { write_exp_elt_opcode (BINOP_DIV); }
 598         ;
 599
 600 exp     :       exp '%' exp
 601                         { write_exp_elt_opcode (BINOP_REM); }
 602         ;
 603
 604 exp     :       exp '+' exp
 605                         { write_exp_elt_opcode (BINOP_ADD); }
 606         ;
 607
 608 exp     :       exp '-' exp
 609                         { write_exp_elt_opcode (BINOP_SUB); }
 610         ;
 611
 612 exp     :       exp LSH exp
 613                         { write_exp_elt_opcode (BINOP_LSH); }
 614         ;
 615
 616 exp     :       exp RSH exp
 617                         { write_exp_elt_opcode (BINOP_RSH); }
 618         ;
 619
 620 exp     :       exp EQUAL exp
 621                         { write_exp_elt_opcode (BINOP_EQUAL); }
 622         ;
 623
 624 exp     :       exp NOTEQUAL exp
 625                         { write_exp_elt_opcode (BINOP_NOTEQUAL); }
 626         ;
 627
 628 exp     :       exp LEQ exp
 629                         { write_exp_elt_opcode (BINOP_LEQ); }
 630         ;
 631
 632 exp     :       exp GEQ exp
 633                         { write_exp_elt_opcode (BINOP_GEQ); }
 634         ;
 635
 636 exp     :       exp '<' exp
 637                         { write_exp_elt_opcode (BINOP_LESS); }
 638         ;
 639
 640 exp     :       exp '>' exp
 641                         { write_exp_elt_opcode (BINOP_GTR); }
 642         ;
 643
 644 exp     :       exp '&' exp
 645                         { write_exp_elt_opcode (BINOP_BITWISE_AND); }
 646         ;
 647
 648 exp     :       exp '^' exp
 649                         { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
 650         ;
 651
 652 exp     :       exp '|' exp
 653                         { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
 654         ;
 655
 656 exp     :       exp ANDAND exp
 657                         { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
 658         ;
 659
 660 exp     :       exp OROR exp
 661                         { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
 662         ;
 663
 664 exp     :       exp '?' exp ':' exp     %prec '?'
 665                         { write_exp_elt_opcode (TERNOP_COND); }
 666         ;
 667
 668 exp     :       exp '=' exp
 669                         { write_exp_elt_opcode (BINOP_ASSIGN); }
 670         ;
 671
 672 exp     :       exp ASSIGN_MODIFY exp
 673                         { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
 674                           write_exp_elt_opcode ($2);
 675                           write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
 676         ;
 677
 678 exp     :       INT
 679                         { write_exp_elt_opcode (OP_LONG);
 680                           write_exp_elt_type ($1.type);
 681                           write_exp_elt_longcst ((LONGEST)($1.val));
 682                           write_exp_elt_opcode (OP_LONG); }
 683         ;
 684
 685 exp     :       CHAR
 686                         {
 687                           struct stoken_vector vec;
 688                           vec.len = 1;
 689                           vec.tokens = &$1;
 690                           write_exp_string_vector ($1.type, &vec);
 691                         }
 692         ;
 693
 694 exp     :       NAME_OR_INT
 695                         { YYSTYPE val;
 696                           parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
 697                           write_exp_elt_opcode (OP_LONG);
 698                           write_exp_elt_type (val.typed_val_int.type);
 699                           write_exp_elt_longcst ((LONGEST)val.typed_val_int.val);
 700                           write_exp_elt_opcode (OP_LONG);
 701                         }
 702         ;
 703
 704
 705 exp     :       FLOAT
 706                         { write_exp_elt_opcode (OP_DOUBLE);
 707                           write_exp_elt_type ($1.type);
 708                           write_exp_elt_dblcst ($1.dval);
 709                           write_exp_elt_opcode (OP_DOUBLE); }
 710         ;
 711
 712 exp     :       DECFLOAT
 713                         { write_exp_elt_opcode (OP_DECFLOAT);
 714                           write_exp_elt_type ($1.type);
 715                           write_exp_elt_decfloatcst ($1.val);
 716                           write_exp_elt_opcode (OP_DECFLOAT); }
 717         ;
 718
 719 exp     :       variable
 720         ;
 721
 722 exp     :       VARIABLE
 723                         {
 724                           write_dollar_variable ($1);
 725                         }
 726         ;
 727
 728 exp     :       SELECTOR '(' name ')'
 729                         {
 730                           write_exp_elt_opcode (OP_OBJC_SELECTOR);
 731                           write_exp_string ($3);
 732                           write_exp_elt_opcode (OP_OBJC_SELECTOR); }
 733         ;
 734
 735 exp     :       SIZEOF '(' type ')'     %prec UNARY
 736                         { write_exp_elt_opcode (OP_LONG);
 737                           write_exp_elt_type (lookup_signed_typename
 738                                               (parse_language, parse_gdbarch,
 739                                                "int"));
 740                           CHECK_TYPEDEF ($3);
 741                           write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
 742                           write_exp_elt_opcode (OP_LONG); }
 743         ;
 744
 745 exp     :       REINTERPRET_CAST '<' type_exp '>' '(' exp ')' %prec UNARY
 746                         { write_exp_elt_opcode (UNOP_REINTERPRET_CAST); }
 747         ;
 748
 749 exp     :       STATIC_CAST '<' type_exp '>' '(' exp ')' %prec UNARY
 750                         { write_exp_elt_opcode (UNOP_CAST_TYPE); }
 751         ;
 752
 753 exp     :       DYNAMIC_CAST '<' type_exp '>' '(' exp ')' %prec UNARY
 754                         { write_exp_elt_opcode (UNOP_DYNAMIC_CAST); }
 755         ;
 756
 757 exp     :       CONST_CAST '<' type_exp '>' '(' exp ')' %prec UNARY
 758                         { /* We could do more error checking here, but
 759                              it doesn't seem worthwhile.  */
 760                           write_exp_elt_opcode (UNOP_CAST_TYPE); }
 761         ;
 762
 763 string_exp:
 764                 STRING
 765                         {
 766                           /* We copy the string here, and not in the
 767                              lexer, to guarantee that we do not leak a
 768                              string.  Note that we follow the
 769                              NUL-termination convention of the
 770                              lexer.  */
 771                           struct typed_stoken *vec = XNEW (struct typed_stoken);
 772                           $$.len = 1;
 773                           $$.tokens = vec;
 774
 775                           vec->type = $1.type;
 776                           vec->length = $1.length;
 777                           vec->ptr = malloc ($1.length + 1);
 778                           memcpy (vec->ptr, $1.ptr, $1.length + 1);
 779                         }
 780
 781         |       string_exp STRING
 782                         {
 783                           /* Note that we NUL-terminate here, but just
 784                              for convenience.  */
 785                           char *p;
 786                           ++$$.len;
 787                           $$.tokens = realloc ($$.tokens,
 788                                                $$.len * sizeof (struct typed_stoken));
 789
 790                           p = malloc ($2.length + 1);
 791                           memcpy (p, $2.ptr, $2.length + 1);
 792
 793                           $$.tokens[$$.len - 1].type = $2.type;
 794                           $$.tokens[$$.len - 1].length = $2.length;
 795                           $$.tokens[$$.len - 1].ptr = p;
 796                         }
 797                 ;
 798
 799 exp     :       string_exp
 800                         {
 801                           int i;
 802                           enum c_string_type type = C_STRING;
 803
 804                           for (i = 0; i < $1.len; ++i)
 805                             {
 806                               switch ($1.tokens[i].type)
 807                                 {
 808                                 case C_STRING:
 809                                   break;
 810                                 case C_WIDE_STRING:
 811                                 case C_STRING_16:
 812                                 case C_STRING_32:
 813                                   if (type != C_STRING
 814                                       && type != $1.tokens[i].type)
 815                                     error (_("Undefined string concatenation."));
 816                                   type = $1.tokens[i].type;
 817                                   break;
 818                                 default:
 819                                   /* internal error */
 820                                   internal_error (__FILE__, __LINE__,
 821                                                   "unrecognized type in string concatenation");
 822                                 }
 823                             }
 824
 825                           write_exp_string_vector (type, &$1);
 826                           for (i = 0; i < $1.len; ++i)
 827                             free ($1.tokens[i].ptr);
 828                           free ($1.tokens);
 829                         }
 830         ;
 831
 832 exp     :       NSSTRING        /* ObjC NextStep NSString constant
 833                                  * of the form '@' '"' string '"'.
 834                                  */
 835                         { write_exp_elt_opcode (OP_OBJC_NSSTRING);
 836                           write_exp_string ($1);
 837                           write_exp_elt_opcode (OP_OBJC_NSSTRING); }
 838         ;
 839
 840 /* C++.  */
 841 exp     :       TRUEKEYWORD
 842                         { write_exp_elt_opcode (OP_LONG);
 843                           write_exp_elt_type (parse_type->builtin_bool);
 844                           write_exp_elt_longcst ((LONGEST) 1);
 845                           write_exp_elt_opcode (OP_LONG); }
 846         ;
 847
 848 exp     :       FALSEKEYWORD
 849                         { write_exp_elt_opcode (OP_LONG);
 850                           write_exp_elt_type (parse_type->builtin_bool);
 851                           write_exp_elt_longcst ((LONGEST) 0);
 852                           write_exp_elt_opcode (OP_LONG); }
 853         ;
 854
 855 /* end of C++.  */
 856
 857 block   :       BLOCKNAME
 858                         {
 859                           if ($1.sym)
 860                             $$ = SYMBOL_BLOCK_VALUE ($1.sym);
 861                           else
 862                             error (_("No file or function \"%s\"."),
 863                                    copy_name ($1.stoken));
 864                         }
 865         |       FILENAME
 866                         {
 867                           $$ = $1;
 868                         }
 869         ;
 870
 871 block   :       block COLONCOLON name
 872                         { struct symbol *tem
 873                             = lookup_symbol (copy_name ($3), $1,
 874                                              VAR_DOMAIN, (int *) NULL);
 875                           if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
 876                             error (_("No function \"%s\" in specified context."),
 877                                    copy_name ($3));
 878                           $$ = SYMBOL_BLOCK_VALUE (tem); }
 879         ;
 880
 881 variable:       name_not_typename ENTRY
 882                         { struct symbol *sym = $1.sym;
 883
 884                           if (sym == NULL || !SYMBOL_IS_ARGUMENT (sym)
 885                               || !symbol_read_needs_frame (sym))
 886                             error (_("@entry can be used only for function "
 887                                      "parameters, not for \"%s\""),
 888                                    copy_name ($1.stoken));
 889
 890                           write_exp_elt_opcode (OP_VAR_ENTRY_VALUE);
 891                           write_exp_elt_sym (sym);
 892                           write_exp_elt_opcode (OP_VAR_ENTRY_VALUE);
 893                         }
 894         ;
 895
 896 variable:       block COLONCOLON name
 897                         { struct symbol *sym;
 898                           sym = lookup_symbol (copy_name ($3), $1,
 899                                                VAR_DOMAIN, (int *) NULL);
 900                           if (sym == 0)
 901                             error (_("No symbol \"%s\" in specified context."),
 902                                    copy_name ($3));
 903                           if (symbol_read_needs_frame (sym))
 904                             {
 905                               if (innermost_block == 0
 906                                   || contained_in (block_found,
 907                                                    innermost_block))
 908                                 innermost_block = block_found;
 909                             }
 910
 911                           write_exp_elt_opcode (OP_VAR_VALUE);
 912                           /* block_found is set by lookup_symbol.  */
 913                           write_exp_elt_block (block_found);
 914                           write_exp_elt_sym (sym);
 915                           write_exp_elt_opcode (OP_VAR_VALUE); }
 916         ;
 917
 918 qualified_name: TYPENAME COLONCOLON name
 919                         {
 920                           struct type *type = $1.type;
 921                           CHECK_TYPEDEF (type);
 922                           if (TYPE_CODE (type) != TYPE_CODE_STRUCT
 923                               && TYPE_CODE (type) != TYPE_CODE_UNION
 924                               && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
 925                             error (_("`%s' is not defined as an aggregate type."),
 926                                    TYPE_NAME (type));
 927
 928                           write_exp_elt_opcode (OP_SCOPE);
 929                           write_exp_elt_type (type);
 930                           write_exp_string ($3);
 931                           write_exp_elt_opcode (OP_SCOPE);
 932                         }
 933         |       TYPENAME COLONCOLON '~' name
 934                         {
 935                           struct type *type = $1.type;
 936                           struct stoken tmp_token;
 937                           CHECK_TYPEDEF (type);
 938                           if (TYPE_CODE (type) != TYPE_CODE_STRUCT
 939                               && TYPE_CODE (type) != TYPE_CODE_UNION
 940                               && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
 941                             error (_("`%s' is not defined as an aggregate type."),
 942                                    TYPE_NAME (type));
 943
 944                           tmp_token.ptr = (char*) alloca ($4.length + 2);
 945                           tmp_token.length = $4.length + 1;
 946                           tmp_token.ptr[0] = '~';
 947                           memcpy (tmp_token.ptr+1, $4.ptr, $4.length);
 948                           tmp_token.ptr[tmp_token.length] = 0;
 949
 950                           /* Check for valid destructor name.  */
 951                           destructor_name_p (tmp_token.ptr, $1.type);
 952                           write_exp_elt_opcode (OP_SCOPE);
 953                           write_exp_elt_type (type);
 954                           write_exp_string (tmp_token);
 955                           write_exp_elt_opcode (OP_SCOPE);
 956                         }
 957         |       TYPENAME COLONCOLON name COLONCOLON name
 958                         {
 959                           char *copy = copy_name ($3);
 960                           error (_("No type \"%s\" within class "
 961                                    "or namespace \"%s\"."),
 962                                  copy, TYPE_NAME ($1.type));
 963                         }
 964         ;
 965
 966 variable:       qualified_name
 967         |       COLONCOLON name_not_typename
 968                         {
 969                           char *name = copy_name ($2.stoken);
 970                           struct symbol *sym;
 971                           struct minimal_symbol *msymbol;
 972
 973                           sym =
 974                             lookup_symbol (name, (const struct block *) NULL,
 975                                            VAR_DOMAIN, (int *) NULL);
 976                           if (sym)
 977                             {
 978                               write_exp_elt_opcode (OP_VAR_VALUE);
 979                               write_exp_elt_block (NULL);
 980                               write_exp_elt_sym (sym);
 981                               write_exp_elt_opcode (OP_VAR_VALUE);
 982                               break;
 983                             }
 984
 985                           msymbol = lookup_minimal_symbol (name, NULL, NULL);
 986                           if (msymbol != NULL)
 987                             write_exp_msymbol (msymbol);
 988                           else if (!have_full_symbols () && !have_partial_symbols ())
 989                             error (_("No symbol table is loaded.  Use the \"file\" command."));
 990                           else
 991                             error (_("No symbol \"%s\" in current context."), name);
 992                         }
 993         ;
 994
 995 variable:       name_not_typename
 996                         { struct symbol *sym = $1.sym;
 997
 998                           if (sym)
 999                             {
1000                               if (symbol_read_needs_frame (sym))
1001                                 {
1002                                   if (innermost_block == 0
1003                                       || contained_in (block_found,
1004                                                        innermost_block))
1005                                     innermost_block = block_found;
1006                                 }
1007
1008                               write_exp_elt_opcode (OP_VAR_VALUE);
1009                               /* We want to use the selected frame, not
1010                                  another more inner frame which happens to
1011                                  be in the same block.  */
1012                               write_exp_elt_block (NULL);
1013                               write_exp_elt_sym (sym);
1014                               write_exp_elt_opcode (OP_VAR_VALUE);
1015                             }
1016                           else if ($1.is_a_field_of_this)
1017                             {
1018                               /* C++: it hangs off of `this'.  Must
1019                                  not inadvertently convert from a method call
1020                                  to data ref.  */
1021                               if (innermost_block == 0
1022                                   || contained_in (block_found,
1023                                                    innermost_block))
1024                                 innermost_block = block_found;
1025                               write_exp_elt_opcode (OP_THIS);
1026                               write_exp_elt_opcode (OP_THIS);
1027                               write_exp_elt_opcode (STRUCTOP_PTR);
1028                               write_exp_string ($1.stoken);
1029                               write_exp_elt_opcode (STRUCTOP_PTR);
1030                             }
1031                           else
1032                             {
1033                               struct minimal_symbol *msymbol;
1034                               char *arg = copy_name ($1.stoken);
1035
1036                               msymbol =
1037                                 lookup_minimal_symbol (arg, NULL, NULL);
1038                               if (msymbol != NULL)
1039                                 write_exp_msymbol (msymbol);
1040                               else if (!have_full_symbols () && !have_partial_symbols ())
1041                                 error (_("No symbol table is loaded.  Use the \"file\" command."));
1042                               else
1043                                 error (_("No symbol \"%s\" in current context."),
1044                                        copy_name ($1.stoken));
1045                             }
1046                         }
1047         ;
1048
1049 space_identifier : '@' NAME
1050                 { insert_type_address_space (copy_name ($2.stoken)); }
1051         ;
1052
1053 const_or_volatile: const_or_volatile_noopt
1054         |
1055         ;
1056
1057 cv_with_space_id : const_or_volatile space_identifier const_or_volatile
1058         ;
1059
1060 const_or_volatile_or_space_identifier_noopt: cv_with_space_id
1061         | const_or_volatile_noopt
1062         ;
1063
1064 const_or_volatile_or_space_identifier:
1065                 const_or_volatile_or_space_identifier_noopt
1066         |
1067         ;
1068
1069 ptr_operator:
1070                 ptr_operator '*'
1071                         { insert_type (tp_pointer); }
1072                 const_or_volatile_or_space_identifier
1073         |       '*'
1074                         { insert_type (tp_pointer); }
1075                 const_or_volatile_or_space_identifier
1076         |       '&'
1077                         { insert_type (tp_reference); }
1078         |       '&' ptr_operator
1079                         { insert_type (tp_reference); }
1080         ;
1081
1082 ptr_operator_ts: ptr_operator
1083                         {
1084                           $$ = get_type_stack ();
1085                           /* This cleanup is eventually run by
1086                              c_parse.  */
1087                           make_cleanup (type_stack_cleanup, $$);
1088                         }
1089         ;
1090
1091 abs_decl:       ptr_operator_ts direct_abs_decl
1092                         { $$ = append_type_stack ($2, $1); }
1093         |       ptr_operator_ts
1094         |       direct_abs_decl
1095         ;
1096
1097 direct_abs_decl: '(' abs_decl ')'
1098                         { $$ = $2; }
1099         |       direct_abs_decl array_mod
1100                         {
1101                           push_type_stack ($1);
1102                           push_type_int ($2);
1103                           push_type (tp_array);
1104                           $$ = get_type_stack ();
1105                         }
1106         |       array_mod
1107                         {
1108                           push_type_int ($1);
1109                           push_type (tp_array);
1110                           $$ = get_type_stack ();
1111                         }
1112
1113         |       direct_abs_decl func_mod
1114                         {
1115                           push_type_stack ($1);
1116                           push_typelist ($2);
1117                           $$ = get_type_stack ();
1118                         }
1119         |       func_mod
1120                         {
1121                           push_typelist ($1);
1122                           $$ = get_type_stack ();
1123                         }
1124         ;
1125
1126 array_mod:      '[' ']'
1127                         { $$ = -1; }
1128         |       OBJC_LBRAC ']'
1129                         { $$ = -1; }
1130         |       '[' INT ']'
1131                         { $$ = $2.val; }
1132         |       OBJC_LBRAC INT ']'
1133                         { $$ = $2.val; }
1134         ;
1135
1136 func_mod:       '(' ')'
1137                         { $$ = NULL; }
1138         |       '(' parameter_typelist ')'
1139                         { $$ = $2; }
1140         ;
1141
1142 /* We used to try to recognize pointer to member types here, but
1143    that didn't work (shift/reduce conflicts meant that these rules never
1144    got executed).  The problem is that
1145      int (foo::bar::baz::bizzle)
1146    is a function type but
1147      int (foo::bar::baz::bizzle::*)
1148    is a pointer to member type.  Stroustrup loses again!  */
1149
1150 type    :       ptype
1151         ;
1152
1153 typebase  /* Implements (approximately): (type-qualifier)* type-specifier */
1154         :       TYPENAME
1155                         { $$ = $1.type; }
1156         |       INT_KEYWORD
1157                         { $$ = lookup_signed_typename (parse_language,
1158                                                        parse_gdbarch,
1159                                                        "int"); }
1160         |       LONG
1161                         { $$ = lookup_signed_typename (parse_language,
1162                                                        parse_gdbarch,
1163                                                        "long"); }
1164         |       SHORT
1165                         { $$ = lookup_signed_typename (parse_language,
1166                                                        parse_gdbarch,
1167                                                        "short"); }
1168         |       LONG INT_KEYWORD
1169                         { $$ = lookup_signed_typename (parse_language,
1170                                                        parse_gdbarch,
1171                                                        "long"); }
1172         |       LONG SIGNED_KEYWORD INT_KEYWORD
1173                         { $$ = lookup_signed_typename (parse_language,
1174                                                        parse_gdbarch,
1175                                                        "long"); }
1176         |       LONG SIGNED_KEYWORD
1177                         { $$ = lookup_signed_typename (parse_language,
1178                                                        parse_gdbarch,
1179                                                        "long"); }
1180         |       SIGNED_KEYWORD LONG INT_KEYWORD
1181                         { $$ = lookup_signed_typename (parse_language,
1182                                                        parse_gdbarch,
1183                                                        "long"); }
1184         |       UNSIGNED LONG INT_KEYWORD
1185                         { $$ = lookup_unsigned_typename (parse_language,
1186                                                          parse_gdbarch,
1187                                                          "long"); }
1188         |       LONG UNSIGNED INT_KEYWORD
1189                         { $$ = lookup_unsigned_typename (parse_language,
1190                                                          parse_gdbarch,
1191                                                          "long"); }
1192         |       LONG UNSIGNED
1193                         { $$ = lookup_unsigned_typename (parse_language,
1194                                                          parse_gdbarch,
1195                                                          "long"); }
1196         |       LONG LONG
1197                         { $$ = lookup_signed_typename (parse_language,
1198                                                        parse_gdbarch,
1199                                                        "long long"); }
1200         |       LONG LONG INT_KEYWORD
1201                         { $$ = lookup_signed_typename (parse_language,
1202                                                        parse_gdbarch,
1203                                                        "long long"); }
1204         |       LONG LONG SIGNED_KEYWORD INT_KEYWORD
1205                         { $$ = lookup_signed_typename (parse_language,
1206                                                        parse_gdbarch,
1207                                                        "long long"); }
1208         |       LONG LONG SIGNED_KEYWORD
1209                         { $$ = lookup_signed_typename (parse_language,
1210                                                        parse_gdbarch,
1211                                                        "long long"); }
1212         |       SIGNED_KEYWORD LONG LONG
1213                         { $$ = lookup_signed_typename (parse_language,
1214                                                        parse_gdbarch,
1215                                                        "long long"); }
1216         |       SIGNED_KEYWORD LONG LONG INT_KEYWORD
1217                         { $$ = lookup_signed_typename (parse_language,
1218                                                        parse_gdbarch,
1219                                                        "long long"); }
1220         |       UNSIGNED LONG LONG
1221                         { $$ = lookup_unsigned_typename (parse_language,
1222                                                          parse_gdbarch,
1223                                                          "long long"); }
1224         |       UNSIGNED LONG LONG INT_KEYWORD
1225                         { $$ = lookup_unsigned_typename (parse_language,
1226                                                          parse_gdbarch,
1227                                                          "long long"); }
1228         |       LONG LONG UNSIGNED
1229                         { $$ = lookup_unsigned_typename (parse_language,
1230                                                          parse_gdbarch,
1231                                                          "long long"); }
1232         |       LONG LONG UNSIGNED INT_KEYWORD
1233                         { $$ = lookup_unsigned_typename (parse_language,
1234                                                          parse_gdbarch,
1235                                                          "long long"); }
1236         |       SHORT INT_KEYWORD
1237                         { $$ = lookup_signed_typename (parse_language,
1238                                                        parse_gdbarch,
1239                                                        "short"); }
1240         |       SHORT SIGNED_KEYWORD INT_KEYWORD
1241                         { $$ = lookup_signed_typename (parse_language,
1242                                                        parse_gdbarch,
1243                                                        "short"); }
1244         |       SHORT SIGNED_KEYWORD
1245                         { $$ = lookup_signed_typename (parse_language,
1246                                                        parse_gdbarch,
1247                                                        "short"); }
1248         |       UNSIGNED SHORT INT_KEYWORD
1249                         { $$ = lookup_unsigned_typename (parse_language,
1250                                                          parse_gdbarch,
1251                                                          "short"); }
1252         |       SHORT UNSIGNED
1253                         { $$ = lookup_unsigned_typename (parse_language,
1254                                                          parse_gdbarch,
1255                                                          "short"); }
1256         |       SHORT UNSIGNED INT_KEYWORD
1257                         { $$ = lookup_unsigned_typename (parse_language,
1258                                                          parse_gdbarch,
1259                                                          "short"); }
1260         |       DOUBLE_KEYWORD
1261                         { $$ = lookup_typename (parse_language, parse_gdbarch,
1262                                                 "double", (struct block *) NULL,
1263                                                 0); }
1264         |       LONG DOUBLE_KEYWORD
1265                         { $$ = lookup_typename (parse_language, parse_gdbarch,
1266                                                 "long double",
1267                                                 (struct block *) NULL, 0); }
1268         |       STRUCT name
1269                         { $$ = lookup_struct (copy_name ($2),
1270                                               expression_context_block); }
1271         |       CLASS name
1272                         { $$ = lookup_struct (copy_name ($2),
1273                                               expression_context_block); }
1274         |       UNION name
1275                         { $$ = lookup_union (copy_name ($2),
1276                                              expression_context_block); }
1277         |       ENUM name
1278                         { $$ = lookup_enum (copy_name ($2),
1279                                             expression_context_block); }
1280         |       UNSIGNED typename
1281                         { $$ = lookup_unsigned_typename (parse_language,
1282                                                          parse_gdbarch,
1283                                                          TYPE_NAME($2.type)); }
1284         |       UNSIGNED
1285                         { $$ = lookup_unsigned_typename (parse_language,
1286                                                          parse_gdbarch,
1287                                                          "int"); }
1288         |       SIGNED_KEYWORD typename
1289                         { $$ = lookup_signed_typename (parse_language,
1290                                                        parse_gdbarch,
1291                                                        TYPE_NAME($2.type)); }
1292         |       SIGNED_KEYWORD
1293                         { $$ = lookup_signed_typename (parse_language,
1294                                                        parse_gdbarch,
1295                                                        "int"); }
1296                 /* It appears that this rule for templates is never
1297                    reduced; template recognition happens by lookahead
1298                    in the token processing code in yylex. */
1299         |       TEMPLATE name '<' type '>'
1300                         { $$ = lookup_template_type(copy_name($2), $4,
1301                                                     expression_context_block);
1302                         }
1303         | const_or_volatile_or_space_identifier_noopt typebase
1304                         { $$ = follow_types ($2); }
1305         | typebase const_or_volatile_or_space_identifier_noopt
1306                         { $$ = follow_types ($1); }
1307         ;
1308
1309 typename:       TYPENAME
1310         |       INT_KEYWORD
1311                 {
1312                   $$.stoken.ptr = "int";
1313                   $$.stoken.length = 3;
1314                   $$.type = lookup_signed_typename (parse_language,
1315                                                     parse_gdbarch,
1316                                                     "int");
1317                 }
1318         |       LONG
1319                 {
1320                   $$.stoken.ptr = "long";
1321                   $$.stoken.length = 4;
1322                   $$.type = lookup_signed_typename (parse_language,
1323                                                     parse_gdbarch,
1324                                                     "long");
1325                 }
1326         |       SHORT
1327                 {
1328                   $$.stoken.ptr = "short";
1329                   $$.stoken.length = 5;
1330                   $$.type = lookup_signed_typename (parse_language,
1331                                                     parse_gdbarch,
1332                                                     "short");
1333                 }
1334         ;
1335
1336 parameter_typelist:
1337                 nonempty_typelist
1338                         { check_parameter_typelist ($1); }
1339         |       nonempty_typelist ',' DOTDOTDOT
1340                         {
1341                           VEC_safe_push (type_ptr, $1, NULL);
1342                           check_parameter_typelist ($1);
1343                           $$ = $1;
1344                         }
1345         ;
1346
1347 nonempty_typelist
1348         :       type
1349                 {
1350                   VEC (type_ptr) *typelist = NULL;
1351                   VEC_safe_push (type_ptr, typelist, $1);
1352                   $$ = typelist;
1353                 }
1354         |       nonempty_typelist ',' type
1355                 {
1356                   VEC_safe_push (type_ptr, $1, $3);
1357                   $$ = $1;
1358                 }
1359         ;
1360
1361 ptype   :       typebase
1362         |       ptype abs_decl
1363                 {
1364                   push_type_stack ($2);
1365                   $$ = follow_types ($1);
1366                 }
1367         ;
1368
1369 conversion_type_id: typebase conversion_declarator
1370                 { $$ = follow_types ($1); }
1371         ;
1372
1373 conversion_declarator:  /* Nothing.  */
1374         | ptr_operator conversion_declarator
1375         ;
1376
1377 const_and_volatile:     CONST_KEYWORD VOLATILE_KEYWORD
1378         |               VOLATILE_KEYWORD CONST_KEYWORD
1379         ;
1380
1381 const_or_volatile_noopt:        const_and_volatile
1382                         { insert_type (tp_const);
1383                           insert_type (tp_volatile);
1384                         }
1385         |               CONST_KEYWORD
1386                         { insert_type (tp_const); }
1387         |               VOLATILE_KEYWORD
1388                         { insert_type (tp_volatile); }
1389         ;
1390
1391 operator:       OPERATOR NEW
1392                         { $$ = operator_stoken (" new"); }
1393         |       OPERATOR DELETE
1394                         { $$ = operator_stoken (" delete"); }
1395         |       OPERATOR NEW '[' ']'
1396                         { $$ = operator_stoken (" new[]"); }
1397         |       OPERATOR DELETE '[' ']'
1398                         { $$ = operator_stoken (" delete[]"); }
1399         |       OPERATOR NEW OBJC_LBRAC ']'
1400                         { $$ = operator_stoken (" new[]"); }
1401         |       OPERATOR DELETE OBJC_LBRAC ']'
1402                         { $$ = operator_stoken (" delete[]"); }
1403         |       OPERATOR '+'
1404                         { $$ = operator_stoken ("+"); }
1405         |       OPERATOR '-'
1406                         { $$ = operator_stoken ("-"); }
1407         |       OPERATOR '*'
1408                         { $$ = operator_stoken ("*"); }
1409         |       OPERATOR '/'
1410                         { $$ = operator_stoken ("/"); }
1411         |       OPERATOR '%'
1412                         { $$ = operator_stoken ("%"); }
1413         |       OPERATOR '^'
1414                         { $$ = operator_stoken ("^"); }
1415         |       OPERATOR '&'
1416                         { $$ = operator_stoken ("&"); }
1417         |       OPERATOR '|'
1418                         { $$ = operator_stoken ("|"); }
1419         |       OPERATOR '~'
1420                         { $$ = operator_stoken ("~"); }
1421         |       OPERATOR '!'
1422                         { $$ = operator_stoken ("!"); }
1423         |       OPERATOR '='
1424                         { $$ = operator_stoken ("="); }
1425         |       OPERATOR '<'
1426                         { $$ = operator_stoken ("<"); }
1427         |       OPERATOR '>'
1428                         { $$ = operator_stoken (">"); }
1429         |       OPERATOR ASSIGN_MODIFY
1430                         { const char *op = "unknown";
1431                           switch ($2)
1432                             {
1433                             case BINOP_RSH:
1434                               op = ">>=";
1435                               break;
1436                             case BINOP_LSH:
1437                               op = "<<=";
1438                               break;
1439                             case BINOP_ADD:
1440                               op = "+=";
1441                               break;
1442                             case BINOP_SUB:
1443                               op = "-=";
1444                               break;
1445                             case BINOP_MUL:
1446                               op = "*=";
1447                               break;
1448                             case BINOP_DIV:
1449                               op = "/=";
1450                               break;
1451                             case BINOP_REM:
1452                               op = "%=";
1453                               break;
1454                             case BINOP_BITWISE_IOR:
1455                               op = "|=";
1456                               break;
1457                             case BINOP_BITWISE_AND:
1458                               op = "&=";
1459                               break;
1460                             case BINOP_BITWISE_XOR:
1461                               op = "^=";
1462                               break;
1463                             default:
1464                               break;
1465                             }
1466
1467                           $$ = operator_stoken (op);
1468                         }
1469         |       OPERATOR LSH
1470                         { $$ = operator_stoken ("<<"); }
1471         |       OPERATOR RSH
1472                         { $$ = operator_stoken (">>"); }
1473         |       OPERATOR EQUAL
1474                         { $$ = operator_stoken ("=="); }
1475         |       OPERATOR NOTEQUAL
1476                         { $$ = operator_stoken ("!="); }
1477         |       OPERATOR LEQ
1478                         { $$ = operator_stoken ("<="); }
1479         |       OPERATOR GEQ
1480                         { $$ = operator_stoken (">="); }
1481         |       OPERATOR ANDAND
1482                         { $$ = operator_stoken ("&&"); }
1483         |       OPERATOR OROR
1484                         { $$ = operator_stoken ("||"); }
1485         |       OPERATOR INCREMENT
1486                         { $$ = operator_stoken ("++"); }
1487         |       OPERATOR DECREMENT
1488                         { $$ = operator_stoken ("--"); }
1489         |       OPERATOR ','
1490                         { $$ = operator_stoken (","); }
1491         |       OPERATOR ARROW_STAR
1492                         { $$ = operator_stoken ("->*"); }
1493         |       OPERATOR ARROW
1494                         { $$ = operator_stoken ("->"); }
1495         |       OPERATOR '(' ')'
1496                         { $$ = operator_stoken ("()"); }
1497         |       OPERATOR '[' ']'
1498                         { $$ = operator_stoken ("[]"); }
1499         |       OPERATOR OBJC_LBRAC ']'
1500                         { $$ = operator_stoken ("[]"); }
1501         |       OPERATOR conversion_type_id
1502                         { char *name;
1503                           long length;
1504                           struct ui_file *buf = mem_fileopen ();
1505
1506                           c_print_type ($2, NULL, buf, -1, 0,
1507                                         &type_print_raw_options);
1508                           name = ui_file_xstrdup (buf, &length);
1509                           ui_file_delete (buf);
1510                           $$ = operator_stoken (name);
1511                           free (name);
1512                         }
1513         ;
1514
1515
1516
1517 name    :       NAME { $$ = $1.stoken; }
1518         |       BLOCKNAME { $$ = $1.stoken; }
1519         |       TYPENAME { $$ = $1.stoken; }
1520         |       NAME_OR_INT  { $$ = $1.stoken; }
1521         |       UNKNOWN_CPP_NAME  { $$ = $1.stoken; }
1522         |       operator { $$ = $1; }
1523         ;
1524
1525 name_not_typename :     NAME
1526         |       BLOCKNAME
1527 /* These would be useful if name_not_typename was useful, but it is just
1528    a fake for "variable", so these cause reduce/reduce conflicts because
1529    the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
1530    =exp) or just an exp.  If name_not_typename was ever used in an lvalue
1531    context where only a name could occur, this might be useful.
1532         |       NAME_OR_INT
1533  */
1534         |       operator
1535                         {
1536                           $$.stoken = $1;
1537                           $$.sym = lookup_symbol ($1.ptr,
1538                                                   expression_context_block,
1539                                                   VAR_DOMAIN,
1540                                                   &$$.is_a_field_of_this);
1541                         }
1542         |       UNKNOWN_CPP_NAME
1543         ;
1544
1545 %%
1546
1547 /* Returns a stoken of the operator name given by OP (which does not
1548    include the string "operator").  */
1549 static struct stoken
1550 operator_stoken (const char *op)
1551 {
1552   static const char *operator_string = "operator";
1553   struct stoken st = { NULL, 0 };
1554   st.length = strlen (operator_string) + strlen (op);
1555   st.ptr = malloc (st.length + 1);
1556   strcpy (st.ptr, operator_string);
1557   strcat (st.ptr, op);
1558
1559   /* The toplevel (c_parse) will free the memory allocated here.  */
1560   make_cleanup (free, st.ptr);
1561   return st;
1562 };
1563
1564 /* Validate a parameter typelist.  */
1565
1566 static void
1567 check_parameter_typelist (VEC (type_ptr) *params)
1568 {
1569   struct type *type;
1570   int ix;
1571
1572   for (ix = 0; VEC_iterate (type_ptr, params, ix, type); ++ix)
1573     {
1574       if (type != NULL && TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
1575         {
1576           if (ix == 0)
1577             {
1578               if (VEC_length (type_ptr, params) == 1)
1579                 {
1580                   /* Ok.  */
1581                   break;
1582                 }
1583               VEC_free (type_ptr, params);
1584               error (_("parameter types following 'void'"));
1585             }
1586           else
1587             {
1588               VEC_free (type_ptr, params);
1589               error (_("'void' invalid as parameter type"));
1590             }
1591         }
1592     }
1593 }
1594
1595 /* Take care of parsing a number (anything that starts with a digit).
1596    Set yylval and return the token type; update lexptr.
1597    LEN is the number of characters in it.  */
1598
1599 /*** Needs some error checking for the float case ***/
1600
1601 static int
1602 parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere)
1603 {
1604   /* FIXME: Shouldn't these be unsigned?  We don't deal with negative values
1605      here, and we do kind of silly things like cast to unsigned.  */
1606   LONGEST n = 0;
1607   LONGEST prevn = 0;
1608   ULONGEST un;
1609
1610   int i = 0;
1611   int c;
1612   int base = input_radix;
1613   int unsigned_p = 0;
1614
1615   /* Number of "L" suffixes encountered.  */
1616   int long_p = 0;
1617
1618   /* We have found a "L" or "U" suffix.  */
1619   int found_suffix = 0;
1620
1621   ULONGEST high_bit;
1622   struct type *signed_type;
1623   struct type *unsigned_type;
1624
1625   if (parsed_float)
1626     {
1627       /* If it ends at "df", "dd" or "dl", take it as type of decimal floating
1628          point.  Return DECFLOAT.  */
1629
1630       if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'f')
1631         {
1632           p[len - 2] = '\0';
1633           putithere->typed_val_decfloat.type
1634             = parse_type->builtin_decfloat;
1635           decimal_from_string (putithere->typed_val_decfloat.val, 4,
1636                                gdbarch_byte_order (parse_gdbarch), p);
1637           p[len - 2] = 'd';
1638           return DECFLOAT;
1639         }
1640
1641       if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'd')
1642         {
1643           p[len - 2] = '\0';
1644           putithere->typed_val_decfloat.type
1645             = parse_type->builtin_decdouble;
1646           decimal_from_string (putithere->typed_val_decfloat.val, 8,
1647                                gdbarch_byte_order (parse_gdbarch), p);
1648           p[len - 2] = 'd';
1649           return DECFLOAT;
1650         }
1651
1652       if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'l')
1653         {
1654           p[len - 2] = '\0';
1655           putithere->typed_val_decfloat.type
1656             = parse_type->builtin_declong;
1657           decimal_from_string (putithere->typed_val_decfloat.val, 16,
1658                                gdbarch_byte_order (parse_gdbarch), p);
1659           p[len - 2] = 'd';
1660           return DECFLOAT;
1661         }
1662
1663       if (! parse_c_float (parse_gdbarch, p, len,
1664                            &putithere->typed_val_float.dval,
1665                            &putithere->typed_val_float.type))
1666         return ERROR;
1667       return FLOAT;
1668     }
1669
1670   /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
1671   if (p[0] == '0')
1672     switch (p[1])
1673       {
1674       case 'x':
1675       case 'X':
1676         if (len >= 3)
1677           {
1678             p += 2;
1679             base = 16;
1680             len -= 2;
1681           }
1682         break;
1683
1684       case 'b':
1685       case 'B':
1686         if (len >= 3)
1687           {
1688             p += 2;
1689             base = 2;
1690             len -= 2;
1691           }
1692         break;
1693
1694       case 't':
1695       case 'T':
1696       case 'd':
1697       case 'D':
1698         if (len >= 3)
1699           {
1700             p += 2;
1701             base = 10;
1702             len -= 2;
1703           }
1704         break;
1705
1706       default:
1707         base = 8;
1708         break;
1709       }
1710
1711   while (len-- > 0)
1712     {
1713       c = *p++;
1714       if (c >= 'A' && c <= 'Z')
1715         c += 'a' - 'A';
1716       if (c != 'l' && c != 'u')
1717         n *= base;
1718       if (c >= '0' && c <= '9')
1719         {
1720           if (found_suffix)
1721             return ERROR;
1722           n += i = c - '0';
1723         }
1724       else
1725         {
1726           if (base > 10 && c >= 'a' && c <= 'f')
1727             {
1728               if (found_suffix)
1729                 return ERROR;
1730               n += i = c - 'a' + 10;
1731             }
1732           else if (c == 'l')
1733             {
1734               ++long_p;
1735               found_suffix = 1;
1736             }
1737           else if (c == 'u')
1738             {
1739               unsigned_p = 1;
1740               found_suffix = 1;
1741             }
1742           else
1743             return ERROR;       /* Char not a digit */
1744         }
1745       if (i >= base)
1746         return ERROR;           /* Invalid digit in this base */
1747
1748       /* Portably test for overflow (only works for nonzero values, so make
1749          a second check for zero).  FIXME: Can't we just make n and prevn
1750          unsigned and avoid this?  */
1751       if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
1752         unsigned_p = 1;         /* Try something unsigned */
1753
1754       /* Portably test for unsigned overflow.
1755          FIXME: This check is wrong; for example it doesn't find overflow
1756          on 0x123456789 when LONGEST is 32 bits.  */
1757       if (c != 'l' && c != 'u' && n != 0)
1758         {
1759           if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n))
1760             error (_("Numeric constant too large."));
1761         }
1762       prevn = n;
1763     }
1764
1765   /* An integer constant is an int, a long, or a long long.  An L
1766      suffix forces it to be long; an LL suffix forces it to be long
1767      long.  If not forced to a larger size, it gets the first type of
1768      the above that it fits in.  To figure out whether it fits, we
1769      shift it right and see whether anything remains.  Note that we
1770      can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
1771      operation, because many compilers will warn about such a shift
1772      (which always produces a zero result).  Sometimes gdbarch_int_bit
1773      or gdbarch_long_bit will be that big, sometimes not.  To deal with
1774      the case where it is we just always shift the value more than
1775      once, with fewer bits each time.  */
1776
1777   un = (ULONGEST)n >> 2;
1778   if (long_p == 0
1779       && (un >> (gdbarch_int_bit (parse_gdbarch) - 2)) == 0)
1780     {
1781       high_bit = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch) - 1);
1782
1783       /* A large decimal (not hex or octal) constant (between INT_MAX
1784          and UINT_MAX) is a long or unsigned long, according to ANSI,
1785          never an unsigned int, but this code treats it as unsigned
1786          int.  This probably should be fixed.  GCC gives a warning on
1787          such constants.  */
1788
1789       unsigned_type = parse_type->builtin_unsigned_int;
1790       signed_type = parse_type->builtin_int;
1791     }
1792   else if (long_p <= 1
1793            && (un >> (gdbarch_long_bit (parse_gdbarch) - 2)) == 0)
1794     {
1795       high_bit = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch) - 1);
1796       unsigned_type = parse_type->builtin_unsigned_long;
1797       signed_type = parse_type->builtin_long;
1798     }
1799   else
1800     {
1801       int shift;
1802       if (sizeof (ULONGEST) * HOST_CHAR_BIT
1803           < gdbarch_long_long_bit (parse_gdbarch))
1804         /* A long long does not fit in a LONGEST.  */
1805         shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
1806       else
1807         shift = (gdbarch_long_long_bit (parse_gdbarch) - 1);
1808       high_bit = (ULONGEST) 1 << shift;
1809       unsigned_type = parse_type->builtin_unsigned_long_long;
1810       signed_type = parse_type->builtin_long_long;
1811     }
1812
1813    putithere->typed_val_int.val = n;
1814
1815    /* If the high bit of the worked out type is set then this number
1816       has to be unsigned. */
1817
1818    if (unsigned_p || (n & high_bit))
1819      {
1820        putithere->typed_val_int.type = unsigned_type;
1821      }
1822    else
1823      {
1824        putithere->typed_val_int.type = signed_type;
1825      }
1826
1827    return INT;
1828 }
1829
1830 /* Temporary obstack used for holding strings.  */
1831 static struct obstack tempbuf;
1832 static int tempbuf_init;
1833
1834 /* Parse a C escape sequence.  The initial backslash of the sequence
1835    is at (*PTR)[-1].  *PTR will be updated to point to just after the
1836    last character of the sequence.  If OUTPUT is not NULL, the
1837    translated form of the escape sequence will be written there.  If
1838    OUTPUT is NULL, no output is written and the call will only affect
1839    *PTR.  If an escape sequence is expressed in target bytes, then the
1840    entire sequence will simply be copied to OUTPUT.  Return 1 if any
1841    character was emitted, 0 otherwise.  */
1842
1843 int
1844 c_parse_escape (char **ptr, struct obstack *output)
1845 {
1846   char *tokptr = *ptr;
1847   int result = 1;
1848
1849   /* Some escape sequences undergo character set conversion.  Those we
1850      translate here.  */
1851   switch (*tokptr)
1852     {
1853       /* Hex escapes do not undergo character set conversion, so keep
1854          the escape sequence for later.  */
1855     case 'x':
1856       if (output)
1857         obstack_grow_str (output, "\\x");
1858       ++tokptr;
1859       if (!isxdigit (*tokptr))
1860         error (_("\\x escape without a following hex digit"));
1861       while (isxdigit (*tokptr))
1862         {
1863           if (output)
1864             obstack_1grow (output, *tokptr);
1865           ++tokptr;
1866         }
1867       break;
1868
1869       /* Octal escapes do not undergo character set conversion, so
1870          keep the escape sequence for later.  */
1871     case '0':
1872     case '1':
1873     case '2':
1874     case '3':
1875     case '4':
1876     case '5':
1877     case '6':
1878     case '7':
1879       {
1880         int i;
1881         if (output)
1882           obstack_grow_str (output, "\\");
1883         for (i = 0;
1884              i < 3 && isdigit (*tokptr) && *tokptr != '8' && *tokptr != '9';
1885              ++i)
1886           {
1887             if (output)
1888               obstack_1grow (output, *tokptr);
1889             ++tokptr;
1890           }
1891       }
1892       break;
1893
1894       /* We handle UCNs later.  We could handle them here, but that
1895          would mean a spurious error in the case where the UCN could
1896          be converted to the target charset but not the host
1897          charset.  */
1898     case 'u':
1899     case 'U':
1900       {
1901         char c = *tokptr;
1902         int i, len = c == 'U' ? 8 : 4;
1903         if (output)
1904           {
1905             obstack_1grow (output, '\\');
1906             obstack_1grow (output, *tokptr);
1907           }
1908         ++tokptr;
1909         if (!isxdigit (*tokptr))
1910           error (_("\\%c escape without a following hex digit"), c);
1911         for (i = 0; i < len && isxdigit (*tokptr); ++i)
1912           {
1913             if (output)
1914               obstack_1grow (output, *tokptr);
1915             ++tokptr;
1916           }
1917       }
1918       break;
1919
1920       /* We must pass backslash through so that it does not
1921          cause quoting during the second expansion.  */
1922     case '\\':
1923       if (output)
1924         obstack_grow_str (output, "\\\\");
1925       ++tokptr;
1926       break;
1927
1928       /* Escapes which undergo conversion.  */
1929     case 'a':
1930       if (output)
1931         obstack_1grow (output, '\a');
1932       ++tokptr;
1933       break;
1934     case 'b':
1935       if (output)
1936         obstack_1grow (output, '\b');
1937       ++tokptr;
1938       break;
1939     case 'f':
1940       if (output)
1941         obstack_1grow (output, '\f');
1942       ++tokptr;
1943       break;
1944     case 'n':
1945       if (output)
1946         obstack_1grow (output, '\n');
1947       ++tokptr;
1948       break;
1949     case 'r':
1950       if (output)
1951         obstack_1grow (output, '\r');
1952       ++tokptr;
1953       break;
1954     case 't':
1955       if (output)
1956         obstack_1grow (output, '\t');
1957       ++tokptr;
1958       break;
1959     case 'v':
1960       if (output)
1961         obstack_1grow (output, '\v');
1962       ++tokptr;
1963       break;
1964
1965       /* GCC extension.  */
1966     case 'e':
1967       if (output)
1968         obstack_1grow (output, HOST_ESCAPE_CHAR);
1969       ++tokptr;
1970       break;
1971
1972       /* Backslash-newline expands to nothing at all.  */
1973     case '\n':
1974       ++tokptr;
1975       result = 0;
1976       break;
1977
1978       /* A few escapes just expand to the character itself.  */
1979     case '\'':
1980     case '\"':
1981     case '?':
1982       /* GCC extensions.  */
1983     case '(':
1984     case '{':
1985     case '[':
1986     case '%':
1987       /* Unrecognized escapes turn into the character itself.  */
1988     default:
1989       if (output)
1990         obstack_1grow (output, *tokptr);
1991       ++tokptr;
1992       break;
1993     }
1994   *ptr = tokptr;
1995   return result;
1996 }
1997
1998 /* Parse a string or character literal from TOKPTR.  The string or
1999    character may be wide or unicode.  *OUTPTR is set to just after the
2000    end of the literal in the input string.  The resulting token is
2001    stored in VALUE.  This returns a token value, either STRING or
2002    CHAR, depending on what was parsed.  *HOST_CHARS is set to the
2003    number of host characters in the literal.  */
2004 static int
2005 parse_string_or_char (char *tokptr, char **outptr, struct typed_stoken *value,
2006                       int *host_chars)
2007 {
2008   int quote;
2009   enum c_string_type type;
2010   int is_objc = 0;
2011
2012   /* Build the gdb internal form of the input string in tempbuf.  Note
2013      that the buffer is null byte terminated *only* for the
2014      convenience of debugging gdb itself and printing the buffer
2015      contents when the buffer contains no embedded nulls.  Gdb does
2016      not depend upon the buffer being null byte terminated, it uses
2017      the length string instead.  This allows gdb to handle C strings
2018      (as well as strings in other languages) with embedded null
2019      bytes */
2020
2021   if (!tempbuf_init)
2022     tempbuf_init = 1;
2023   else
2024     obstack_free (&tempbuf, NULL);
2025   obstack_init (&tempbuf);
2026
2027   /* Record the string type.  */
2028   if (*tokptr == 'L')
2029     {
2030       type = C_WIDE_STRING;
2031       ++tokptr;
2032     }
2033   else if (*tokptr == 'u')
2034     {
2035       type = C_STRING_16;
2036       ++tokptr;
2037     }
2038   else if (*tokptr == 'U')
2039     {
2040       type = C_STRING_32;
2041       ++tokptr;
2042     }
2043   else if (*tokptr == '@')
2044     {
2045       /* An Objective C string.  */
2046       is_objc = 1;
2047       type = C_STRING;
2048       ++tokptr;
2049     }
2050   else
2051     type = C_STRING;
2052
2053   /* Skip the quote.  */
2054   quote = *tokptr;
2055   if (quote == '\'')
2056     type |= C_CHAR;
2057   ++tokptr;
2058
2059   *host_chars = 0;
2060
2061   while (*tokptr)
2062     {
2063       char c = *tokptr;
2064       if (c == '\\')
2065         {
2066           ++tokptr;
2067           *host_chars += c_parse_escape (&tokptr, &tempbuf);
2068         }
2069       else if (c == quote)
2070         break;
2071       else
2072         {
2073           obstack_1grow (&tempbuf, c);
2074           ++tokptr;
2075           /* FIXME: this does the wrong thing with multi-byte host
2076              characters.  We could use mbrlen here, but that would
2077              make "set host-charset" a bit less useful.  */
2078           ++*host_chars;
2079         }
2080     }
2081
2082   if (*tokptr != quote)
2083     {
2084       if (quote == '"')
2085         error (_("Unterminated string in expression."));
2086       else
2087         error (_("Unmatched single quote."));
2088     }
2089   ++tokptr;
2090
2091   value->type = type;
2092   value->ptr = obstack_base (&tempbuf);
2093   value->length = obstack_object_size (&tempbuf);
2094
2095   *outptr = tokptr;
2096
2097   return quote == '"' ? (is_objc ? NSSTRING : STRING) : CHAR;
2098 }
2099
2100 /* This is used to associate some attributes with a token.  */
2101
2102 enum token_flags
2103 {
2104   /* If this bit is set, the token is C++-only.  */
2105
2106   FLAG_CXX = 1,
2107
2108   /* If this bit is set, the token is conditional: if there is a
2109      symbol of the same name, then the token is a symbol; otherwise,
2110      the token is a keyword.  */
2111
2112   FLAG_SHADOW = 2
2113 };
2114
2115 struct token
2116 {
2117   char *operator;
2118   int token;
2119   enum exp_opcode opcode;
2120   enum token_flags flags;
2121 };
2122
2123 static const struct token tokentab3[] =
2124   {
2125     {">>=", ASSIGN_MODIFY, BINOP_RSH, 0},
2126     {"<<=", ASSIGN_MODIFY, BINOP_LSH, 0},
2127     {"->*", ARROW_STAR, BINOP_END, FLAG_CXX},
2128     {"...", DOTDOTDOT, BINOP_END, 0}
2129   };
2130
2131 static const struct token tokentab2[] =
2132   {
2133     {"+=", ASSIGN_MODIFY, BINOP_ADD, 0},
2134     {"-=", ASSIGN_MODIFY, BINOP_SUB, 0},
2135     {"*=", ASSIGN_MODIFY, BINOP_MUL, 0},
2136     {"/=", ASSIGN_MODIFY, BINOP_DIV, 0},
2137     {"%=", ASSIGN_MODIFY, BINOP_REM, 0},
2138     {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR, 0},
2139     {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND, 0},
2140     {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR, 0},
2141     {"++", INCREMENT, BINOP_END, 0},
2142     {"--", DECREMENT, BINOP_END, 0},
2143     {"->", ARROW, BINOP_END, 0},
2144     {"&&", ANDAND, BINOP_END, 0},
2145     {"||", OROR, BINOP_END, 0},
2146     /* "::" is *not* only C++: gdb overrides its meaning in several
2147        different ways, e.g., 'filename'::func, function::variable.  */
2148     {"::", COLONCOLON, BINOP_END, 0},
2149     {"<<", LSH, BINOP_END, 0},
2150     {">>", RSH, BINOP_END, 0},
2151     {"==", EQUAL, BINOP_END, 0},
2152     {"!=", NOTEQUAL, BINOP_END, 0},
2153     {"<=", LEQ, BINOP_END, 0},
2154     {">=", GEQ, BINOP_END, 0},
2155     {".*", DOT_STAR, BINOP_END, FLAG_CXX}
2156   };
2157
2158 /* Identifier-like tokens.  */
2159 static const struct token ident_tokens[] =
2160   {
2161     {"unsigned", UNSIGNED, OP_NULL, 0},
2162     {"template", TEMPLATE, OP_NULL, FLAG_CXX},
2163     {"volatile", VOLATILE_KEYWORD, OP_NULL, 0},
2164     {"struct", STRUCT, OP_NULL, 0},
2165     {"signed", SIGNED_KEYWORD, OP_NULL, 0},
2166     {"sizeof", SIZEOF, OP_NULL, 0},
2167     {"double", DOUBLE_KEYWORD, OP_NULL, 0},
2168     {"false", FALSEKEYWORD, OP_NULL, FLAG_CXX},
2169     {"class", CLASS, OP_NULL, FLAG_CXX},
2170     {"union", UNION, OP_NULL, 0},
2171     {"short", SHORT, OP_NULL, 0},
2172     {"const", CONST_KEYWORD, OP_NULL, 0},
2173     {"enum", ENUM, OP_NULL, 0},
2174     {"long", LONG, OP_NULL, 0},
2175     {"true", TRUEKEYWORD, OP_NULL, FLAG_CXX},
2176     {"int", INT_KEYWORD, OP_NULL, 0},
2177     {"new", NEW, OP_NULL, FLAG_CXX},
2178     {"delete", DELETE, OP_NULL, FLAG_CXX},
2179     {"operator", OPERATOR, OP_NULL, FLAG_CXX},
2180
2181     {"and", ANDAND, BINOP_END, FLAG_CXX},
2182     {"and_eq", ASSIGN_MODIFY, BINOP_BITWISE_AND, FLAG_CXX},
2183     {"bitand", '&', OP_NULL, FLAG_CXX},
2184     {"bitor", '|', OP_NULL, FLAG_CXX},
2185     {"compl", '~', OP_NULL, FLAG_CXX},
2186     {"not", '!', OP_NULL, FLAG_CXX},
2187     {"not_eq", NOTEQUAL, BINOP_END, FLAG_CXX},
2188     {"or", OROR, BINOP_END, FLAG_CXX},
2189     {"or_eq", ASSIGN_MODIFY, BINOP_BITWISE_IOR, FLAG_CXX},
2190     {"xor", '^', OP_NULL, FLAG_CXX},
2191     {"xor_eq", ASSIGN_MODIFY, BINOP_BITWISE_XOR, FLAG_CXX},
2192
2193     {"const_cast", CONST_CAST, OP_NULL, FLAG_CXX },
2194     {"dynamic_cast", DYNAMIC_CAST, OP_NULL, FLAG_CXX },
2195     {"static_cast", STATIC_CAST, OP_NULL, FLAG_CXX },
2196     {"reinterpret_cast", REINTERPRET_CAST, OP_NULL, FLAG_CXX },
2197
2198     {"__typeof__", TYPEOF, OP_TYPEOF, 0 },
2199     {"__typeof", TYPEOF, OP_TYPEOF, 0 },
2200     {"typeof", TYPEOF, OP_TYPEOF, FLAG_SHADOW },
2201     {"__decltype", DECLTYPE, OP_DECLTYPE, FLAG_CXX },
2202     {"decltype", DECLTYPE, OP_DECLTYPE, FLAG_CXX | FLAG_SHADOW }
2203   };
2204
2205 /* When we find that lexptr (the global var defined in parse.c) is
2206    pointing at a macro invocation, we expand the invocation, and call
2207    scan_macro_expansion to save the old lexptr here and point lexptr
2208    into the expanded text.  When we reach the end of that, we call
2209    end_macro_expansion to pop back to the value we saved here.  The
2210    macro expansion code promises to return only fully-expanded text,
2211    so we don't need to "push" more than one level.
2212
2213    This is disgusting, of course.  It would be cleaner to do all macro
2214    expansion beforehand, and then hand that to lexptr.  But we don't
2215    really know where the expression ends.  Remember, in a command like
2216
2217      (gdb) break *ADDRESS if CONDITION
2218
2219    we evaluate ADDRESS in the scope of the current frame, but we
2220    evaluate CONDITION in the scope of the breakpoint's location.  So
2221    it's simply wrong to try to macro-expand the whole thing at once.  */
2222 static char *macro_original_text;
2223
2224 /* We save all intermediate macro expansions on this obstack for the
2225    duration of a single parse.  The expansion text may sometimes have
2226    to live past the end of the expansion, due to yacc lookahead.
2227    Rather than try to be clever about saving the data for a single
2228    token, we simply keep it all and delete it after parsing has
2229    completed.  */
2230 static struct obstack expansion_obstack;
2231
2232 static void
2233 scan_macro_expansion (char *expansion)
2234 {
2235   char *copy;
2236
2237   /* We'd better not be trying to push the stack twice.  */
2238   gdb_assert (! macro_original_text);
2239
2240   /* Copy to the obstack, and then free the intermediate
2241      expansion.  */
2242   copy = obstack_copy0 (&expansion_obstack, expansion, strlen (expansion));
2243   xfree (expansion);
2244
2245   /* Save the old lexptr value, so we can return to it when we're done
2246      parsing the expanded text.  */
2247   macro_original_text = lexptr;
2248   lexptr = copy;
2249 }
2250
2251
2252 static int
2253 scanning_macro_expansion (void)
2254 {
2255   return macro_original_text != 0;
2256 }
2257
2258
2259 static void
2260 finished_macro_expansion (void)
2261 {
2262   /* There'd better be something to pop back to.  */
2263   gdb_assert (macro_original_text);
2264
2265   /* Pop back to the original text.  */
2266   lexptr = macro_original_text;
2267   macro_original_text = 0;
2268 }
2269
2270
2271 static void
2272 scan_macro_cleanup (void *dummy)
2273 {
2274   if (macro_original_text)
2275     finished_macro_expansion ();
2276
2277   obstack_free (&expansion_obstack, NULL);
2278 }
2279
2280 /* Return true iff the token represents a C++ cast operator.  */
2281
2282 static int
2283 is_cast_operator (const char *token, int len)
2284 {
2285   return (! strncmp (token, "dynamic_cast", len)
2286           || ! strncmp (token, "static_cast", len)
2287           || ! strncmp (token, "reinterpret_cast", len)
2288           || ! strncmp (token, "const_cast", len));
2289 }
2290
2291 /* The scope used for macro expansion.  */
2292 static struct macro_scope *expression_macro_scope;
2293
2294 /* This is set if a NAME token appeared at the very end of the input
2295    string, with no whitespace separating the name from the EOF.  This
2296    is used only when parsing to do field name completion.  */
2297 static int saw_name_at_eof;
2298
2299 /* This is set if the previously-returned token was a structure
2300    operator -- either '.' or ARROW.  This is used only when parsing to
2301    do field name completion.  */
2302 static int last_was_structop;
2303
2304 /* Read one token, getting characters through lexptr.  */
2305
2306 static int
2307 lex_one_token (void)
2308 {
2309   int c;
2310   int namelen;
2311   unsigned int i;
2312   char *tokstart;
2313   int saw_structop = last_was_structop;
2314   char *copy;
2315
2316   last_was_structop = 0;
2317
2318  retry:
2319
2320   /* Check if this is a macro invocation that we need to expand.  */
2321   if (! scanning_macro_expansion ())
2322     {
2323       char *expanded = macro_expand_next (&lexptr,
2324                                           standard_macro_lookup,
2325                                           expression_macro_scope);
2326
2327       if (expanded)
2328         scan_macro_expansion (expanded);
2329     }
2330
2331   prev_lexptr = lexptr;
2332
2333   tokstart = lexptr;
2334   /* See if it is a special token of length 3.  */
2335   for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
2336     if (strncmp (tokstart, tokentab3[i].operator, 3) == 0)
2337       {
2338         if ((tokentab3[i].flags & FLAG_CXX) != 0
2339             && parse_language->la_language != language_cplus)
2340           break;
2341
2342         lexptr += 3;
2343         yylval.opcode = tokentab3[i].opcode;
2344         return tokentab3[i].token;
2345       }
2346
2347   /* See if it is a special token of length 2.  */
2348   for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
2349     if (strncmp (tokstart, tokentab2[i].operator, 2) == 0)
2350       {
2351         if ((tokentab2[i].flags & FLAG_CXX) != 0
2352             && parse_language->la_language != language_cplus)
2353           break;
2354
2355         lexptr += 2;
2356         yylval.opcode = tokentab2[i].opcode;
2357         if (parse_completion && tokentab2[i].token == ARROW)
2358           last_was_structop = 1;
2359         return tokentab2[i].token;
2360       }
2361
2362   switch (c = *tokstart)
2363     {
2364     case 0:
2365       /* If we were just scanning the result of a macro expansion,
2366          then we need to resume scanning the original text.
2367          If we're parsing for field name completion, and the previous
2368          token allows such completion, return a COMPLETE token.
2369          Otherwise, we were already scanning the original text, and
2370          we're really done.  */
2371       if (scanning_macro_expansion ())
2372         {
2373           finished_macro_expansion ();
2374           goto retry;
2375         }
2376       else if (saw_name_at_eof)
2377         {
2378           saw_name_at_eof = 0;
2379           return COMPLETE;
2380         }
2381       else if (saw_structop)
2382         return COMPLETE;
2383       else
2384         return 0;
2385
2386     case ' ':
2387     case '\t':
2388     case '\n':
2389       lexptr++;
2390       goto retry;
2391
2392     case '[':
2393     case '(':
2394       paren_depth++;
2395       lexptr++;
2396       if (parse_language->la_language == language_objc && c == '[')
2397         return OBJC_LBRAC;
2398       return c;
2399
2400     case ']':
2401     case ')':
2402       if (paren_depth == 0)
2403         return 0;
2404       paren_depth--;
2405       lexptr++;
2406       return c;
2407
2408     case ',':
2409       if (comma_terminates
2410           && paren_depth == 0
2411           && ! scanning_macro_expansion ())
2412         return 0;
2413       lexptr++;
2414       return c;
2415
2416     case '.':
2417       /* Might be a floating point number.  */
2418       if (lexptr[1] < '0' || lexptr[1] > '9')
2419         {
2420           if (parse_completion)
2421             last_was_structop = 1;
2422           goto symbol;          /* Nope, must be a symbol. */
2423         }
2424       /* FALL THRU into number case.  */
2425
2426     case '0':
2427     case '1':
2428     case '2':
2429     case '3':
2430     case '4':
2431     case '5':
2432     case '6':
2433     case '7':
2434     case '8':
2435     case '9':
2436       {
2437         /* It's a number.  */
2438         int got_dot = 0, got_e = 0, toktype;
2439         char *p = tokstart;
2440         int hex = input_radix > 10;
2441
2442         if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
2443           {
2444             p += 2;
2445             hex = 1;
2446           }
2447         else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
2448           {
2449             p += 2;
2450             hex = 0;
2451           }
2452
2453         for (;; ++p)
2454           {
2455             /* This test includes !hex because 'e' is a valid hex digit
2456                and thus does not indicate a floating point number when
2457                the radix is hex.  */
2458             if (!hex && !got_e && (*p == 'e' || *p == 'E'))
2459               got_dot = got_e = 1;
2460             /* This test does not include !hex, because a '.' always indicates
2461                a decimal floating point number regardless of the radix.  */
2462             else if (!got_dot && *p == '.')
2463               got_dot = 1;
2464             else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
2465                      && (*p == '-' || *p == '+'))
2466               /* This is the sign of the exponent, not the end of the
2467                  number.  */
2468               continue;
2469             /* We will take any letters or digits.  parse_number will
2470                complain if past the radix, or if L or U are not final.  */
2471             else if ((*p < '0' || *p > '9')
2472                      && ((*p < 'a' || *p > 'z')
2473                                   && (*p < 'A' || *p > 'Z')))
2474               break;
2475           }
2476         toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
2477         if (toktype == ERROR)
2478           {
2479             char *err_copy = (char *) alloca (p - tokstart + 1);
2480
2481             memcpy (err_copy, tokstart, p - tokstart);
2482             err_copy[p - tokstart] = 0;
2483             error (_("Invalid number \"%s\"."), err_copy);
2484           }
2485         lexptr = p;
2486         return toktype;
2487       }
2488
2489     case '@':
2490       {
2491         char *p = &tokstart[1];
2492         size_t len = strlen ("entry");
2493
2494         if (parse_language->la_language == language_objc)
2495           {
2496             size_t len = strlen ("selector");
2497
2498             if (strncmp (p, "selector", len) == 0
2499                 && (p[len] == '\0' || isspace (p[len])))
2500               {
2501                 lexptr = p + len;
2502                 return SELECTOR;
2503               }
2504             else if (*p == '"')
2505               goto parse_string;
2506           }
2507
2508         while (isspace (*p))
2509           p++;
2510         if (strncmp (p, "entry", len) == 0 && !isalnum (p[len])
2511             && p[len] != '_')
2512           {
2513             lexptr = &p[len];
2514             return ENTRY;
2515           }
2516       }
2517       /* FALLTHRU */
2518     case '+':
2519     case '-':
2520     case '*':
2521     case '/':
2522     case '%':
2523     case '|':
2524     case '&':
2525     case '^':
2526     case '~':
2527     case '!':
2528     case '<':
2529     case '>':
2530     case '?':
2531     case ':':
2532     case '=':
2533     case '{':
2534     case '}':
2535     symbol:
2536       lexptr++;
2537       return c;
2538
2539     case 'L':
2540     case 'u':
2541     case 'U':
2542       if (tokstart[1] != '"' && tokstart[1] != '\'')
2543         break;
2544       /* Fall through.  */
2545     case '\'':
2546     case '"':
2547
2548     parse_string:
2549       {
2550         int host_len;
2551         int result = parse_string_or_char (tokstart, &lexptr, &yylval.tsval,
2552                                            &host_len);
2553         if (result == CHAR)
2554           {
2555             if (host_len == 0)
2556               error (_("Empty character constant."));
2557             else if (host_len > 2 && c == '\'')
2558               {
2559                 ++tokstart;
2560                 namelen = lexptr - tokstart - 1;
2561                 goto tryname;
2562               }
2563             else if (host_len > 1)
2564               error (_("Invalid character constant."));
2565           }
2566         return result;
2567       }
2568     }
2569
2570   if (!(c == '_' || c == '$'
2571         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
2572     /* We must have come across a bad character (e.g. ';').  */
2573     error (_("Invalid character '%c' in expression."), c);
2574
2575   /* It's a name.  See how long it is.  */
2576   namelen = 0;
2577   for (c = tokstart[namelen];
2578        (c == '_' || c == '$' || (c >= '0' && c <= '9')
2579         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
2580     {
2581       /* Template parameter lists are part of the name.
2582          FIXME: This mishandles `print $a<4&&$a>3'.  */
2583
2584       if (c == '<')
2585         {
2586           if (! is_cast_operator (tokstart, namelen))
2587             {
2588               /* Scan ahead to get rest of the template specification.  Note
2589                  that we look ahead only when the '<' adjoins non-whitespace
2590                  characters; for comparison expressions, e.g. "a < b > c",
2591                  there must be spaces before the '<', etc. */
2592
2593               char * p = find_template_name_end (tokstart + namelen);
2594               if (p)
2595                 namelen = p - tokstart;
2596             }
2597           break;
2598         }
2599       c = tokstart[++namelen];
2600     }
2601
2602   /* The token "if" terminates the expression and is NOT removed from
2603      the input stream.  It doesn't count if it appears in the
2604      expansion of a macro.  */
2605   if (namelen == 2
2606       && tokstart[0] == 'i'
2607       && tokstart[1] == 'f'
2608       && ! scanning_macro_expansion ())
2609     {
2610       return 0;
2611     }
2612
2613   /* For the same reason (breakpoint conditions), "thread N"
2614      terminates the expression.  "thread" could be an identifier, but
2615      an identifier is never followed by a number without intervening
2616      punctuation.  "task" is similar.  Handle abbreviations of these,
2617      similarly to breakpoint.c:find_condition_and_thread.  */
2618   if (namelen >= 1
2619       && (strncmp (tokstart, "thread", namelen) == 0
2620           || strncmp (tokstart, "task", namelen) == 0)
2621       && (tokstart[namelen] == ' ' || tokstart[namelen] == '\t')
2622       && ! scanning_macro_expansion ())
2623     {
2624       char *p = tokstart + namelen + 1;
2625       while (*p == ' ' || *p == '\t')
2626         p++;
2627       if (*p >= '0' && *p <= '9')
2628         return 0;
2629     }
2630
2631   lexptr += namelen;
2632
2633   tryname:
2634
2635   yylval.sval.ptr = tokstart;
2636   yylval.sval.length = namelen;
2637
2638   /* Catch specific keywords.  */
2639   copy = copy_name (yylval.sval);
2640   for (i = 0; i < sizeof ident_tokens / sizeof ident_tokens[0]; i++)
2641     if (strcmp (copy, ident_tokens[i].operator) == 0)
2642       {
2643         if ((ident_tokens[i].flags & FLAG_CXX) != 0
2644             && parse_language->la_language != language_cplus)
2645           break;
2646
2647         if ((ident_tokens[i].flags & FLAG_SHADOW) != 0)
2648           {
2649             int is_a_field_of_this = 0;
2650
2651             if (lookup_symbol (copy, expression_context_block,
2652                                VAR_DOMAIN,
2653                                (parse_language->la_language == language_cplus
2654                                 ? &is_a_field_of_this
2655                                 : NULL))
2656                 != NULL)
2657               {
2658                 /* The keyword is shadowed.  */
2659                 break;
2660               }
2661           }
2662
2663         /* It is ok to always set this, even though we don't always
2664            strictly need to.  */
2665         yylval.opcode = ident_tokens[i].opcode;
2666         return ident_tokens[i].token;
2667       }
2668
2669   if (*tokstart == '$')
2670     return VARIABLE;
2671
2672   if (parse_completion && *lexptr == '\0')
2673     saw_name_at_eof = 1;
2674   return NAME;
2675 }
2676
2677 /* An object of this type is pushed on a FIFO by the "outer" lexer.  */
2678 typedef struct
2679 {
2680   int token;
2681   YYSTYPE value;
2682 } token_and_value;
2683
2684 DEF_VEC_O (token_and_value);
2685
2686 /* A FIFO of tokens that have been read but not yet returned to the
2687    parser.  */
2688 static VEC (token_and_value) *token_fifo;
2689
2690 /* Non-zero if the lexer should return tokens from the FIFO.  */
2691 static int popping;
2692
2693 /* Temporary storage for c_lex; this holds symbol names as they are
2694    built up.  */
2695 static struct obstack name_obstack;
2696
2697 /* Classify a NAME token.  The contents of the token are in `yylval'.
2698    Updates yylval and returns the new token type.  BLOCK is the block
2699    in which lookups start; this can be NULL to mean the global
2700    scope.  */
2701 static int
2702 classify_name (const struct block *block)
2703 {
2704   struct symbol *sym;
2705   char *copy;
2706   int is_a_field_of_this = 0;
2707
2708   copy = copy_name (yylval.sval);
2709
2710   sym = lookup_symbol (copy, block, VAR_DOMAIN,
2711                        parse_language->la_name_of_this
2712                        ? &is_a_field_of_this : (int *) NULL);
2713
2714   if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
2715     {
2716       yylval.ssym.sym = sym;
2717       yylval.ssym.is_a_field_of_this = is_a_field_of_this;
2718       return BLOCKNAME;
2719     }
2720   else if (!sym)
2721     {
2722       /* See if it's a file name. */
2723       struct symtab *symtab;
2724
2725       symtab = lookup_symtab (copy);
2726       if (symtab)
2727         {
2728           yylval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
2729           return FILENAME;
2730         }
2731     }
2732
2733   if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
2734     {
2735       yylval.tsym.type = SYMBOL_TYPE (sym);
2736       return TYPENAME;
2737     }
2738
2739   yylval.tsym.type
2740     = language_lookup_primitive_type_by_name (parse_language,
2741                                               parse_gdbarch, copy);
2742   if (yylval.tsym.type != NULL)
2743     return TYPENAME;
2744
2745   /* See if it's an ObjC classname.  */
2746   if (parse_language->la_language == language_objc && !sym)
2747     {
2748       CORE_ADDR Class = lookup_objc_class (parse_gdbarch, copy);
2749       if (Class)
2750         {
2751           yylval.class.class = Class;
2752           sym = lookup_struct_typedef (copy, expression_context_block, 1);
2753           if (sym)
2754             yylval.class.type = SYMBOL_TYPE (sym);
2755           return CLASSNAME;
2756         }
2757     }
2758
2759   /* Input names that aren't symbols but ARE valid hex numbers, when
2760      the input radix permits them, can be names or numbers depending
2761      on the parse.  Note we support radixes > 16 here.  */
2762   if (!sym
2763       && ((copy[0] >= 'a' && copy[0] < 'a' + input_radix - 10)
2764           || (copy[0] >= 'A' && copy[0] < 'A' + input_radix - 10)))
2765     {
2766       YYSTYPE newlval;  /* Its value is ignored.  */
2767       int hextype = parse_number (copy, yylval.sval.length, 0, &newlval);
2768       if (hextype == INT)
2769         {
2770           yylval.ssym.sym = sym;
2771           yylval.ssym.is_a_field_of_this = is_a_field_of_this;
2772           return NAME_OR_INT;
2773         }
2774     }
2775
2776   /* Any other kind of symbol */
2777   yylval.ssym.sym = sym;
2778   yylval.ssym.is_a_field_of_this = is_a_field_of_this;
2779
2780   if (sym == NULL
2781       && parse_language->la_language == language_cplus
2782       && !is_a_field_of_this
2783       && !lookup_minimal_symbol (copy, NULL, NULL))
2784     return UNKNOWN_CPP_NAME;
2785
2786   return NAME;
2787 }
2788
2789 /* Like classify_name, but used by the inner loop of the lexer, when a
2790    name might have already been seen.  FIRST_NAME is true if the token
2791    in `yylval' is the first component of a name, false otherwise.  */
2792
2793 static int
2794 classify_inner_name (const struct block *block, int first_name)
2795 {
2796   struct type *type, *new_type;
2797   char *copy;
2798
2799   if (first_name)
2800     return classify_name (block);
2801
2802   type = check_typedef (yylval.tsym.type);
2803   if (TYPE_CODE (type) != TYPE_CODE_STRUCT
2804       && TYPE_CODE (type) != TYPE_CODE_UNION
2805       && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
2806     return ERROR;
2807
2808   copy = copy_name (yylval.tsym.stoken);
2809   yylval.ssym.sym = cp_lookup_nested_symbol (yylval.tsym.type, copy, block);
2810   if (yylval.ssym.sym == NULL)
2811     return ERROR;
2812
2813   switch (SYMBOL_CLASS (yylval.ssym.sym))
2814     {
2815     case LOC_BLOCK:
2816     case LOC_LABEL:
2817       return ERROR;
2818
2819     case LOC_TYPEDEF:
2820       yylval.tsym.type = SYMBOL_TYPE (yylval.ssym.sym);;
2821       return TYPENAME;
2822
2823     default:
2824       yylval.ssym.is_a_field_of_this = 0;
2825       return NAME;
2826     }
2827   internal_error (__FILE__, __LINE__, _("not reached"));
2828 }
2829
2830 /* The outer level of a two-level lexer.  This calls the inner lexer
2831    to return tokens.  It then either returns these tokens, or
2832    aggregates them into a larger token.  This lets us work around a
2833    problem in our parsing approach, where the parser could not
2834    distinguish between qualified names and qualified types at the
2835    right point.
2836
2837    This approach is still not ideal, because it mishandles template
2838    types.  See the comment in lex_one_token for an example.  However,
2839    this is still an improvement over the earlier approach, and will
2840    suffice until we move to better parsing technology.  */
2841 static int
2842 yylex (void)
2843 {
2844   token_and_value current;
2845   int first_was_coloncolon, last_was_coloncolon, first_iter;
2846
2847   if (popping && !VEC_empty (token_and_value, token_fifo))
2848     {
2849       token_and_value tv = *VEC_index (token_and_value, token_fifo, 0);
2850       VEC_ordered_remove (token_and_value, token_fifo, 0);
2851       yylval = tv.value;
2852       return tv.token;
2853     }
2854   popping = 0;
2855
2856   current.token = lex_one_token ();
2857   if (current.token == NAME)
2858     current.token = classify_name (expression_context_block);
2859   if (parse_language->la_language != language_cplus
2860       || (current.token != TYPENAME && current.token != COLONCOLON))
2861     return current.token;
2862
2863   first_was_coloncolon = current.token == COLONCOLON;
2864   last_was_coloncolon = first_was_coloncolon;
2865   obstack_free (&name_obstack, obstack_base (&name_obstack));
2866   if (!last_was_coloncolon)
2867     obstack_grow (&name_obstack, yylval.sval.ptr, yylval.sval.length);
2868   current.value = yylval;
2869   first_iter = 1;
2870   while (1)
2871     {
2872       token_and_value next;
2873
2874       next.token = lex_one_token ();
2875       next.value = yylval;
2876
2877       if (next.token == NAME && last_was_coloncolon)
2878         {
2879           int classification;
2880
2881           classification = classify_inner_name (first_was_coloncolon
2882                                                 ? NULL
2883                                                 : expression_context_block,
2884                                                 first_iter);
2885           /* We keep going until we either run out of names, or until
2886              we have a qualified name which is not a type.  */
2887           if (classification != TYPENAME && classification != NAME)
2888             {
2889               /* Push the final component and leave the loop.  */
2890               VEC_safe_push (token_and_value, token_fifo, &next);
2891               break;
2892             }
2893
2894           /* Update the partial name we are constructing.  */
2895           if (!first_iter)
2896             {
2897               /* We don't want to put a leading "::" into the name.  */
2898               obstack_grow_str (&name_obstack, "::");
2899             }
2900           obstack_grow (&name_obstack, next.value.sval.ptr,
2901                         next.value.sval.length);
2902
2903           yylval.sval.ptr = obstack_base (&name_obstack);
2904           yylval.sval.length = obstack_object_size (&name_obstack);
2905           current.value = yylval;
2906           current.token = classification;
2907
2908           last_was_coloncolon = 0;
2909         }
2910       else if (next.token == COLONCOLON && !last_was_coloncolon)
2911         last_was_coloncolon = 1;
2912       else
2913         {
2914           /* We've reached the end of the name.  */
2915           VEC_safe_push (token_and_value, token_fifo, &next);
2916           break;
2917         }
2918
2919       first_iter = 0;
2920     }
2921
2922   popping = 1;
2923
2924   /* If we ended with a "::", insert it too.  */
2925   if (last_was_coloncolon)
2926     {
2927       token_and_value cc;
2928       memset (&cc, 0, sizeof (token_and_value));
2929       if (first_was_coloncolon && first_iter)
2930         {
2931           yylval = cc.value;
2932           return COLONCOLON;
2933         }
2934       cc.token = COLONCOLON;
2935       VEC_safe_insert (token_and_value, token_fifo, 0, &cc);
2936     }
2937
2938   yylval = current.value;
2939   yylval.sval.ptr = obstack_copy0 (&expansion_obstack,
2940                                    yylval.sval.ptr,
2941                                    yylval.sval.length);
2942   return current.token;
2943 }
2944
2945 int
2946 c_parse (void)
2947 {
2948   int result;
2949   struct cleanup *back_to = make_cleanup (free_current_contents,
2950                                           &expression_macro_scope);
2951
2952   /* Set up the scope for macro expansion.  */
2953   expression_macro_scope = NULL;
2954
2955   if (expression_context_block)
2956     expression_macro_scope
2957       = sal_macro_scope (find_pc_line (expression_context_pc, 0));
2958   else
2959     expression_macro_scope = default_macro_scope ();
2960   if (! expression_macro_scope)
2961     expression_macro_scope = user_macro_scope ();
2962
2963   /* Initialize macro expansion code.  */
2964   obstack_init (&expansion_obstack);
2965   gdb_assert (! macro_original_text);
2966   make_cleanup (scan_macro_cleanup, 0);
2967
2968   make_cleanup_restore_integer (&yydebug);
2969   yydebug = parser_debug;
2970
2971   /* Initialize some state used by the lexer.  */
2972   last_was_structop = 0;
2973   saw_name_at_eof = 0;
2974
2975   VEC_free (token_and_value, token_fifo);
2976   popping = 0;
2977   obstack_init (&name_obstack);
2978   make_cleanup_obstack_free (&name_obstack);
2979
2980   result = yyparse ();
2981   do_cleanups (back_to);
2982   return result;
2983 }
2984
2985
2986 void
2987 yyerror (char *msg)
2988 {
2989   if (prev_lexptr)
2990     lexptr = prev_lexptr;
2991
2992   error (_("A %s in expression, near `%s'."), (msg ? msg : "error"), lexptr);
2993 }