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