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