contrib/gcc/cp/error.c

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