gdb/c-exp.y

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