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