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