contrib/gcc/cp/error.c

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