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       dump_expr (TREE_OPERAND (t, 0), flags);
1880       break;
1881
1882       /*  This list is incomplete, but should suffice for now.
1883           It is very important that `sorry' does not call
1884           `report_error_function'.  That could cause an infinite loop.  */
1885     default:
1886       pp_unsupported_tree (cxx_pp, t);
1887       /* fall through to ERROR_MARK...  */
1888     case ERROR_MARK:
1889       pp_identifier (cxx_pp, "<expression error>");
1890       break;
1891     }
1892 }
1893
1894 static void
1895 dump_binary_op (const char *opstring, tree t, int flags)
1896 {
1897   pp_left_paren (cxx_pp);
1898   dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1899   pp_space (cxx_pp);
1900   if (opstring)
1901     pp_identifier (cxx_pp, opstring);
1902   else
1903     pp_identifier (cxx_pp, "<unknown operator>");
1904   pp_space (cxx_pp);
1905   dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1906   pp_right_paren (cxx_pp);
1907 }
1908
1909 static void
1910 dump_unary_op (const char *opstring, tree t, int flags)
1911 {
1912   if (flags & TFF_EXPR_IN_PARENS)
1913     pp_left_paren (cxx_pp);
1914   pp_identifier (cxx_pp, opstring);
1915   dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1916   if (flags & TFF_EXPR_IN_PARENS)
1917     pp_right_paren (cxx_pp);
1918 }
1919
1920 /* Exported interface to stringifying types, exprs and decls under TFF_*
1921    control.  */
1922
1923 const char *
1924 type_as_string (tree typ, int flags)
1925 {
1926   pp_clear_output_area (cxx_pp);
1927   dump_type (typ, flags);
1928   return pp_formatted_text (cxx_pp);
1929 }
1930
1931 const char *
1932 expr_as_string (tree decl, int flags)
1933 {
1934   pp_clear_output_area (cxx_pp);
1935   dump_expr (decl, flags);
1936   return pp_formatted_text (cxx_pp);
1937 }
1938
1939 const char *
1940 decl_as_string (tree decl, int flags)
1941 {
1942   pp_clear_output_area (cxx_pp);
1943   dump_decl (decl, flags);
1944   return pp_formatted_text (cxx_pp);
1945 }
1946
1947 const char *
1948 context_as_string (tree context, int flags)
1949 {
1950   pp_clear_output_area (cxx_pp);
1951   dump_scope (context, flags);
1952   return pp_formatted_text (cxx_pp);
1953 }
1954
1955 /* Generate the three forms of printable names for cxx_printable_name.  */
1956
1957 const char *
1958 lang_decl_name (tree decl, int v)
1959 {
1960   if (v >= 2)
1961     return decl_as_string (decl, TFF_DECL_SPECIFIERS);
1962
1963   pp_clear_output_area (cxx_pp);
1964   if (v == 1 && DECL_CLASS_SCOPE_P (decl))
1965     {
1966       dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
1967       pp_colon_colon (cxx_pp);
1968     }
1969
1970   if (TREE_CODE (decl) == FUNCTION_DECL)
1971     dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
1972   else
1973     dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
1974
1975   return pp_formatted_text (cxx_pp);
1976 }
1977
1978 static location_t
1979 location_of (tree t)
1980 {
1981   if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
1982     t = DECL_CONTEXT (t);
1983   else if (TYPE_P (t))
1984     t = TYPE_MAIN_DECL (t);
1985   else if (TREE_CODE (t) == OVERLOAD)
1986     t = OVL_FUNCTION (t);
1987
1988   return DECL_SOURCE_LOCATION (t);
1989 }
1990
1991 /* Now the interfaces from error et al to dump_type et al. Each takes an
1992    on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
1993    function.  */
1994
1995 static const char *
1996 decl_to_string (tree decl, int verbose)
1997 {
1998   int flags = 0;
1999
2000   if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2001       || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2002     flags = TFF_CLASS_KEY_OR_ENUM;
2003   if (verbose)
2004     flags |= TFF_DECL_SPECIFIERS;
2005   else if (TREE_CODE (decl) == FUNCTION_DECL)
2006     flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2007   flags |= TFF_TEMPLATE_HEADER;
2008
2009   pp_clear_output_area (cxx_pp);
2010   dump_decl (decl, flags);
2011   return pp_formatted_text (cxx_pp);
2012 }
2013
2014 static const char *
2015 expr_to_string (tree decl)
2016 {
2017   pp_clear_output_area (cxx_pp);
2018   dump_expr (decl, 0);
2019   return pp_formatted_text (cxx_pp);
2020 }
2021
2022 static const char *
2023 fndecl_to_string (tree fndecl, int verbose)
2024 {
2025   int flags;
2026
2027   flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS;
2028   if (verbose)
2029     flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2030   pp_clear_output_area (cxx_pp);
2031   dump_decl (fndecl, flags);
2032   return pp_formatted_text (cxx_pp);
2033 }
2034
2035
2036 static const char *
2037 code_to_string (enum tree_code c)
2038 {
2039   return tree_code_name [c];
2040 }
2041
2042 const char *
2043 language_to_string (enum languages c)
2044 {
2045   switch (c)
2046     {
2047     case lang_c:
2048       return "C";
2049
2050     case lang_cplusplus:
2051       return "C++";
2052
2053     case lang_java:
2054       return "Java";
2055
2056     default:
2057       abort ();
2058       return 0;
2059     }
2060 }
2061
2062 /* Return the proper printed version of a parameter to a C++ function.  */
2063
2064 static const char *
2065 parm_to_string (int p)
2066 {
2067   pp_clear_output_area (cxx_pp);
2068   if (p < 0)
2069     pp_string (cxx_pp, "'this'");
2070   else
2071     pp_decimal_int (cxx_pp, p + 1);
2072   return pp_formatted_text (cxx_pp);
2073 }
2074
2075 static const char *
2076 op_to_string (enum tree_code p)
2077 {
2078   tree id = operator_name_info[(int) p].identifier;
2079   return id ? IDENTIFIER_POINTER (id) : "<unknown>";
2080 }
2081
2082 static const char *
2083 type_to_string (tree typ, int verbose)
2084 {
2085   int flags = 0;
2086   if (verbose)
2087     flags |= TFF_CLASS_KEY_OR_ENUM;
2088   flags |= TFF_TEMPLATE_HEADER;
2089
2090   pp_clear_output_area (cxx_pp);
2091   dump_type (typ, flags);
2092   return pp_formatted_text (cxx_pp);
2093 }
2094
2095 static const char *
2096 assop_to_string (enum tree_code p)
2097 {
2098   tree id = assignment_operator_name_info[(int) p].identifier;
2099   return id ? IDENTIFIER_POINTER (id) : "{unknown}";
2100 }
2101
2102 static const char *
2103 args_to_string (tree p, int verbose)
2104 {
2105   int flags = 0;
2106   if (verbose)
2107     flags |= TFF_CLASS_KEY_OR_ENUM;
2108
2109   if (p == NULL_TREE)
2110     return "";
2111
2112   if (TYPE_P (TREE_VALUE (p)))
2113     return type_as_string (p, flags);
2114
2115   pp_clear_output_area (cxx_pp);
2116   for (; p; p = TREE_CHAIN (p))
2117     {
2118       if (TREE_VALUE (p) == null_node)
2119         pp_identifier (cxx_pp, "NULL");
2120       else
2121         dump_type (error_type (TREE_VALUE (p)), flags);
2122       if (TREE_CHAIN (p))
2123         pp_separate_with_comma (cxx_pp);
2124     }
2125   return pp_formatted_text (cxx_pp);
2126 }
2127
2128 static const char *
2129 cv_to_string (tree p, int v)
2130 {
2131   pp_clear_output_area (cxx_pp);
2132   dump_qualifiers (p, v ? before : none);
2133   return pp_formatted_text (cxx_pp);
2134 }
2135
2136 /* Langhook for print_error_function.  */
2137 void
2138 cxx_print_error_function (diagnostic_context *context, const char *file)
2139 {
2140   lhd_print_error_function (context, file);
2141   pp_base_set_prefix (context->printer, file);
2142   maybe_print_instantiation_context (context);
2143 }
2144
2145 static void
2146 cp_diagnostic_starter (diagnostic_context *context,
2147                        diagnostic_info *diagnostic)
2148 {
2149   diagnostic_report_current_module (context);
2150   cp_print_error_function (context, diagnostic);
2151   maybe_print_instantiation_context (context);
2152   pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
2153 }
2154
2155 static void
2156 cp_diagnostic_finalizer (diagnostic_context *context,
2157                          diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2158 {
2159   pp_base_destroy_prefix (context->printer);
2160 }
2161
2162 /* Print current function onto BUFFER, in the process of reporting
2163    a diagnostic message.  Called from cp_diagnostic_starter.  */
2164 static void
2165 cp_print_error_function (diagnostic_context *context,
2166                          diagnostic_info *diagnostic)
2167 {
2168   if (diagnostic_last_function_changed (context))
2169     {
2170       const char *old_prefix = context->printer->prefix;
2171       char *new_prefix = diagnostic->location.file
2172         ? file_name_as_prefix (diagnostic->location.file)
2173         : NULL;
2174
2175       pp_base_set_prefix (context->printer, new_prefix);
2176
2177       if (current_function_decl == NULL)
2178         pp_base_string (context->printer, "At global scope:");
2179       else
2180         pp_printf (context->printer, "In %s `%s':",
2181                    function_category (current_function_decl),
2182                    cxx_printable_name (current_function_decl, 2));
2183       pp_base_newline (context->printer);
2184
2185       diagnostic_set_last_function (context);
2186       pp_base_destroy_prefix (context->printer);
2187       context->printer->prefix = old_prefix;
2188     }
2189 }
2190
2191 /* Returns a description of FUNCTION using standard terminology.  */
2192 static const char *
2193 function_category (tree fn)
2194 {
2195   if (DECL_FUNCTION_MEMBER_P (fn))
2196     {
2197       if (DECL_STATIC_FUNCTION_P (fn))
2198         return "static member function";
2199       else if (DECL_COPY_CONSTRUCTOR_P (fn))
2200         return "copy constructor";
2201       else if (DECL_CONSTRUCTOR_P (fn))
2202         return "constructor";
2203       else if (DECL_DESTRUCTOR_P (fn))
2204         return "destructor";
2205       else
2206         return "member function";
2207     }
2208   else
2209     return "function";
2210 }
2211
2212 /* Report the full context of a current template instantiation,
2213    onto BUFFER.  */
2214 static void
2215 print_instantiation_full_context (diagnostic_context *context)
2216 {
2217   tree p = current_instantiation ();
2218   location_t location = input_location;
2219
2220   if (p)
2221     {
2222       if (current_function_decl != TINST_DECL (p)
2223           && current_function_decl != NULL_TREE)
2224         /* We can get here during the processing of some synthesized
2225            method.  Then, TINST_DECL (p) will be the function that's causing
2226            the synthesis.  */
2227         ;
2228       else
2229         {
2230           if (current_function_decl == TINST_DECL (p))
2231             /* Avoid redundancy with the the "In function" line.  */;
2232           else
2233             pp_verbatim (context->printer,
2234                          "%s: In instantiation of `%s':\n", location.file,
2235                          decl_as_string (TINST_DECL (p),
2236                                          TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2237
2238           location.line = TINST_LINE (p);
2239           location.file = TINST_FILE (p);
2240           p = TREE_CHAIN (p);
2241         }
2242     }
2243
2244   print_instantiation_partial_context (context, p, location);
2245 }
2246
2247 /* Same as above but less verbose.  */
2248 static void
2249 print_instantiation_partial_context (diagnostic_context *context,
2250                                      tree t, location_t loc)
2251 {
2252   for (; t; t = TREE_CHAIN (t))
2253     {
2254       pp_verbatim (context->printer, "%s:%d:   instantiated from `%s'\n",
2255                    loc.file, loc.line,
2256                    decl_as_string (TINST_DECL (t),
2257                                    TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2258       loc.line = TINST_LINE (t);
2259       loc.file = TINST_FILE (t);
2260     }
2261   pp_verbatim (context->printer, "%s:%d:   instantiated from here\n",
2262                loc.file, loc.line);
2263 }
2264
2265 /* Called from cp_thing to print the template context for an error.  */
2266 static void
2267 maybe_print_instantiation_context (diagnostic_context *context)
2268 {
2269   if (!problematic_instantiation_changed () || current_instantiation () == 0)
2270     return;
2271
2272   record_last_problematic_instantiation ();
2273   print_instantiation_full_context (context);
2274 }
2275
2276 /* Report the bare minimum context of a template instantiation.  */
2277 void
2278 print_instantiation_context (void)
2279 {
2280   print_instantiation_partial_context
2281     (global_dc, current_instantiation (), input_location);
2282   diagnostic_flush_buffer (global_dc);
2283 }
2284 \f
2285 /* Called from output_format -- during diagnostic message processing --
2286    to handle C++ specific format specifier with the following meanings:
2287    %A   function argument-list.
2288    %C   tree code.
2289    %D   declaration.
2290    %E   expression.
2291    %F   function declaration.
2292    %L   language as used in extern "lang".
2293    %O   binary operator.
2294    %P   function parameter whose position is indicated by an integer.
2295    %Q   assignment operator.
2296    %T   type.
2297    %V   cv-qualifier.  */
2298 static bool
2299 cp_printer (pretty_printer *pp, text_info *text)
2300 {
2301   int verbose = 0;
2302   const char *result;
2303 #define next_tree    va_arg (*text->args_ptr, tree)
2304 #define next_tcode   va_arg (*text->args_ptr, enum tree_code)
2305 #define next_lang    va_arg (*text->args_ptr, enum languages)
2306 #define next_int     va_arg (*text->args_ptr, int)
2307
2308   if (*text->format_spec == '+')
2309     ++text->format_spec;
2310   if (*text->format_spec == '#')
2311     {
2312       verbose = 1;
2313       ++text->format_spec;
2314     }
2315
2316   switch (*text->format_spec)
2317     {
2318     case 'A': result = args_to_string (next_tree, verbose);     break;
2319     case 'C': result = code_to_string (next_tcode);             break;
2320     case 'D': result = decl_to_string (next_tree, verbose);     break;
2321     case 'E': result = expr_to_string (next_tree);              break;
2322     case 'F': result = fndecl_to_string (next_tree, verbose);   break;
2323     case 'L': result = language_to_string (next_lang);          break;
2324     case 'O': result = op_to_string (next_tcode);               break;
2325     case 'P': result = parm_to_string (next_int);               break;
2326     case 'Q': result = assop_to_string (next_tcode);            break;
2327     case 'T': result = type_to_string (next_tree, verbose);     break;
2328     case 'V': result = cv_to_string (next_tree, verbose);       break;
2329
2330     default:
2331       return false;
2332     }
2333
2334   pp_base_string (pp, result);
2335   return true;
2336 #undef next_tree
2337 #undef next_tcode
2338 #undef next_lang
2339 #undef next_int
2340 }
2341
2342 static void
2343 pp_non_consecutive_character (cxx_pretty_printer *pp, int c)
2344 {
2345   const char *p = pp_last_position_in_text (pp);
2346
2347   if (p != NULL && *p == c)
2348     pp_space (pp);
2349   pp_character (pp, c);
2350 }
2351
2352 /* These are temporary wrapper functions which handle the historic
2353    behavior of cp_*_at.  */
2354
2355 static tree
2356 locate_error (const char *msgid, va_list ap)
2357 {
2358   tree here = 0, t;
2359   int plus = 0;
2360   const char *f;
2361
2362   for (f = msgid; *f; f++)
2363     {
2364       plus = 0;
2365       if (*f == '%')
2366         {
2367           f++;
2368           if (*f == '+')
2369             f++, plus = 1;
2370           if (*f == '#')
2371             f++;
2372
2373           switch (*f)
2374             {
2375               /* Just ignore these possibilities.  */
2376             case '%':                                           break;
2377             case 'P':
2378             case 'd':   (void) va_arg (ap, int);                break;
2379             case 's':   (void) va_arg (ap, char *);             break;
2380             case 'L':   (void) va_arg (ap, enum languages);     break;
2381             case 'C':
2382             case 'O':
2383             case 'Q':   (void) va_arg (ap, enum tree_code);     break;
2384
2385               /* These take a tree, which may be where the error is
2386                  located.  */
2387             case 'A':
2388             case 'D':
2389             case 'E':
2390             case 'F':
2391             case 'T':
2392             case 'V':
2393               t = va_arg (ap, tree);
2394               if (!here || plus)
2395                 here = t;
2396               break;
2397
2398             default:
2399               errorcount = 0;  /* damn ICE suppression */
2400               internal_error ("unexpected letter `%c' in locate_error\n", *f);
2401             }
2402         }
2403     }
2404
2405   if (here == 0)
2406     here = va_arg (ap, tree);
2407
2408   return here;
2409 }
2410
2411
2412 void
2413 cp_error_at (const char *msgid, ...)
2414 {
2415   tree here;
2416   diagnostic_info diagnostic;
2417   va_list ap;
2418
2419   va_start (ap, msgid);
2420   here = locate_error (msgid, ap);
2421   va_end (ap);
2422
2423   va_start (ap, msgid);
2424   diagnostic_set_info (&diagnostic, msgid, &ap,
2425                        location_of (here), DK_ERROR);
2426   report_diagnostic (&diagnostic);
2427   va_end (ap);
2428 }
2429
2430 void
2431 cp_warning_at (const char *msgid, ...)
2432 {
2433   tree here;
2434   diagnostic_info diagnostic;
2435   va_list ap;
2436
2437   va_start (ap, msgid);
2438   here = locate_error (msgid, ap);
2439   va_end (ap);
2440
2441   va_start (ap, msgid);
2442   diagnostic_set_info (&diagnostic, msgid, &ap,
2443                        location_of (here), DK_WARNING);
2444   report_diagnostic (&diagnostic);
2445   va_end (ap);
2446 }
2447
2448 void
2449 cp_pedwarn_at (const char *msgid, ...)
2450 {
2451   tree here;
2452   diagnostic_info diagnostic;
2453   va_list ap;
2454
2455   va_start (ap, msgid);
2456   here = locate_error (msgid, ap);
2457   va_end (ap);
2458
2459   va_start (ap, msgid);
2460   diagnostic_set_info (&diagnostic, msgid, &ap,
2461                        location_of (here), pedantic_error_kind());
2462   report_diagnostic (&diagnostic);
2463   va_end (ap);
2464 }