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