contrib/gcc-4.1/gcc/cp/error.c

   1 /* Call-backs for C++ error reporting.
   2    This code is non-reentrant.
   3    Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002,
   4    2003, 2004, 2005 Free Software Foundation, Inc.
   5    This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GCC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
  20 Boston, MA 02110-1301, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "tree.h"
  27 #include "cp-tree.h"
  28 #include "real.h"
  29 #include "toplev.h"
  30 #include "flags.h"
  31 #include "diagnostic.h"
  32 #include "langhooks-def.h"
  33 #include "cxx-pretty-print.h"
  34
  35 #define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
  36
  37 /* The global buffer where we dump everything.  It is there only for
  38    transitional purpose.  It is expected, in the near future, to be
  39    completely removed.  */
  40 static cxx_pretty_printer scratch_pretty_printer;
  41 #define cxx_pp (&scratch_pretty_printer)
  42
  43 # define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
  44
  45 static const char *args_to_string (tree, int);
  46 static const char *assop_to_string (enum tree_code);
  47 static const char *code_to_string (enum tree_code);
  48 static const char *cv_to_string (tree, int);
  49 static const char *decl_to_string (tree, int);
  50 static const char *expr_to_string (tree);
  51 static const char *fndecl_to_string (tree, int);
  52 static const char *op_to_string (enum tree_code);
  53 static const char *parm_to_string (int);
  54 static const char *type_to_string (tree, int);
  55
  56 static void dump_type (tree, int);
  57 static void dump_typename (tree, int);
  58 static void dump_simple_decl (tree, tree, int);
  59 static void dump_decl (tree, int);
  60 static void dump_template_decl (tree, int);
  61 static void dump_function_decl (tree, int);
  62 static void dump_expr (tree, int);
  63 static void dump_unary_op (const char *, tree, int);
  64 static void dump_binary_op (const char *, tree, int);
  65 static void dump_aggr_type (tree, int);
  66 static void dump_type_prefix (tree, int);
  67 static void dump_type_suffix (tree, int);
  68 static void dump_function_name (tree, int);
  69 static void dump_expr_list (tree, int);
  70 static void dump_global_iord (tree);
  71 static void dump_parameters (tree, int);
  72 static void dump_exception_spec (tree, int);
  73 static void dump_template_argument (tree, int);
  74 static void dump_template_argument_list (tree, int);
  75 static void dump_template_parameter (tree, int);
  76 static void dump_template_bindings (tree, tree);
  77 static void dump_scope (tree, int);
  78 static void dump_template_parms (tree, int, int);
  79
  80 static const char *function_category (tree);
  81 static void maybe_print_instantiation_context (diagnostic_context *);
  82 static void print_instantiation_full_context (diagnostic_context *);
  83 static void print_instantiation_partial_context (diagnostic_context *,
  84                                                  tree, location_t);
  85 static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *);
  86 static void cp_diagnostic_finalizer (diagnostic_context *, diagnostic_info *);
  87 static void cp_print_error_function (diagnostic_context *, diagnostic_info *);
  88
  89 static bool cp_printer (pretty_printer *, text_info *, const char *,
  90                         int, bool, bool, bool);
  91 static location_t location_of (tree);
  92
  93 void
  94 init_error (void)
  95 {
  96   diagnostic_starter (global_dc) = cp_diagnostic_starter;
  97   diagnostic_finalizer (global_dc) = cp_diagnostic_finalizer;
  98   diagnostic_format_decoder (global_dc) = cp_printer;
  99
 100   pp_construct (pp_base (cxx_pp), NULL, 0);
 101   pp_cxx_pretty_printer_init (cxx_pp);
 102 }
 103
 104 /* Dump a scope, if deemed necessary.  */
 105
 106 static void
 107 dump_scope (tree scope, int flags)
 108 {
 109   int f = ~TFF_RETURN_TYPE & (flags & (TFF_SCOPE | TFF_CHASE_TYPEDEF));
 110
 111   if (scope == NULL_TREE)
 112     return;
 113
 114   if (TREE_CODE (scope) == NAMESPACE_DECL)
 115     {
 116       if (scope != global_namespace)
 117         {
 118           dump_decl (scope, f);
 119           pp_cxx_colon_colon (cxx_pp);
 120         }
 121     }
 122   else if (AGGREGATE_TYPE_P (scope))
 123     {
 124       dump_type (scope, f);
 125       pp_cxx_colon_colon (cxx_pp);
 126     }
 127   else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL)
 128     {
 129       dump_function_decl (scope, f);
 130       pp_cxx_colon_colon (cxx_pp);
 131     }
 132 }
 133
 134 /* Dump the template ARGument under control of FLAGS.  */
 135
 136 static void
 137 dump_template_argument (tree arg, int flags)
 138 {
 139   if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
 140     dump_type (arg, flags & ~TFF_CLASS_KEY_OR_ENUM);
 141   else
 142     dump_expr (arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM);
 143 }
 144
 145 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
 146    of FLAGS.  */
 147
 148 static void
 149 dump_template_argument_list (tree args, int flags)
 150 {
 151   int n = TREE_VEC_LENGTH (args);
 152   int need_comma = 0;
 153   int i;
 154
 155   for (i = 0; i< n; ++i)
 156     {
 157       if (need_comma)
 158         pp_separate_with_comma (cxx_pp);
 159       dump_template_argument (TREE_VEC_ELT (args, i), flags);
 160       need_comma = 1;
 161     }
 162 }
 163
 164 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS.  */
 165
 166 static void
 167 dump_template_parameter (tree parm, int flags)
 168 {
 169   tree p = TREE_VALUE (parm);
 170   tree a = TREE_PURPOSE (parm);
 171
 172   if (TREE_CODE (p) == TYPE_DECL)
 173     {
 174       if (flags & TFF_DECL_SPECIFIERS)
 175         {
 176           pp_cxx_identifier (cxx_pp, "class");
 177           if (DECL_NAME (p))
 178             pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
 179         }
 180       else if (DECL_NAME (p))
 181         pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
 182       else
 183         pp_cxx_canonical_template_parameter (cxx_pp, TREE_TYPE (p));
 184     }
 185   else
 186     dump_decl (p, flags | TFF_DECL_SPECIFIERS);
 187
 188   if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE)
 189     {
 190       pp_cxx_whitespace (cxx_pp);
 191       pp_equal (cxx_pp);
 192       pp_cxx_whitespace (cxx_pp);
 193       if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
 194         dump_type (a, flags & ~TFF_CHASE_TYPEDEF);
 195       else
 196         dump_expr (a, flags | TFF_EXPR_IN_PARENS);
 197     }
 198 }
 199
 200 /* Dump, under control of FLAGS, a template-parameter-list binding.
 201    PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
 202    TREE_VEC.  */
 203
 204 static void
 205 dump_template_bindings (tree parms, tree args)
 206 {
 207   int need_comma = 0;
 208
 209   while (parms)
 210     {
 211       tree p = TREE_VALUE (parms);
 212       int lvl = TMPL_PARMS_DEPTH (parms);
 213       int arg_idx = 0;
 214       int i;
 215
 216       for (i = 0; i < TREE_VEC_LENGTH (p); ++i)
 217         {
 218           tree arg = NULL_TREE;
 219
 220           /* Don't crash if we had an invalid argument list.  */
 221           if (TMPL_ARGS_DEPTH (args) >= lvl)
 222             {
 223               tree lvl_args = TMPL_ARGS_LEVEL (args, lvl);
 224               if (NUM_TMPL_ARGS (lvl_args) > arg_idx)
 225                 arg = TREE_VEC_ELT (lvl_args, arg_idx);
 226             }
 227
 228           if (need_comma)
 229             pp_separate_with_comma (cxx_pp);
 230           dump_template_parameter (TREE_VEC_ELT (p, i), TFF_PLAIN_IDENTIFIER);
 231           pp_cxx_whitespace (cxx_pp);
 232           pp_equal (cxx_pp);
 233           pp_cxx_whitespace (cxx_pp);
 234           if (arg)
 235             dump_template_argument (arg, TFF_PLAIN_IDENTIFIER);
 236           else
 237             pp_identifier (cxx_pp, "<missing>");
 238
 239           ++arg_idx;
 240           need_comma = 1;
 241         }
 242
 243       parms = TREE_CHAIN (parms);
 244     }
 245 }
 246
 247 /* Dump a human-readable equivalent of TYPE.  FLAGS controls the
 248    format.  */
 249
 250 static void
 251 dump_type (tree t, int flags)
 252 {
 253   if (t == NULL_TREE)
 254     return;
 255
 256   if (TYPE_PTRMEMFUNC_P (t))
 257     goto offset_type;
 258
 259   switch (TREE_CODE (t))
 260     {
 261     case UNKNOWN_TYPE:
 262       pp_identifier (cxx_pp, "<unresolved overloaded function type>");
 263       break;
 264
 265     case TREE_LIST:
 266       /* A list of function parms.  */
 267       dump_parameters (t, flags);
 268       break;
 269
 270     case IDENTIFIER_NODE:
 271       pp_cxx_tree_identifier (cxx_pp, t);
 272       break;
 273
 274     case TREE_BINFO:
 275       dump_type (BINFO_TYPE (t), flags);
 276       break;
 277
 278     case RECORD_TYPE:
 279     case UNION_TYPE:
 280     case ENUMERAL_TYPE:
 281       dump_aggr_type (t, flags);
 282       break;
 283
 284     case TYPE_DECL:
 285       if (flags & TFF_CHASE_TYPEDEF)
 286         {
 287           dump_type (DECL_ORIGINAL_TYPE (t)
 288                      ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
 289           break;
 290         }
 291       /* Else fall through.  */
 292
 293     case TEMPLATE_DECL:
 294     case NAMESPACE_DECL:
 295       dump_decl (t, flags & ~TFF_DECL_SPECIFIERS);
 296       break;
 297
 298     case INTEGER_TYPE:
 299     case REAL_TYPE:
 300     case VOID_TYPE:
 301     case BOOLEAN_TYPE:
 302     case COMPLEX_TYPE:
 303     case VECTOR_TYPE:
 304       pp_type_specifier_seq (cxx_pp, t);
 305       break;
 306
 307     case TEMPLATE_TEMPLATE_PARM:
 308       /* For parameters inside template signature.  */
 309       if (TYPE_IDENTIFIER (t))
 310         pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
 311       else
 312         pp_cxx_canonical_template_parameter (cxx_pp, t);
 313       break;
 314
 315     case BOUND_TEMPLATE_TEMPLATE_PARM:
 316       {
 317         tree args = TYPE_TI_ARGS (t);
 318         pp_cxx_cv_qualifier_seq (cxx_pp, t);
 319         pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
 320         pp_cxx_begin_template_argument_list (cxx_pp);
 321         dump_template_argument_list (args, flags);
 322         pp_cxx_end_template_argument_list (cxx_pp);
 323       }
 324       break;
 325
 326     case TEMPLATE_TYPE_PARM:
 327       pp_cxx_cv_qualifier_seq (cxx_pp, t);
 328       if (TYPE_IDENTIFIER (t))
 329         pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
 330       else
 331         pp_cxx_canonical_template_parameter
 332           (cxx_pp, TEMPLATE_TYPE_PARM_INDEX (t));
 333       break;
 334
 335       /* This is not always necessary for pointers and such, but doing this
 336          reduces code size.  */
 337     case ARRAY_TYPE:
 338     case POINTER_TYPE:
 339     case REFERENCE_TYPE:
 340     case OFFSET_TYPE:
 341     offset_type:
 342     case FUNCTION_TYPE:
 343     case METHOD_TYPE:
 344     {
 345       dump_type_prefix (t, flags);
 346       dump_type_suffix (t, flags);
 347       break;
 348     }
 349     case TYPENAME_TYPE:
 350       pp_cxx_cv_qualifier_seq (cxx_pp, t);
 351       pp_cxx_identifier (cxx_pp,
 352                          TYPENAME_IS_ENUM_P (t) ? "enum"
 353                          : TYPENAME_IS_CLASS_P (t) ? "class"
 354                          : "typename");
 355       dump_typename (t, flags);
 356       break;
 357
 358     case UNBOUND_CLASS_TEMPLATE:
 359       dump_type (TYPE_CONTEXT (t), flags);
 360       pp_cxx_colon_colon (cxx_pp);
 361       pp_cxx_identifier (cxx_pp, "template");
 362       dump_type (DECL_NAME (TYPE_NAME (t)), flags);
 363       break;
 364
 365     case TYPEOF_TYPE:
 366       pp_cxx_identifier (cxx_pp, "__typeof__");
 367       pp_cxx_whitespace (cxx_pp);
 368       pp_cxx_left_paren (cxx_pp);
 369       dump_expr (TYPEOF_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
 370       pp_cxx_right_paren (cxx_pp);
 371       break;
 372
 373     default:
 374       pp_unsupported_tree (cxx_pp, t);
 375       /* Fall through to error.  */
 376
 377     case ERROR_MARK:
 378       pp_identifier (cxx_pp, "<type error>");
 379       break;
 380     }
 381 }
 382
 383 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
 384    a TYPENAME_TYPE.  */
 385
 386 static void
 387 dump_typename (tree t, int flags)
 388 {
 389   tree ctx = TYPE_CONTEXT (t);
 390
 391   if (TREE_CODE (ctx) == TYPENAME_TYPE)
 392     dump_typename (ctx, flags);
 393   else
 394     dump_type (ctx, flags & ~TFF_CLASS_KEY_OR_ENUM);
 395   pp_cxx_colon_colon (cxx_pp);
 396   dump_decl (TYPENAME_TYPE_FULLNAME (t), flags);
 397 }
 398
 399 /* Return the name of the supplied aggregate, or enumeral type.  */
 400
 401 const char *
 402 class_key_or_enum_as_string (tree t)
 403 {
 404   if (TREE_CODE (t) == ENUMERAL_TYPE)
 405     return "enum";
 406   else if (TREE_CODE (t) == UNION_TYPE)
 407     return "union";
 408   else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
 409     return "class";
 410   else
 411     return "struct";
 412 }
 413
 414 /* Print out a class declaration T under the control of FLAGS,
 415    in the form `class foo'.  */
 416
 417 static void
 418 dump_aggr_type (tree t, int flags)
 419 {
 420   tree name;
 421   const char *variety = class_key_or_enum_as_string (t);
 422   int typdef = 0;
 423   int tmplate = 0;
 424
 425   pp_cxx_cv_qualifier_seq (cxx_pp, t);
 426
 427   if (flags & TFF_CLASS_KEY_OR_ENUM)
 428     pp_cxx_identifier (cxx_pp, variety);
 429
 430   if (flags & TFF_CHASE_TYPEDEF)
 431     t = TYPE_MAIN_VARIANT (t);
 432
 433   name = TYPE_NAME (t);
 434
 435   if (name)
 436     {
 437       typdef = !DECL_ARTIFICIAL (name);
 438       tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
 439                 && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
 440                 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
 441                     || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
 442       dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE);
 443       if (tmplate)
 444         {
 445           /* Because the template names are mangled, we have to locate
 446              the most general template, and use that name.  */
 447           tree tpl = CLASSTYPE_TI_TEMPLATE (t);
 448
 449           while (DECL_TEMPLATE_INFO (tpl))
 450             tpl = DECL_TI_TEMPLATE (tpl);
 451           name = tpl;
 452         }
 453       name = DECL_NAME (name);
 454     }
 455
 456   if (name == 0 || ANON_AGGRNAME_P (name))
 457     {
 458       if (flags & TFF_CLASS_KEY_OR_ENUM)
 459         pp_identifier (cxx_pp, "<anonymous>");
 460       else
 461         pp_printf (pp_base (cxx_pp), "<anonymous %s>", variety);
 462     }
 463   else
 464     pp_cxx_tree_identifier (cxx_pp, name);
 465   if (tmplate)
 466     dump_template_parms (TYPE_TEMPLATE_INFO (t),
 467                          !CLASSTYPE_USE_TEMPLATE (t),
 468                          flags & ~TFF_TEMPLATE_HEADER);
 469 }
 470
 471 /* Dump into the obstack the initial part of the output for a given type.
 472    This is necessary when dealing with things like functions returning
 473    functions.  Examples:
 474
 475    return type of `int (* fee ())()': pointer -> function -> int.  Both
 476    pointer (and reference and offset) and function (and member) types must
 477    deal with prefix and suffix.
 478
 479    Arrays must also do this for DECL nodes, like int a[], and for things like
 480    int *[]&.  */
 481
 482 static void
 483 dump_type_prefix (tree t, int flags)
 484 {
 485   if (TYPE_PTRMEMFUNC_P (t))
 486     {
 487       t = TYPE_PTRMEMFUNC_FN_TYPE (t);
 488       goto offset_type;
 489     }
 490
 491   switch (TREE_CODE (t))
 492     {
 493     case POINTER_TYPE:
 494     case REFERENCE_TYPE:
 495       {
 496         tree sub = TREE_TYPE (t);
 497
 498         dump_type_prefix (sub, flags);
 499         if (TREE_CODE (sub) == ARRAY_TYPE)
 500           {
 501             pp_cxx_whitespace (cxx_pp);
 502             pp_cxx_left_paren (cxx_pp);
 503           }
 504         pp_character (cxx_pp, "&*"[TREE_CODE (t) == POINTER_TYPE]);
 505         pp_base (cxx_pp)->padding = pp_before;
 506         pp_cxx_cv_qualifier_seq (cxx_pp, t);
 507       }
 508       break;
 509
 510     case OFFSET_TYPE:
 511     offset_type:
 512       dump_type_prefix (TREE_TYPE (t), flags);
 513       if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
 514         {
 515           pp_maybe_space (cxx_pp);
 516           if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
 517              pp_cxx_left_paren (cxx_pp);
 518           dump_type (TYPE_OFFSET_BASETYPE (t), flags);
 519           pp_cxx_colon_colon (cxx_pp);
 520         }
 521       pp_cxx_star (cxx_pp);
 522       pp_cxx_cv_qualifier_seq (cxx_pp, t);
 523       pp_base (cxx_pp)->padding = pp_before;
 524       break;
 525
 526       /* Can only be reached through function pointer -- this would not be
 527          correct if FUNCTION_DECLs used it.  */
 528     case FUNCTION_TYPE:
 529       dump_type_prefix (TREE_TYPE (t), flags);
 530       pp_maybe_space (cxx_pp);
 531       pp_cxx_left_paren (cxx_pp);
 532       break;
 533
 534     case METHOD_TYPE:
 535       dump_type_prefix (TREE_TYPE (t), flags);
 536       pp_maybe_space (cxx_pp);
 537       pp_cxx_left_paren (cxx_pp);
 538       dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags);
 539       pp_cxx_colon_colon (cxx_pp);
 540       break;
 541
 542     case ARRAY_TYPE:
 543       dump_type_prefix (TREE_TYPE (t), flags);
 544       break;
 545
 546     case ENUMERAL_TYPE:
 547     case IDENTIFIER_NODE:
 548     case INTEGER_TYPE:
 549     case BOOLEAN_TYPE:
 550     case REAL_TYPE:
 551     case RECORD_TYPE:
 552     case TEMPLATE_TYPE_PARM:
 553     case TEMPLATE_TEMPLATE_PARM:
 554     case BOUND_TEMPLATE_TEMPLATE_PARM:
 555     case TREE_LIST:
 556     case TYPE_DECL:
 557     case TREE_VEC:
 558     case UNION_TYPE:
 559     case UNKNOWN_TYPE:
 560     case VOID_TYPE:
 561     case TYPENAME_TYPE:
 562     case COMPLEX_TYPE:
 563     case VECTOR_TYPE:
 564     case TYPEOF_TYPE:
 565       dump_type (t, flags);
 566       pp_base (cxx_pp)->padding = pp_before;
 567       break;
 568
 569     default:
 570       pp_unsupported_tree (cxx_pp, t);
 571       /* fall through.  */
 572     case ERROR_MARK:
 573       pp_identifier (cxx_pp, "<typeprefixerror>");
 574       break;
 575     }
 576 }
 577
 578 /* Dump the suffix of type T, under control of FLAGS.  This is the part
 579    which appears after the identifier (or function parms).  */
 580
 581 static void
 582 dump_type_suffix (tree t, int flags)
 583 {
 584   if (TYPE_PTRMEMFUNC_P (t))
 585     t = TYPE_PTRMEMFUNC_FN_TYPE (t);
 586
 587   switch (TREE_CODE (t))
 588     {
 589     case POINTER_TYPE:
 590     case REFERENCE_TYPE:
 591     case OFFSET_TYPE:
 592       if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
 593         pp_cxx_right_paren (cxx_pp);
 594       dump_type_suffix (TREE_TYPE (t), flags);
 595       break;
 596
 597       /* Can only be reached through function pointer.  */
 598     case FUNCTION_TYPE:
 599     case METHOD_TYPE:
 600       {
 601         tree arg;
 602         pp_cxx_right_paren (cxx_pp);
 603         arg = TYPE_ARG_TYPES (t);
 604         if (TREE_CODE (t) == METHOD_TYPE)
 605           arg = TREE_CHAIN (arg);
 606
 607         /* Function pointers don't have default args.  Not in standard C++,
 608            anyway; they may in g++, but we'll just pretend otherwise.  */
 609         dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
 610
 611         if (TREE_CODE (t) == METHOD_TYPE)
 612           pp_cxx_cv_qualifier_seq
 613             (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
 614         else
 615           pp_cxx_cv_qualifier_seq(cxx_pp, t);
 616         dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags);
 617         dump_type_suffix (TREE_TYPE (t), flags);
 618         break;
 619       }
 620
 621     case ARRAY_TYPE:
 622       pp_maybe_space (cxx_pp);
 623       pp_cxx_left_bracket (cxx_pp);
 624       if (TYPE_DOMAIN (t))
 625         {
 626           if (host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0))
 627             pp_wide_integer
 628               (cxx_pp, tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0) + 1);
 629           else if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (t))) == MINUS_EXPR)
 630             dump_expr (TREE_OPERAND (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0),
 631                        flags & ~TFF_EXPR_IN_PARENS);
 632           else
 633             dump_expr (fold (cp_build_binary_op
 634                              (PLUS_EXPR, TYPE_MAX_VALUE (TYPE_DOMAIN (t)),
 635                               integer_one_node)),
 636                        flags & ~TFF_EXPR_IN_PARENS);
 637         }
 638       pp_cxx_right_bracket (cxx_pp);
 639       dump_type_suffix (TREE_TYPE (t), flags);
 640       break;
 641
 642     case ENUMERAL_TYPE:
 643     case IDENTIFIER_NODE:
 644     case INTEGER_TYPE:
 645     case BOOLEAN_TYPE:
 646     case REAL_TYPE:
 647     case RECORD_TYPE:
 648     case TEMPLATE_TYPE_PARM:
 649     case TEMPLATE_TEMPLATE_PARM:
 650     case BOUND_TEMPLATE_TEMPLATE_PARM:
 651     case TREE_LIST:
 652     case TYPE_DECL:
 653     case TREE_VEC:
 654     case UNION_TYPE:
 655     case UNKNOWN_TYPE:
 656     case VOID_TYPE:
 657     case TYPENAME_TYPE:
 658     case COMPLEX_TYPE:
 659     case VECTOR_TYPE:
 660     case TYPEOF_TYPE:
 661       break;
 662
 663     default:
 664       pp_unsupported_tree (cxx_pp, t);
 665     case ERROR_MARK:
 666       /* Don't mark it here, we should have already done in
 667          dump_type_prefix.  */
 668       break;
 669     }
 670 }
 671
 672 static void
 673 dump_global_iord (tree t)
 674 {
 675   const char *p = NULL;
 676
 677   if (DECL_GLOBAL_CTOR_P (t))
 678     p = "initializers";
 679   else if (DECL_GLOBAL_DTOR_P (t))
 680     p = "destructors";
 681   else
 682     gcc_unreachable ();
 683
 684   pp_printf (pp_base (cxx_pp), "(static %s for %s)", p, input_filename);
 685 }
 686
 687 static void
 688 dump_simple_decl (tree t, tree type, int flags)
 689 {
 690   if (flags & TFF_DECL_SPECIFIERS)
 691     {
 692       dump_type_prefix (type, flags);
 693       pp_maybe_space (cxx_pp);
 694     }
 695   if (!DECL_INITIAL (t) || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX)
 696     dump_scope (CP_DECL_CONTEXT (t), flags);
 697   if (DECL_NAME (t))
 698     dump_decl (DECL_NAME (t), flags);
 699   else
 700     pp_identifier (cxx_pp, "<anonymous>");
 701   if (flags & TFF_DECL_SPECIFIERS)
 702     dump_type_suffix (type, flags);
 703 }
 704
 705 /* Dump a human readable string for the decl T under control of FLAGS.  */
 706
 707 static void
 708 dump_decl (tree t, int flags)
 709 {
 710   if (t == NULL_TREE)
 711     return;
 712
 713   switch (TREE_CODE (t))
 714     {
 715     case TYPE_DECL:
 716       /* Don't say 'typedef class A' */
 717       if (DECL_ARTIFICIAL (t))
 718         {
 719           if ((flags & TFF_DECL_SPECIFIERS)
 720               && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
 721             /* Say `class T' not just `T'.  */
 722             pp_cxx_identifier (cxx_pp, "class");
 723
 724           dump_type (TREE_TYPE (t), flags);
 725           break;
 726         }
 727       if (flags & TFF_DECL_SPECIFIERS)
 728         pp_cxx_identifier (cxx_pp, "typedef");
 729       dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
 730                         ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
 731                         flags);
 732       break;
 733
 734     case VAR_DECL:
 735       if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
 736         {
 737           pp_string (cxx_pp, "vtable for ");
 738           gcc_assert (TYPE_P (DECL_CONTEXT (t)));
 739           dump_type (DECL_CONTEXT (t), flags);
 740           break;
 741         }
 742       /* Else fall through.  */
 743     case FIELD_DECL:
 744     case PARM_DECL:
 745       dump_simple_decl (t, TREE_TYPE (t), flags);
 746       break;
 747
 748     case RESULT_DECL:
 749       pp_string (cxx_pp, "<return value> ");
 750       dump_simple_decl (t, TREE_TYPE (t), flags);
 751       break;
 752
 753     case NAMESPACE_DECL:
 754       if (flags & TFF_DECL_SPECIFIERS)
 755         pp_cxx_declaration (cxx_pp, t);
 756       else
 757         {
 758           dump_scope (CP_DECL_CONTEXT (t), flags);
 759           if (DECL_NAME (t) == NULL_TREE)
 760             pp_identifier (cxx_pp, "<unnamed>");
 761           else
 762             pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
 763         }
 764       break;
 765
 766     case SCOPE_REF:
 767       pp_expression (cxx_pp, t);
 768       break;
 769
 770     case ARRAY_REF:
 771       dump_decl (TREE_OPERAND (t, 0), flags);
 772       pp_cxx_left_bracket (cxx_pp);
 773       dump_decl (TREE_OPERAND (t, 1), flags);
 774       pp_cxx_right_bracket (cxx_pp);
 775       break;
 776
 777       /* So that we can do dump_decl on an aggr type.  */
 778     case RECORD_TYPE:
 779     case UNION_TYPE:
 780     case ENUMERAL_TYPE:
 781       dump_type (t, flags);
 782       break;
 783
 784     case BIT_NOT_EXPR:
 785       /* This is a pseudo destructor call which has not been folded into
 786          a PSEUDO_DTOR_EXPR yet.  */
 787       pp_cxx_complement (cxx_pp);
 788       dump_type (TREE_OPERAND (t, 0), flags);
 789       break;
 790
 791     case TYPE_EXPR:
 792       gcc_unreachable ();
 793       break;
 794
 795       /* These special cases are duplicated here so that other functions
 796          can feed identifiers to error and get them demangled properly.  */
 797     case IDENTIFIER_NODE:
 798       if (IDENTIFIER_TYPENAME_P (t))
 799         {
 800           pp_cxx_identifier (cxx_pp, "operator");
 801           /* Not exactly IDENTIFIER_TYPE_VALUE.  */
 802           dump_type (TREE_TYPE (t), flags);
 803           break;
 804         }
 805       else
 806         pp_cxx_tree_identifier (cxx_pp, t);
 807       break;
 808
 809     case OVERLOAD:
 810       if (OVL_CHAIN (t))
 811         {
 812           t = OVL_CURRENT (t);
 813           if (DECL_CLASS_SCOPE_P (t))
 814             {
 815               dump_type (DECL_CONTEXT (t), flags);
 816               pp_cxx_colon_colon (cxx_pp);
 817             }
 818           else if (DECL_CONTEXT (t))
 819             {
 820               dump_decl (DECL_CONTEXT (t), flags);
 821               pp_cxx_colon_colon (cxx_pp);
 822             }
 823           dump_decl (DECL_NAME (t), flags);
 824           break;
 825         }
 826
 827       /* If there's only one function, just treat it like an ordinary
 828          FUNCTION_DECL.  */
 829       t = OVL_CURRENT (t);
 830       /* Fall through.  */
 831
 832     case FUNCTION_DECL:
 833       if (! DECL_LANG_SPECIFIC (t))
 834         pp_identifier (cxx_pp, "<built-in>");
 835       else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
 836         dump_global_iord (t);
 837       else
 838         dump_function_decl (t, flags);
 839       break;
 840
 841     case TEMPLATE_DECL:
 842       dump_template_decl (t, flags);
 843       break;
 844
 845     case TEMPLATE_ID_EXPR:
 846       {
 847         tree name = TREE_OPERAND (t, 0);
 848
 849         if (is_overloaded_fn (name))
 850           name = DECL_NAME (get_first_fn (name));
 851         dump_decl (name, flags);
 852         pp_cxx_begin_template_argument_list (cxx_pp);
 853         if (TREE_OPERAND (t, 1))
 854           dump_template_argument_list (TREE_OPERAND (t, 1), flags);
 855         pp_cxx_end_template_argument_list (cxx_pp);
 856       }
 857       break;
 858
 859     case LABEL_DECL:
 860       pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
 861       break;
 862
 863     case CONST_DECL:
 864       if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
 865           || (DECL_INITIAL (t) &&
 866               TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
 867         dump_simple_decl (t, TREE_TYPE (t), flags);
 868       else if (DECL_NAME (t))
 869         dump_decl (DECL_NAME (t), flags);
 870       else if (DECL_INITIAL (t))
 871         dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
 872       else
 873         pp_identifier (cxx_pp, "<enumerator>");
 874       break;
 875
 876     case USING_DECL:
 877       pp_cxx_identifier (cxx_pp, "using");
 878       dump_type (USING_DECL_SCOPE (t), flags);
 879       pp_cxx_colon_colon (cxx_pp);
 880       dump_decl (DECL_NAME (t), flags);
 881       break;
 882
 883     case BASELINK:
 884       dump_decl (BASELINK_FUNCTIONS (t), flags);
 885       break;
 886
 887     case NON_DEPENDENT_EXPR:
 888       dump_expr (t, flags);
 889       break;
 890
 891     case TEMPLATE_TYPE_PARM:
 892       if (flags & TFF_DECL_SPECIFIERS)
 893         pp_cxx_declaration (cxx_pp, t);
 894       else
 895         pp_type_id (cxx_pp, t);
 896       break;
 897
 898     default:
 899       pp_unsupported_tree (cxx_pp, t);
 900       /* Fall through to error.  */
 901
 902     case ERROR_MARK:
 903       pp_identifier (cxx_pp, "<declaration error>");
 904       break;
 905     }
 906 }
 907
 908 /* Dump a template declaration T under control of FLAGS. This means the
 909    'template <...> leaders plus the 'class X' or 'void fn(...)' part.  */
 910
 911 static void
 912 dump_template_decl (tree t, int flags)
 913 {
 914   tree orig_parms = DECL_TEMPLATE_PARMS (t);
 915   tree parms;
 916   int i;
 917
 918   if (flags & TFF_TEMPLATE_HEADER)
 919     {
 920       for (parms = orig_parms = nreverse (orig_parms);
 921            parms;
 922            parms = TREE_CHAIN (parms))
 923         {
 924           tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
 925           int len = TREE_VEC_LENGTH (inner_parms);
 926
 927           pp_cxx_identifier (cxx_pp, "template");
 928           pp_cxx_begin_template_argument_list (cxx_pp);
 929
 930           /* If we've shown the template prefix, we'd better show the
 931              parameters' and decl's type too.  */
 932             flags |= TFF_DECL_SPECIFIERS;
 933
 934           for (i = 0; i < len; i++)
 935             {
 936               if (i)
 937                 pp_separate_with_comma (cxx_pp);
 938               dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
 939             }
 940           pp_cxx_end_template_argument_list (cxx_pp);
 941           pp_cxx_whitespace (cxx_pp);
 942         }
 943       nreverse(orig_parms);
 944
 945       if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
 946         /* Say `template<arg> class TT' not just `template<arg> TT'.  */
 947         pp_cxx_identifier (cxx_pp, "class");
 948     }
 949
 950   if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
 951     dump_type (TREE_TYPE (t),
 952                ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
 953                 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
 954   else if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
 955     dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
 956   else
 957     {
 958       gcc_assert (TREE_TYPE (t));
 959       switch (NEXT_CODE (t))
 960         {
 961         case METHOD_TYPE:
 962         case FUNCTION_TYPE:
 963           dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
 964           break;
 965         default:
 966           /* This case can occur with some invalid code.  */
 967           dump_type (TREE_TYPE (t),
 968                      (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
 969                      | (flags & TFF_DECL_SPECIFIERS
 970                         ? TFF_CLASS_KEY_OR_ENUM : 0));
 971         }
 972     }
 973 }
 974
 975 /* Pretty print a function decl. There are several ways we want to print a
 976    function declaration. The TFF_ bits in FLAGS tells us how to behave.
 977    As error can only apply the '#' flag once to give 0 and 1 for V, there
 978    is %D which doesn't print the throw specs, and %F which does.  */
 979
 980 static void
 981 dump_function_decl (tree t, int flags)
 982 {
 983   tree fntype;
 984   tree parmtypes;
 985   tree cname = NULL_TREE;
 986   tree template_args = NULL_TREE;
 987   tree template_parms = NULL_TREE;
 988   int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
 989
 990   if (TREE_CODE (t) == TEMPLATE_DECL)
 991     t = DECL_TEMPLATE_RESULT (t);
 992
 993   /* Pretty print template instantiations only.  */
 994   if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t))
 995     {
 996       tree tmpl;
 997
 998       template_args = DECL_TI_ARGS (t);
 999       tmpl = most_general_template (t);
1000       if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1001         {
1002           template_parms = DECL_TEMPLATE_PARMS (tmpl);
1003           t = tmpl;
1004         }
1005     }
1006
1007   fntype = TREE_TYPE (t);
1008   parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1009
1010   if (DECL_CLASS_SCOPE_P (t))
1011     cname = DECL_CONTEXT (t);
1012   /* This is for partially instantiated template methods.  */
1013   else if (TREE_CODE (fntype) == METHOD_TYPE)
1014     cname = TREE_TYPE (TREE_VALUE (parmtypes));
1015
1016   if (!(flags & TFF_DECL_SPECIFIERS))
1017     /* OK */;
1018   else if (DECL_STATIC_FUNCTION_P (t))
1019     pp_cxx_identifier (cxx_pp, "static");
1020   else if (DECL_VIRTUAL_P (t))
1021     pp_cxx_identifier (cxx_pp, "virtual");
1022
1023   /* Print the return type?  */
1024   if (show_return)
1025     show_return = !DECL_CONV_FN_P (t)  && !DECL_CONSTRUCTOR_P (t)
1026                   && !DECL_DESTRUCTOR_P (t);
1027   if (show_return)
1028     dump_type_prefix (TREE_TYPE (fntype), flags);
1029
1030   /* Print the function name.  */
1031   if (cname)
1032     {
1033       dump_type (cname, flags);
1034       pp_cxx_colon_colon (cxx_pp);
1035     }
1036   else
1037     dump_scope (CP_DECL_CONTEXT (t), flags);
1038
1039   dump_function_name (t, flags);
1040
1041   if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1042     {
1043       dump_parameters (parmtypes, flags);
1044
1045       if (TREE_CODE (fntype) == METHOD_TYPE)
1046         {
1047           pp_base (cxx_pp)->padding = pp_before;
1048           pp_cxx_cv_qualifier_seq
1049             (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))));
1050         }
1051
1052       if (flags & TFF_EXCEPTION_SPECIFICATION)
1053         {
1054           pp_base (cxx_pp)->padding = pp_before;
1055           dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags);
1056         }
1057
1058       if (show_return)
1059         dump_type_suffix (TREE_TYPE (fntype), flags);
1060     }
1061
1062   /* If T is a template instantiation, dump the parameter binding.  */
1063   if (template_parms != NULL_TREE && template_args != NULL_TREE)
1064     {
1065       pp_cxx_whitespace (cxx_pp);
1066       pp_cxx_left_bracket (cxx_pp);
1067       pp_cxx_identifier (cxx_pp, "with");
1068       pp_cxx_whitespace (cxx_pp);
1069       dump_template_bindings (template_parms, template_args);
1070       pp_cxx_right_bracket (cxx_pp);
1071     }
1072 }
1073
1074 /* Print a parameter list. If this is for a member function, the
1075    member object ptr (and any other hidden args) should have
1076    already been removed.  */
1077
1078 static void
1079 dump_parameters (tree parmtypes, int flags)
1080 {
1081   int first;
1082
1083   pp_cxx_left_paren (cxx_pp);
1084
1085   for (first = 1; parmtypes != void_list_node;
1086        parmtypes = TREE_CHAIN (parmtypes))
1087     {
1088       if (!first)
1089         pp_separate_with_comma (cxx_pp);
1090       first = 0;
1091       if (!parmtypes)
1092         {
1093           pp_cxx_identifier (cxx_pp, "...");
1094           break;
1095         }
1096       dump_type (TREE_VALUE (parmtypes), flags);
1097
1098       if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1099         {
1100           pp_cxx_whitespace (cxx_pp);
1101           pp_equal (cxx_pp);
1102           pp_cxx_whitespace (cxx_pp);
1103           dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1104         }
1105     }
1106
1107   pp_cxx_right_paren (cxx_pp);
1108 }
1109
1110 /* Print an exception specification. T is the exception specification.  */
1111
1112 static void
1113 dump_exception_spec (tree t, int flags)
1114 {
1115   if (t)
1116     {
1117       pp_cxx_identifier (cxx_pp, "throw");
1118       pp_cxx_whitespace (cxx_pp);
1119       pp_cxx_left_paren (cxx_pp);
1120       if (TREE_VALUE (t) != NULL_TREE)
1121         while (1)
1122           {
1123             dump_type (TREE_VALUE (t), flags);
1124             t = TREE_CHAIN (t);
1125             if (!t)
1126               break;
1127             pp_separate_with_comma (cxx_pp);
1128           }
1129       pp_cxx_right_paren (cxx_pp);
1130     }
1131 }
1132
1133 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1134    and destructors properly.  */
1135
1136 static void
1137 dump_function_name (tree t, int flags)
1138 {
1139   tree name = DECL_NAME (t);
1140
1141   /* We can get here with a decl that was synthesized by language-
1142      independent machinery (e.g. coverage.c) in which case it won't
1143      have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1144      will crash.  In this case it is safe just to print out the
1145      literal name.  */
1146   if (!DECL_LANG_SPECIFIC (t))
1147     {
1148       pp_cxx_tree_identifier (cxx_pp, name);
1149       return;
1150     }
1151
1152   if (TREE_CODE (t) == TEMPLATE_DECL)
1153     t = DECL_TEMPLATE_RESULT (t);
1154
1155   /* Don't let the user see __comp_ctor et al.  */
1156   if (DECL_CONSTRUCTOR_P (t)
1157       || DECL_DESTRUCTOR_P (t))
1158     name = constructor_name (DECL_CONTEXT (t));
1159
1160   if (DECL_DESTRUCTOR_P (t))
1161     {
1162       pp_cxx_complement (cxx_pp);
1163       dump_decl (name, TFF_PLAIN_IDENTIFIER);
1164     }
1165   else if (DECL_CONV_FN_P (t))
1166     {
1167       /* This cannot use the hack that the operator's return
1168          type is stashed off of its name because it may be
1169          used for error reporting.  In the case of conflicting
1170          declarations, both will have the same name, yet
1171          the types will be different, hence the TREE_TYPE field
1172          of the first name will be clobbered by the second.  */
1173       pp_cxx_identifier (cxx_pp, "operator");
1174       dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1175     }
1176   else if (IDENTIFIER_OPNAME_P (name))
1177     pp_cxx_tree_identifier (cxx_pp, name);
1178   else
1179     dump_decl (name, flags);
1180
1181   if (DECL_TEMPLATE_INFO (t)
1182       && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1183       && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1184           || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1185     dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
1186 }
1187
1188 /* Dump the template parameters from the template info INFO under control of
1189    FLAGS. PRIMARY indicates whether this is a primary template decl, or
1190    specialization (partial or complete). For partial specializations we show
1191    the specialized parameter values. For a primary template we show no
1192    decoration.  */
1193
1194 static void
1195 dump_template_parms (tree info, int primary, int flags)
1196 {
1197   tree args = info ? TI_ARGS (info) : NULL_TREE;
1198
1199   if (primary && flags & TFF_TEMPLATE_NAME)
1200     return;
1201   flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1202   pp_cxx_begin_template_argument_list (cxx_pp);
1203
1204   /* Be careful only to print things when we have them, so as not
1205          to crash producing error messages.  */
1206   if (args && !primary)
1207     {
1208       int len, ix;
1209
1210       if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
1211         args = TREE_VEC_ELT (args, TREE_VEC_LENGTH (args) - 1);
1212
1213       len = TREE_VEC_LENGTH (args);
1214
1215       for (ix = 0; ix != len; ix++)
1216         {
1217           tree arg = TREE_VEC_ELT (args, ix);
1218
1219           if (ix)
1220             pp_separate_with_comma (cxx_pp);
1221
1222           if (!arg)
1223             pp_identifier (cxx_pp, "<template parameter error>");
1224           else
1225             dump_template_argument (arg, flags);
1226         }
1227     }
1228   else if (primary)
1229     {
1230       tree tpl = TI_TEMPLATE (info);
1231       tree parms = DECL_TEMPLATE_PARMS (tpl);
1232       int len, ix;
1233
1234       parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1235       len = parms ? TREE_VEC_LENGTH (parms) : 0;
1236
1237       for (ix = 0; ix != len; ix++)
1238         {
1239           tree parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1240
1241           if (ix)
1242             pp_separate_with_comma (cxx_pp);
1243
1244           dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
1245         }
1246     }
1247   pp_cxx_end_template_argument_list (cxx_pp);
1248 }
1249
1250 /* Print out a list of initializers (subr of dump_expr).  */
1251
1252 static void
1253 dump_expr_list (tree l, int flags)
1254 {
1255   while (l)
1256     {
1257       dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1258       l = TREE_CHAIN (l);
1259       if (l)
1260         pp_separate_with_comma (cxx_pp);
1261     }
1262 }
1263
1264 /* Print out a vector of initializers (subr of dump_expr).  */
1265
1266 static void
1267 dump_expr_init_vec (VEC(constructor_elt,gc) *v, int flags)
1268 {
1269   unsigned HOST_WIDE_INT idx;
1270   tree value;
1271
1272   FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1273     {
1274       dump_expr (value, flags | TFF_EXPR_IN_PARENS);
1275       if (idx != VEC_length (constructor_elt, v) - 1)
1276         pp_separate_with_comma (cxx_pp);
1277     }
1278 }
1279
1280
1281 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1282    function.  Resolve it to a close relative -- in the sense of static
1283    type -- variant being overridden.  That is close to what was written in
1284    the source code.  Subroutine of dump_expr.  */
1285
1286 static tree
1287 resolve_virtual_fun_from_obj_type_ref (tree ref)
1288 {
1289   tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref));
1290   int index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
1291   tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
1292     while (index--)
1293       fun = TREE_CHAIN (fun);
1294
1295   return BV_FN (fun);
1296 }
1297
1298 /* Print out an expression E under control of FLAGS.  */
1299
1300 static void
1301 dump_expr (tree t, int flags)
1302 {
1303   if (t == 0)
1304     return;
1305
1306   switch (TREE_CODE (t))
1307     {
1308     case VAR_DECL:
1309     case PARM_DECL:
1310     case FIELD_DECL:
1311     case CONST_DECL:
1312     case FUNCTION_DECL:
1313     case TEMPLATE_DECL:
1314     case NAMESPACE_DECL:
1315     case LABEL_DECL:
1316     case OVERLOAD:
1317     case IDENTIFIER_NODE:
1318       dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS);
1319       break;
1320
1321     case STRING_CST:
1322       if (PAREN_STRING_LITERAL_P (t))
1323         pp_cxx_left_paren (cxx_pp);
1324       pp_c_constant (pp_c_base (cxx_pp), t);
1325       if (PAREN_STRING_LITERAL_P (t))
1326         pp_cxx_right_paren (cxx_pp);
1327       break;
1328
1329     case INTEGER_CST:
1330     case REAL_CST:
1331        pp_c_constant (pp_c_base (cxx_pp), t);
1332       break;
1333
1334     case THROW_EXPR:
1335       pp_cxx_identifier (cxx_pp, "throw");
1336       dump_expr (TREE_OPERAND (t, 0), flags);
1337       break;
1338
1339     case PTRMEM_CST:
1340       pp_ampersand (cxx_pp);
1341       dump_type (PTRMEM_CST_CLASS (t), flags);
1342       pp_cxx_colon_colon (cxx_pp);
1343       pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1344       break;
1345
1346     case COMPOUND_EXPR:
1347       pp_cxx_left_paren (cxx_pp);
1348       dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1349       pp_separate_with_comma (cxx_pp);
1350       dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1351       pp_cxx_right_paren (cxx_pp);
1352       break;
1353
1354     case COND_EXPR:
1355       pp_cxx_left_paren (cxx_pp);
1356       dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1357       pp_string (cxx_pp, " ? ");
1358       dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1359       pp_string (cxx_pp, " : ");
1360       dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1361       pp_cxx_right_paren (cxx_pp);
1362       break;
1363
1364     case SAVE_EXPR:
1365       if (TREE_HAS_CONSTRUCTOR (t))
1366         {
1367           pp_cxx_identifier (cxx_pp, "new");
1368           pp_cxx_whitespace (cxx_pp);
1369           dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1370         }
1371       else
1372         dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1373       break;
1374
1375     case AGGR_INIT_EXPR:
1376       {
1377         tree fn = NULL_TREE;
1378
1379         if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR)
1380           fn = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
1381
1382         if (fn && TREE_CODE (fn) == FUNCTION_DECL)
1383           {
1384             if (DECL_CONSTRUCTOR_P (fn))
1385               dump_type (DECL_CONTEXT (fn), flags);
1386             else
1387               dump_decl (fn, 0);
1388           }
1389         else
1390           dump_expr (TREE_OPERAND (t, 0), 0);
1391       }
1392       pp_cxx_left_paren (cxx_pp);
1393       if (TREE_OPERAND (t, 1))
1394         dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
1395       pp_cxx_right_paren (cxx_pp);
1396       break;
1397
1398     case CALL_EXPR:
1399       {
1400         tree fn = TREE_OPERAND (t, 0);
1401         tree args = TREE_OPERAND (t, 1);
1402
1403         if (TREE_CODE (fn) == ADDR_EXPR)
1404           fn = TREE_OPERAND (fn, 0);
1405
1406         /* Nobody is interested in seeing the guts of vcalls.  */
1407         if (TREE_CODE (fn) == OBJ_TYPE_REF)
1408           fn = resolve_virtual_fun_from_obj_type_ref (fn);
1409
1410         if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE)
1411           {
1412             tree ob = TREE_VALUE (args);
1413             if (TREE_CODE (ob) == ADDR_EXPR)
1414               {
1415                 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1416                 pp_dot (cxx_pp);
1417               }
1418             else if (TREE_CODE (ob) != PARM_DECL
1419                      || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1420               {
1421                 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1422                 pp_arrow (cxx_pp);
1423               }
1424             args = TREE_CHAIN (args);
1425           }
1426         dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
1427         pp_cxx_left_paren (cxx_pp);
1428         dump_expr_list (args, flags);
1429         pp_cxx_right_paren (cxx_pp);
1430       }
1431       break;
1432
1433     case NEW_EXPR:
1434       {
1435         tree type = TREE_OPERAND (t, 1);
1436         tree init = TREE_OPERAND (t, 2);
1437         if (NEW_EXPR_USE_GLOBAL (t))
1438           pp_cxx_colon_colon (cxx_pp);
1439         pp_cxx_identifier (cxx_pp, "new");
1440         if (TREE_OPERAND (t, 0))
1441           {
1442             pp_cxx_left_paren (cxx_pp);
1443             dump_expr_list (TREE_OPERAND (t, 0), flags);
1444             pp_cxx_right_paren (cxx_pp);
1445             pp_cxx_whitespace (cxx_pp);
1446           }
1447         if (TREE_CODE (type) == ARRAY_REF)
1448           type = build_cplus_array_type
1449             (TREE_OPERAND (type, 0),
1450              build_index_type (fold_build2 (MINUS_EXPR, integer_type_node,
1451                                             TREE_OPERAND (type, 1),
1452                                             integer_one_node)));
1453         dump_type (type, flags);
1454         if (init)
1455           {
1456             pp_cxx_left_paren (cxx_pp);
1457             if (TREE_CODE (init) == TREE_LIST)
1458               dump_expr_list (init, flags);
1459             else if (init == void_zero_node)
1460               /* This representation indicates an empty initializer,
1461                  e.g.: "new int()".  */
1462               ;
1463             else
1464               dump_expr (init, flags);
1465             pp_cxx_right_paren (cxx_pp);
1466           }
1467       }
1468       break;
1469
1470     case TARGET_EXPR:
1471       /* Note that this only works for G++ target exprs.  If somebody
1472          builds a general TARGET_EXPR, there's no way to represent that
1473          it initializes anything other that the parameter slot for the
1474          default argument.  Note we may have cleared out the first
1475          operand in expand_expr, so don't go killing ourselves.  */
1476       if (TREE_OPERAND (t, 1))
1477         dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1478       break;
1479
1480     case INIT_EXPR:
1481     case MODIFY_EXPR:
1482     case PLUS_EXPR:
1483     case MINUS_EXPR:
1484     case MULT_EXPR:
1485     case TRUNC_DIV_EXPR:
1486     case TRUNC_MOD_EXPR:
1487     case MIN_EXPR:
1488     case MAX_EXPR:
1489     case LSHIFT_EXPR:
1490     case RSHIFT_EXPR:
1491     case BIT_IOR_EXPR:
1492     case BIT_XOR_EXPR:
1493     case BIT_AND_EXPR:
1494     case TRUTH_ANDIF_EXPR:
1495     case TRUTH_ORIF_EXPR:
1496     case LT_EXPR:
1497     case LE_EXPR:
1498     case GT_EXPR:
1499     case GE_EXPR:
1500     case EQ_EXPR:
1501     case NE_EXPR:
1502     case EXACT_DIV_EXPR:
1503       dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags);
1504       break;
1505
1506     case CEIL_DIV_EXPR:
1507     case FLOOR_DIV_EXPR:
1508     case ROUND_DIV_EXPR:
1509     case RDIV_EXPR:
1510       dump_binary_op ("/", t, flags);
1511       break;
1512
1513     case CEIL_MOD_EXPR:
1514     case FLOOR_MOD_EXPR:
1515     case ROUND_MOD_EXPR:
1516       dump_binary_op ("%", t, flags);
1517       break;
1518
1519     case COMPONENT_REF:
1520       {
1521         tree ob = TREE_OPERAND (t, 0);
1522         if (TREE_CODE (ob) == INDIRECT_REF)
1523           {
1524             ob = TREE_OPERAND (ob, 0);
1525             if (TREE_CODE (ob) != PARM_DECL
1526                 || (DECL_NAME (ob)
1527                     && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")))
1528               {
1529                 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1530                 pp_cxx_arrow (cxx_pp);
1531               }
1532           }
1533         else
1534           {
1535             dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1536             pp_cxx_dot (cxx_pp);
1537           }
1538         dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1539       }
1540       break;
1541
1542     case ARRAY_REF:
1543       dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1544       pp_cxx_left_bracket (cxx_pp);
1545       dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1546       pp_cxx_right_bracket (cxx_pp);
1547       break;
1548
1549     case UNARY_PLUS_EXPR:
1550       dump_unary_op ("+", t, flags);
1551       break;
1552
1553     case ADDR_EXPR:
1554       if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1555           || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
1556           /* An ADDR_EXPR can have reference type.  In that case, we
1557              shouldn't print the `&' doing so indicates to the user
1558              that the expression has pointer type.  */
1559           || (TREE_TYPE (t)
1560               && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
1561         dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1562       else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
1563         dump_unary_op ("&&", t, flags);
1564       else
1565         dump_unary_op ("&", t, flags);
1566       break;
1567
1568     case INDIRECT_REF:
1569       if (TREE_HAS_CONSTRUCTOR (t))
1570         {
1571           t = TREE_OPERAND (t, 0);
1572           gcc_assert (TREE_CODE (t) == CALL_EXPR);
1573           dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1574           pp_cxx_left_paren (cxx_pp);
1575           dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
1576           pp_cxx_right_paren (cxx_pp);
1577         }
1578       else
1579         {
1580           if (TREE_OPERAND (t,0) != NULL_TREE
1581               && TREE_TYPE (TREE_OPERAND (t, 0))
1582               && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
1583             dump_expr (TREE_OPERAND (t, 0), flags);
1584           else
1585             dump_unary_op ("*", t, flags);
1586         }
1587       break;
1588
1589     case NEGATE_EXPR:
1590     case BIT_NOT_EXPR:
1591     case TRUTH_NOT_EXPR:
1592     case PREDECREMENT_EXPR:
1593     case PREINCREMENT_EXPR:
1594       dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags);
1595       break;
1596
1597     case POSTDECREMENT_EXPR:
1598     case POSTINCREMENT_EXPR:
1599       pp_cxx_left_paren (cxx_pp);
1600       dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1601       pp_cxx_identifier (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
1602       pp_cxx_right_paren (cxx_pp);
1603       break;
1604
1605     case NON_LVALUE_EXPR:
1606       /* FIXME: This is a KLUDGE workaround for a parsing problem.  There
1607          should be another level of INDIRECT_REF so that I don't have to do
1608          this.  */
1609       if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
1610         {
1611           tree next = TREE_TYPE (TREE_TYPE (t));
1612
1613           while (TREE_CODE (next) == POINTER_TYPE)
1614             next = TREE_TYPE (next);
1615
1616           if (TREE_CODE (next) == FUNCTION_TYPE)
1617             {
1618               if (flags & TFF_EXPR_IN_PARENS)
1619                 pp_cxx_left_paren (cxx_pp);
1620               pp_cxx_star (cxx_pp);
1621               dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1622               if (flags & TFF_EXPR_IN_PARENS)
1623                 pp_cxx_right_paren (cxx_pp);
1624               break;
1625             }
1626           /* Else fall through.  */
1627         }
1628       dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1629       break;
1630
1631     case NOP_EXPR:
1632     case CONVERT_EXPR:
1633       {
1634         tree op = TREE_OPERAND (t, 0);
1635
1636         if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
1637           {
1638             /* It is a cast, but we cannot tell whether it is a
1639                reinterpret or static cast. Use the C style notation.  */
1640             if (flags & TFF_EXPR_IN_PARENS)
1641               pp_cxx_left_paren (cxx_pp);
1642             pp_cxx_left_paren (cxx_pp);
1643             dump_type (TREE_TYPE (t), flags);
1644             pp_cxx_right_paren (cxx_pp);
1645             dump_expr (op, flags | TFF_EXPR_IN_PARENS);
1646             if (flags & TFF_EXPR_IN_PARENS)
1647               pp_cxx_right_paren (cxx_pp);
1648           }
1649         else
1650           dump_expr (op, flags);
1651         break;
1652       }
1653
1654     case CONSTRUCTOR:
1655       if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
1656         {
1657           tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
1658
1659           if (integer_zerop (idx))
1660             {
1661               /* A NULL pointer-to-member constant.  */
1662               pp_cxx_left_paren (cxx_pp);
1663               pp_cxx_left_paren (cxx_pp);
1664               dump_type (TREE_TYPE (t), flags);
1665               pp_cxx_right_paren (cxx_pp);
1666               pp_character (cxx_pp, '0');
1667               pp_cxx_right_paren (cxx_pp);
1668               break;
1669             }
1670           else if (host_integerp (idx, 0))
1671             {
1672               tree virtuals;
1673               unsigned HOST_WIDE_INT n;
1674
1675               t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
1676               t = TYPE_METHOD_BASETYPE (t);
1677               virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
1678
1679               n = tree_low_cst (idx, 0);
1680
1681               /* Map vtable index back one, to allow for the null pointer to
1682                  member.  */
1683               --n;
1684
1685               while (n > 0 && virtuals)
1686                 {
1687                   --n;
1688                   virtuals = TREE_CHAIN (virtuals);
1689                 }
1690               if (virtuals)
1691                 {
1692                   dump_expr (BV_FN (virtuals),
1693                              flags | TFF_EXPR_IN_PARENS);
1694                   break;
1695                 }
1696             }
1697         }
1698       if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
1699         {
1700           dump_type (TREE_TYPE (t), 0);
1701           pp_cxx_left_paren (cxx_pp);
1702           pp_cxx_right_paren (cxx_pp);
1703         }
1704       else
1705         {
1706           pp_cxx_left_brace (cxx_pp);
1707           dump_expr_init_vec (CONSTRUCTOR_ELTS (t), flags);
1708           pp_cxx_right_brace (cxx_pp);
1709         }
1710
1711       break;
1712
1713     case OFFSET_REF:
1714       {
1715         tree ob = TREE_OPERAND (t, 0);
1716         if (is_dummy_object (ob))
1717           {
1718             t = TREE_OPERAND (t, 1);
1719             if (TREE_CODE (t) == FUNCTION_DECL)
1720               /* A::f */
1721               dump_expr (t, flags | TFF_EXPR_IN_PARENS);
1722             else if (BASELINK_P (t))
1723               dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
1724                          flags | TFF_EXPR_IN_PARENS);
1725             else
1726               dump_decl (t, flags);
1727           }
1728         else
1729           {
1730             if (TREE_CODE (ob) == INDIRECT_REF)
1731               {
1732                 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1733                 pp_cxx_arrow (cxx_pp);
1734                 pp_cxx_star (cxx_pp);
1735               }
1736             else
1737               {
1738                 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1739                 pp_cxx_dot (cxx_pp);
1740                 pp_cxx_star (cxx_pp);
1741               }
1742             dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1743           }
1744         break;
1745       }
1746
1747     case TEMPLATE_PARM_INDEX:
1748       dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
1749       break;
1750
1751     case SCOPE_REF:
1752       pp_expression (cxx_pp, t);
1753       break;
1754
1755     case CAST_EXPR:
1756       if (TREE_OPERAND (t, 0) == NULL_TREE
1757           || TREE_CHAIN (TREE_OPERAND (t, 0)))
1758         {
1759           dump_type (TREE_TYPE (t), flags);
1760           pp_cxx_left_paren (cxx_pp);
1761           dump_expr_list (TREE_OPERAND (t, 0), flags);
1762           pp_cxx_right_paren (cxx_pp);
1763         }
1764       else
1765         {
1766           pp_cxx_left_paren (cxx_pp);
1767           dump_type (TREE_TYPE (t), flags);
1768           pp_cxx_right_paren (cxx_pp);
1769           pp_cxx_left_paren (cxx_pp);
1770           dump_expr_list (TREE_OPERAND (t, 0), flags);
1771           pp_cxx_right_paren (cxx_pp);
1772         }
1773       break;
1774
1775     case STATIC_CAST_EXPR:
1776       pp_cxx_identifier (cxx_pp, "static_cast");
1777       goto cast;
1778     case REINTERPRET_CAST_EXPR:
1779       pp_cxx_identifier (cxx_pp, "reinterpret_cast");
1780       goto cast;
1781     case CONST_CAST_EXPR:
1782       pp_cxx_identifier (cxx_pp, "const_cast");
1783       goto cast;
1784     case DYNAMIC_CAST_EXPR:
1785       pp_cxx_identifier (cxx_pp, "dynamic_cast");
1786     cast:
1787       pp_cxx_begin_template_argument_list (cxx_pp);
1788       dump_type (TREE_TYPE (t), flags);
1789       pp_cxx_end_template_argument_list (cxx_pp);
1790       pp_cxx_left_paren (cxx_pp);
1791       dump_expr (TREE_OPERAND (t, 0), flags);
1792       pp_cxx_right_paren (cxx_pp);
1793       break;
1794
1795     case ARROW_EXPR:
1796       dump_expr (TREE_OPERAND (t, 0), flags);
1797       pp_cxx_arrow (cxx_pp);
1798       break;
1799
1800     case SIZEOF_EXPR:
1801     case ALIGNOF_EXPR:
1802       if (TREE_CODE (t) == SIZEOF_EXPR)
1803         pp_cxx_identifier (cxx_pp, "sizeof");
1804       else
1805         {
1806           gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
1807           pp_cxx_identifier (cxx_pp, "__alignof__");
1808         }
1809       pp_cxx_whitespace (cxx_pp);
1810       pp_cxx_left_paren (cxx_pp);
1811       if (TYPE_P (TREE_OPERAND (t, 0)))
1812         dump_type (TREE_OPERAND (t, 0), flags);
1813       else
1814         dump_expr (TREE_OPERAND (t, 0), flags);
1815       pp_cxx_right_paren (cxx_pp);
1816       break;
1817
1818     case REALPART_EXPR:
1819     case IMAGPART_EXPR:
1820       pp_cxx_identifier (cxx_pp, operator_name_info[TREE_CODE (t)].name);
1821       pp_cxx_whitespace (cxx_pp);
1822       dump_expr (TREE_OPERAND (t, 0), flags);
1823       break;
1824
1825     case DEFAULT_ARG:
1826       pp_identifier (cxx_pp, "<unparsed>");
1827       break;
1828
1829     case TRY_CATCH_EXPR:
1830     case WITH_CLEANUP_EXPR:
1831     case CLEANUP_POINT_EXPR:
1832       dump_expr (TREE_OPERAND (t, 0), flags);
1833       break;
1834
1835     case PSEUDO_DTOR_EXPR:
1836       dump_expr (TREE_OPERAND (t, 2), flags);
1837       pp_cxx_dot (cxx_pp);
1838       dump_type (TREE_OPERAND (t, 0), flags);
1839       pp_cxx_colon_colon (cxx_pp);
1840       pp_cxx_complement (cxx_pp);
1841       dump_type (TREE_OPERAND (t, 1), flags);
1842       break;
1843
1844     case TEMPLATE_ID_EXPR:
1845       dump_decl (t, flags);
1846       break;
1847
1848     case BIND_EXPR:
1849     case STMT_EXPR:
1850     case STATEMENT_LIST:
1851       /* We don't yet have a way of dumping statements in a
1852          human-readable format.  */
1853       pp_string (cxx_pp, "({...})");
1854       break;
1855
1856     case LOOP_EXPR:
1857       pp_string (cxx_pp, "while (1) { ");
1858       dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1859       pp_cxx_right_brace (cxx_pp);
1860       break;
1861
1862     case EXIT_EXPR:
1863       pp_string (cxx_pp, "if (");
1864       dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1865       pp_string (cxx_pp, ") break; ");
1866       break;
1867
1868     case BASELINK:
1869       dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS);
1870       break;
1871
1872     case EMPTY_CLASS_EXPR:
1873       dump_type (TREE_TYPE (t), flags);
1874       pp_cxx_left_paren (cxx_pp);
1875       pp_cxx_right_paren (cxx_pp);
1876       break;
1877
1878     case NON_DEPENDENT_EXPR:
1879       dump_expr (TREE_OPERAND (t, 0), flags);
1880       break;
1881
1882       /*  This list is incomplete, but should suffice for now.
1883           It is very important that `sorry' does not call
1884           `report_error_function'.  That could cause an infinite loop.  */
1885     default:
1886       pp_unsupported_tree (cxx_pp, t);
1887       /* fall through to ERROR_MARK...  */
1888     case ERROR_MARK:
1889       pp_identifier (cxx_pp, "<expression error>");
1890       break;
1891     }
1892 }
1893
1894 static void
1895 dump_binary_op (const char *opstring, tree t, int flags)
1896 {
1897   pp_cxx_left_paren (cxx_pp);
1898   dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1899   pp_cxx_whitespace (cxx_pp);
1900   if (opstring)
1901     pp_cxx_identifier (cxx_pp, opstring);
1902   else
1903     pp_identifier (cxx_pp, "<unknown operator>");
1904   pp_cxx_whitespace (cxx_pp);
1905   dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1906   pp_cxx_right_paren (cxx_pp);
1907 }
1908
1909 static void
1910 dump_unary_op (const char *opstring, tree t, int flags)
1911 {
1912   if (flags & TFF_EXPR_IN_PARENS)
1913     pp_cxx_left_paren (cxx_pp);
1914   pp_cxx_identifier (cxx_pp, opstring);
1915   dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1916   if (flags & TFF_EXPR_IN_PARENS)
1917     pp_cxx_right_paren (cxx_pp);
1918 }
1919
1920 static void
1921 reinit_cxx_pp (void)
1922 {
1923   pp_clear_output_area (cxx_pp);
1924   pp_base (cxx_pp)->padding = pp_none;
1925   pp_indentation (cxx_pp) = 0;
1926   pp_needs_newline (cxx_pp) = false;
1927   cxx_pp->enclosing_scope = 0;
1928 }
1929
1930
1931 /* Exported interface to stringifying types, exprs and decls under TFF_*
1932    control.  */
1933
1934 const char *
1935 type_as_string (tree typ, int flags)
1936 {
1937   reinit_cxx_pp ();
1938   dump_type (typ, flags);
1939   return pp_formatted_text (cxx_pp);
1940 }
1941
1942 const char *
1943 expr_as_string (tree decl, int flags)
1944 {
1945   reinit_cxx_pp ();
1946   dump_expr (decl, flags);
1947   return pp_formatted_text (cxx_pp);
1948 }
1949
1950 const char *
1951 decl_as_string (tree decl, int flags)
1952 {
1953   reinit_cxx_pp ();
1954   dump_decl (decl, flags);
1955   return pp_formatted_text (cxx_pp);
1956 }
1957
1958 /* Generate the three forms of printable names for cxx_printable_name.  */
1959
1960 const char *
1961 lang_decl_name (tree decl, int v)
1962 {
1963   if (v >= 2)
1964     return decl_as_string (decl, TFF_DECL_SPECIFIERS);
1965
1966   reinit_cxx_pp ();
1967   if (v == 1 && DECL_CLASS_SCOPE_P (decl))
1968     {
1969       dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
1970       pp_cxx_colon_colon (cxx_pp);
1971     }
1972
1973   if (TREE_CODE (decl) == FUNCTION_DECL)
1974     dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
1975   else
1976     dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
1977
1978   return pp_formatted_text (cxx_pp);
1979 }
1980
1981 /* Return the location of a tree passed to %+ formats.  */
1982
1983 static location_t
1984 location_of (tree t)
1985 {
1986   if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
1987     t = DECL_CONTEXT (t);
1988   else if (TYPE_P (t))
1989     t = TYPE_MAIN_DECL (t);
1990   else if (TREE_CODE (t) == OVERLOAD)
1991     t = OVL_FUNCTION (t);
1992
1993   return DECL_SOURCE_LOCATION (t);
1994 }
1995
1996 /* Now the interfaces from error et al to dump_type et al. Each takes an
1997    on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
1998    function.  */
1999
2000 static const char *
2001 decl_to_string (tree decl, int verbose)
2002 {
2003   int flags = 0;
2004
2005   if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2006       || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2007     flags = TFF_CLASS_KEY_OR_ENUM;
2008   if (verbose)
2009     flags |= TFF_DECL_SPECIFIERS;
2010   else if (TREE_CODE (decl) == FUNCTION_DECL)
2011     flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2012   flags |= TFF_TEMPLATE_HEADER;
2013
2014   reinit_cxx_pp ();
2015   dump_decl (decl, flags);
2016   return pp_formatted_text (cxx_pp);
2017 }
2018
2019 static const char *
2020 expr_to_string (tree decl)
2021 {
2022   reinit_cxx_pp ();
2023   dump_expr (decl, 0);
2024   return pp_formatted_text (cxx_pp);
2025 }
2026
2027 static const char *
2028 fndecl_to_string (tree fndecl, int verbose)
2029 {
2030   int flags;
2031
2032   flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
2033     | TFF_TEMPLATE_HEADER;
2034   if (verbose)
2035     flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2036   reinit_cxx_pp ();
2037   dump_decl (fndecl, flags);
2038   return pp_formatted_text (cxx_pp);
2039 }
2040
2041
2042 static const char *
2043 code_to_string (enum tree_code c)
2044 {
2045   return tree_code_name [c];
2046 }
2047
2048 const char *
2049 language_to_string (enum languages c)
2050 {
2051   switch (c)
2052     {
2053     case lang_c:
2054       return "C";
2055
2056     case lang_cplusplus:
2057       return "C++";
2058
2059     case lang_java:
2060       return "Java";
2061
2062     default:
2063       gcc_unreachable ();
2064     }
2065   return 0;
2066 }
2067
2068 /* Return the proper printed version of a parameter to a C++ function.  */
2069
2070 static const char *
2071 parm_to_string (int p)
2072 {
2073   reinit_cxx_pp ();
2074   if (p < 0)
2075     pp_string (cxx_pp, "'this'");
2076   else
2077     pp_decimal_int (cxx_pp, p + 1);
2078   return pp_formatted_text (cxx_pp);
2079 }
2080
2081 static const char *
2082 op_to_string (enum tree_code p)
2083 {
2084   tree id = operator_name_info[(int) p].identifier;
2085   return id ? IDENTIFIER_POINTER (id) : "<unknown>";
2086 }
2087
2088 static const char *
2089 type_to_string (tree typ, int verbose)
2090 {
2091   int flags = 0;
2092   if (verbose)
2093     flags |= TFF_CLASS_KEY_OR_ENUM;
2094   flags |= TFF_TEMPLATE_HEADER;
2095
2096   reinit_cxx_pp ();
2097   dump_type (typ, flags);
2098   return pp_formatted_text (cxx_pp);
2099 }
2100
2101 static const char *
2102 assop_to_string (enum tree_code p)
2103 {
2104   tree id = assignment_operator_name_info[(int) p].identifier;
2105   return id ? IDENTIFIER_POINTER (id) : "{unknown}";
2106 }
2107
2108 static const char *
2109 args_to_string (tree p, int verbose)
2110 {
2111   int flags = 0;
2112   if (verbose)
2113     flags |= TFF_CLASS_KEY_OR_ENUM;
2114
2115   if (p == NULL_TREE)
2116     return "";
2117
2118   if (TYPE_P (TREE_VALUE (p)))
2119     return type_as_string (p, flags);
2120
2121   reinit_cxx_pp ();
2122   for (; p; p = TREE_CHAIN (p))
2123     {
2124       if (TREE_VALUE (p) == null_node)
2125         pp_cxx_identifier (cxx_pp, "NULL");
2126       else
2127         dump_type (error_type (TREE_VALUE (p)), flags);
2128       if (TREE_CHAIN (p))
2129         pp_separate_with_comma (cxx_pp);
2130     }
2131   return pp_formatted_text (cxx_pp);
2132 }
2133
2134 static const char *
2135 cv_to_string (tree p, int v)
2136 {
2137   reinit_cxx_pp ();
2138   pp_base (cxx_pp)->padding = v ? pp_before : pp_none;
2139   pp_cxx_cv_qualifier_seq (cxx_pp, p);
2140   return pp_formatted_text (cxx_pp);
2141 }
2142
2143 /* Langhook for print_error_function.  */
2144 void
2145 cxx_print_error_function (diagnostic_context *context, const char *file)
2146 {
2147   lhd_print_error_function (context, file);
2148   pp_base_set_prefix (context->printer, file);
2149   maybe_print_instantiation_context (context);
2150 }
2151
2152 static void
2153 cp_diagnostic_starter (diagnostic_context *context,
2154                        diagnostic_info *diagnostic)
2155 {
2156   diagnostic_report_current_module (context);
2157   cp_print_error_function (context, diagnostic);
2158   maybe_print_instantiation_context (context);
2159   pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
2160 }
2161
2162 static void
2163 cp_diagnostic_finalizer (diagnostic_context *context,
2164                          diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2165 {
2166   pp_base_destroy_prefix (context->printer);
2167 }
2168
2169 /* Print current function onto BUFFER, in the process of reporting
2170    a diagnostic message.  Called from cp_diagnostic_starter.  */
2171 static void
2172 cp_print_error_function (diagnostic_context *context,
2173                          diagnostic_info *diagnostic)
2174 {
2175   if (diagnostic_last_function_changed (context))
2176     {
2177       const char *old_prefix = context->printer->prefix;
2178       const char *file = LOCATION_FILE (diagnostic->location);
2179       char *new_prefix = file ? file_name_as_prefix (file) : NULL;
2180
2181       pp_base_set_prefix (context->printer, new_prefix);
2182
2183       if (current_function_decl == NULL)
2184         pp_base_string (context->printer, "At global scope:");
2185       else
2186         pp_printf (context->printer, "In %s %qs:",
2187                    function_category (current_function_decl),
2188                    cxx_printable_name (current_function_decl, 2));
2189       pp_base_newline (context->printer);
2190
2191       diagnostic_set_last_function (context);
2192       pp_base_destroy_prefix (context->printer);
2193       context->printer->prefix = old_prefix;
2194     }
2195 }
2196
2197 /* Returns a description of FUNCTION using standard terminology.  */
2198 static const char *
2199 function_category (tree fn)
2200 {
2201   if (DECL_FUNCTION_MEMBER_P (fn))
2202     {
2203       if (DECL_STATIC_FUNCTION_P (fn))
2204         return "static member function";
2205       else if (DECL_COPY_CONSTRUCTOR_P (fn))
2206         return "copy constructor";
2207       else if (DECL_CONSTRUCTOR_P (fn))
2208         return "constructor";
2209       else if (DECL_DESTRUCTOR_P (fn))
2210         return "destructor";
2211       else
2212         return "member function";
2213     }
2214   else
2215     return "function";
2216 }
2217
2218 /* Report the full context of a current template instantiation,
2219    onto BUFFER.  */
2220 static void
2221 print_instantiation_full_context (diagnostic_context *context)
2222 {
2223   tree p = current_instantiation ();
2224   location_t location = input_location;
2225
2226   if (p)
2227     {
2228       if (current_function_decl != TINST_DECL (p)
2229           && current_function_decl != NULL_TREE)
2230         /* We can get here during the processing of some synthesized
2231            method.  Then, TINST_DECL (p) will be the function that's causing
2232            the synthesis.  */
2233         ;
2234       else
2235         {
2236           if (current_function_decl == TINST_DECL (p))
2237             /* Avoid redundancy with the "In function" line.  */;
2238           else
2239             pp_verbatim (context->printer,
2240                          "%s: In instantiation of %qs:\n",
2241                          LOCATION_FILE (location),
2242                          decl_as_string (TINST_DECL (p),
2243                                          TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2244
2245           location = TINST_LOCATION (p);
2246           p = TREE_CHAIN (p);
2247         }
2248     }
2249
2250   print_instantiation_partial_context (context, p, location);
2251 }
2252
2253 /* Same as above but less verbose.  */
2254 static void
2255 print_instantiation_partial_context (diagnostic_context *context,
2256                                      tree t, location_t loc)
2257 {
2258   expanded_location xloc;
2259   for (; ; t = TREE_CHAIN (t))
2260     {
2261       xloc = expand_location (loc);
2262       if (t == NULL_TREE)
2263         break;
2264       pp_verbatim (context->printer, "%s:%d:   instantiated from %qs\n",
2265                    xloc.file, xloc.line,
2266                    decl_as_string (TINST_DECL (t),
2267                                    TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2268       loc = TINST_LOCATION (t);
2269     }
2270   pp_verbatim (context->printer, "%s:%d:   instantiated from here",
2271                xloc.file, xloc.line);
2272   pp_base_newline (context->printer);
2273 }
2274
2275 /* Called from cp_thing to print the template context for an error.  */
2276 static void
2277 maybe_print_instantiation_context (diagnostic_context *context)
2278 {
2279   if (!problematic_instantiation_changed () || current_instantiation () == 0)
2280     return;
2281
2282   record_last_problematic_instantiation ();
2283   print_instantiation_full_context (context);
2284 }
2285
2286 /* Report the bare minimum context of a template instantiation.  */
2287 void
2288 print_instantiation_context (void)
2289 {
2290   print_instantiation_partial_context
2291     (global_dc, current_instantiation (), input_location);
2292   diagnostic_flush_buffer (global_dc);
2293 }
2294 \f
2295 /* Called from output_format -- during diagnostic message processing --
2296    to handle C++ specific format specifier with the following meanings:
2297    %A   function argument-list.
2298    %C   tree code.
2299    %D   declaration.
2300    %E   expression.
2301    %F   function declaration.
2302    %L   language as used in extern "lang".
2303    %O   binary operator.
2304    %P   function parameter whose position is indicated by an integer.
2305    %Q   assignment operator.
2306    %T   type.
2307    %V   cv-qualifier.  */
2308 static bool
2309 cp_printer (pretty_printer *pp, text_info *text, const char *spec,
2310             int precision, bool wide, bool set_locus, bool verbose)
2311 {
2312   const char *result;
2313   tree t = NULL;
2314 #define next_tree    (t = va_arg (*text->args_ptr, tree))
2315 #define next_tcode   va_arg (*text->args_ptr, enum tree_code)
2316 #define next_lang    va_arg (*text->args_ptr, enum languages)
2317 #define next_int     va_arg (*text->args_ptr, int)
2318
2319   if (precision != 0 || wide)
2320     return false;
2321
2322   if (text->locus == NULL)
2323     set_locus = false;
2324
2325   switch (*spec)
2326     {
2327     case 'A': result = args_to_string (next_tree, verbose);     break;
2328     case 'C': result = code_to_string (next_tcode);             break;
2329     case 'D':
2330       {
2331         tree temp = next_tree;
2332         if (DECL_P (temp)
2333             && DECL_DEBUG_EXPR_IS_FROM (temp) && DECL_DEBUG_EXPR (temp))
2334           {
2335             temp = DECL_DEBUG_EXPR (temp);
2336             if (!DECL_P (temp))
2337               {
2338                 result = expr_to_string (temp);
2339                 break;
2340               }
2341           }
2342         result = decl_to_string (temp, verbose);
2343       }
2344       break;
2345     case 'E': result = expr_to_string (next_tree);              break;
2346     case 'F': result = fndecl_to_string (next_tree, verbose);   break;
2347     case 'L': result = language_to_string (next_lang);          break;
2348     case 'O': result = op_to_string (next_tcode);               break;
2349     case 'P': result = parm_to_string (next_int);               break;
2350     case 'Q': result = assop_to_string (next_tcode);            break;
2351     case 'T': result = type_to_string (next_tree, verbose);     break;
2352     case 'V': result = cv_to_string (next_tree, verbose);       break;
2353
2354     default:
2355       return false;
2356     }
2357
2358   pp_base_string (pp, result);
2359   if (set_locus && t != NULL)
2360     *text->locus = location_of (t);
2361   return true;
2362 #undef next_tree
2363 #undef next_tcode
2364 #undef next_lang
2365 #undef next_int
2366 }
2367 \f
2368 /* Callback from cpp_error for PFILE to print diagnostics arising from
2369    interpreting strings.  The diagnostic is of type LEVEL; MSG is the
2370    translated message and AP the arguments.  */
2371
2372 void
2373 cp_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level,
2374               const char *msg, va_list *ap)
2375 {
2376   diagnostic_info diagnostic;
2377   diagnostic_t dlevel;
2378   switch (level)
2379     {
2380     case CPP_DL_WARNING:
2381     case CPP_DL_WARNING_SYSHDR:
2382       dlevel = DK_WARNING;
2383       break;
2384     case CPP_DL_PEDWARN:
2385       dlevel = pedantic_error_kind ();
2386       break;
2387     case CPP_DL_ERROR:
2388       dlevel = DK_ERROR;
2389       break;
2390     case CPP_DL_ICE:
2391       dlevel = DK_ICE;
2392       break;
2393     default:
2394       gcc_unreachable ();
2395     }
2396   diagnostic_set_info_translated (&diagnostic, msg, ap,
2397                                   input_location, dlevel);
2398   report_diagnostic (&diagnostic);
2399 }