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