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