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         |       STRUCT COMPLETE
1272                         {
1273                           mark_completion_tag (TYPE_CODE_STRUCT, "", 0);
1274                           $$ = NULL;
1275                         }
1276         |       STRUCT name COMPLETE
1277                         {
1278                           mark_completion_tag (TYPE_CODE_STRUCT, $2.ptr,
1279                                                $2.length);
1280                           $$ = NULL;
1281                         }
1282         |       CLASS name
1283                         { $$ = lookup_struct (copy_name ($2),
1284                                               expression_context_block); }
1285         |       CLASS COMPLETE
1286                         {
1287                           mark_completion_tag (TYPE_CODE_CLASS, "", 0);
1288                           $$ = NULL;
1289                         }
1290         |       CLASS name COMPLETE
1291                         {
1292                           mark_completion_tag (TYPE_CODE_CLASS, $2.ptr,
1293                                                $2.length);
1294                           $$ = NULL;
1295                         }
1296         |       UNION name
1297                         { $$ = lookup_union (copy_name ($2),
1298                                              expression_context_block); }
1299         |       UNION COMPLETE
1300                         {
1301                           mark_completion_tag (TYPE_CODE_UNION, "", 0);
1302                           $$ = NULL;
1303                         }
1304         |       UNION name COMPLETE
1305                         {
1306                           mark_completion_tag (TYPE_CODE_UNION, $2.ptr,
1307                                                $2.length);
1308                           $$ = NULL;
1309                         }
1310         |       ENUM name
1311                         { $$ = lookup_enum (copy_name ($2),
1312                                             expression_context_block); }
1313         |       ENUM COMPLETE
1314                         {
1315                           mark_completion_tag (TYPE_CODE_ENUM, "", 0);
1316                           $$ = NULL;
1317                         }
1318         |       ENUM name COMPLETE
1319                         {
1320                           mark_completion_tag (TYPE_CODE_ENUM, $2.ptr,
1321                                                $2.length);
1322                           $$ = NULL;
1323                         }
1324         |       UNSIGNED typename
1325                         { $$ = lookup_unsigned_typename (parse_language,
1326                                                          parse_gdbarch,
1327                                                          TYPE_NAME($2.type)); }
1328         |       UNSIGNED
1329                         { $$ = lookup_unsigned_typename (parse_language,
1330                                                          parse_gdbarch,
1331                                                          "int"); }
1332         |       SIGNED_KEYWORD typename
1333                         { $$ = lookup_signed_typename (parse_language,
1334                                                        parse_gdbarch,
1335                                                        TYPE_NAME($2.type)); }
1336         |       SIGNED_KEYWORD
1337                         { $$ = lookup_signed_typename (parse_language,
1338                                                        parse_gdbarch,
1339                                                        "int"); }
1340                 /* It appears that this rule for templates is never
1341                    reduced; template recognition happens by lookahead
1342                    in the token processing code in yylex. */
1343         |       TEMPLATE name '<' type '>'
1344                         { $$ = lookup_template_type(copy_name($2), $4,
1345                                                     expression_context_block);
1346                         }
1347         | const_or_volatile_or_space_identifier_noopt typebase
1348                         { $$ = follow_types ($2); }
1349         | typebase const_or_volatile_or_space_identifier_noopt
1350                         { $$ = follow_types ($1); }
1351         ;
1352
1353 typename:       TYPENAME
1354         |       INT_KEYWORD
1355                 {
1356                   $$.stoken.ptr = "int";
1357                   $$.stoken.length = 3;
1358                   $$.type = lookup_signed_typename (parse_language,
1359                                                     parse_gdbarch,
1360                                                     "int");
1361                 }
1362         |       LONG
1363                 {
1364                   $$.stoken.ptr = "long";
1365                   $$.stoken.length = 4;
1366                   $$.type = lookup_signed_typename (parse_language,
1367                                                     parse_gdbarch,
1368                                                     "long");
1369                 }
1370         |       SHORT
1371                 {
1372                   $$.stoken.ptr = "short";
1373                   $$.stoken.length = 5;
1374                   $$.type = lookup_signed_typename (parse_language,
1375                                                     parse_gdbarch,
1376                                                     "short");
1377                 }
1378         ;
1379
1380 parameter_typelist:
1381                 nonempty_typelist
1382                         { check_parameter_typelist ($1); }
1383         |       nonempty_typelist ',' DOTDOTDOT
1384                         {
1385                           VEC_safe_push (type_ptr, $1, NULL);
1386                           check_parameter_typelist ($1);
1387                           $$ = $1;
1388                         }
1389         ;
1390
1391 nonempty_typelist
1392         :       type
1393                 {
1394                   VEC (type_ptr) *typelist = NULL;
1395                   VEC_safe_push (type_ptr, typelist, $1);
1396                   $$ = typelist;
1397                 }
1398         |       nonempty_typelist ',' type
1399                 {
1400                   VEC_safe_push (type_ptr, $1, $3);
1401                   $$ = $1;
1402                 }
1403         ;
1404
1405 ptype   :       typebase
1406         |       ptype abs_decl
1407                 {
1408                   push_type_stack ($2);
1409                   $$ = follow_types ($1);
1410                 }
1411         ;
1412
1413 conversion_type_id: typebase conversion_declarator
1414                 { $$ = follow_types ($1); }
1415         ;
1416
1417 conversion_declarator:  /* Nothing.  */
1418         | ptr_operator conversion_declarator
1419         ;
1420
1421 const_and_volatile:     CONST_KEYWORD VOLATILE_KEYWORD
1422         |               VOLATILE_KEYWORD CONST_KEYWORD
1423         ;
1424
1425 const_or_volatile_noopt:        const_and_volatile
1426                         { insert_type (tp_const);
1427                           insert_type (tp_volatile);
1428                         }
1429         |               CONST_KEYWORD
1430                         { insert_type (tp_const); }
1431         |               VOLATILE_KEYWORD
1432                         { insert_type (tp_volatile); }
1433         ;
1434
1435 operator:       OPERATOR NEW
1436                         { $$ = operator_stoken (" new"); }
1437         |       OPERATOR DELETE
1438                         { $$ = operator_stoken (" delete"); }
1439         |       OPERATOR NEW '[' ']'
1440                         { $$ = operator_stoken (" new[]"); }
1441         |       OPERATOR DELETE '[' ']'
1442                         { $$ = operator_stoken (" delete[]"); }
1443         |       OPERATOR NEW OBJC_LBRAC ']'
1444                         { $$ = operator_stoken (" new[]"); }
1445         |       OPERATOR DELETE OBJC_LBRAC ']'
1446                         { $$ = operator_stoken (" delete[]"); }
1447         |       OPERATOR '+'
1448                         { $$ = operator_stoken ("+"); }
1449         |       OPERATOR '-'
1450                         { $$ = operator_stoken ("-"); }
1451         |       OPERATOR '*'
1452                         { $$ = operator_stoken ("*"); }
1453         |       OPERATOR '/'
1454                         { $$ = operator_stoken ("/"); }
1455         |       OPERATOR '%'
1456                         { $$ = operator_stoken ("%"); }
1457         |       OPERATOR '^'
1458                         { $$ = operator_stoken ("^"); }
1459         |       OPERATOR '&'
1460                         { $$ = operator_stoken ("&"); }
1461         |       OPERATOR '|'
1462                         { $$ = operator_stoken ("|"); }
1463         |       OPERATOR '~'
1464                         { $$ = operator_stoken ("~"); }
1465         |       OPERATOR '!'
1466                         { $$ = operator_stoken ("!"); }
1467         |       OPERATOR '='
1468                         { $$ = operator_stoken ("="); }
1469         |       OPERATOR '<'
1470                         { $$ = operator_stoken ("<"); }
1471         |       OPERATOR '>'
1472                         { $$ = operator_stoken (">"); }
1473         |       OPERATOR ASSIGN_MODIFY
1474                         { const char *op = "unknown";
1475                           switch ($2)
1476                             {
1477                             case BINOP_RSH:
1478                               op = ">>=";
1479                               break;
1480                             case BINOP_LSH:
1481                               op = "<<=";
1482                               break;
1483                             case BINOP_ADD:
1484                               op = "+=";
1485                               break;
1486                             case BINOP_SUB:
1487                               op = "-=";
1488                               break;
1489                             case BINOP_MUL:
1490                               op = "*=";
1491                               break;
1492                             case BINOP_DIV:
1493                               op = "/=";
1494                               break;
1495                             case BINOP_REM:
1496                               op = "%=";
1497                               break;
1498                             case BINOP_BITWISE_IOR:
1499                               op = "|=";
1500                               break;
1501                             case BINOP_BITWISE_AND:
1502                               op = "&=";
1503                               break;
1504                             case BINOP_BITWISE_XOR:
1505                               op = "^=";
1506                               break;
1507                             default:
1508                               break;
1509                             }
1510
1511                           $$ = operator_stoken (op);
1512                         }
1513         |       OPERATOR LSH
1514                         { $$ = operator_stoken ("<<"); }
1515         |       OPERATOR RSH
1516                         { $$ = operator_stoken (">>"); }
1517         |       OPERATOR EQUAL
1518                         { $$ = operator_stoken ("=="); }
1519         |       OPERATOR NOTEQUAL
1520                         { $$ = operator_stoken ("!="); }
1521         |       OPERATOR LEQ
1522                         { $$ = operator_stoken ("<="); }
1523         |       OPERATOR GEQ
1524                         { $$ = operator_stoken (">="); }
1525         |       OPERATOR ANDAND
1526                         { $$ = operator_stoken ("&&"); }
1527         |       OPERATOR OROR
1528                         { $$ = operator_stoken ("||"); }
1529         |       OPERATOR INCREMENT
1530                         { $$ = operator_stoken ("++"); }
1531         |       OPERATOR DECREMENT
1532                         { $$ = operator_stoken ("--"); }
1533         |       OPERATOR ','
1534                         { $$ = operator_stoken (","); }
1535         |       OPERATOR ARROW_STAR
1536                         { $$ = operator_stoken ("->*"); }
1537         |       OPERATOR ARROW
1538                         { $$ = operator_stoken ("->"); }
1539         |       OPERATOR '(' ')'
1540                         { $$ = operator_stoken ("()"); }
1541         |       OPERATOR '[' ']'
1542                         { $$ = operator_stoken ("[]"); }
1543         |       OPERATOR OBJC_LBRAC ']'
1544                         { $$ = operator_stoken ("[]"); }
1545         |       OPERATOR conversion_type_id
1546                         { char *name;
1547                           long length;
1548                           struct ui_file *buf = mem_fileopen ();
1549
1550                           c_print_type ($2, NULL, buf, -1, 0,
1551                                         &type_print_raw_options);
1552                           name = ui_file_xstrdup (buf, &length);
1553                           ui_file_delete (buf);
1554                           $$ = operator_stoken (name);
1555                           free (name);
1556                         }
1557         ;
1558
1559
1560
1561 name    :       NAME { $$ = $1.stoken; }
1562         |       BLOCKNAME { $$ = $1.stoken; }
1563         |       TYPENAME { $$ = $1.stoken; }
1564         |       NAME_OR_INT  { $$ = $1.stoken; }
1565         |       UNKNOWN_CPP_NAME  { $$ = $1.stoken; }
1566         |       operator { $$ = $1; }
1567         ;
1568
1569 name_not_typename :     NAME
1570         |       BLOCKNAME
1571 /* These would be useful if name_not_typename was useful, but it is just
1572    a fake for "variable", so these cause reduce/reduce conflicts because
1573    the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
1574    =exp) or just an exp.  If name_not_typename was ever used in an lvalue
1575    context where only a name could occur, this might be useful.
1576         |       NAME_OR_INT
1577  */
1578         |       operator
1579                         {
1580                           $$.stoken = $1;
1581                           $$.sym = lookup_symbol ($1.ptr,
1582                                                   expression_context_block,
1583                                                   VAR_DOMAIN,
1584                                                   &$$.is_a_field_of_this);
1585                         }
1586         |       UNKNOWN_CPP_NAME
1587         ;
1588
1589 %%
1590
1591 /* Returns a stoken of the operator name given by OP (which does not
1592    include the string "operator").  */
1593 static struct stoken
1594 operator_stoken (const char *op)
1595 {
1596   static const char *operator_string = "operator";
1597   struct stoken st = { NULL, 0 };
1598   st.length = strlen (operator_string) + strlen (op);
1599   st.ptr = malloc (st.length + 1);
1600   strcpy (st.ptr, operator_string);
1601   strcat (st.ptr, op);
1602
1603   /* The toplevel (c_parse) will free the memory allocated here.  */
1604   make_cleanup (free, st.ptr);
1605   return st;
1606 };
1607
1608 /* Validate a parameter typelist.  */
1609
1610 static void
1611 check_parameter_typelist (VEC (type_ptr) *params)
1612 {
1613   struct type *type;
1614   int ix;
1615
1616   for (ix = 0; VEC_iterate (type_ptr, params, ix, type); ++ix)
1617     {
1618       if (type != NULL && TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
1619         {
1620           if (ix == 0)
1621             {
1622               if (VEC_length (type_ptr, params) == 1)
1623                 {
1624                   /* Ok.  */
1625                   break;
1626                 }
1627               VEC_free (type_ptr, params);
1628               error (_("parameter types following 'void'"));
1629             }
1630           else
1631             {
1632               VEC_free (type_ptr, params);
1633               error (_("'void' invalid as parameter type"));
1634             }
1635         }
1636     }
1637 }
1638
1639 /* Take care of parsing a number (anything that starts with a digit).
1640    Set yylval and return the token type; update lexptr.
1641    LEN is the number of characters in it.  */
1642
1643 /*** Needs some error checking for the float case ***/
1644
1645 static int
1646 parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere)
1647 {
1648   /* FIXME: Shouldn't these be unsigned?  We don't deal with negative values
1649      here, and we do kind of silly things like cast to unsigned.  */
1650   LONGEST n = 0;
1651   LONGEST prevn = 0;
1652   ULONGEST un;
1653
1654   int i = 0;
1655   int c;
1656   int base = input_radix;
1657   int unsigned_p = 0;
1658
1659   /* Number of "L" suffixes encountered.  */
1660   int long_p = 0;
1661
1662   /* We have found a "L" or "U" suffix.  */
1663   int found_suffix = 0;
1664
1665   ULONGEST high_bit;
1666   struct type *signed_type;
1667   struct type *unsigned_type;
1668
1669   if (parsed_float)
1670     {
1671       /* If it ends at "df", "dd" or "dl", take it as type of decimal floating
1672          point.  Return DECFLOAT.  */
1673
1674       if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'f')
1675         {
1676           p[len - 2] = '\0';
1677           putithere->typed_val_decfloat.type
1678             = parse_type->builtin_decfloat;
1679           decimal_from_string (putithere->typed_val_decfloat.val, 4,
1680                                gdbarch_byte_order (parse_gdbarch), p);
1681           p[len - 2] = 'd';
1682           return DECFLOAT;
1683         }
1684
1685       if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'd')
1686         {
1687           p[len - 2] = '\0';
1688           putithere->typed_val_decfloat.type
1689             = parse_type->builtin_decdouble;
1690           decimal_from_string (putithere->typed_val_decfloat.val, 8,
1691                                gdbarch_byte_order (parse_gdbarch), p);
1692           p[len - 2] = 'd';
1693           return DECFLOAT;
1694         }
1695
1696       if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'l')
1697         {
1698           p[len - 2] = '\0';
1699           putithere->typed_val_decfloat.type
1700             = parse_type->builtin_declong;
1701           decimal_from_string (putithere->typed_val_decfloat.val, 16,
1702                                gdbarch_byte_order (parse_gdbarch), p);
1703           p[len - 2] = 'd';
1704           return DECFLOAT;
1705         }
1706
1707       if (! parse_c_float (parse_gdbarch, p, len,
1708                            &putithere->typed_val_float.dval,
1709                            &putithere->typed_val_float.type))
1710         return ERROR;
1711       return FLOAT;
1712     }
1713
1714   /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
1715   if (p[0] == '0')
1716     switch (p[1])
1717       {
1718       case 'x':
1719       case 'X':
1720         if (len >= 3)
1721           {
1722             p += 2;
1723             base = 16;
1724             len -= 2;
1725           }
1726         break;
1727
1728       case 'b':
1729       case 'B':
1730         if (len >= 3)
1731           {
1732             p += 2;
1733             base = 2;
1734             len -= 2;
1735           }
1736         break;
1737
1738       case 't':
1739       case 'T':
1740       case 'd':
1741       case 'D':
1742         if (len >= 3)
1743           {
1744             p += 2;
1745             base = 10;
1746             len -= 2;
1747           }
1748         break;
1749
1750       default:
1751         base = 8;
1752         break;
1753       }
1754
1755   while (len-- > 0)
1756     {
1757       c = *p++;
1758       if (c >= 'A' && c <= 'Z')
1759         c += 'a' - 'A';
1760       if (c != 'l' && c != 'u')
1761         n *= base;
1762       if (c >= '0' && c <= '9')
1763         {
1764           if (found_suffix)
1765             return ERROR;
1766           n += i = c - '0';
1767         }
1768       else
1769         {
1770           if (base > 10 && c >= 'a' && c <= 'f')
1771             {
1772               if (found_suffix)
1773                 return ERROR;
1774               n += i = c - 'a' + 10;
1775             }
1776           else if (c == 'l')
1777             {
1778               ++long_p;
1779               found_suffix = 1;
1780             }
1781           else if (c == 'u')
1782             {
1783               unsigned_p = 1;
1784               found_suffix = 1;
1785             }
1786           else
1787             return ERROR;       /* Char not a digit */
1788         }
1789       if (i >= base)
1790         return ERROR;           /* Invalid digit in this base */
1791
1792       /* Portably test for overflow (only works for nonzero values, so make
1793          a second check for zero).  FIXME: Can't we just make n and prevn
1794          unsigned and avoid this?  */
1795       if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
1796         unsigned_p = 1;         /* Try something unsigned */
1797
1798       /* Portably test for unsigned overflow.
1799          FIXME: This check is wrong; for example it doesn't find overflow
1800          on 0x123456789 when LONGEST is 32 bits.  */
1801       if (c != 'l' && c != 'u' && n != 0)
1802         {
1803           if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n))
1804             error (_("Numeric constant too large."));
1805         }
1806       prevn = n;
1807     }
1808
1809   /* An integer constant is an int, a long, or a long long.  An L
1810      suffix forces it to be long; an LL suffix forces it to be long
1811      long.  If not forced to a larger size, it gets the first type of
1812      the above that it fits in.  To figure out whether it fits, we
1813      shift it right and see whether anything remains.  Note that we
1814      can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
1815      operation, because many compilers will warn about such a shift
1816      (which always produces a zero result).  Sometimes gdbarch_int_bit
1817      or gdbarch_long_bit will be that big, sometimes not.  To deal with
1818      the case where it is we just always shift the value more than
1819      once, with fewer bits each time.  */
1820
1821   un = (ULONGEST)n >> 2;
1822   if (long_p == 0
1823       && (un >> (gdbarch_int_bit (parse_gdbarch) - 2)) == 0)
1824     {
1825       high_bit = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch) - 1);
1826
1827       /* A large decimal (not hex or octal) constant (between INT_MAX
1828          and UINT_MAX) is a long or unsigned long, according to ANSI,
1829          never an unsigned int, but this code treats it as unsigned
1830          int.  This probably should be fixed.  GCC gives a warning on
1831          such constants.  */
1832
1833       unsigned_type = parse_type->builtin_unsigned_int;
1834       signed_type = parse_type->builtin_int;
1835     }
1836   else if (long_p <= 1
1837            && (un >> (gdbarch_long_bit (parse_gdbarch) - 2)) == 0)
1838     {
1839       high_bit = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch) - 1);
1840       unsigned_type = parse_type->builtin_unsigned_long;
1841       signed_type = parse_type->builtin_long;
1842     }
1843   else
1844     {
1845       int shift;
1846       if (sizeof (ULONGEST) * HOST_CHAR_BIT
1847           < gdbarch_long_long_bit (parse_gdbarch))
1848         /* A long long does not fit in a LONGEST.  */
1849         shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
1850       else
1851         shift = (gdbarch_long_long_bit (parse_gdbarch) - 1);
1852       high_bit = (ULONGEST) 1 << shift;
1853       unsigned_type = parse_type->builtin_unsigned_long_long;
1854       signed_type = parse_type->builtin_long_long;
1855     }
1856
1857    putithere->typed_val_int.val = n;
1858
1859    /* If the high bit of the worked out type is set then this number
1860       has to be unsigned. */
1861
1862    if (unsigned_p || (n & high_bit))
1863      {
1864        putithere->typed_val_int.type = unsigned_type;
1865      }
1866    else
1867      {
1868        putithere->typed_val_int.type = signed_type;
1869      }
1870
1871    return INT;
1872 }
1873
1874 /* Temporary obstack used for holding strings.  */
1875 static struct obstack tempbuf;
1876 static int tempbuf_init;
1877
1878 /* Parse a C escape sequence.  The initial backslash of the sequence
1879    is at (*PTR)[-1].  *PTR will be updated to point to just after the
1880    last character of the sequence.  If OUTPUT is not NULL, the
1881    translated form of the escape sequence will be written there.  If
1882    OUTPUT is NULL, no output is written and the call will only affect
1883    *PTR.  If an escape sequence is expressed in target bytes, then the
1884    entire sequence will simply be copied to OUTPUT.  Return 1 if any
1885    character was emitted, 0 otherwise.  */
1886
1887 int
1888 c_parse_escape (char **ptr, struct obstack *output)
1889 {
1890   char *tokptr = *ptr;
1891   int result = 1;
1892
1893   /* Some escape sequences undergo character set conversion.  Those we
1894      translate here.  */
1895   switch (*tokptr)
1896     {
1897       /* Hex escapes do not undergo character set conversion, so keep
1898          the escape sequence for later.  */
1899     case 'x':
1900       if (output)
1901         obstack_grow_str (output, "\\x");
1902       ++tokptr;
1903       if (!isxdigit (*tokptr))
1904         error (_("\\x escape without a following hex digit"));
1905       while (isxdigit (*tokptr))
1906         {
1907           if (output)
1908             obstack_1grow (output, *tokptr);
1909           ++tokptr;
1910         }
1911       break;
1912
1913       /* Octal escapes do not undergo character set conversion, so
1914          keep the escape sequence for later.  */
1915     case '0':
1916     case '1':
1917     case '2':
1918     case '3':
1919     case '4':
1920     case '5':
1921     case '6':
1922     case '7':
1923       {
1924         int i;
1925         if (output)
1926           obstack_grow_str (output, "\\");
1927         for (i = 0;
1928              i < 3 && isdigit (*tokptr) && *tokptr != '8' && *tokptr != '9';
1929              ++i)
1930           {
1931             if (output)
1932               obstack_1grow (output, *tokptr);
1933             ++tokptr;
1934           }
1935       }
1936       break;
1937
1938       /* We handle UCNs later.  We could handle them here, but that
1939          would mean a spurious error in the case where the UCN could
1940          be converted to the target charset but not the host
1941          charset.  */
1942     case 'u':
1943     case 'U':
1944       {
1945         char c = *tokptr;
1946         int i, len = c == 'U' ? 8 : 4;
1947         if (output)
1948           {
1949             obstack_1grow (output, '\\');
1950             obstack_1grow (output, *tokptr);
1951           }
1952         ++tokptr;
1953         if (!isxdigit (*tokptr))
1954           error (_("\\%c escape without a following hex digit"), c);
1955         for (i = 0; i < len && isxdigit (*tokptr); ++i)
1956           {
1957             if (output)
1958               obstack_1grow (output, *tokptr);
1959             ++tokptr;
1960           }
1961       }
1962       break;
1963
1964       /* We must pass backslash through so that it does not
1965          cause quoting during the second expansion.  */
1966     case '\\':
1967       if (output)
1968         obstack_grow_str (output, "\\\\");
1969       ++tokptr;
1970       break;
1971
1972       /* Escapes which undergo conversion.  */
1973     case 'a':
1974       if (output)
1975         obstack_1grow (output, '\a');
1976       ++tokptr;
1977       break;
1978     case 'b':
1979       if (output)
1980         obstack_1grow (output, '\b');
1981       ++tokptr;
1982       break;
1983     case 'f':
1984       if (output)
1985         obstack_1grow (output, '\f');
1986       ++tokptr;
1987       break;
1988     case 'n':
1989       if (output)
1990         obstack_1grow (output, '\n');
1991       ++tokptr;
1992       break;
1993     case 'r':
1994       if (output)
1995         obstack_1grow (output, '\r');
1996       ++tokptr;
1997       break;
1998     case 't':
1999       if (output)
2000         obstack_1grow (output, '\t');
2001       ++tokptr;
2002       break;
2003     case 'v':
2004       if (output)
2005         obstack_1grow (output, '\v');
2006       ++tokptr;
2007       break;
2008
2009       /* GCC extension.  */
2010     case 'e':
2011       if (output)
2012         obstack_1grow (output, HOST_ESCAPE_CHAR);
2013       ++tokptr;
2014       break;
2015
2016       /* Backslash-newline expands to nothing at all.  */
2017     case '\n':
2018       ++tokptr;
2019       result = 0;
2020       break;
2021
2022       /* A few escapes just expand to the character itself.  */
2023     case '\'':
2024     case '\"':
2025     case '?':
2026       /* GCC extensions.  */
2027     case '(':
2028     case '{':
2029     case '[':
2030     case '%':
2031       /* Unrecognized escapes turn into the character itself.  */
2032     default:
2033       if (output)
2034         obstack_1grow (output, *tokptr);
2035       ++tokptr;
2036       break;
2037     }
2038   *ptr = tokptr;
2039   return result;
2040 }
2041
2042 /* Parse a string or character literal from TOKPTR.  The string or
2043    character may be wide or unicode.  *OUTPTR is set to just after the
2044    end of the literal in the input string.  The resulting token is
2045    stored in VALUE.  This returns a token value, either STRING or
2046    CHAR, depending on what was parsed.  *HOST_CHARS is set to the
2047    number of host characters in the literal.  */
2048 static int
2049 parse_string_or_char (char *tokptr, char **outptr, struct typed_stoken *value,
2050                       int *host_chars)
2051 {
2052   int quote;
2053   enum c_string_type type;
2054   int is_objc = 0;
2055
2056   /* Build the gdb internal form of the input string in tempbuf.  Note
2057      that the buffer is null byte terminated *only* for the
2058      convenience of debugging gdb itself and printing the buffer
2059      contents when the buffer contains no embedded nulls.  Gdb does
2060      not depend upon the buffer being null byte terminated, it uses
2061      the length string instead.  This allows gdb to handle C strings
2062      (as well as strings in other languages) with embedded null
2063      bytes */
2064
2065   if (!tempbuf_init)
2066     tempbuf_init = 1;
2067   else
2068     obstack_free (&tempbuf, NULL);
2069   obstack_init (&tempbuf);
2070
2071   /* Record the string type.  */
2072   if (*tokptr == 'L')
2073     {
2074       type = C_WIDE_STRING;
2075       ++tokptr;
2076     }
2077   else if (*tokptr == 'u')
2078     {
2079       type = C_STRING_16;
2080       ++tokptr;
2081     }
2082   else if (*tokptr == 'U')
2083     {
2084       type = C_STRING_32;
2085       ++tokptr;
2086     }
2087   else if (*tokptr == '@')
2088     {
2089       /* An Objective C string.  */
2090       is_objc = 1;
2091       type = C_STRING;
2092       ++tokptr;
2093     }
2094   else
2095     type = C_STRING;
2096
2097   /* Skip the quote.  */
2098   quote = *tokptr;
2099   if (quote == '\'')
2100     type |= C_CHAR;
2101   ++tokptr;
2102
2103   *host_chars = 0;
2104
2105   while (*tokptr)
2106     {
2107       char c = *tokptr;
2108       if (c == '\\')
2109         {
2110           ++tokptr;
2111           *host_chars += c_parse_escape (&tokptr, &tempbuf);
2112         }
2113       else if (c == quote)
2114         break;
2115       else
2116         {
2117           obstack_1grow (&tempbuf, c);
2118           ++tokptr;
2119           /* FIXME: this does the wrong thing with multi-byte host
2120              characters.  We could use mbrlen here, but that would
2121              make "set host-charset" a bit less useful.  */
2122           ++*host_chars;
2123         }
2124     }
2125
2126   if (*tokptr != quote)
2127     {
2128       if (quote == '"')
2129         error (_("Unterminated string in expression."));
2130       else
2131         error (_("Unmatched single quote."));
2132     }
2133   ++tokptr;
2134
2135   value->type = type;
2136   value->ptr = obstack_base (&tempbuf);
2137   value->length = obstack_object_size (&tempbuf);
2138
2139   *outptr = tokptr;
2140
2141   return quote == '"' ? (is_objc ? NSSTRING : STRING) : CHAR;
2142 }
2143
2144 /* This is used to associate some attributes with a token.  */
2145
2146 enum token_flags
2147 {
2148   /* If this bit is set, the token is C++-only.  */
2149
2150   FLAG_CXX = 1,
2151
2152   /* If this bit is set, the token is conditional: if there is a
2153      symbol of the same name, then the token is a symbol; otherwise,
2154      the token is a keyword.  */
2155
2156   FLAG_SHADOW = 2
2157 };
2158
2159 struct token
2160 {
2161   char *operator;
2162   int token;
2163   enum exp_opcode opcode;
2164   enum token_flags flags;
2165 };
2166
2167 static const struct token tokentab3[] =
2168   {
2169     {">>=", ASSIGN_MODIFY, BINOP_RSH, 0},
2170     {"<<=", ASSIGN_MODIFY, BINOP_LSH, 0},
2171     {"->*", ARROW_STAR, BINOP_END, FLAG_CXX},
2172     {"...", DOTDOTDOT, BINOP_END, 0}
2173   };
2174
2175 static const struct token tokentab2[] =
2176   {
2177     {"+=", ASSIGN_MODIFY, BINOP_ADD, 0},
2178     {"-=", ASSIGN_MODIFY, BINOP_SUB, 0},
2179     {"*=", ASSIGN_MODIFY, BINOP_MUL, 0},
2180     {"/=", ASSIGN_MODIFY, BINOP_DIV, 0},
2181     {"%=", ASSIGN_MODIFY, BINOP_REM, 0},
2182     {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR, 0},
2183     {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND, 0},
2184     {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR, 0},
2185     {"++", INCREMENT, BINOP_END, 0},
2186     {"--", DECREMENT, BINOP_END, 0},
2187     {"->", ARROW, BINOP_END, 0},
2188     {"&&", ANDAND, BINOP_END, 0},
2189     {"||", OROR, BINOP_END, 0},
2190     /* "::" is *not* only C++: gdb overrides its meaning in several
2191        different ways, e.g., 'filename'::func, function::variable.  */
2192     {"::", COLONCOLON, BINOP_END, 0},
2193     {"<<", LSH, BINOP_END, 0},
2194     {">>", RSH, BINOP_END, 0},
2195     {"==", EQUAL, BINOP_END, 0},
2196     {"!=", NOTEQUAL, BINOP_END, 0},
2197     {"<=", LEQ, BINOP_END, 0},
2198     {">=", GEQ, BINOP_END, 0},
2199     {".*", DOT_STAR, BINOP_END, FLAG_CXX}
2200   };
2201
2202 /* Identifier-like tokens.  */
2203 static const struct token ident_tokens[] =
2204   {
2205     {"unsigned", UNSIGNED, OP_NULL, 0},
2206     {"template", TEMPLATE, OP_NULL, FLAG_CXX},
2207     {"volatile", VOLATILE_KEYWORD, OP_NULL, 0},
2208     {"struct", STRUCT, OP_NULL, 0},
2209     {"signed", SIGNED_KEYWORD, OP_NULL, 0},
2210     {"sizeof", SIZEOF, OP_NULL, 0},
2211     {"double", DOUBLE_KEYWORD, OP_NULL, 0},
2212     {"false", FALSEKEYWORD, OP_NULL, FLAG_CXX},
2213     {"class", CLASS, OP_NULL, FLAG_CXX},
2214     {"union", UNION, OP_NULL, 0},
2215     {"short", SHORT, OP_NULL, 0},
2216     {"const", CONST_KEYWORD, OP_NULL, 0},
2217     {"enum", ENUM, OP_NULL, 0},
2218     {"long", LONG, OP_NULL, 0},
2219     {"true", TRUEKEYWORD, OP_NULL, FLAG_CXX},
2220     {"int", INT_KEYWORD, OP_NULL, 0},
2221     {"new", NEW, OP_NULL, FLAG_CXX},
2222     {"delete", DELETE, OP_NULL, FLAG_CXX},
2223     {"operator", OPERATOR, OP_NULL, FLAG_CXX},
2224
2225     {"and", ANDAND, BINOP_END, FLAG_CXX},
2226     {"and_eq", ASSIGN_MODIFY, BINOP_BITWISE_AND, FLAG_CXX},
2227     {"bitand", '&', OP_NULL, FLAG_CXX},
2228     {"bitor", '|', OP_NULL, FLAG_CXX},
2229     {"compl", '~', OP_NULL, FLAG_CXX},
2230     {"not", '!', OP_NULL, FLAG_CXX},
2231     {"not_eq", NOTEQUAL, BINOP_END, FLAG_CXX},
2232     {"or", OROR, BINOP_END, FLAG_CXX},
2233     {"or_eq", ASSIGN_MODIFY, BINOP_BITWISE_IOR, FLAG_CXX},
2234     {"xor", '^', OP_NULL, FLAG_CXX},
2235     {"xor_eq", ASSIGN_MODIFY, BINOP_BITWISE_XOR, FLAG_CXX},
2236
2237     {"const_cast", CONST_CAST, OP_NULL, FLAG_CXX },
2238     {"dynamic_cast", DYNAMIC_CAST, OP_NULL, FLAG_CXX },
2239     {"static_cast", STATIC_CAST, OP_NULL, FLAG_CXX },
2240     {"reinterpret_cast", REINTERPRET_CAST, OP_NULL, FLAG_CXX },
2241
2242     {"__typeof__", TYPEOF, OP_TYPEOF, 0 },
2243     {"__typeof", TYPEOF, OP_TYPEOF, 0 },
2244     {"typeof", TYPEOF, OP_TYPEOF, FLAG_SHADOW },
2245     {"__decltype", DECLTYPE, OP_DECLTYPE, FLAG_CXX },
2246     {"decltype", DECLTYPE, OP_DECLTYPE, FLAG_CXX | FLAG_SHADOW }
2247   };
2248
2249 /* When we find that lexptr (the global var defined in parse.c) is
2250    pointing at a macro invocation, we expand the invocation, and call
2251    scan_macro_expansion to save the old lexptr here and point lexptr
2252    into the expanded text.  When we reach the end of that, we call
2253    end_macro_expansion to pop back to the value we saved here.  The
2254    macro expansion code promises to return only fully-expanded text,
2255    so we don't need to "push" more than one level.
2256
2257    This is disgusting, of course.  It would be cleaner to do all macro
2258    expansion beforehand, and then hand that to lexptr.  But we don't
2259    really know where the expression ends.  Remember, in a command like
2260
2261      (gdb) break *ADDRESS if CONDITION
2262
2263    we evaluate ADDRESS in the scope of the current frame, but we
2264    evaluate CONDITION in the scope of the breakpoint's location.  So
2265    it's simply wrong to try to macro-expand the whole thing at once.  */
2266 static char *macro_original_text;
2267
2268 /* We save all intermediate macro expansions on this obstack for the
2269    duration of a single parse.  The expansion text may sometimes have
2270    to live past the end of the expansion, due to yacc lookahead.
2271    Rather than try to be clever about saving the data for a single
2272    token, we simply keep it all and delete it after parsing has
2273    completed.  */
2274 static struct obstack expansion_obstack;
2275
2276 static void
2277 scan_macro_expansion (char *expansion)
2278 {
2279   char *copy;
2280
2281   /* We'd better not be trying to push the stack twice.  */
2282   gdb_assert (! macro_original_text);
2283
2284   /* Copy to the obstack, and then free the intermediate
2285      expansion.  */
2286   copy = obstack_copy0 (&expansion_obstack, expansion, strlen (expansion));
2287   xfree (expansion);
2288
2289   /* Save the old lexptr value, so we can return to it when we're done
2290      parsing the expanded text.  */
2291   macro_original_text = lexptr;
2292   lexptr = copy;
2293 }
2294
2295
2296 static int
2297 scanning_macro_expansion (void)
2298 {
2299   return macro_original_text != 0;
2300 }
2301
2302
2303 static void
2304 finished_macro_expansion (void)
2305 {
2306   /* There'd better be something to pop back to.  */
2307   gdb_assert (macro_original_text);
2308
2309   /* Pop back to the original text.  */
2310   lexptr = macro_original_text;
2311   macro_original_text = 0;
2312 }
2313
2314
2315 static void
2316 scan_macro_cleanup (void *dummy)
2317 {
2318   if (macro_original_text)
2319     finished_macro_expansion ();
2320
2321   obstack_free (&expansion_obstack, NULL);
2322 }
2323
2324 /* Return true iff the token represents a C++ cast operator.  */
2325
2326 static int
2327 is_cast_operator (const char *token, int len)
2328 {
2329   return (! strncmp (token, "dynamic_cast", len)
2330           || ! strncmp (token, "static_cast", len)
2331           || ! strncmp (token, "reinterpret_cast", len)
2332           || ! strncmp (token, "const_cast", len));
2333 }
2334
2335 /* The scope used for macro expansion.  */
2336 static struct macro_scope *expression_macro_scope;
2337
2338 /* This is set if a NAME token appeared at the very end of the input
2339    string, with no whitespace separating the name from the EOF.  This
2340    is used only when parsing to do field name completion.  */
2341 static int saw_name_at_eof;
2342
2343 /* This is set if the previously-returned token was a structure
2344    operator -- either '.' or ARROW.  This is used only when parsing to
2345    do field name completion.  */
2346 static int last_was_structop;
2347
2348 /* Read one token, getting characters through lexptr.  */
2349
2350 static int
2351 lex_one_token (void)
2352 {
2353   int c;
2354   int namelen;
2355   unsigned int i;
2356   char *tokstart;
2357   int saw_structop = last_was_structop;
2358   char *copy;
2359
2360   last_was_structop = 0;
2361
2362  retry:
2363
2364   /* Check if this is a macro invocation that we need to expand.  */
2365   if (! scanning_macro_expansion ())
2366     {
2367       char *expanded = macro_expand_next (&lexptr,
2368                                           standard_macro_lookup,
2369                                           expression_macro_scope);
2370
2371       if (expanded)
2372         scan_macro_expansion (expanded);
2373     }
2374
2375   prev_lexptr = lexptr;
2376
2377   tokstart = lexptr;
2378   /* See if it is a special token of length 3.  */
2379   for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
2380     if (strncmp (tokstart, tokentab3[i].operator, 3) == 0)
2381       {
2382         if ((tokentab3[i].flags & FLAG_CXX) != 0
2383             && parse_language->la_language != language_cplus)
2384           break;
2385
2386         lexptr += 3;
2387         yylval.opcode = tokentab3[i].opcode;
2388         return tokentab3[i].token;
2389       }
2390
2391   /* See if it is a special token of length 2.  */
2392   for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
2393     if (strncmp (tokstart, tokentab2[i].operator, 2) == 0)
2394       {
2395         if ((tokentab2[i].flags & FLAG_CXX) != 0
2396             && parse_language->la_language != language_cplus)
2397           break;
2398
2399         lexptr += 2;
2400         yylval.opcode = tokentab2[i].opcode;
2401         if (parse_completion && tokentab2[i].token == ARROW)
2402           last_was_structop = 1;
2403         return tokentab2[i].token;
2404       }
2405
2406   switch (c = *tokstart)
2407     {
2408     case 0:
2409       /* If we were just scanning the result of a macro expansion,
2410          then we need to resume scanning the original text.
2411          If we're parsing for field name completion, and the previous
2412          token allows such completion, return a COMPLETE token.
2413          Otherwise, we were already scanning the original text, and
2414          we're really done.  */
2415       if (scanning_macro_expansion ())
2416         {
2417           finished_macro_expansion ();
2418           goto retry;
2419         }
2420       else if (saw_name_at_eof)
2421         {
2422           saw_name_at_eof = 0;
2423           return COMPLETE;
2424         }
2425       else if (saw_structop)
2426         return COMPLETE;
2427       else
2428         return 0;
2429
2430     case ' ':
2431     case '\t':
2432     case '\n':
2433       lexptr++;
2434       goto retry;
2435
2436     case '[':
2437     case '(':
2438       paren_depth++;
2439       lexptr++;
2440       if (parse_language->la_language == language_objc && c == '[')
2441         return OBJC_LBRAC;
2442       return c;
2443
2444     case ']':
2445     case ')':
2446       if (paren_depth == 0)
2447         return 0;
2448       paren_depth--;
2449       lexptr++;
2450       return c;
2451
2452     case ',':
2453       if (comma_terminates
2454           && paren_depth == 0
2455           && ! scanning_macro_expansion ())
2456         return 0;
2457       lexptr++;
2458       return c;
2459
2460     case '.':
2461       /* Might be a floating point number.  */
2462       if (lexptr[1] < '0' || lexptr[1] > '9')
2463         {
2464           if (parse_completion)
2465             last_was_structop = 1;
2466           goto symbol;          /* Nope, must be a symbol. */
2467         }
2468       /* FALL THRU into number case.  */
2469
2470     case '0':
2471     case '1':
2472     case '2':
2473     case '3':
2474     case '4':
2475     case '5':
2476     case '6':
2477     case '7':
2478     case '8':
2479     case '9':
2480       {
2481         /* It's a number.  */
2482         int got_dot = 0, got_e = 0, toktype;
2483         char *p = tokstart;
2484         int hex = input_radix > 10;
2485
2486         if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
2487           {
2488             p += 2;
2489             hex = 1;
2490           }
2491         else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
2492           {
2493             p += 2;
2494             hex = 0;
2495           }
2496
2497         for (;; ++p)
2498           {
2499             /* This test includes !hex because 'e' is a valid hex digit
2500                and thus does not indicate a floating point number when
2501                the radix is hex.  */
2502             if (!hex && !got_e && (*p == 'e' || *p == 'E'))
2503               got_dot = got_e = 1;
2504             /* This test does not include !hex, because a '.' always indicates
2505                a decimal floating point number regardless of the radix.  */
2506             else if (!got_dot && *p == '.')
2507               got_dot = 1;
2508             else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
2509                      && (*p == '-' || *p == '+'))
2510               /* This is the sign of the exponent, not the end of the
2511                  number.  */
2512               continue;
2513             /* We will take any letters or digits.  parse_number will
2514                complain if past the radix, or if L or U are not final.  */
2515             else if ((*p < '0' || *p > '9')
2516                      && ((*p < 'a' || *p > 'z')
2517                                   && (*p < 'A' || *p > 'Z')))
2518               break;
2519           }
2520         toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
2521         if (toktype == ERROR)
2522           {
2523             char *err_copy = (char *) alloca (p - tokstart + 1);
2524
2525             memcpy (err_copy, tokstart, p - tokstart);
2526             err_copy[p - tokstart] = 0;
2527             error (_("Invalid number \"%s\"."), err_copy);
2528           }
2529         lexptr = p;
2530         return toktype;
2531       }
2532
2533     case '@':
2534       {
2535         char *p = &tokstart[1];
2536         size_t len = strlen ("entry");
2537
2538         if (parse_language->la_language == language_objc)
2539           {
2540             size_t len = strlen ("selector");
2541
2542             if (strncmp (p, "selector", len) == 0
2543                 && (p[len] == '\0' || isspace (p[len])))
2544               {
2545                 lexptr = p + len;
2546                 return SELECTOR;
2547               }
2548             else if (*p == '"')
2549               goto parse_string;
2550           }
2551
2552         while (isspace (*p))
2553           p++;
2554         if (strncmp (p, "entry", len) == 0 && !isalnum (p[len])
2555             && p[len] != '_')
2556           {
2557             lexptr = &p[len];
2558             return ENTRY;
2559           }
2560       }
2561       /* FALLTHRU */
2562     case '+':
2563     case '-':
2564     case '*':
2565     case '/':
2566     case '%':
2567     case '|':
2568     case '&':
2569     case '^':
2570     case '~':
2571     case '!':
2572     case '<':
2573     case '>':
2574     case '?':
2575     case ':':
2576     case '=':
2577     case '{':
2578     case '}':
2579     symbol:
2580       lexptr++;
2581       return c;
2582
2583     case 'L':
2584     case 'u':
2585     case 'U':
2586       if (tokstart[1] != '"' && tokstart[1] != '\'')
2587         break;
2588       /* Fall through.  */
2589     case '\'':
2590     case '"':
2591
2592     parse_string:
2593       {
2594         int host_len;
2595         int result = parse_string_or_char (tokstart, &lexptr, &yylval.tsval,
2596                                            &host_len);
2597         if (result == CHAR)
2598           {
2599             if (host_len == 0)
2600               error (_("Empty character constant."));
2601             else if (host_len > 2 && c == '\'')
2602               {
2603                 ++tokstart;
2604                 namelen = lexptr - tokstart - 1;
2605                 goto tryname;
2606               }
2607             else if (host_len > 1)
2608               error (_("Invalid character constant."));
2609           }
2610         return result;
2611       }
2612     }
2613
2614   if (!(c == '_' || c == '$'
2615         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
2616     /* We must have come across a bad character (e.g. ';').  */
2617     error (_("Invalid character '%c' in expression."), c);
2618
2619   /* It's a name.  See how long it is.  */
2620   namelen = 0;
2621   for (c = tokstart[namelen];
2622        (c == '_' || c == '$' || (c >= '0' && c <= '9')
2623         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
2624     {
2625       /* Template parameter lists are part of the name.
2626          FIXME: This mishandles `print $a<4&&$a>3'.  */
2627
2628       if (c == '<')
2629         {
2630           if (! is_cast_operator (tokstart, namelen))
2631             {
2632               /* Scan ahead to get rest of the template specification.  Note
2633                  that we look ahead only when the '<' adjoins non-whitespace
2634                  characters; for comparison expressions, e.g. "a < b > c",
2635                  there must be spaces before the '<', etc. */
2636
2637               char * p = find_template_name_end (tokstart + namelen);
2638               if (p)
2639                 namelen = p - tokstart;
2640             }
2641           break;
2642         }
2643       c = tokstart[++namelen];
2644     }
2645
2646   /* The token "if" terminates the expression and is NOT removed from
2647      the input stream.  It doesn't count if it appears in the
2648      expansion of a macro.  */
2649   if (namelen == 2
2650       && tokstart[0] == 'i'
2651       && tokstart[1] == 'f'
2652       && ! scanning_macro_expansion ())
2653     {
2654       return 0;
2655     }
2656
2657   /* For the same reason (breakpoint conditions), "thread N"
2658      terminates the expression.  "thread" could be an identifier, but
2659      an identifier is never followed by a number without intervening
2660      punctuation.  "task" is similar.  Handle abbreviations of these,
2661      similarly to breakpoint.c:find_condition_and_thread.  */
2662   if (namelen >= 1
2663       && (strncmp (tokstart, "thread", namelen) == 0
2664           || strncmp (tokstart, "task", namelen) == 0)
2665       && (tokstart[namelen] == ' ' || tokstart[namelen] == '\t')
2666       && ! scanning_macro_expansion ())
2667     {
2668       char *p = tokstart + namelen + 1;
2669       while (*p == ' ' || *p == '\t')
2670         p++;
2671       if (*p >= '0' && *p <= '9')
2672         return 0;
2673     }
2674
2675   lexptr += namelen;
2676
2677   tryname:
2678
2679   yylval.sval.ptr = tokstart;
2680   yylval.sval.length = namelen;
2681
2682   /* Catch specific keywords.  */
2683   copy = copy_name (yylval.sval);
2684   for (i = 0; i < sizeof ident_tokens / sizeof ident_tokens[0]; i++)
2685     if (strcmp (copy, ident_tokens[i].operator) == 0)
2686       {
2687         if ((ident_tokens[i].flags & FLAG_CXX) != 0
2688             && parse_language->la_language != language_cplus)
2689           break;
2690
2691         if ((ident_tokens[i].flags & FLAG_SHADOW) != 0)
2692           {
2693             int is_a_field_of_this = 0;
2694
2695             if (lookup_symbol (copy, expression_context_block,
2696                                VAR_DOMAIN,
2697                                (parse_language->la_language == language_cplus
2698                                 ? &is_a_field_of_this
2699                                 : NULL))
2700                 != NULL)
2701               {
2702                 /* The keyword is shadowed.  */
2703                 break;
2704               }
2705           }
2706
2707         /* It is ok to always set this, even though we don't always
2708            strictly need to.  */
2709         yylval.opcode = ident_tokens[i].opcode;
2710         return ident_tokens[i].token;
2711       }
2712
2713   if (*tokstart == '$')
2714     return VARIABLE;
2715
2716   if (parse_completion && *lexptr == '\0')
2717     saw_name_at_eof = 1;
2718   return NAME;
2719 }
2720
2721 /* An object of this type is pushed on a FIFO by the "outer" lexer.  */
2722 typedef struct
2723 {
2724   int token;
2725   YYSTYPE value;
2726 } token_and_value;
2727
2728 DEF_VEC_O (token_and_value);
2729
2730 /* A FIFO of tokens that have been read but not yet returned to the
2731    parser.  */
2732 static VEC (token_and_value) *token_fifo;
2733
2734 /* Non-zero if the lexer should return tokens from the FIFO.  */
2735 static int popping;
2736
2737 /* Temporary storage for c_lex; this holds symbol names as they are
2738    built up.  */
2739 static struct obstack name_obstack;
2740
2741 /* Classify a NAME token.  The contents of the token are in `yylval'.
2742    Updates yylval and returns the new token type.  BLOCK is the block
2743    in which lookups start; this can be NULL to mean the global
2744    scope.  */
2745 static int
2746 classify_name (const struct block *block)
2747 {
2748   struct symbol *sym;
2749   char *copy;
2750   int is_a_field_of_this = 0;
2751
2752   copy = copy_name (yylval.sval);
2753
2754   sym = lookup_symbol (copy, block, VAR_DOMAIN,
2755                        parse_language->la_name_of_this
2756                        ? &is_a_field_of_this : (int *) NULL);
2757
2758   if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
2759     {
2760       yylval.ssym.sym = sym;
2761       yylval.ssym.is_a_field_of_this = is_a_field_of_this;
2762       return BLOCKNAME;
2763     }
2764   else if (!sym)
2765     {
2766       /* See if it's a file name. */
2767       struct symtab *symtab;
2768
2769       symtab = lookup_symtab (copy);
2770       if (symtab)
2771         {
2772           yylval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
2773           return FILENAME;
2774         }
2775     }
2776
2777   if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
2778     {
2779       yylval.tsym.type = SYMBOL_TYPE (sym);
2780       return TYPENAME;
2781     }
2782
2783   yylval.tsym.type
2784     = language_lookup_primitive_type_by_name (parse_language,
2785                                               parse_gdbarch, copy);
2786   if (yylval.tsym.type != NULL)
2787     return TYPENAME;
2788
2789   /* See if it's an ObjC classname.  */
2790   if (parse_language->la_language == language_objc && !sym)
2791     {
2792       CORE_ADDR Class = lookup_objc_class (parse_gdbarch, copy);
2793       if (Class)
2794         {
2795           yylval.class.class = Class;
2796           sym = lookup_struct_typedef (copy, expression_context_block, 1);
2797           if (sym)
2798             yylval.class.type = SYMBOL_TYPE (sym);
2799           return CLASSNAME;
2800         }
2801     }
2802
2803   /* Input names that aren't symbols but ARE valid hex numbers, when
2804      the input radix permits them, can be names or numbers depending
2805      on the parse.  Note we support radixes > 16 here.  */
2806   if (!sym
2807       && ((copy[0] >= 'a' && copy[0] < 'a' + input_radix - 10)
2808           || (copy[0] >= 'A' && copy[0] < 'A' + input_radix - 10)))
2809     {
2810       YYSTYPE newlval;  /* Its value is ignored.  */
2811       int hextype = parse_number (copy, yylval.sval.length, 0, &newlval);
2812       if (hextype == INT)
2813         {
2814           yylval.ssym.sym = sym;
2815           yylval.ssym.is_a_field_of_this = is_a_field_of_this;
2816           return NAME_OR_INT;
2817         }
2818     }
2819
2820   /* Any other kind of symbol */
2821   yylval.ssym.sym = sym;
2822   yylval.ssym.is_a_field_of_this = is_a_field_of_this;
2823
2824   if (sym == NULL
2825       && parse_language->la_language == language_cplus
2826       && !is_a_field_of_this
2827       && !lookup_minimal_symbol (copy, NULL, NULL))
2828     return UNKNOWN_CPP_NAME;
2829
2830   return NAME;
2831 }
2832
2833 /* Like classify_name, but used by the inner loop of the lexer, when a
2834    name might have already been seen.  FIRST_NAME is true if the token
2835    in `yylval' is the first component of a name, false otherwise.  */
2836
2837 static int
2838 classify_inner_name (const struct block *block, int first_name)
2839 {
2840   struct type *type, *new_type;
2841   char *copy;
2842
2843   if (first_name)
2844     return classify_name (block);
2845
2846   type = check_typedef (yylval.tsym.type);
2847   if (TYPE_CODE (type) != TYPE_CODE_STRUCT
2848       && TYPE_CODE (type) != TYPE_CODE_UNION
2849       && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
2850     return ERROR;
2851
2852   copy = copy_name (yylval.tsym.stoken);
2853   yylval.ssym.sym = cp_lookup_nested_symbol (yylval.tsym.type, copy, block);
2854   if (yylval.ssym.sym == NULL)
2855     return ERROR;
2856
2857   switch (SYMBOL_CLASS (yylval.ssym.sym))
2858     {
2859     case LOC_BLOCK:
2860     case LOC_LABEL:
2861       return ERROR;
2862
2863     case LOC_TYPEDEF:
2864       yylval.tsym.type = SYMBOL_TYPE (yylval.ssym.sym);;
2865       return TYPENAME;
2866
2867     default:
2868       yylval.ssym.is_a_field_of_this = 0;
2869       return NAME;
2870     }
2871   internal_error (__FILE__, __LINE__, _("not reached"));
2872 }
2873
2874 /* The outer level of a two-level lexer.  This calls the inner lexer
2875    to return tokens.  It then either returns these tokens, or
2876    aggregates them into a larger token.  This lets us work around a
2877    problem in our parsing approach, where the parser could not
2878    distinguish between qualified names and qualified types at the
2879    right point.
2880
2881    This approach is still not ideal, because it mishandles template
2882    types.  See the comment in lex_one_token for an example.  However,
2883    this is still an improvement over the earlier approach, and will
2884    suffice until we move to better parsing technology.  */
2885 static int
2886 yylex (void)
2887 {
2888   token_and_value current;
2889   int first_was_coloncolon, last_was_coloncolon, first_iter;
2890
2891   if (popping && !VEC_empty (token_and_value, token_fifo))
2892     {
2893       token_and_value tv = *VEC_index (token_and_value, token_fifo, 0);
2894       VEC_ordered_remove (token_and_value, token_fifo, 0);
2895       yylval = tv.value;
2896       return tv.token;
2897     }
2898   popping = 0;
2899
2900   current.token = lex_one_token ();
2901   if (current.token == NAME)
2902     current.token = classify_name (expression_context_block);
2903   if (parse_language->la_language != language_cplus
2904       || (current.token != TYPENAME && current.token != COLONCOLON))
2905     return current.token;
2906
2907   first_was_coloncolon = current.token == COLONCOLON;
2908   last_was_coloncolon = first_was_coloncolon;
2909   obstack_free (&name_obstack, obstack_base (&name_obstack));
2910   if (!last_was_coloncolon)
2911     obstack_grow (&name_obstack, yylval.sval.ptr, yylval.sval.length);
2912   current.value = yylval;
2913   first_iter = 1;
2914   while (1)
2915     {
2916       token_and_value next;
2917
2918       next.token = lex_one_token ();
2919       next.value = yylval;
2920
2921       if (next.token == NAME && last_was_coloncolon)
2922         {
2923           int classification;
2924
2925           classification = classify_inner_name (first_was_coloncolon
2926                                                 ? NULL
2927                                                 : expression_context_block,
2928                                                 first_iter);
2929           /* We keep going until we either run out of names, or until
2930              we have a qualified name which is not a type.  */
2931           if (classification != TYPENAME && classification != NAME)
2932             {
2933               /* Push the final component and leave the loop.  */
2934               VEC_safe_push (token_and_value, token_fifo, &next);
2935               break;
2936             }
2937
2938           /* Update the partial name we are constructing.  */
2939           if (!first_iter)
2940             {
2941               /* We don't want to put a leading "::" into the name.  */
2942               obstack_grow_str (&name_obstack, "::");
2943             }
2944           obstack_grow (&name_obstack, next.value.sval.ptr,
2945                         next.value.sval.length);
2946
2947           yylval.sval.ptr = obstack_base (&name_obstack);
2948           yylval.sval.length = obstack_object_size (&name_obstack);
2949           current.value = yylval;
2950           current.token = classification;
2951
2952           last_was_coloncolon = 0;
2953         }
2954       else if (next.token == COLONCOLON && !last_was_coloncolon)
2955         last_was_coloncolon = 1;
2956       else
2957         {
2958           /* We've reached the end of the name.  */
2959           VEC_safe_push (token_and_value, token_fifo, &next);
2960           break;
2961         }
2962
2963       first_iter = 0;
2964     }
2965
2966   popping = 1;
2967
2968   /* If we ended with a "::", insert it too.  */
2969   if (last_was_coloncolon)
2970     {
2971       token_and_value cc;
2972       memset (&cc, 0, sizeof (token_and_value));
2973       if (first_was_coloncolon && first_iter)
2974         {
2975           yylval = cc.value;
2976           return COLONCOLON;
2977         }
2978       cc.token = COLONCOLON;
2979       VEC_safe_insert (token_and_value, token_fifo, 0, &cc);
2980     }
2981
2982   yylval = current.value;
2983   yylval.sval.ptr = obstack_copy0 (&expansion_obstack,
2984                                    yylval.sval.ptr,
2985                                    yylval.sval.length);
2986   return current.token;
2987 }
2988
2989 int
2990 c_parse (void)
2991 {
2992   int result;
2993   struct cleanup *back_to = make_cleanup (free_current_contents,
2994                                           &expression_macro_scope);
2995
2996   /* Set up the scope for macro expansion.  */
2997   expression_macro_scope = NULL;
2998
2999   if (expression_context_block)
3000     expression_macro_scope
3001       = sal_macro_scope (find_pc_line (expression_context_pc, 0));
3002   else
3003     expression_macro_scope = default_macro_scope ();
3004   if (! expression_macro_scope)
3005     expression_macro_scope = user_macro_scope ();
3006
3007   /* Initialize macro expansion code.  */
3008   obstack_init (&expansion_obstack);
3009   gdb_assert (! macro_original_text);
3010   make_cleanup (scan_macro_cleanup, 0);
3011
3012   make_cleanup_restore_integer (&yydebug);
3013   yydebug = parser_debug;
3014
3015   /* Initialize some state used by the lexer.  */
3016   last_was_structop = 0;
3017   saw_name_at_eof = 0;
3018
3019   VEC_free (token_and_value, token_fifo);
3020   popping = 0;
3021   obstack_init (&name_obstack);
3022   make_cleanup_obstack_free (&name_obstack);
3023
3024   result = yyparse ();
3025   do_cleanups (back_to);
3026   return result;
3027 }
3028
3029
3030 void
3031 yyerror (char *msg)
3032 {
3033   if (prev_lexptr)
3034     lexptr = prev_lexptr;
3035
3036   error (_("A %s in expression, near `%s'."), (msg ? msg : "error"), lexptr);
3037 }