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