gcc/cp/error.c

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