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     default:
 966       pp_unsupported_tree (cxx_pp, t);
 967       /* Fall through to error.  */
 968
 969     case ERROR_MARK:
 970       pp_identifier (cxx_pp, "<declaration error>");
 971       break;
 972     }
 973 }
 974
 975 /* Dump a template declaration T under control of FLAGS. This means the
 976    'template <...> leaders plus the 'class X' or 'void fn(...)' part.  */
 977
 978 static void
 979 dump_template_decl (tree t, int flags)
 980 {
 981   tree orig_parms = DECL_TEMPLATE_PARMS (t);
 982   tree parms;
 983   int i;
 984
 985   if (flags & TFF_TEMPLATE_HEADER)
 986     {
 987       for (parms = orig_parms = nreverse (orig_parms);
 988            parms;
 989            parms = TREE_CHAIN (parms))
 990         {
 991           tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
 992           int len = TREE_VEC_LENGTH (inner_parms);
 993
 994           pp_cxx_identifier (cxx_pp, "template");
 995           pp_cxx_begin_template_argument_list (cxx_pp);
 996
 997           /* If we've shown the template prefix, we'd better show the
 998              parameters' and decl's type too.  */
 999             flags |= TFF_DECL_SPECIFIERS;
1000
1001           for (i = 0; i < len; i++)
1002             {
1003               if (i)
1004                 pp_separate_with_comma (cxx_pp);
1005               dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
1006             }
1007           pp_cxx_end_template_argument_list (cxx_pp);
1008           pp_cxx_whitespace (cxx_pp);
1009         }
1010       nreverse(orig_parms);
1011
1012       if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
1013         /* Say `template<arg> class TT' not just `template<arg> TT'.  */
1014         pp_cxx_identifier (cxx_pp, "class");
1015     }
1016
1017   if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
1018     dump_type (TREE_TYPE (t),
1019                ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1020                 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
1021   else if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
1022     dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
1023   else
1024     {
1025       gcc_assert (TREE_TYPE (t));
1026       switch (NEXT_CODE (t))
1027         {
1028         case METHOD_TYPE:
1029         case FUNCTION_TYPE:
1030           dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
1031           break;
1032         default:
1033           /* This case can occur with some invalid code.  */
1034           dump_type (TREE_TYPE (t),
1035                      (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1036                      | (flags & TFF_DECL_SPECIFIERS
1037                         ? TFF_CLASS_KEY_OR_ENUM : 0));
1038         }
1039     }
1040 }
1041
1042 /* Pretty print a function decl. There are several ways we want to print a
1043    function declaration. The TFF_ bits in FLAGS tells us how to behave.
1044    As error can only apply the '#' flag once to give 0 and 1 for V, there
1045    is %D which doesn't print the throw specs, and %F which does.  */
1046
1047 static void
1048 dump_function_decl (tree t, int flags)
1049 {
1050   tree fntype;
1051   tree parmtypes;
1052   tree cname = NULL_TREE;
1053   tree template_args = NULL_TREE;
1054   tree template_parms = NULL_TREE;
1055   int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
1056   int do_outer_scope = ! (flags & TFF_UNQUALIFIED_NAME);
1057
1058   flags &= ~TFF_UNQUALIFIED_NAME;
1059   if (TREE_CODE (t) == TEMPLATE_DECL)
1060     t = DECL_TEMPLATE_RESULT (t);
1061
1062   /* Pretty print template instantiations only.  */
1063   if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t))
1064     {
1065       tree tmpl;
1066
1067       template_args = DECL_TI_ARGS (t);
1068       tmpl = most_general_template (t);
1069       if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1070         {
1071           template_parms = DECL_TEMPLATE_PARMS (tmpl);
1072           t = tmpl;
1073         }
1074     }
1075
1076   fntype = TREE_TYPE (t);
1077   parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1078
1079   if (DECL_CLASS_SCOPE_P (t))
1080     cname = DECL_CONTEXT (t);
1081   /* This is for partially instantiated template methods.  */
1082   else if (TREE_CODE (fntype) == METHOD_TYPE)
1083     cname = TREE_TYPE (TREE_VALUE (parmtypes));
1084
1085   if (!(flags & TFF_DECL_SPECIFIERS))
1086     /* OK */;
1087   else if (DECL_STATIC_FUNCTION_P (t))
1088     pp_cxx_identifier (cxx_pp, "static");
1089   else if (DECL_VIRTUAL_P (t))
1090     pp_cxx_identifier (cxx_pp, "virtual");
1091
1092   /* Print the return type?  */
1093   if (show_return)
1094     show_return = !DECL_CONV_FN_P (t)  && !DECL_CONSTRUCTOR_P (t)
1095                   && !DECL_DESTRUCTOR_P (t);
1096   if (show_return)
1097     dump_type_prefix (TREE_TYPE (fntype), flags);
1098
1099   /* Print the function name.  */
1100   if (!do_outer_scope)
1101     /* Nothing.  */;
1102   else if (cname)
1103     {
1104       dump_type (cname, flags);
1105       pp_cxx_colon_colon (cxx_pp);
1106     }
1107   else
1108     dump_scope (CP_DECL_CONTEXT (t), flags);
1109
1110   dump_function_name (t, flags);
1111
1112   if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1113     {
1114       dump_parameters (parmtypes, flags);
1115
1116       if (TREE_CODE (fntype) == METHOD_TYPE)
1117         {
1118           pp_base (cxx_pp)->padding = pp_before;
1119           pp_cxx_cv_qualifier_seq
1120             (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))));
1121         }
1122
1123       if (flags & TFF_EXCEPTION_SPECIFICATION)
1124         {
1125           pp_base (cxx_pp)->padding = pp_before;
1126           dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags);
1127         }
1128
1129       if (show_return)
1130         dump_type_suffix (TREE_TYPE (fntype), flags);
1131     }
1132
1133   /* If T is a template instantiation, dump the parameter binding.  */
1134   if (template_parms != NULL_TREE && template_args != NULL_TREE)
1135     {
1136       pp_cxx_whitespace (cxx_pp);
1137       pp_cxx_left_bracket (cxx_pp);
1138       pp_cxx_identifier (cxx_pp, "with");
1139       pp_cxx_whitespace (cxx_pp);
1140       dump_template_bindings (template_parms, template_args);
1141       pp_cxx_right_bracket (cxx_pp);
1142     }
1143 }
1144
1145 /* Print a parameter list. If this is for a member function, the
1146    member object ptr (and any other hidden args) should have
1147    already been removed.  */
1148
1149 static void
1150 dump_parameters (tree parmtypes, int flags)
1151 {
1152   int first = 1;
1153   pp_cxx_left_paren (cxx_pp);
1154
1155   for (first = 1; parmtypes != void_list_node;
1156        parmtypes = TREE_CHAIN (parmtypes))
1157     {
1158       if (!first)
1159         pp_separate_with_comma (cxx_pp);
1160       first = 0;
1161       if (!parmtypes)
1162         {
1163           pp_cxx_identifier (cxx_pp, "...");
1164           break;
1165         }
1166       if (ARGUMENT_PACK_P (TREE_VALUE (parmtypes)))
1167         {
1168           tree types = ARGUMENT_PACK_ARGS (TREE_VALUE (parmtypes));
1169           int i, len = TREE_VEC_LENGTH (types);
1170           first = 1;
1171           for (i = 0; i < len; ++i)
1172             {
1173               if (!first)
1174                 pp_separate_with_comma (cxx_pp);
1175               first = 0;
1176
1177               dump_type (TREE_VEC_ELT (types, i), flags);
1178             }
1179         }
1180       else
1181         dump_type (TREE_VALUE (parmtypes), flags);
1182
1183       if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1184         {
1185           pp_cxx_whitespace (cxx_pp);
1186           pp_equal (cxx_pp);
1187           pp_cxx_whitespace (cxx_pp);
1188           dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1189         }
1190     }
1191
1192   pp_cxx_right_paren (cxx_pp);
1193 }
1194
1195 /* Print an exception specification. T is the exception specification.  */
1196
1197 static void
1198 dump_exception_spec (tree t, int flags)
1199 {
1200   if (t)
1201     {
1202       pp_cxx_identifier (cxx_pp, "throw");
1203       pp_cxx_whitespace (cxx_pp);
1204       pp_cxx_left_paren (cxx_pp);
1205       if (TREE_VALUE (t) != NULL_TREE)
1206         while (1)
1207           {
1208             dump_type (TREE_VALUE (t), flags);
1209             t = TREE_CHAIN (t);
1210             if (!t)
1211               break;
1212             pp_separate_with_comma (cxx_pp);
1213           }
1214       pp_cxx_right_paren (cxx_pp);
1215     }
1216 }
1217
1218 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1219    and destructors properly.  */
1220
1221 static void
1222 dump_function_name (tree t, int flags)
1223 {
1224   tree name = DECL_NAME (t);
1225
1226   /* We can get here with a decl that was synthesized by language-
1227      independent machinery (e.g. coverage.c) in which case it won't
1228      have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1229      will crash.  In this case it is safe just to print out the
1230      literal name.  */
1231   if (!DECL_LANG_SPECIFIC (t))
1232     {
1233       pp_cxx_tree_identifier (cxx_pp, name);
1234       return;
1235     }
1236
1237   if (TREE_CODE (t) == TEMPLATE_DECL)
1238     t = DECL_TEMPLATE_RESULT (t);
1239
1240   /* Don't let the user see __comp_ctor et al.  */
1241   if (DECL_CONSTRUCTOR_P (t)
1242       || DECL_DESTRUCTOR_P (t))
1243     name = constructor_name (DECL_CONTEXT (t));
1244
1245   if (DECL_DESTRUCTOR_P (t))
1246     {
1247       pp_cxx_complement (cxx_pp);
1248       dump_decl (name, TFF_PLAIN_IDENTIFIER);
1249     }
1250   else if (DECL_CONV_FN_P (t))
1251     {
1252       /* This cannot use the hack that the operator's return
1253          type is stashed off of its name because it may be
1254          used for error reporting.  In the case of conflicting
1255          declarations, both will have the same name, yet
1256          the types will be different, hence the TREE_TYPE field
1257          of the first name will be clobbered by the second.  */
1258       pp_cxx_identifier (cxx_pp, "operator");
1259       dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1260     }
1261   else if (IDENTIFIER_OPNAME_P (name))
1262     pp_cxx_tree_identifier (cxx_pp, name);
1263   else
1264     dump_decl (name, flags);
1265
1266   if (DECL_TEMPLATE_INFO (t)
1267       && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1268       && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1269           || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1270     dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
1271 }
1272
1273 /* Dump the template parameters from the template info INFO under control of
1274    FLAGS. PRIMARY indicates whether this is a primary template decl, or
1275    specialization (partial or complete). For partial specializations we show
1276    the specialized parameter values. For a primary template we show no
1277    decoration.  */
1278
1279 static void
1280 dump_template_parms (tree info, int primary, int flags)
1281 {
1282   tree args = info ? TI_ARGS (info) : NULL_TREE;
1283
1284   if (primary && flags & TFF_TEMPLATE_NAME)
1285     return;
1286   flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1287   pp_cxx_begin_template_argument_list (cxx_pp);
1288
1289   /* Be careful only to print things when we have them, so as not
1290          to crash producing error messages.  */
1291   if (args && !primary)
1292     {
1293       int len, ix;
1294
1295       if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
1296         args = TREE_VEC_ELT (args, TREE_VEC_LENGTH (args) - 1);
1297
1298       len = TREE_VEC_LENGTH (args);
1299
1300       for (ix = 0; ix != len; ix++)
1301         {
1302           tree arg = TREE_VEC_ELT (args, ix);
1303
1304           /* Only print a comma if we know there is an argument coming. In
1305              the case of an empty template argument pack, no actual
1306              argument will be printed.  */
1307           if (ix
1308               && (!ARGUMENT_PACK_P (arg)
1309                   || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
1310             pp_separate_with_comma (cxx_pp);
1311
1312           if (!arg)
1313             pp_identifier (cxx_pp, "<template parameter error>");
1314           else
1315             dump_template_argument (arg, flags);
1316         }
1317     }
1318   else if (primary)
1319     {
1320       tree tpl = TI_TEMPLATE (info);
1321       tree parms = DECL_TEMPLATE_PARMS (tpl);
1322       int len, ix;
1323
1324       parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1325       len = parms ? TREE_VEC_LENGTH (parms) : 0;
1326
1327       for (ix = 0; ix != len; ix++)
1328         {
1329           tree parm;
1330
1331           if (TREE_VEC_ELT (parms, ix) == error_mark_node)
1332             {
1333               pp_identifier (cxx_pp, "<template parameter error>");
1334               continue;
1335             }
1336
1337           parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1338
1339           if (ix)
1340             pp_separate_with_comma (cxx_pp);
1341
1342           dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
1343         }
1344     }
1345   pp_cxx_end_template_argument_list (cxx_pp);
1346 }
1347
1348 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1349    flags FLAGS.  Skip over the first argument if SKIPFIRST is true.  */
1350
1351 static void
1352 dump_call_expr_args (tree t, int flags, bool skipfirst)
1353 {
1354   tree arg;
1355   call_expr_arg_iterator iter;
1356
1357   pp_cxx_left_paren (cxx_pp);
1358   FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
1359     {
1360       if (skipfirst)
1361         skipfirst = false;
1362       else
1363         {
1364           dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1365           if (more_call_expr_args_p (&iter))
1366             pp_separate_with_comma (cxx_pp);
1367         }
1368     }
1369   pp_cxx_right_paren (cxx_pp);
1370 }
1371
1372 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1373    using flags FLAGS.  Skip over the first argument if SKIPFIRST is
1374    true.  */
1375
1376 static void
1377 dump_aggr_init_expr_args (tree t, int flags, bool skipfirst)
1378 {
1379   tree arg;
1380   aggr_init_expr_arg_iterator iter;
1381
1382   pp_cxx_left_paren (cxx_pp);
1383   FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
1384     {
1385       if (skipfirst)
1386         skipfirst = false;
1387       else
1388         {
1389           dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1390           if (more_aggr_init_expr_args_p (&iter))
1391             pp_separate_with_comma (cxx_pp);
1392         }
1393     }
1394   pp_cxx_right_paren (cxx_pp);
1395 }
1396
1397 /* Print out a list of initializers (subr of dump_expr).  */
1398
1399 static void
1400 dump_expr_list (tree l, int flags)
1401 {
1402   while (l)
1403     {
1404       dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1405       l = TREE_CHAIN (l);
1406       if (l)
1407         pp_separate_with_comma (cxx_pp);
1408     }
1409 }
1410
1411 /* Print out a vector of initializers (subr of dump_expr).  */
1412
1413 static void
1414 dump_expr_init_vec (VEC(constructor_elt,gc) *v, int flags)
1415 {
1416   unsigned HOST_WIDE_INT idx;
1417   tree value;
1418
1419   FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1420     {
1421       dump_expr (value, flags | TFF_EXPR_IN_PARENS);
1422       if (idx != VEC_length (constructor_elt, v) - 1)
1423         pp_separate_with_comma (cxx_pp);
1424     }
1425 }
1426
1427
1428 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1429    function.  Resolve it to a close relative -- in the sense of static
1430    type -- variant being overridden.  That is close to what was written in
1431    the source code.  Subroutine of dump_expr.  */
1432
1433 static tree
1434 resolve_virtual_fun_from_obj_type_ref (tree ref)
1435 {
1436   tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref));
1437   int index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
1438   tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
1439     while (index--)
1440       fun = TREE_CHAIN (fun);
1441
1442   return BV_FN (fun);
1443 }
1444
1445 /* Print out an expression E under control of FLAGS.  */
1446
1447 static void
1448 dump_expr (tree t, int flags)
1449 {
1450   if (t == 0)
1451     return;
1452
1453   switch (TREE_CODE (t))
1454     {
1455     case VAR_DECL:
1456     case PARM_DECL:
1457     case FIELD_DECL:
1458     case CONST_DECL:
1459     case FUNCTION_DECL:
1460     case TEMPLATE_DECL:
1461     case NAMESPACE_DECL:
1462     case LABEL_DECL:
1463     case OVERLOAD:
1464     case IDENTIFIER_NODE:
1465       dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS);
1466       break;
1467
1468     case INTEGER_CST:
1469     case REAL_CST:
1470     case STRING_CST:
1471       pp_constant (cxx_pp, t);
1472       break;
1473
1474     case THROW_EXPR:
1475       pp_cxx_identifier (cxx_pp, "throw");
1476       dump_expr (TREE_OPERAND (t, 0), flags);
1477       break;
1478
1479     case PTRMEM_CST:
1480       pp_ampersand (cxx_pp);
1481       dump_type (PTRMEM_CST_CLASS (t), flags);
1482       pp_cxx_colon_colon (cxx_pp);
1483       pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1484       break;
1485
1486     case COMPOUND_EXPR:
1487       pp_cxx_left_paren (cxx_pp);
1488       dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1489       pp_separate_with_comma (cxx_pp);
1490       dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1491       pp_cxx_right_paren (cxx_pp);
1492       break;
1493
1494     case COND_EXPR:
1495       pp_cxx_left_paren (cxx_pp);
1496       dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1497       pp_string (cxx_pp, " ? ");
1498       dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1499       pp_string (cxx_pp, " : ");
1500       dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1501       pp_cxx_right_paren (cxx_pp);
1502       break;
1503
1504     case SAVE_EXPR:
1505       if (TREE_HAS_CONSTRUCTOR (t))
1506         {
1507           pp_cxx_identifier (cxx_pp, "new");
1508           pp_cxx_whitespace (cxx_pp);
1509           dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1510         }
1511       else
1512         dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1513       break;
1514
1515     case AGGR_INIT_EXPR:
1516       {
1517         tree fn = NULL_TREE;
1518
1519         if (TREE_CODE (AGGR_INIT_EXPR_FN (t)) == ADDR_EXPR)
1520           fn = TREE_OPERAND (AGGR_INIT_EXPR_FN (t), 0);
1521
1522         if (fn && TREE_CODE (fn) == FUNCTION_DECL)
1523           {
1524             if (DECL_CONSTRUCTOR_P (fn))
1525               dump_type (DECL_CONTEXT (fn), flags);
1526             else
1527               dump_decl (fn, 0);
1528           }
1529         else
1530           dump_expr (AGGR_INIT_EXPR_FN (t), 0);
1531       }
1532       dump_aggr_init_expr_args (t, flags, true);
1533       break;
1534
1535     case CALL_EXPR:
1536       {
1537         tree fn = CALL_EXPR_FN (t);
1538         bool skipfirst = false;
1539
1540         if (TREE_CODE (fn) == ADDR_EXPR)
1541           fn = TREE_OPERAND (fn, 0);
1542
1543         /* Nobody is interested in seeing the guts of vcalls.  */
1544         if (TREE_CODE (fn) == OBJ_TYPE_REF)
1545           fn = resolve_virtual_fun_from_obj_type_ref (fn);
1546
1547         if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE)
1548           {
1549             tree ob = CALL_EXPR_ARG (t, 0);
1550             if (TREE_CODE (ob) == ADDR_EXPR)
1551               {
1552                 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1553                 pp_dot (cxx_pp);
1554               }
1555             else if (TREE_CODE (ob) != PARM_DECL
1556                      || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1557               {
1558                 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1559                 pp_arrow (cxx_pp);
1560               }
1561             skipfirst = true;
1562           }
1563         dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
1564         dump_call_expr_args (t, flags, skipfirst);
1565       }
1566       break;
1567
1568     case NEW_EXPR:
1569       {
1570         tree type = TREE_OPERAND (t, 1);
1571         tree init = TREE_OPERAND (t, 2);
1572         if (NEW_EXPR_USE_GLOBAL (t))
1573           pp_cxx_colon_colon (cxx_pp);
1574         pp_cxx_identifier (cxx_pp, "new");
1575         if (TREE_OPERAND (t, 0))
1576           {
1577             pp_cxx_left_paren (cxx_pp);
1578             dump_expr_list (TREE_OPERAND (t, 0), flags);
1579             pp_cxx_right_paren (cxx_pp);
1580             pp_cxx_whitespace (cxx_pp);
1581           }
1582         if (TREE_CODE (type) == ARRAY_REF)
1583           type = build_cplus_array_type
1584             (TREE_OPERAND (type, 0),
1585              build_index_type (fold_build2 (MINUS_EXPR, integer_type_node,
1586                                             TREE_OPERAND (type, 1),
1587                                             integer_one_node)));
1588         dump_type (type, flags);
1589         if (init)
1590           {
1591             pp_cxx_left_paren (cxx_pp);
1592             if (TREE_CODE (init) == TREE_LIST)
1593               dump_expr_list (init, flags);
1594             else if (init == void_zero_node)
1595               /* This representation indicates an empty initializer,
1596                  e.g.: "new int()".  */
1597               ;
1598             else
1599               dump_expr (init, flags);
1600             pp_cxx_right_paren (cxx_pp);
1601           }
1602       }
1603       break;
1604
1605     case TARGET_EXPR:
1606       /* Note that this only works for G++ target exprs.  If somebody
1607          builds a general TARGET_EXPR, there's no way to represent that
1608          it initializes anything other that the parameter slot for the
1609          default argument.  Note we may have cleared out the first
1610          operand in expand_expr, so don't go killing ourselves.  */
1611       if (TREE_OPERAND (t, 1))
1612         dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1613       break;
1614
1615     case POINTER_PLUS_EXPR:
1616       dump_binary_op ("+", t, flags);
1617       break;
1618
1619     case INIT_EXPR:
1620     case MODIFY_EXPR:
1621     case PLUS_EXPR:
1622     case MINUS_EXPR:
1623     case MULT_EXPR:
1624     case TRUNC_DIV_EXPR:
1625     case TRUNC_MOD_EXPR:
1626     case MIN_EXPR:
1627     case MAX_EXPR:
1628     case LSHIFT_EXPR:
1629     case RSHIFT_EXPR:
1630     case BIT_IOR_EXPR:
1631     case BIT_XOR_EXPR:
1632     case BIT_AND_EXPR:
1633     case TRUTH_ANDIF_EXPR:
1634     case TRUTH_ORIF_EXPR:
1635     case LT_EXPR:
1636     case LE_EXPR:
1637     case GT_EXPR:
1638     case GE_EXPR:
1639     case EQ_EXPR:
1640     case NE_EXPR:
1641     case EXACT_DIV_EXPR:
1642       dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags);
1643       break;
1644
1645     case CEIL_DIV_EXPR:
1646     case FLOOR_DIV_EXPR:
1647     case ROUND_DIV_EXPR:
1648     case RDIV_EXPR:
1649       dump_binary_op ("/", t, flags);
1650       break;
1651
1652     case CEIL_MOD_EXPR:
1653     case FLOOR_MOD_EXPR:
1654     case ROUND_MOD_EXPR:
1655       dump_binary_op ("%", t, flags);
1656       break;
1657
1658     case COMPONENT_REF:
1659       {
1660         tree ob = TREE_OPERAND (t, 0);
1661         if (TREE_CODE (ob) == INDIRECT_REF)
1662           {
1663             ob = TREE_OPERAND (ob, 0);
1664             if (TREE_CODE (ob) != PARM_DECL
1665                 || (DECL_NAME (ob)
1666                     && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")))
1667               {
1668                 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1669                 pp_cxx_arrow (cxx_pp);
1670               }
1671           }
1672         else
1673           {
1674             dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1675             pp_cxx_dot (cxx_pp);
1676           }
1677         dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1678       }
1679       break;
1680
1681     case ARRAY_REF:
1682       dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1683       pp_cxx_left_bracket (cxx_pp);
1684       dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1685       pp_cxx_right_bracket (cxx_pp);
1686       break;
1687
1688     case UNARY_PLUS_EXPR:
1689       dump_unary_op ("+", t, flags);
1690       break;
1691
1692     case ADDR_EXPR:
1693       if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1694           || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
1695           /* An ADDR_EXPR can have reference type.  In that case, we
1696              shouldn't print the `&' doing so indicates to the user
1697              that the expression has pointer type.  */
1698           || (TREE_TYPE (t)
1699               && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
1700         dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1701       else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
1702         dump_unary_op ("&&", t, flags);
1703       else
1704         dump_unary_op ("&", t, flags);
1705       break;
1706
1707     case INDIRECT_REF:
1708       if (TREE_HAS_CONSTRUCTOR (t))
1709         {
1710           t = TREE_OPERAND (t, 0);
1711           gcc_assert (TREE_CODE (t) == CALL_EXPR);
1712           dump_expr (CALL_EXPR_FN (t), flags | TFF_EXPR_IN_PARENS);
1713           dump_call_expr_args (t, flags, true);
1714         }
1715       else
1716         {
1717           if (TREE_OPERAND (t,0) != NULL_TREE
1718               && TREE_TYPE (TREE_OPERAND (t, 0))
1719               && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
1720             dump_expr (TREE_OPERAND (t, 0), flags);
1721           else
1722             dump_unary_op ("*", t, flags);
1723         }
1724       break;
1725
1726     case NEGATE_EXPR:
1727     case BIT_NOT_EXPR:
1728     case TRUTH_NOT_EXPR:
1729     case PREDECREMENT_EXPR:
1730     case PREINCREMENT_EXPR:
1731       dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags);
1732       break;
1733
1734     case POSTDECREMENT_EXPR:
1735     case POSTINCREMENT_EXPR:
1736       pp_cxx_left_paren (cxx_pp);
1737       dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1738       pp_cxx_identifier (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
1739       pp_cxx_right_paren (cxx_pp);
1740       break;
1741
1742     case NON_LVALUE_EXPR:
1743       /* FIXME: This is a KLUDGE workaround for a parsing problem.  There
1744          should be another level of INDIRECT_REF so that I don't have to do
1745          this.  */
1746       if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
1747         {
1748           tree next = TREE_TYPE (TREE_TYPE (t));
1749
1750           while (TREE_CODE (next) == POINTER_TYPE)
1751             next = TREE_TYPE (next);
1752
1753           if (TREE_CODE (next) == FUNCTION_TYPE)
1754             {
1755               if (flags & TFF_EXPR_IN_PARENS)
1756                 pp_cxx_left_paren (cxx_pp);
1757               pp_cxx_star (cxx_pp);
1758               dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1759               if (flags & TFF_EXPR_IN_PARENS)
1760                 pp_cxx_right_paren (cxx_pp);
1761               break;
1762             }
1763           /* Else fall through.  */
1764         }
1765       dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1766       break;
1767
1768     case NOP_EXPR:
1769     case CONVERT_EXPR:
1770       {
1771         tree op = TREE_OPERAND (t, 0);
1772
1773         if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
1774           {
1775             /* It is a cast, but we cannot tell whether it is a
1776                reinterpret or static cast. Use the C style notation.  */
1777             if (flags & TFF_EXPR_IN_PARENS)
1778               pp_cxx_left_paren (cxx_pp);
1779             pp_cxx_left_paren (cxx_pp);
1780             dump_type (TREE_TYPE (t), flags);
1781             pp_cxx_right_paren (cxx_pp);
1782             dump_expr (op, flags | TFF_EXPR_IN_PARENS);
1783             if (flags & TFF_EXPR_IN_PARENS)
1784               pp_cxx_right_paren (cxx_pp);
1785           }
1786         else
1787           dump_expr (op, flags);
1788         break;
1789       }
1790
1791     case CONSTRUCTOR:
1792       if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
1793         {
1794           tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
1795
1796           if (integer_zerop (idx))
1797             {
1798               /* A NULL pointer-to-member constant.  */
1799               pp_cxx_left_paren (cxx_pp);
1800               pp_cxx_left_paren (cxx_pp);
1801               dump_type (TREE_TYPE (t), flags);
1802               pp_cxx_right_paren (cxx_pp);
1803               pp_character (cxx_pp, '0');
1804               pp_cxx_right_paren (cxx_pp);
1805               break;
1806             }
1807           else if (host_integerp (idx, 0))
1808             {
1809               tree virtuals;
1810               unsigned HOST_WIDE_INT n;
1811
1812               t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
1813               t = TYPE_METHOD_BASETYPE (t);
1814               virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
1815
1816               n = tree_low_cst (idx, 0);
1817
1818               /* Map vtable index back one, to allow for the null pointer to
1819                  member.  */
1820               --n;
1821
1822               while (n > 0 && virtuals)
1823                 {
1824                   --n;
1825                   virtuals = TREE_CHAIN (virtuals);
1826                 }
1827               if (virtuals)
1828                 {
1829                   dump_expr (BV_FN (virtuals),
1830                              flags | TFF_EXPR_IN_PARENS);
1831                   break;
1832                 }
1833             }
1834         }
1835       if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
1836         {
1837           dump_type (TREE_TYPE (t), 0);
1838           pp_cxx_left_paren (cxx_pp);
1839           pp_cxx_right_paren (cxx_pp);
1840         }
1841       else
1842         {
1843           pp_cxx_left_brace (cxx_pp);
1844           dump_expr_init_vec (CONSTRUCTOR_ELTS (t), flags);
1845           pp_cxx_right_brace (cxx_pp);
1846         }
1847
1848       break;
1849
1850     case OFFSET_REF:
1851       {
1852         tree ob = TREE_OPERAND (t, 0);
1853         if (is_dummy_object (ob))
1854           {
1855             t = TREE_OPERAND (t, 1);
1856             if (TREE_CODE (t) == FUNCTION_DECL)
1857               /* A::f */
1858               dump_expr (t, flags | TFF_EXPR_IN_PARENS);
1859             else if (BASELINK_P (t))
1860               dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
1861                          flags | TFF_EXPR_IN_PARENS);
1862             else
1863               dump_decl (t, flags);
1864           }
1865         else
1866           {
1867             if (TREE_CODE (ob) == INDIRECT_REF)
1868               {
1869                 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1870                 pp_cxx_arrow (cxx_pp);
1871                 pp_cxx_star (cxx_pp);
1872               }
1873             else
1874               {
1875                 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1876                 pp_cxx_dot (cxx_pp);
1877                 pp_cxx_star (cxx_pp);
1878               }
1879             dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1880           }
1881         break;
1882       }
1883
1884     case TEMPLATE_PARM_INDEX:
1885       dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
1886       break;
1887
1888     case SCOPE_REF:
1889       pp_expression (cxx_pp, t);
1890       break;
1891
1892     case CAST_EXPR:
1893       if (TREE_OPERAND (t, 0) == NULL_TREE
1894           || TREE_CHAIN (TREE_OPERAND (t, 0)))
1895         {
1896           dump_type (TREE_TYPE (t), flags);
1897           pp_cxx_left_paren (cxx_pp);
1898           dump_expr_list (TREE_OPERAND (t, 0), flags);
1899           pp_cxx_right_paren (cxx_pp);
1900         }
1901       else
1902         {
1903           pp_cxx_left_paren (cxx_pp);
1904           dump_type (TREE_TYPE (t), flags);
1905           pp_cxx_right_paren (cxx_pp);
1906           pp_cxx_left_paren (cxx_pp);
1907           dump_expr_list (TREE_OPERAND (t, 0), flags);
1908           pp_cxx_right_paren (cxx_pp);
1909         }
1910       break;
1911
1912     case STATIC_CAST_EXPR:
1913       pp_cxx_identifier (cxx_pp, "static_cast");
1914       goto cast;
1915     case REINTERPRET_CAST_EXPR:
1916       pp_cxx_identifier (cxx_pp, "reinterpret_cast");
1917       goto cast;
1918     case CONST_CAST_EXPR:
1919       pp_cxx_identifier (cxx_pp, "const_cast");
1920       goto cast;
1921     case DYNAMIC_CAST_EXPR:
1922       pp_cxx_identifier (cxx_pp, "dynamic_cast");
1923     cast:
1924       pp_cxx_begin_template_argument_list (cxx_pp);
1925       dump_type (TREE_TYPE (t), flags);
1926       pp_cxx_end_template_argument_list (cxx_pp);
1927       pp_cxx_left_paren (cxx_pp);
1928       dump_expr (TREE_OPERAND (t, 0), flags);
1929       pp_cxx_right_paren (cxx_pp);
1930       break;
1931
1932     case ARROW_EXPR:
1933       dump_expr (TREE_OPERAND (t, 0), flags);
1934       pp_cxx_arrow (cxx_pp);
1935       break;
1936
1937     case SIZEOF_EXPR:
1938     case ALIGNOF_EXPR:
1939       if (TREE_CODE (t) == SIZEOF_EXPR)
1940         pp_cxx_identifier (cxx_pp, "sizeof");
1941       else
1942         {
1943           gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
1944           pp_cxx_identifier (cxx_pp, "__alignof__");
1945         }
1946       pp_cxx_whitespace (cxx_pp);
1947       pp_cxx_left_paren (cxx_pp);
1948       if (TYPE_P (TREE_OPERAND (t, 0)))
1949         dump_type (TREE_OPERAND (t, 0), flags);
1950       else
1951         dump_expr (TREE_OPERAND (t, 0), flags);
1952       pp_cxx_right_paren (cxx_pp);
1953       break;
1954
1955     case REALPART_EXPR:
1956     case IMAGPART_EXPR:
1957       pp_cxx_identifier (cxx_pp, operator_name_info[TREE_CODE (t)].name);
1958       pp_cxx_whitespace (cxx_pp);
1959       dump_expr (TREE_OPERAND (t, 0), flags);
1960       break;
1961
1962     case DEFAULT_ARG:
1963       pp_identifier (cxx_pp, "<unparsed>");
1964       break;
1965
1966     case TRY_CATCH_EXPR:
1967     case WITH_CLEANUP_EXPR:
1968     case CLEANUP_POINT_EXPR:
1969       dump_expr (TREE_OPERAND (t, 0), flags);
1970       break;
1971
1972     case PSEUDO_DTOR_EXPR:
1973       dump_expr (TREE_OPERAND (t, 2), flags);
1974       pp_cxx_dot (cxx_pp);
1975       dump_type (TREE_OPERAND (t, 0), flags);
1976       pp_cxx_colon_colon (cxx_pp);
1977       pp_cxx_complement (cxx_pp);
1978       dump_type (TREE_OPERAND (t, 1), flags);
1979       break;
1980
1981     case TEMPLATE_ID_EXPR:
1982       dump_decl (t, flags);
1983       break;
1984
1985     case BIND_EXPR:
1986     case STMT_EXPR:
1987     case STATEMENT_LIST:
1988       /* We don't yet have a way of dumping statements in a
1989          human-readable format.  */
1990       pp_string (cxx_pp, "({...})");
1991       break;
1992
1993     case LOOP_EXPR:
1994       pp_string (cxx_pp, "while (1) { ");
1995       dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1996       pp_cxx_right_brace (cxx_pp);
1997       break;
1998
1999     case EXIT_EXPR:
2000       pp_string (cxx_pp, "if (");
2001       dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2002       pp_string (cxx_pp, ") break; ");
2003       break;
2004
2005     case BASELINK:
2006       dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS);
2007       break;
2008
2009     case EMPTY_CLASS_EXPR:
2010       dump_type (TREE_TYPE (t), flags);
2011       pp_cxx_left_paren (cxx_pp);
2012       pp_cxx_right_paren (cxx_pp);
2013       break;
2014
2015     case NON_DEPENDENT_EXPR:
2016       dump_expr (TREE_OPERAND (t, 0), flags);
2017       break;
2018
2019     case EXPR_PACK_EXPANSION:
2020       dump_expr (PACK_EXPANSION_PATTERN (t), flags);
2021       pp_cxx_identifier (cxx_pp, "...");
2022       break;
2023
2024     case RECORD_TYPE:
2025     case UNION_TYPE:
2026     case ENUMERAL_TYPE:
2027     case REAL_TYPE:
2028     case VOID_TYPE:
2029     case BOOLEAN_TYPE:
2030     case INTEGER_TYPE:
2031     case COMPLEX_TYPE:
2032     case VECTOR_TYPE:
2033       pp_type_specifier_seq (cxx_pp, t);
2034       break;
2035
2036     case TYPENAME_TYPE:
2037       /* We get here when we want to print a dependent type as an
2038          id-expression, without any disambiguator decoration.  */
2039       pp_id_expression (cxx_pp, t);
2040       break;
2041
2042       /*  This list is incomplete, but should suffice for now.
2043           It is very important that `sorry' does not call
2044           `report_error_function'.  That could cause an infinite loop.  */
2045     default:
2046       pp_unsupported_tree (cxx_pp, t);
2047       /* fall through to ERROR_MARK...  */
2048     case ERROR_MARK:
2049       pp_identifier (cxx_pp, "<expression error>");
2050       break;
2051     }
2052 }
2053
2054 static void
2055 dump_binary_op (const char *opstring, tree t, int flags)
2056 {
2057   pp_cxx_left_paren (cxx_pp);
2058   dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2059   pp_cxx_whitespace (cxx_pp);
2060   if (opstring)
2061     pp_cxx_identifier (cxx_pp, opstring);
2062   else
2063     pp_identifier (cxx_pp, "<unknown operator>");
2064   pp_cxx_whitespace (cxx_pp);
2065   dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2066   pp_cxx_right_paren (cxx_pp);
2067 }
2068
2069 static void
2070 dump_unary_op (const char *opstring, tree t, int flags)
2071 {
2072   if (flags & TFF_EXPR_IN_PARENS)
2073     pp_cxx_left_paren (cxx_pp);
2074   pp_cxx_identifier (cxx_pp, opstring);
2075   dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2076   if (flags & TFF_EXPR_IN_PARENS)
2077     pp_cxx_right_paren (cxx_pp);
2078 }
2079
2080 static void
2081 reinit_cxx_pp (void)
2082 {
2083   pp_clear_output_area (cxx_pp);
2084   pp_base (cxx_pp)->padding = pp_none;
2085   pp_indentation (cxx_pp) = 0;
2086   pp_needs_newline (cxx_pp) = false;
2087   cxx_pp->enclosing_scope = 0;
2088 }
2089
2090
2091 /* Exported interface to stringifying types, exprs and decls under TFF_*
2092    control.  */
2093
2094 const char *
2095 type_as_string (tree typ, int flags)
2096 {
2097   reinit_cxx_pp ();
2098   dump_type (typ, flags);
2099   return pp_formatted_text (cxx_pp);
2100 }
2101
2102 const char *
2103 expr_as_string (tree decl, int flags)
2104 {
2105   reinit_cxx_pp ();
2106   dump_expr (decl, flags);
2107   return pp_formatted_text (cxx_pp);
2108 }
2109
2110 const char *
2111 decl_as_string (tree decl, int flags)
2112 {
2113   reinit_cxx_pp ();
2114   dump_decl (decl, flags);
2115   return pp_formatted_text (cxx_pp);
2116 }
2117
2118 /* Generate the three forms of printable names for cxx_printable_name.  */
2119
2120 const char *
2121 lang_decl_name (tree decl, int v)
2122 {
2123   if (v >= 2)
2124     return decl_as_string (decl, TFF_DECL_SPECIFIERS);
2125
2126   reinit_cxx_pp ();
2127   if (v == 1 && DECL_CLASS_SCOPE_P (decl))
2128     {
2129       dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
2130       pp_cxx_colon_colon (cxx_pp);
2131     }
2132
2133   if (TREE_CODE (decl) == FUNCTION_DECL)
2134     dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
2135   else
2136     dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
2137
2138   return pp_formatted_text (cxx_pp);
2139 }
2140
2141 /* Return the location of a tree passed to %+ formats.  */
2142
2143 static location_t
2144 location_of (tree t)
2145 {
2146   if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
2147     t = DECL_CONTEXT (t);
2148   else if (TYPE_P (t))
2149     t = TYPE_MAIN_DECL (t);
2150   else if (TREE_CODE (t) == OVERLOAD)
2151     t = OVL_FUNCTION (t);
2152
2153   return DECL_SOURCE_LOCATION (t);
2154 }
2155
2156 /* Now the interfaces from error et al to dump_type et al. Each takes an
2157    on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2158    function.  */
2159
2160 static const char *
2161 decl_to_string (tree decl, int verbose)
2162 {
2163   int flags = 0;
2164
2165   if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2166       || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2167     flags = TFF_CLASS_KEY_OR_ENUM;
2168   if (verbose)
2169     flags |= TFF_DECL_SPECIFIERS;
2170   else if (TREE_CODE (decl) == FUNCTION_DECL)
2171     flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2172   flags |= TFF_TEMPLATE_HEADER;
2173
2174   reinit_cxx_pp ();
2175   dump_decl (decl, flags);
2176   return pp_formatted_text (cxx_pp);
2177 }
2178
2179 static const char *
2180 expr_to_string (tree decl)
2181 {
2182   reinit_cxx_pp ();
2183   dump_expr (decl, 0);
2184   return pp_formatted_text (cxx_pp);
2185 }
2186
2187 static const char *
2188 fndecl_to_string (tree fndecl, int verbose)
2189 {
2190   int flags;
2191
2192   flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
2193     | TFF_TEMPLATE_HEADER;
2194   if (verbose)
2195     flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2196   reinit_cxx_pp ();
2197   dump_decl (fndecl, flags);
2198   return pp_formatted_text (cxx_pp);
2199 }
2200
2201
2202 static const char *
2203 code_to_string (enum tree_code c)
2204 {
2205   return tree_code_name [c];
2206 }
2207
2208 const char *
2209 language_to_string (enum languages c)
2210 {
2211   switch (c)
2212     {
2213     case lang_c:
2214       return "C";
2215
2216     case lang_cplusplus:
2217       return "C++";
2218
2219     case lang_java:
2220       return "Java";
2221
2222     default:
2223       gcc_unreachable ();
2224     }
2225   return NULL;
2226 }
2227
2228 /* Return the proper printed version of a parameter to a C++ function.  */
2229
2230 static const char *
2231 parm_to_string (int p)
2232 {
2233   reinit_cxx_pp ();
2234   if (p < 0)
2235     pp_string (cxx_pp, "'this'");
2236   else
2237     pp_decimal_int (cxx_pp, p + 1);
2238   return pp_formatted_text (cxx_pp);
2239 }
2240
2241 static const char *
2242 op_to_string (enum tree_code p)
2243 {
2244   tree id = operator_name_info[(int) p].identifier;
2245   return id ? IDENTIFIER_POINTER (id) : "<unknown>";
2246 }
2247
2248 static const char *
2249 type_to_string (tree typ, int verbose)
2250 {
2251   int flags = 0;
2252   if (verbose)
2253     flags |= TFF_CLASS_KEY_OR_ENUM;
2254   flags |= TFF_TEMPLATE_HEADER;
2255
2256   reinit_cxx_pp ();
2257   dump_type (typ, flags);
2258   return pp_formatted_text (cxx_pp);
2259 }
2260
2261 static const char *
2262 assop_to_string (enum tree_code p)
2263 {
2264   tree id = assignment_operator_name_info[(int) p].identifier;
2265   return id ? IDENTIFIER_POINTER (id) : "{unknown}";
2266 }
2267
2268 static const char *
2269 args_to_string (tree p, int verbose)
2270 {
2271   int flags = 0;
2272   if (verbose)
2273     flags |= TFF_CLASS_KEY_OR_ENUM;
2274
2275   if (p == NULL_TREE)
2276     return "";
2277
2278   if (TYPE_P (TREE_VALUE (p)))
2279     return type_as_string (p, flags);
2280
2281   reinit_cxx_pp ();
2282   for (; p; p = TREE_CHAIN (p))
2283     {
2284       if (TREE_VALUE (p) == null_node)
2285         pp_cxx_identifier (cxx_pp, "NULL");
2286       else
2287         dump_type (error_type (TREE_VALUE (p)), flags);
2288       if (TREE_CHAIN (p))
2289         pp_separate_with_comma (cxx_pp);
2290     }
2291   return pp_formatted_text (cxx_pp);
2292 }
2293
2294 static const char *
2295 cv_to_string (tree p, int v)
2296 {
2297   reinit_cxx_pp ();
2298   pp_base (cxx_pp)->padding = v ? pp_before : pp_none;
2299   pp_cxx_cv_qualifier_seq (cxx_pp, p);
2300   return pp_formatted_text (cxx_pp);
2301 }
2302
2303 /* Langhook for print_error_function.  */
2304 void
2305 cxx_print_error_function (diagnostic_context *context, const char *file)
2306 {
2307   lhd_print_error_function (context, file);
2308   pp_base_set_prefix (context->printer, file);
2309   maybe_print_instantiation_context (context);
2310 }
2311
2312 static void
2313 cp_diagnostic_starter (diagnostic_context *context,
2314                        diagnostic_info *diagnostic)
2315 {
2316   diagnostic_report_current_module (context);
2317   cp_print_error_function (context, diagnostic);
2318   maybe_print_instantiation_context (context);
2319   pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
2320 }
2321
2322 static void
2323 cp_diagnostic_finalizer (diagnostic_context *context,
2324                          diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2325 {
2326   pp_base_destroy_prefix (context->printer);
2327 }
2328
2329 /* Print current function onto BUFFER, in the process of reporting
2330    a diagnostic message.  Called from cp_diagnostic_starter.  */
2331 static void
2332 cp_print_error_function (diagnostic_context *context,
2333                          diagnostic_info *diagnostic)
2334 {
2335   if (diagnostic_last_function_changed (context))
2336     {
2337       const char *old_prefix = context->printer->prefix;
2338       const char *file = LOCATION_FILE (diagnostic->location);
2339       char *new_prefix = file ? file_name_as_prefix (file) : NULL;
2340
2341       pp_base_set_prefix (context->printer, new_prefix);
2342
2343       if (current_function_decl == NULL)
2344         pp_base_string (context->printer, "At global scope:");
2345       else
2346         pp_printf (context->printer, "In %s %qs:",
2347                    function_category (current_function_decl),
2348                    cxx_printable_name (current_function_decl, 2));
2349       pp_base_newline (context->printer);
2350
2351       diagnostic_set_last_function (context);
2352       pp_base_destroy_prefix (context->printer);
2353       context->printer->prefix = old_prefix;
2354     }
2355 }
2356
2357 /* Returns a description of FUNCTION using standard terminology.  */
2358 static const char *
2359 function_category (tree fn)
2360 {
2361   if (DECL_FUNCTION_MEMBER_P (fn))
2362     {
2363       if (DECL_STATIC_FUNCTION_P (fn))
2364         return "static member function";
2365       else if (DECL_COPY_CONSTRUCTOR_P (fn))
2366         return "copy constructor";
2367       else if (DECL_CONSTRUCTOR_P (fn))
2368         return "constructor";
2369       else if (DECL_DESTRUCTOR_P (fn))
2370         return "destructor";
2371       else
2372         return "member function";
2373     }
2374   else
2375     return "function";
2376 }
2377
2378 /* Report the full context of a current template instantiation,
2379    onto BUFFER.  */
2380 static void
2381 print_instantiation_full_context (diagnostic_context *context)
2382 {
2383   tree p = current_instantiation ();
2384   location_t location = input_location;
2385
2386   if (p)
2387     {
2388       if (current_function_decl != TINST_DECL (p)
2389           && current_function_decl != NULL_TREE)
2390         /* We can get here during the processing of some synthesized
2391            method.  Then, TINST_DECL (p) will be the function that's causing
2392            the synthesis.  */
2393         ;
2394       else
2395         {
2396           if (current_function_decl == TINST_DECL (p))
2397             /* Avoid redundancy with the "In function" line.  */;
2398           else
2399             pp_verbatim (context->printer,
2400                          "%s: In instantiation of %qs:\n",
2401                          LOCATION_FILE (location),
2402                          decl_as_string (TINST_DECL (p),
2403                                          TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2404
2405           location = TINST_LOCATION (p);
2406           p = TREE_CHAIN (p);
2407         }
2408     }
2409
2410   print_instantiation_partial_context (context, p, location);
2411 }
2412
2413 /* Same as above but less verbose.  */
2414 static void
2415 print_instantiation_partial_context (diagnostic_context *context,
2416                                      tree t, location_t loc)
2417 {
2418   expanded_location xloc;
2419   for (; ; t = TREE_CHAIN (t))
2420     {
2421       xloc = expand_location (loc);
2422       if (t == NULL_TREE)
2423         break;
2424       pp_verbatim (context->printer, "%s:%d:   instantiated from %qs\n",
2425                    xloc.file, xloc.line,
2426                    decl_as_string (TINST_DECL (t),
2427                                    TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2428       loc = TINST_LOCATION (t);
2429     }
2430   pp_verbatim (context->printer, "%s:%d:   instantiated from here",
2431                xloc.file, xloc.line);
2432   pp_base_newline (context->printer);
2433 }
2434
2435 /* Called from cp_thing to print the template context for an error.  */
2436 static void
2437 maybe_print_instantiation_context (diagnostic_context *context)
2438 {
2439   if (!problematic_instantiation_changed () || current_instantiation () == 0)
2440     return;
2441
2442   record_last_problematic_instantiation ();
2443   print_instantiation_full_context (context);
2444 }
2445
2446 /* Report the bare minimum context of a template instantiation.  */
2447 void
2448 print_instantiation_context (void)
2449 {
2450   print_instantiation_partial_context
2451     (global_dc, current_instantiation (), input_location);
2452   diagnostic_flush_buffer (global_dc);
2453 }
2454 \f
2455 /* Called from output_format -- during diagnostic message processing --
2456    to handle C++ specific format specifier with the following meanings:
2457    %A   function argument-list.
2458    %C   tree code.
2459    %D   declaration.
2460    %E   expression.
2461    %F   function declaration.
2462    %L   language as used in extern "lang".
2463    %O   binary operator.
2464    %P   function parameter whose position is indicated by an integer.
2465    %Q   assignment operator.
2466    %T   type.
2467    %V   cv-qualifier.  */
2468 static bool
2469 cp_printer (pretty_printer *pp, text_info *text, const char *spec,
2470             int precision, bool wide, bool set_locus, bool verbose)
2471 {
2472   const char *result;
2473   tree t = NULL;
2474 #define next_tree    (t = va_arg (*text->args_ptr, tree))
2475 #define next_tcode   va_arg (*text->args_ptr, enum tree_code)
2476 #define next_lang    va_arg (*text->args_ptr, enum languages)
2477 #define next_int     va_arg (*text->args_ptr, int)
2478
2479   if (precision != 0 || wide)
2480     return false;
2481
2482   if (text->locus == NULL)
2483     set_locus = false;
2484
2485   switch (*spec)
2486     {
2487     case 'A': result = args_to_string (next_tree, verbose);     break;
2488     case 'C': result = code_to_string (next_tcode);             break;
2489     case 'D':
2490       {
2491         tree temp = next_tree;
2492         if (DECL_P (temp)
2493             && DECL_DEBUG_EXPR_IS_FROM (temp) && DECL_DEBUG_EXPR (temp))
2494           {
2495             temp = DECL_DEBUG_EXPR (temp);
2496             if (!DECL_P (temp))
2497               {
2498                 result = expr_to_string (temp);
2499                 break;
2500               }
2501           }
2502         result = decl_to_string (temp, verbose);
2503       }
2504       break;
2505     case 'E': result = expr_to_string (next_tree);              break;
2506     case 'F': result = fndecl_to_string (next_tree, verbose);   break;
2507     case 'L': result = language_to_string (next_lang);          break;
2508     case 'O': result = op_to_string (next_tcode);               break;
2509     case 'P': result = parm_to_string (next_int);               break;
2510     case 'Q': result = assop_to_string (next_tcode);            break;
2511     case 'T': result = type_to_string (next_tree, verbose);     break;
2512     case 'V': result = cv_to_string (next_tree, verbose);       break;
2513
2514     default:
2515       return false;
2516     }
2517
2518   pp_base_string (pp, result);
2519   if (set_locus && t != NULL)
2520     *text->locus = location_of (t);
2521   return true;
2522 #undef next_tree
2523 #undef next_tcode
2524 #undef next_lang
2525 #undef next_int
2526 }
2527 \f
2528 /* Callback from cpp_error for PFILE to print diagnostics arising from
2529    interpreting strings.  The diagnostic is of type LEVEL; MSG is the
2530    translated message and AP the arguments.  */
2531
2532 void
2533 cp_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level,
2534               const char *msg, va_list *ap)
2535 {
2536   diagnostic_info diagnostic;
2537   diagnostic_t dlevel;
2538   switch (level)
2539     {
2540     case CPP_DL_WARNING:
2541     case CPP_DL_WARNING_SYSHDR:
2542       dlevel = DK_WARNING;
2543       break;
2544     case CPP_DL_PEDWARN:
2545       dlevel = pedantic_error_kind ();
2546       break;
2547     case CPP_DL_ERROR:
2548       dlevel = DK_ERROR;
2549       break;
2550     case CPP_DL_ICE:
2551       dlevel = DK_ICE;
2552       break;
2553     default:
2554       gcc_unreachable ();
2555     }
2556   diagnostic_set_info_translated (&diagnostic, msg, ap,
2557                                   input_location, dlevel);
2558   report_diagnostic (&diagnostic);
2559 }
2560
2561 /* Warn about the use of variadic templates when appropriate.  */
2562 void
2563 maybe_warn_variadic_templates (void)
2564 {
2565   if ((cxx_dialect == cxx98) && !in_system_header)
2566     /* We really want to suppress this warning in system headers,
2567        because libstdc++ uses variadic templates even when we aren't
2568        in C++0x mode. */
2569     pedwarn ("ISO C++ does not include variadic templates");
2570 }