gcc/cp/error.c

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