contrib/gcc-3.4/gcc/cp/error.c

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