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