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