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           dump_type (TYPE_OFFSET_BASETYPE (t), flags);
 516           pp_cxx_colon_colon (cxx_pp);
 517         }
 518       pp_cxx_star (cxx_pp);
 519       pp_cxx_cv_qualifier_seq (cxx_pp, t);
 520       break;
 521
 522       /* Can only be reached through function pointer -- this would not be
 523          correct if FUNCTION_DECLs used it.  */
 524     case FUNCTION_TYPE:
 525       dump_type_prefix (TREE_TYPE (t), flags);
 526       pp_maybe_space (cxx_pp);
 527       pp_cxx_left_paren (cxx_pp);
 528       break;
 529
 530     case METHOD_TYPE:
 531       dump_type_prefix (TREE_TYPE (t), flags);
 532       pp_maybe_space (cxx_pp);
 533       pp_cxx_left_paren (cxx_pp);
 534       dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags);
 535       pp_cxx_colon_colon (cxx_pp);
 536       break;
 537
 538     case ARRAY_TYPE:
 539       dump_type_prefix (TREE_TYPE (t), flags);
 540       break;
 541
 542     case ENUMERAL_TYPE:
 543     case IDENTIFIER_NODE:
 544     case INTEGER_TYPE:
 545     case BOOLEAN_TYPE:
 546     case REAL_TYPE:
 547     case RECORD_TYPE:
 548     case TEMPLATE_TYPE_PARM:
 549     case TEMPLATE_TEMPLATE_PARM:
 550     case BOUND_TEMPLATE_TEMPLATE_PARM:
 551     case TREE_LIST:
 552     case TYPE_DECL:
 553     case TREE_VEC:
 554     case UNION_TYPE:
 555     case UNKNOWN_TYPE:
 556     case VOID_TYPE:
 557     case TYPENAME_TYPE:
 558     case COMPLEX_TYPE:
 559     case VECTOR_TYPE:
 560     case TYPEOF_TYPE:
 561       dump_type (t, flags);
 562       pp_base (cxx_pp)->padding = pp_before;
 563       break;
 564
 565     default:
 566       pp_unsupported_tree (cxx_pp, t);
 567       /* fall through.  */
 568     case ERROR_MARK:
 569       pp_identifier (cxx_pp, "<typeprefixerror>");
 570       break;
 571     }
 572 }
 573
 574 /* Dump the suffix of type T, under control of FLAGS.  This is the part
 575    which appears after the identifier (or function parms).  */
 576
 577 static void
 578 dump_type_suffix (tree t, int flags)
 579 {
 580   if (TYPE_PTRMEMFUNC_P (t))
 581     t = TYPE_PTRMEMFUNC_FN_TYPE (t);
 582
 583   switch (TREE_CODE (t))
 584     {
 585     case POINTER_TYPE:
 586     case REFERENCE_TYPE:
 587     case OFFSET_TYPE:
 588       if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
 589         pp_cxx_right_paren (cxx_pp);
 590       dump_type_suffix (TREE_TYPE (t), flags);
 591       break;
 592
 593       /* Can only be reached through function pointer.  */
 594     case FUNCTION_TYPE:
 595     case METHOD_TYPE:
 596       {
 597         tree arg;
 598         pp_cxx_right_paren (cxx_pp);
 599         arg = TYPE_ARG_TYPES (t);
 600         if (TREE_CODE (t) == METHOD_TYPE)
 601           arg = TREE_CHAIN (arg);
 602
 603         /* Function pointers don't have default args.  Not in standard C++,
 604            anyway; they may in g++, but we'll just pretend otherwise.  */
 605         dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
 606
 607         if (TREE_CODE (t) == METHOD_TYPE)
 608           pp_cxx_cv_qualifier_seq
 609             (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
 610         dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags);
 611         dump_type_suffix (TREE_TYPE (t), flags);
 612         break;
 613       }
 614
 615     case ARRAY_TYPE:
 616       pp_cxx_left_bracket (cxx_pp);
 617       if (TYPE_DOMAIN (t))
 618         {
 619           if (host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0))
 620             pp_wide_integer
 621               (cxx_pp, tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0) + 1);
 622           else if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (t))) == MINUS_EXPR)
 623             dump_expr (TREE_OPERAND (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0),
 624                        flags & ~TFF_EXPR_IN_PARENS);
 625           else
 626             dump_expr (fold (cp_build_binary_op
 627                              (PLUS_EXPR, TYPE_MAX_VALUE (TYPE_DOMAIN (t)),
 628                               integer_one_node)),
 629                        flags & ~TFF_EXPR_IN_PARENS);
 630         }
 631       pp_cxx_right_bracket (cxx_pp);
 632       dump_type_suffix (TREE_TYPE (t), flags);
 633       break;
 634
 635     case ENUMERAL_TYPE:
 636     case IDENTIFIER_NODE:
 637     case INTEGER_TYPE:
 638     case BOOLEAN_TYPE:
 639     case REAL_TYPE:
 640     case RECORD_TYPE:
 641     case TEMPLATE_TYPE_PARM:
 642     case TEMPLATE_TEMPLATE_PARM:
 643     case BOUND_TEMPLATE_TEMPLATE_PARM:
 644     case TREE_LIST:
 645     case TYPE_DECL:
 646     case TREE_VEC:
 647     case UNION_TYPE:
 648     case UNKNOWN_TYPE:
 649     case VOID_TYPE:
 650     case TYPENAME_TYPE:
 651     case COMPLEX_TYPE:
 652     case VECTOR_TYPE:
 653     case TYPEOF_TYPE:
 654       break;
 655
 656     default:
 657       pp_unsupported_tree (cxx_pp, t);
 658     case ERROR_MARK:
 659       /* Don't mark it here, we should have already done in
 660          dump_type_prefix.  */
 661       break;
 662     }
 663 }
 664
 665 static void
 666 dump_global_iord (tree t)
 667 {
 668   const char *p = NULL;
 669
 670   if (DECL_GLOBAL_CTOR_P (t))
 671     p = "initializers";
 672   else if (DECL_GLOBAL_DTOR_P (t))
 673     p = "destructors";
 674   else
 675     abort ();
 676
 677   pp_printf (pp_base (cxx_pp), "(static %s for %s)", p, input_filename);
 678 }
 679
 680 static void
 681 dump_simple_decl (tree t, tree type, int flags)
 682 {
 683   if (flags & TFF_DECL_SPECIFIERS)
 684     {
 685       dump_type_prefix (type, flags);
 686       pp_maybe_space (cxx_pp);
 687     }
 688   if (!DECL_INITIAL (t) || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX)
 689     dump_scope (CP_DECL_CONTEXT (t), flags);
 690   if (DECL_NAME (t))
 691     dump_decl (DECL_NAME (t), flags);
 692   else
 693     pp_identifier (cxx_pp, "<anonymous>");
 694   if (flags & TFF_DECL_SPECIFIERS)
 695     dump_type_suffix (type, flags);
 696 }
 697
 698 /* Dump a human readable string for the decl T under control of FLAGS.  */
 699
 700 static void
 701 dump_decl (tree t, int flags)
 702 {
 703   if (t == NULL_TREE)
 704     return;
 705
 706   switch (TREE_CODE (t))
 707     {
 708     case TYPE_DECL:
 709       {
 710         /* Don't say 'typedef class A' */
 711         if (DECL_ARTIFICIAL (t))
 712           {
 713             if ((flags & TFF_DECL_SPECIFIERS)
 714                 && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
 715               /* Say `class T' not just `T'.  */
 716               pp_cxx_identifier (cxx_pp, "class");
 717
 718             dump_type (TREE_TYPE (t), flags);
 719             break;
 720           }
 721       }
 722       if (flags & TFF_DECL_SPECIFIERS)
 723         pp_cxx_identifier (cxx_pp, "typedef");
 724       dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
 725                         ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
 726                         flags);
 727       break;
 728
 729     case VAR_DECL:
 730       if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
 731         {
 732           pp_string (cxx_pp, "vtable for ");
 733           my_friendly_assert (TYPE_P (DECL_CONTEXT (t)), 20010720);
 734           dump_type (DECL_CONTEXT (t), flags);
 735           break;
 736         }
 737       /* Else fall through.  */
 738     case FIELD_DECL:
 739     case PARM_DECL:
 740     case ALIAS_DECL:
 741       dump_simple_decl (t, TREE_TYPE (t), flags);
 742       break;
 743
 744     case RESULT_DECL:
 745       pp_string (cxx_pp, "<return value> ");
 746       dump_simple_decl (t, TREE_TYPE (t), flags);
 747       break;
 748
 749     case NAMESPACE_DECL:
 750       if (flags & TFF_DECL_SPECIFIERS)
 751         pp_cxx_declaration (cxx_pp, t);
 752       else
 753         {
 754           dump_scope (CP_DECL_CONTEXT (t), flags);
 755           if (DECL_NAME (t) == NULL_TREE)
 756             pp_identifier (cxx_pp, "<unnamed>");
 757           else
 758             pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
 759         }
 760       break;
 761
 762     case SCOPE_REF:
 763       dump_decl (TREE_OPERAND (t, 0), flags & ~TFF_DECL_SPECIFIERS);
 764       pp_colon_colon (cxx_pp);
 765       dump_decl (TREE_OPERAND (t, 1), flags);
 766       break;
 767
 768     case ARRAY_REF:
 769       dump_decl (TREE_OPERAND (t, 0), flags);
 770       pp_cxx_left_bracket (cxx_pp);
 771       dump_decl (TREE_OPERAND (t, 1), flags);
 772       pp_cxx_right_bracket (cxx_pp);
 773       break;
 774
 775       /* So that we can do dump_decl on an aggr type.  */
 776     case RECORD_TYPE:
 777     case UNION_TYPE:
 778     case ENUMERAL_TYPE:
 779       dump_type (t, flags);
 780       break;
 781
 782     case BIT_NOT_EXPR:
 783       /* This is a pseudo destructor call which has not been folded into
 784          a PSEUDO_DTOR_EXPR yet.  */
 785       pp_cxx_complement (cxx_pp);
 786       dump_type (TREE_OPERAND (t, 0), flags);
 787       break;
 788
 789     case TYPE_EXPR:
 790       abort ();
 791       break;
 792
 793       /* These special cases are duplicated here so that other functions
 794          can feed identifiers to error and get them demangled properly.  */
 795     case IDENTIFIER_NODE:
 796       if (IDENTIFIER_TYPENAME_P (t))
 797         {
 798           pp_cxx_identifier (cxx_pp, "operator");
 799           /* Not exactly IDENTIFIER_TYPE_VALUE.  */
 800           dump_type (TREE_TYPE (t), flags);
 801           break;
 802         }
 803       else
 804         pp_cxx_tree_identifier (cxx_pp, t);
 805       break;
 806
 807     case OVERLOAD:
 808       if (OVL_CHAIN (t))
 809         {
 810           t = OVL_CURRENT (t);
 811           if (DECL_CLASS_SCOPE_P (t))
 812             {
 813               dump_type (DECL_CONTEXT (t), flags);
 814               pp_cxx_colon_colon (cxx_pp);
 815             }
 816           else if (DECL_CONTEXT (t))
 817             {
 818               dump_decl (DECL_CONTEXT (t), flags);
 819               pp_cxx_colon_colon (cxx_pp);
 820             }
 821           dump_decl (DECL_NAME (t), flags);
 822           break;
 823         }
 824
 825       /* If there's only one function, just treat it like an ordinary
 826          FUNCTION_DECL.  */
 827       t = OVL_CURRENT (t);
 828       /* Fall through.  */
 829
 830     case FUNCTION_DECL:
 831       if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
 832         dump_global_iord (t);
 833       else if (! DECL_LANG_SPECIFIC (t))
 834         pp_identifier (cxx_pp, "<internal>");
 835       else
 836         dump_function_decl (t, flags);
 837       break;
 838
 839     case TEMPLATE_DECL:
 840       dump_template_decl (t, flags);
 841       break;
 842
 843     case TEMPLATE_ID_EXPR:
 844       {
 845         tree name = TREE_OPERAND (t, 0);
 846
 847         if (is_overloaded_fn (name))
 848           name = DECL_NAME (get_first_fn (name));
 849         dump_decl (name, flags);
 850         pp_cxx_begin_template_argument_list (cxx_pp);
 851         if (TREE_OPERAND (t, 1))
 852           dump_template_argument_list (TREE_OPERAND (t, 1), flags);
 853         pp_cxx_end_template_argument_list (cxx_pp);
 854       }
 855       break;
 856
 857     case LABEL_DECL:
 858       pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
 859       break;
 860
 861     case CONST_DECL:
 862       if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
 863           || (DECL_INITIAL (t) &&
 864               TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
 865         dump_simple_decl (t, TREE_TYPE (t), flags);
 866       else if (DECL_NAME (t))
 867         dump_decl (DECL_NAME (t), flags);
 868       else if (DECL_INITIAL (t))
 869         dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
 870       else
 871         pp_identifier (cxx_pp, "<enumerator>");
 872       break;
 873
 874     case USING_DECL:
 875       pp_cxx_identifier (cxx_pp, "using");
 876       dump_type (DECL_INITIAL (t), flags);
 877       pp_cxx_colon_colon (cxx_pp);
 878       dump_decl (DECL_NAME (t), flags);
 879       break;
 880
 881     case BASELINK:
 882       dump_decl (BASELINK_FUNCTIONS (t), flags);
 883       break;
 884
 885     case NON_DEPENDENT_EXPR:
 886       dump_expr (t, flags);
 887       break;
 888
 889     case TEMPLATE_TYPE_PARM:
 890       if (flags & TFF_DECL_SPECIFIERS)
 891         pp_cxx_declaration (cxx_pp, t);
 892       else
 893         pp_type_id (cxx_pp, t);
 894       break;
 895
 896     default:
 897       pp_unsupported_tree (cxx_pp, t);
 898       /* Fall through to error.  */
 899
 900     case ERROR_MARK:
 901       pp_identifier (cxx_pp, "<declaration error>");
 902       break;
 903     }
 904 }
 905
 906 /* Dump a template declaration T under control of FLAGS. This means the
 907    'template <...> leaders plus the 'class X' or 'void fn(...)' part.  */
 908
 909 static void
 910 dump_template_decl (tree t, int flags)
 911 {
 912   tree orig_parms = DECL_TEMPLATE_PARMS (t);
 913   tree parms;
 914   int i;
 915
 916   if (flags & TFF_TEMPLATE_HEADER)
 917     {
 918       for (parms = orig_parms = nreverse (orig_parms);
 919            parms;
 920            parms = TREE_CHAIN (parms))
 921         {
 922           tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
 923           int len = TREE_VEC_LENGTH (inner_parms);
 924
 925           pp_cxx_identifier (cxx_pp, "template");
 926           pp_cxx_begin_template_argument_list (cxx_pp);
 927
 928           /* If we've shown the template prefix, we'd better show the
 929              parameters' and decl's type too.  */
 930             flags |= TFF_DECL_SPECIFIERS;
 931
 932           for (i = 0; i < len; i++)
 933             {
 934               if (i)
 935                 pp_separate_with_comma (cxx_pp);
 936               dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
 937             }
 938           pp_cxx_end_template_argument_list (cxx_pp);
 939           pp_cxx_whitespace (cxx_pp);
 940         }
 941       nreverse(orig_parms);
 942
 943       if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
 944         /* Say `template<arg> class TT' not just `template<arg> TT'.  */
 945         pp_cxx_identifier (cxx_pp, "class");
 946     }
 947
 948   if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
 949     dump_type (TREE_TYPE (t),
 950                ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
 951                 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
 952   else if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
 953     dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
 954   else if (TREE_TYPE (t) == NULL_TREE)
 955     abort ();
 956   else
 957     switch (NEXT_CODE (t))
 958     {
 959       case METHOD_TYPE:
 960       case FUNCTION_TYPE:
 961         dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
 962         break;
 963       default:
 964         /* This case can occur with some invalid code.  */
 965         dump_type (TREE_TYPE (t),
 966                    (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
 967                    | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0));
 968     }
 969 }
 970
 971 /* Pretty print a function decl. There are several ways we want to print a
 972    function declaration. The TFF_ bits in FLAGS tells us how to behave.
 973    As error can only apply the '#' flag once to give 0 and 1 for V, there
 974    is %D which doesn't print the throw specs, and %F which does.  */
 975
 976 static void
 977 dump_function_decl (tree t, int flags)
 978 {
 979   tree fntype;
 980   tree parmtypes;
 981   tree cname = NULL_TREE;
 982   tree template_args = NULL_TREE;
 983   tree template_parms = NULL_TREE;
 984   int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
 985
 986   if (TREE_CODE (t) == TEMPLATE_DECL)
 987     t = DECL_TEMPLATE_RESULT (t);
 988
 989   /* Pretty print template instantiations only.  */
 990   if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t))
 991     {
 992       tree tmpl;
 993
 994       template_args = DECL_TI_ARGS (t);
 995       tmpl = most_general_template (t);
 996       if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
 997         {
 998           template_parms = DECL_TEMPLATE_PARMS (tmpl);
 999           t = tmpl;
1000         }
1001     }
1002
1003   fntype = TREE_TYPE (t);
1004   parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1005
1006   if (DECL_CLASS_SCOPE_P (t))
1007     cname = DECL_CONTEXT (t);
1008   /* This is for partially instantiated template methods.  */
1009   else if (TREE_CODE (fntype) == METHOD_TYPE)
1010     cname = TREE_TYPE (TREE_VALUE (parmtypes));
1011
1012   if (!(flags & TFF_DECL_SPECIFIERS))
1013     /* OK */;
1014   else if (DECL_STATIC_FUNCTION_P (t))
1015     pp_cxx_identifier (cxx_pp, "static");
1016   else if (DECL_VIRTUAL_P (t))
1017     pp_cxx_identifier (cxx_pp, "virtual");
1018
1019   /* Print the return type?  */
1020   if (show_return)
1021     show_return = !DECL_CONV_FN_P (t)  && !DECL_CONSTRUCTOR_P (t)
1022                   && !DECL_DESTRUCTOR_P (t);
1023   if (show_return)
1024     dump_type_prefix (TREE_TYPE (fntype), flags);
1025
1026   /* Print the function name.  */
1027   if (cname)
1028     {
1029       dump_type (cname, flags);
1030       pp_cxx_colon_colon (cxx_pp);
1031     }
1032   else
1033     dump_scope (CP_DECL_CONTEXT (t), flags);
1034
1035   dump_function_name (t, flags);
1036
1037   if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1038     {
1039       dump_parameters (parmtypes, flags);
1040
1041       if (TREE_CODE (fntype) == METHOD_TYPE)
1042         {
1043           pp_base (cxx_pp)->padding = pp_before;
1044           pp_cxx_cv_qualifier_seq
1045             (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))));
1046         }
1047
1048       if (flags & TFF_EXCEPTION_SPECIFICATION)
1049         {
1050           pp_base (cxx_pp)->padding = pp_before;
1051           dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags);
1052         }
1053
1054       if (show_return)
1055         dump_type_suffix (TREE_TYPE (fntype), flags);
1056     }
1057
1058   /* If T is a template instantiation, dump the parameter binding.  */
1059   if (template_parms != NULL_TREE && template_args != NULL_TREE)
1060     {
1061       pp_cxx_whitespace (cxx_pp);
1062       pp_cxx_left_bracket (cxx_pp);
1063       pp_cxx_identifier (cxx_pp, "with");
1064       pp_cxx_whitespace (cxx_pp);
1065       dump_template_bindings (template_parms, template_args);
1066       pp_cxx_right_bracket (cxx_pp);
1067     }
1068 }
1069
1070 /* Print a parameter list. If this is for a member function, the
1071    member object ptr (and any other hidden args) should have
1072    already been removed.  */
1073
1074 static void
1075 dump_parameters (tree parmtypes, int flags)
1076 {
1077   int first;
1078
1079   pp_cxx_left_paren (cxx_pp);
1080
1081   for (first = 1; parmtypes != void_list_node;
1082        parmtypes = TREE_CHAIN (parmtypes))
1083     {
1084       if (!first)
1085         pp_separate_with_comma (cxx_pp);
1086       first = 0;
1087       if (!parmtypes)
1088         {
1089           pp_cxx_identifier (cxx_pp, "...");
1090           break;
1091         }
1092       dump_type (TREE_VALUE (parmtypes), flags);
1093
1094       if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1095         {
1096           pp_cxx_whitespace (cxx_pp);
1097           pp_equal (cxx_pp);
1098           pp_cxx_whitespace (cxx_pp);
1099           dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1100         }
1101     }
1102
1103   pp_cxx_right_paren (cxx_pp);
1104 }
1105
1106 /* Print an exception specification. T is the exception specification.  */
1107
1108 static void
1109 dump_exception_spec (tree t, int flags)
1110 {
1111   if (t)
1112     {
1113       pp_cxx_identifier (cxx_pp, "throw");
1114       pp_cxx_whitespace (cxx_pp);
1115       pp_cxx_left_paren (cxx_pp);
1116       if (TREE_VALUE (t) != NULL_TREE)
1117         while (1)
1118           {
1119             dump_type (TREE_VALUE (t), flags);
1120             t = TREE_CHAIN (t);
1121             if (!t)
1122               break;
1123             pp_separate_with_comma (cxx_pp);
1124           }
1125       pp_cxx_right_paren (cxx_pp);
1126     }
1127 }
1128
1129 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1130    and destructors properly.  */
1131
1132 static void
1133 dump_function_name (tree t, int flags)
1134 {
1135   tree name = DECL_NAME (t);
1136
1137   /* We can get here with a decl that was synthesized by language-
1138      independent machinery (e.g. coverage.c) in which case it won't
1139      have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1140      will crash.  In this case it is safe just to print out the
1141      literal name.  */
1142   if (!DECL_LANG_SPECIFIC (t))
1143     {
1144       pp_cxx_tree_identifier (cxx_pp, name);
1145       return;
1146     }
1147
1148   if (TREE_CODE (t) == TEMPLATE_DECL)
1149     t = DECL_TEMPLATE_RESULT (t);
1150
1151   /* Don't let the user see __comp_ctor et al.  */
1152   if (DECL_CONSTRUCTOR_P (t)
1153       || DECL_DESTRUCTOR_P (t))
1154     name = constructor_name (DECL_CONTEXT (t));
1155
1156   if (DECL_DESTRUCTOR_P (t))
1157     {
1158       pp_cxx_complement (cxx_pp);
1159       dump_decl (name, TFF_PLAIN_IDENTIFIER);
1160     }
1161   else if (DECL_CONV_FN_P (t))
1162     {
1163       /* This cannot use the hack that the operator's return
1164          type is stashed off of its name because it may be
1165          used for error reporting.  In the case of conflicting
1166          declarations, both will have the same name, yet
1167          the types will be different, hence the TREE_TYPE field
1168          of the first name will be clobbered by the second.  */
1169       pp_cxx_identifier (cxx_pp, "operator");
1170       dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1171     }
1172   else if (IDENTIFIER_OPNAME_P (name))
1173     pp_cxx_tree_identifier (cxx_pp, name);
1174   else
1175     dump_decl (name, flags);
1176
1177   if (DECL_TEMPLATE_INFO (t)
1178       && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1179       && (DECL_TEMPLATE_SPECIALIZATION (t)
1180           || TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1181           || DECL_TEMPLATE_SPECIALIZATION (DECL_TI_TEMPLATE (t))
1182           || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1183     dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
1184 }
1185
1186 /* Dump the template parameters from the template info INFO under control of
1187    FLAGS. PRIMARY indicates whether this is a primary template decl, or
1188    specialization (partial or complete). For partial specializations we show
1189    the specialized parameter values. For a primary template we show no
1190    decoration.  */
1191
1192 static void
1193 dump_template_parms (tree info, int primary, int flags)
1194 {
1195   tree args = info ? TI_ARGS (info) : NULL_TREE;
1196
1197   if (primary && flags & TFF_TEMPLATE_NAME)
1198     return;
1199   flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1200   pp_cxx_begin_template_argument_list (cxx_pp);
1201
1202   /* Be careful only to print things when we have them, so as not
1203          to crash producing error messages.  */
1204   if (args && !primary)
1205     {
1206       int len, ix;
1207
1208       if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
1209         args = TREE_VEC_ELT (args, TREE_VEC_LENGTH (args) - 1);
1210
1211       len = TREE_VEC_LENGTH (args);
1212
1213       for (ix = 0; ix != len; ix++)
1214         {
1215           tree arg = TREE_VEC_ELT (args, ix);
1216
1217           if (ix)
1218             pp_separate_with_comma (cxx_pp);
1219
1220           if (!arg)
1221             pp_identifier (cxx_pp, "<template parameter error>");
1222           else
1223             dump_template_argument (arg, flags);
1224         }
1225     }
1226   else if (primary)
1227     {
1228       tree tpl = TI_TEMPLATE (info);
1229       tree parms = DECL_TEMPLATE_PARMS (tpl);
1230       int len, ix;
1231
1232       parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1233       len = parms ? TREE_VEC_LENGTH (parms) : 0;
1234
1235       for (ix = 0; ix != len; ix++)
1236         {
1237           tree parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1238
1239           if (ix)
1240             pp_separate_with_comma (cxx_pp);
1241
1242           dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
1243         }
1244     }
1245   pp_cxx_end_template_argument_list (cxx_pp);
1246 }
1247
1248 /* Print out a list of initializers (subr of dump_expr).  */
1249
1250 static void
1251 dump_expr_list (tree l, int flags)
1252 {
1253   while (l)
1254     {
1255       dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1256       l = TREE_CHAIN (l);
1257       if (l)
1258         pp_separate_with_comma (cxx_pp);
1259     }
1260 }
1261
1262 /* Print out an expression E under control of FLAGS.  */
1263
1264 static void
1265 dump_expr (tree t, int flags)
1266 {
1267   if (t == 0)
1268     return;
1269
1270   switch (TREE_CODE (t))
1271     {
1272     case VAR_DECL:
1273     case PARM_DECL:
1274     case FIELD_DECL:
1275     case CONST_DECL:
1276     case FUNCTION_DECL:
1277     case TEMPLATE_DECL:
1278     case NAMESPACE_DECL:
1279     case OVERLOAD:
1280     case IDENTIFIER_NODE:
1281       dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS);
1282       break;
1283
1284     case INTEGER_CST:
1285     case STRING_CST:
1286     case REAL_CST:
1287        pp_c_constant (pp_c_base (cxx_pp), t);
1288       break;
1289
1290     case THROW_EXPR:
1291       pp_cxx_identifier (cxx_pp, "throw");
1292       dump_expr (TREE_OPERAND (t, 0), flags);
1293       break;
1294
1295     case PTRMEM_CST:
1296       pp_ampersand (cxx_pp);
1297       dump_type (PTRMEM_CST_CLASS (t), flags);
1298       pp_cxx_colon_colon (cxx_pp);
1299       pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1300       break;
1301
1302     case COMPOUND_EXPR:
1303       pp_cxx_left_paren (cxx_pp);
1304       dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1305       pp_separate_with_comma (cxx_pp);
1306       dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1307       pp_cxx_right_paren (cxx_pp);
1308       break;
1309
1310     case COND_EXPR:
1311       pp_cxx_left_paren (cxx_pp);
1312       dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1313       pp_string (cxx_pp, " ? ");
1314       dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1315       pp_string (cxx_pp, " : ");
1316       dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1317       pp_cxx_right_paren (cxx_pp);
1318       break;
1319
1320     case SAVE_EXPR:
1321       if (TREE_HAS_CONSTRUCTOR (t))
1322         {
1323           pp_cxx_identifier (cxx_pp, "new");
1324           pp_cxx_whitespace (cxx_pp);
1325           dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1326         }
1327       else
1328         dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1329       break;
1330
1331     case AGGR_INIT_EXPR:
1332       {
1333         tree fn = NULL_TREE;
1334
1335         if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR)
1336           fn = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
1337
1338         if (fn && TREE_CODE (fn) == FUNCTION_DECL)
1339           {
1340             if (DECL_CONSTRUCTOR_P (fn))
1341               pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (TREE_TYPE (t)));
1342             else
1343               dump_decl (fn, 0);
1344           }
1345         else
1346           dump_expr (TREE_OPERAND (t, 0), 0);
1347       }
1348       pp_cxx_left_paren (cxx_pp);
1349       if (TREE_OPERAND (t, 1))
1350         dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
1351       pp_cxx_right_paren (cxx_pp);
1352       break;
1353
1354     case CALL_EXPR:
1355       {
1356         tree fn = TREE_OPERAND (t, 0);
1357         tree args = TREE_OPERAND (t, 1);
1358
1359         if (TREE_CODE (fn) == ADDR_EXPR)
1360           fn = TREE_OPERAND (fn, 0);
1361
1362         if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE)
1363           {
1364             tree ob = TREE_VALUE (args);
1365             if (TREE_CODE (ob) == ADDR_EXPR)
1366               {
1367                 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1368                 pp_dot (cxx_pp);
1369               }
1370             else if (TREE_CODE (ob) != PARM_DECL
1371                      || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1372               {
1373                 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1374                 pp_arrow (cxx_pp);
1375               }
1376             args = TREE_CHAIN (args);
1377           }
1378         dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
1379         pp_cxx_left_paren (cxx_pp);
1380         dump_expr_list (args, flags);
1381         pp_cxx_right_paren (cxx_pp);
1382       }
1383       break;
1384
1385     case NEW_EXPR:
1386       {
1387         tree type = TREE_OPERAND (t, 1);
1388         tree init = TREE_OPERAND (t, 2);
1389         if (NEW_EXPR_USE_GLOBAL (t))
1390           pp_cxx_colon_colon (cxx_pp);
1391         pp_cxx_identifier (cxx_pp, "new");
1392         if (TREE_OPERAND (t, 0))
1393           {
1394             pp_cxx_left_paren (cxx_pp);
1395             dump_expr_list (TREE_OPERAND (t, 0), flags);
1396             pp_cxx_right_paren (cxx_pp);
1397             pp_cxx_whitespace (cxx_pp);
1398           }
1399         if (TREE_CODE (type) == ARRAY_REF)
1400           type = build_cplus_array_type
1401             (TREE_OPERAND (type, 0),
1402              build_index_type (fold (build (MINUS_EXPR, integer_type_node,
1403                                             TREE_OPERAND (type, 1),
1404                                             integer_one_node))));
1405         dump_type (type, flags);
1406         if (init)
1407           {
1408             pp_cxx_left_paren (cxx_pp);
1409             if (TREE_CODE (init) == TREE_LIST)
1410               dump_expr_list (init, flags);
1411             else if (init == void_zero_node)
1412               /* This representation indicates an empty initializer,
1413                  e.g.: "new int()".  */
1414               ;
1415             else
1416               dump_expr (init, flags);
1417             pp_cxx_right_paren (cxx_pp);
1418           }
1419       }
1420       break;
1421
1422     case TARGET_EXPR:
1423       /* Note that this only works for G++ target exprs.  If somebody
1424          builds a general TARGET_EXPR, there's no way to represent that
1425          it initializes anything other that the parameter slot for the
1426          default argument.  Note we may have cleared out the first
1427          operand in expand_expr, so don't go killing ourselves.  */
1428       if (TREE_OPERAND (t, 1))
1429         dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1430       break;
1431
1432     case INIT_EXPR:
1433     case MODIFY_EXPR:
1434     case PLUS_EXPR:
1435     case MINUS_EXPR:
1436     case MULT_EXPR:
1437     case TRUNC_DIV_EXPR:
1438     case TRUNC_MOD_EXPR:
1439     case MIN_EXPR:
1440     case MAX_EXPR:
1441     case LSHIFT_EXPR:
1442     case RSHIFT_EXPR:
1443     case BIT_IOR_EXPR:
1444     case BIT_XOR_EXPR:
1445     case BIT_AND_EXPR:
1446     case TRUTH_ANDIF_EXPR:
1447     case TRUTH_ORIF_EXPR:
1448     case LT_EXPR:
1449     case LE_EXPR:
1450     case GT_EXPR:
1451     case GE_EXPR:
1452     case EQ_EXPR:
1453     case NE_EXPR:
1454     case EXACT_DIV_EXPR:
1455       dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags);
1456       break;
1457
1458     case CEIL_DIV_EXPR:
1459     case FLOOR_DIV_EXPR:
1460     case ROUND_DIV_EXPR:
1461       dump_binary_op ("/", t, flags);
1462       break;
1463
1464     case CEIL_MOD_EXPR:
1465     case FLOOR_MOD_EXPR:
1466     case ROUND_MOD_EXPR:
1467       dump_binary_op ("%", t, flags);
1468       break;
1469
1470     case COMPONENT_REF:
1471       {
1472         tree ob = TREE_OPERAND (t, 0);
1473         if (TREE_CODE (ob) == INDIRECT_REF)
1474           {
1475             ob = TREE_OPERAND (ob, 0);
1476             if (TREE_CODE (ob) != PARM_DECL
1477                 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1478               {
1479                 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1480                 pp_cxx_arrow (cxx_pp);
1481               }
1482           }
1483         else
1484           {
1485             dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1486             pp_cxx_dot (cxx_pp);
1487           }
1488         dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1489       }
1490       break;
1491
1492     case ARRAY_REF:
1493       dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1494       pp_cxx_left_bracket (cxx_pp);
1495       dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1496       pp_cxx_right_bracket (cxx_pp);
1497       break;
1498
1499     case CONVERT_EXPR:
1500       if (TREE_TYPE (t) && VOID_TYPE_P (TREE_TYPE (t)))
1501         {
1502           pp_cxx_left_paren (cxx_pp);
1503           dump_type (TREE_TYPE (t), flags);
1504           pp_cxx_right_paren (cxx_pp);
1505           dump_expr (TREE_OPERAND (t, 0), flags);
1506         }
1507       else
1508         dump_unary_op ("+", t, flags);
1509       break;
1510
1511     case ADDR_EXPR:
1512       if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1513           || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
1514           /* An ADDR_EXPR can have reference type.  In that case, we
1515              shouldn't print the `&' doing so indicates to the user
1516              that the expression has pointer type.  */
1517           || (TREE_TYPE (t)
1518               && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
1519         dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1520       else
1521         dump_unary_op ("&", t, flags);
1522       break;
1523
1524     case INDIRECT_REF:
1525       if (TREE_HAS_CONSTRUCTOR (t))
1526         {
1527           t = TREE_OPERAND (t, 0);
1528           my_friendly_assert (TREE_CODE (t) == CALL_EXPR, 237);
1529           dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1530           pp_cxx_left_paren (cxx_pp);
1531           dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
1532           pp_cxx_right_paren (cxx_pp);
1533         }
1534       else
1535         {
1536           if (TREE_OPERAND (t,0) != NULL_TREE
1537               && TREE_TYPE (TREE_OPERAND (t, 0))
1538               && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
1539             dump_expr (TREE_OPERAND (t, 0), flags);
1540           else
1541             dump_unary_op ("*", t, flags);
1542         }
1543       break;
1544
1545     case NEGATE_EXPR:
1546     case BIT_NOT_EXPR:
1547     case TRUTH_NOT_EXPR:
1548     case PREDECREMENT_EXPR:
1549     case PREINCREMENT_EXPR:
1550       dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags);
1551       break;
1552
1553     case POSTDECREMENT_EXPR:
1554     case POSTINCREMENT_EXPR:
1555       pp_cxx_left_paren (cxx_pp);
1556       dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1557       pp_cxx_identifier (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
1558       pp_cxx_right_paren (cxx_pp);
1559       break;
1560
1561     case NON_LVALUE_EXPR:
1562       /* FIXME: This is a KLUDGE workaround for a parsing problem.  There
1563          should be another level of INDIRECT_REF so that I don't have to do
1564          this.  */
1565       if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
1566         {
1567           tree next = TREE_TYPE (TREE_TYPE (t));
1568
1569           while (TREE_CODE (next) == POINTER_TYPE)
1570             next = TREE_TYPE (next);
1571
1572           if (TREE_CODE (next) == FUNCTION_TYPE)
1573             {
1574               if (flags & TFF_EXPR_IN_PARENS)
1575                 pp_cxx_left_paren (cxx_pp);
1576               pp_cxx_star (cxx_pp);
1577               dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1578               if (flags & TFF_EXPR_IN_PARENS)
1579                 pp_cxx_right_paren (cxx_pp);
1580               break;
1581             }
1582           /* Else fall through.  */
1583         }
1584       dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1585       break;
1586
1587     case NOP_EXPR:
1588       {
1589         tree op = TREE_OPERAND (t, 0);
1590
1591         if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
1592           {
1593             /* It is a cast, but we cannot tell whether it is a
1594                reinterpret or static cast. Use the C style notation.  */
1595             if (flags & TFF_EXPR_IN_PARENS)
1596               pp_cxx_left_paren (cxx_pp);
1597             pp_cxx_left_paren (cxx_pp);
1598             dump_type (TREE_TYPE (t), flags);
1599             pp_cxx_right_paren (cxx_pp);
1600             dump_expr (op, flags | TFF_EXPR_IN_PARENS);
1601             if (flags & TFF_EXPR_IN_PARENS)
1602               pp_cxx_right_paren (cxx_pp);
1603           }
1604         else
1605           dump_expr (op, flags);
1606         break;
1607       }
1608
1609     case CONSTRUCTOR:
1610       if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
1611         {
1612           tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
1613
1614           if (integer_zerop (idx))
1615             {
1616               /* A NULL pointer-to-member constant.  */
1617               pp_cxx_left_paren (cxx_pp);
1618               pp_cxx_left_paren (cxx_pp);
1619               dump_type (TREE_TYPE (t), flags);
1620               pp_cxx_right_paren (cxx_pp);
1621               pp_character (cxx_pp, '0');
1622               pp_cxx_right_paren (cxx_pp);
1623               break;
1624             }
1625           else if (host_integerp (idx, 0))
1626             {
1627               tree virtuals;
1628               unsigned HOST_WIDE_INT n;
1629
1630               t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
1631               t = TYPE_METHOD_BASETYPE (t);
1632               virtuals = TYPE_BINFO_VIRTUALS (TYPE_MAIN_VARIANT (t));
1633
1634               n = tree_low_cst (idx, 0);
1635
1636               /* Map vtable index back one, to allow for the null pointer to
1637                  member.  */
1638               --n;
1639
1640               while (n > 0 && virtuals)
1641                 {
1642                   --n;
1643                   virtuals = TREE_CHAIN (virtuals);
1644                 }
1645               if (virtuals)
1646                 {
1647                   dump_expr (BV_FN (virtuals),
1648                              flags | TFF_EXPR_IN_PARENS);
1649                   break;
1650                 }
1651             }
1652         }
1653       if (TREE_TYPE (t) && !CONSTRUCTOR_ELTS (t))
1654         {
1655           dump_type (TREE_TYPE (t), 0);
1656           pp_cxx_left_paren (cxx_pp);
1657           pp_cxx_right_paren (cxx_pp);
1658         }
1659       else
1660         {
1661           pp_cxx_left_brace (cxx_pp);
1662           dump_expr_list (CONSTRUCTOR_ELTS (t), flags);
1663           pp_cxx_right_brace (cxx_pp);
1664         }
1665
1666       break;
1667
1668     case OFFSET_REF:
1669       {
1670         tree ob = TREE_OPERAND (t, 0);
1671         if (is_dummy_object (ob))
1672           {
1673             t = TREE_OPERAND (t, 1);
1674             if (TREE_CODE (t) == FUNCTION_DECL)
1675               /* A::f */
1676               dump_expr (t, flags | TFF_EXPR_IN_PARENS);
1677             else if (BASELINK_P (t))
1678               dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
1679                          flags | TFF_EXPR_IN_PARENS);
1680             else
1681               dump_decl (t, flags);
1682           }
1683         else
1684           {
1685             if (TREE_CODE (ob) == INDIRECT_REF)
1686               {
1687                 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1688                 pp_cxx_arrow (cxx_pp);
1689                 pp_cxx_star (cxx_pp);
1690               }
1691             else
1692               {
1693                 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1694                 pp_cxx_dot (cxx_pp);
1695                 pp_cxx_star (cxx_pp);
1696               }
1697             dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1698           }
1699         break;
1700       }
1701
1702     case TEMPLATE_PARM_INDEX:
1703       dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
1704       break;
1705
1706     case SCOPE_REF:
1707       dump_type (TREE_OPERAND (t, 0), flags);
1708       pp_cxx_colon_colon (cxx_pp);
1709       dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
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       char *new_prefix = diagnostic->location.file
2145         ? file_name_as_prefix (diagnostic->location.file)
2146         : NULL;
2147
2148       pp_base_set_prefix (context->printer, new_prefix);
2149
2150       if (current_function_decl == NULL)
2151         pp_base_string (context->printer, "At global scope:");
2152       else
2153         pp_printf (context->printer, "In %s `%s':",
2154                    function_category (current_function_decl),
2155                    cxx_printable_name (current_function_decl, 2));
2156       pp_base_newline (context->printer);
2157
2158       diagnostic_set_last_function (context);
2159       pp_base_destroy_prefix (context->printer);
2160       context->printer->prefix = old_prefix;
2161     }
2162 }
2163
2164 /* Returns a description of FUNCTION using standard terminology.  */
2165 static const char *
2166 function_category (tree fn)
2167 {
2168   if (DECL_FUNCTION_MEMBER_P (fn))
2169     {
2170       if (DECL_STATIC_FUNCTION_P (fn))
2171         return "static member function";
2172       else if (DECL_COPY_CONSTRUCTOR_P (fn))
2173         return "copy constructor";
2174       else if (DECL_CONSTRUCTOR_P (fn))
2175         return "constructor";
2176       else if (DECL_DESTRUCTOR_P (fn))
2177         return "destructor";
2178       else
2179         return "member function";
2180     }
2181   else
2182     return "function";
2183 }
2184
2185 /* Report the full context of a current template instantiation,
2186    onto BUFFER.  */
2187 static void
2188 print_instantiation_full_context (diagnostic_context *context)
2189 {
2190   tree p = current_instantiation ();
2191   location_t location = input_location;
2192
2193   if (p)
2194     {
2195       if (current_function_decl != TINST_DECL (p)
2196           && current_function_decl != NULL_TREE)
2197         /* We can get here during the processing of some synthesized
2198            method.  Then, TINST_DECL (p) will be the function that's causing
2199            the synthesis.  */
2200         ;
2201       else
2202         {
2203           if (current_function_decl == TINST_DECL (p))
2204             /* Avoid redundancy with the the "In function" line.  */;
2205           else
2206             pp_verbatim (context->printer,
2207                          "%s: In instantiation of `%s':\n", location.file,
2208                          decl_as_string (TINST_DECL (p),
2209                                          TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2210
2211           location = *EXPR_LOCUS (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   for (; t; t = TREE_CHAIN (t))
2225     {
2226       pp_verbatim (context->printer, "%s:%d:   instantiated from `%s'\n",
2227                    loc.file, loc.line,
2228                    decl_as_string (TINST_DECL (t),
2229                                    TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2230       loc = *EXPR_LOCUS (t);
2231     }
2232   pp_verbatim (context->printer, "%s:%d:   instantiated from here\n",
2233                loc.file, loc.line);
2234 }
2235
2236 /* Called from cp_thing to print the template context for an error.  */
2237 static void
2238 maybe_print_instantiation_context (diagnostic_context *context)
2239 {
2240   if (!problematic_instantiation_changed () || current_instantiation () == 0)
2241     return;
2242
2243   record_last_problematic_instantiation ();
2244   print_instantiation_full_context (context);
2245 }
2246
2247 /* Report the bare minimum context of a template instantiation.  */
2248 void
2249 print_instantiation_context (void)
2250 {
2251   print_instantiation_partial_context
2252     (global_dc, current_instantiation (), input_location);
2253   diagnostic_flush_buffer (global_dc);
2254 }
2255 \f
2256 /* Called from output_format -- during diagnostic message processing --
2257    to handle C++ specific format specifier with the following meanings:
2258    %A   function argument-list.
2259    %C   tree code.
2260    %D   declaration.
2261    %E   expression.
2262    %F   function declaration.
2263    %L   language as used in extern "lang".
2264    %O   binary operator.
2265    %P   function parameter whose position is indicated by an integer.
2266    %Q   assignment operator.
2267    %T   type.
2268    %V   cv-qualifier.  */
2269 static bool
2270 cp_printer (pretty_printer *pp, text_info *text)
2271 {
2272   int verbose = 0;
2273   const char *result;
2274 #define next_tree    va_arg (*text->args_ptr, tree)
2275 #define next_tcode   va_arg (*text->args_ptr, enum tree_code)
2276 #define next_lang    va_arg (*text->args_ptr, enum languages)
2277 #define next_int     va_arg (*text->args_ptr, int)
2278
2279   if (*text->format_spec == '+')
2280     ++text->format_spec;
2281   if (*text->format_spec == '#')
2282     {
2283       verbose = 1;
2284       ++text->format_spec;
2285     }
2286
2287   switch (*text->format_spec)
2288     {
2289     case 'A': result = args_to_string (next_tree, verbose);     break;
2290     case 'C': result = code_to_string (next_tcode);             break;
2291     case 'D': result = decl_to_string (next_tree, verbose);     break;
2292     case 'E': result = expr_to_string (next_tree);              break;
2293     case 'F': result = fndecl_to_string (next_tree, verbose);   break;
2294     case 'L': result = language_to_string (next_lang);          break;
2295     case 'O': result = op_to_string (next_tcode);               break;
2296     case 'P': result = parm_to_string (next_int);               break;
2297     case 'Q': result = assop_to_string (next_tcode);            break;
2298     case 'T': result = type_to_string (next_tree, verbose);     break;
2299     case 'V': result = cv_to_string (next_tree, verbose);       break;
2300
2301     default:
2302       return false;
2303     }
2304
2305   pp_base_string (pp, result);
2306   return true;
2307 #undef next_tree
2308 #undef next_tcode
2309 #undef next_lang
2310 #undef next_int
2311 }
2312
2313 /* These are temporary wrapper functions which handle the historic
2314    behavior of cp_*_at.  */
2315
2316 static tree
2317 locate_error (const char *msgid, va_list ap)
2318 {
2319   tree here = 0, t;
2320   int plus = 0;
2321   const char *f;
2322
2323   for (f = msgid; *f; f++)
2324     {
2325       plus = 0;
2326       if (*f == '%')
2327         {
2328           f++;
2329           if (*f == '+')
2330             f++, plus = 1;
2331           if (*f == '#')
2332             f++;
2333
2334           switch (*f)
2335             {
2336               /* Just ignore these possibilities.  */
2337             case '%':                                           break;
2338             case 'P':
2339             case 'd':   (void) va_arg (ap, int);                break;
2340             case 's':   (void) va_arg (ap, char *);             break;
2341             case 'L':   (void) va_arg (ap, enum languages);     break;
2342             case 'C':
2343             case 'O':
2344             case 'Q':   (void) va_arg (ap, enum tree_code);     break;
2345
2346               /* These take a tree, which may be where the error is
2347                  located.  */
2348             case 'A':
2349             case 'D':
2350             case 'E':
2351             case 'F':
2352             case 'T':
2353             case 'V':
2354               t = va_arg (ap, tree);
2355               if (!here || plus)
2356                 here = t;
2357               break;
2358
2359             default:
2360               errorcount = 0;  /* damn ICE suppression */
2361               internal_error ("unexpected letter `%c' in locate_error\n", *f);
2362             }
2363         }
2364     }
2365
2366   if (here == 0)
2367     here = va_arg (ap, tree);
2368
2369   return here;
2370 }
2371
2372
2373 void
2374 cp_error_at (const char *msgid, ...)
2375 {
2376   tree here;
2377   diagnostic_info diagnostic;
2378   va_list ap;
2379
2380   va_start (ap, msgid);
2381   here = locate_error (msgid, ap);
2382   va_end (ap);
2383
2384   va_start (ap, msgid);
2385   diagnostic_set_info (&diagnostic, msgid, &ap,
2386                        location_of (here), DK_ERROR);
2387   report_diagnostic (&diagnostic);
2388   va_end (ap);
2389 }
2390
2391 void
2392 cp_warning_at (const char *msgid, ...)
2393 {
2394   tree here;
2395   diagnostic_info diagnostic;
2396   va_list ap;
2397
2398   va_start (ap, msgid);
2399   here = locate_error (msgid, ap);
2400   va_end (ap);
2401
2402   va_start (ap, msgid);
2403   diagnostic_set_info (&diagnostic, msgid, &ap,
2404                        location_of (here), DK_WARNING);
2405   report_diagnostic (&diagnostic);
2406   va_end (ap);
2407 }
2408
2409 void
2410 cp_pedwarn_at (const char *msgid, ...)
2411 {
2412   tree here;
2413   diagnostic_info diagnostic;
2414   va_list ap;
2415
2416   va_start (ap, msgid);
2417   here = locate_error (msgid, ap);
2418   va_end (ap);
2419
2420   va_start (ap, msgid);
2421   diagnostic_set_info (&diagnostic, msgid, &ap,
2422                        location_of (here), pedantic_error_kind());
2423   report_diagnostic (&diagnostic);
2424   va_end (ap);
2425 }