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