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