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