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