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