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     case TEMPLATE_TYPE_PARM:
 944       if (flags & TFF_DECL_SPECIFIERS)
 945         pp_cxx_declaration (cxx_pp, t);
 946       else
 947         pp_type_id (cxx_pp, t);
 948       break;
 949
 950     default:
 951       pp_unsupported_tree (cxx_pp, t);
 952       /* Fall through to error.  */
 953
 954     case ERROR_MARK:
 955       pp_identifier (cxx_pp, "<declaration error>");
 956       break;
 957     }
 958 }
 959
 960 /* Dump a template declaration T under control of FLAGS. This means the
 961    'template <...> leaders plus the 'class X' or 'void fn(...)' part.  */
 962
 963 static void
 964 dump_template_decl (tree t, int flags)
 965 {
 966   tree orig_parms = DECL_TEMPLATE_PARMS (t);
 967   tree parms;
 968   int i;
 969
 970   if (flags & TFF_TEMPLATE_HEADER)
 971     {
 972       for (parms = orig_parms = nreverse (orig_parms);
 973            parms;
 974            parms = TREE_CHAIN (parms))
 975         {
 976           tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
 977           int len = TREE_VEC_LENGTH (inner_parms);
 978
 979           pp_string (cxx_pp, "template<");
 980
 981           /* If we've shown the template prefix, we'd better show the
 982              parameters' and decl's type too.  */
 983             flags |= TFF_DECL_SPECIFIERS;
 984
 985           for (i = 0; i < len; i++)
 986             {
 987               if (i)
 988                 pp_separate_with_comma (cxx_pp);
 989               dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
 990             }
 991           pp_template_argument_list_end (cxx_pp);
 992           pp_space (cxx_pp);
 993         }
 994       nreverse(orig_parms);
 995
 996       if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
 997         /* Say `template<arg> class TT' not just `template<arg> TT'.  */
 998         pp_string (cxx_pp, "class ");
 999     }
1000
1001   if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
1002     dump_type (TREE_TYPE (t),
1003                ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1004                 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
1005   else if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
1006     dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
1007   else if (TREE_TYPE (t) == NULL_TREE)
1008     abort ();
1009   else
1010     switch (NEXT_CODE (t))
1011     {
1012       case METHOD_TYPE:
1013       case FUNCTION_TYPE:
1014         dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
1015         break;
1016       default:
1017         /* This case can occur with some invalid code.  */
1018         dump_type (TREE_TYPE (t),
1019                    (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1020                    | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0));
1021     }
1022 }
1023
1024 /* Pretty print a function decl. There are several ways we want to print a
1025    function declaration. The TFF_ bits in FLAGS tells us how to behave.
1026    As error can only apply the '#' flag once to give 0 and 1 for V, there
1027    is %D which doesn't print the throw specs, and %F which does.  */
1028
1029 static void
1030 dump_function_decl (tree t, int flags)
1031 {
1032   tree fntype;
1033   tree parmtypes;
1034   tree cname = NULL_TREE;
1035   tree template_args = NULL_TREE;
1036   tree template_parms = NULL_TREE;
1037   int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
1038
1039   if (TREE_CODE (t) == TEMPLATE_DECL)
1040     t = DECL_TEMPLATE_RESULT (t);
1041
1042   /* Pretty print template instantiations only.  */
1043   if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t))
1044     {
1045       tree tmpl;
1046
1047       template_args = DECL_TI_ARGS (t);
1048       tmpl = most_general_template (t);
1049       if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1050         {
1051           template_parms = DECL_TEMPLATE_PARMS (tmpl);
1052           t = tmpl;
1053         }
1054     }
1055
1056   fntype = TREE_TYPE (t);
1057   parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1058
1059   if (DECL_CLASS_SCOPE_P (t))
1060     cname = DECL_CONTEXT (t);
1061   /* This is for partially instantiated template methods.  */
1062   else if (TREE_CODE (fntype) == METHOD_TYPE)
1063     cname = TREE_TYPE (TREE_VALUE (parmtypes));
1064
1065   if (!(flags & TFF_DECL_SPECIFIERS))
1066     /* OK */;
1067   else if (DECL_STATIC_FUNCTION_P (t))
1068     pp_identifier (cxx_pp, "static ");
1069   else if (DECL_VIRTUAL_P (t))
1070     pp_identifier (cxx_pp, "virtual ");
1071
1072   /* Print the return type?  */
1073   if (show_return)
1074     show_return = !DECL_CONV_FN_P (t)  && !DECL_CONSTRUCTOR_P (t)
1075                   && !DECL_DESTRUCTOR_P (t);
1076   if (show_return)
1077     {
1078       dump_type_prefix (TREE_TYPE (fntype), flags);
1079       pp_space (cxx_pp);
1080     }
1081
1082   /* Print the function name.  */
1083   if (cname)
1084     {
1085       dump_type (cname, flags);
1086       pp_colon_colon (cxx_pp);
1087     }
1088   else
1089     dump_scope (CP_DECL_CONTEXT (t), flags);
1090
1091   dump_function_name (t, flags);
1092
1093   if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1094     {
1095       dump_parameters (parmtypes, flags);
1096
1097       if (TREE_CODE (fntype) == METHOD_TYPE)
1098         dump_qualifiers (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))),
1099                          before);
1100
1101       if (flags & TFF_EXCEPTION_SPECIFICATION)
1102         dump_exception_spec (TYPE_RAISES_EXCEPTIONS (fntype), flags);
1103
1104       if (show_return)
1105         dump_type_suffix (TREE_TYPE (fntype), flags);
1106     }
1107
1108   /* If T is a template instantiation, dump the parameter binding.  */
1109   if (template_parms != NULL_TREE && template_args != NULL_TREE)
1110     {
1111       pp_string (cxx_pp, " [with ");
1112       dump_template_bindings (template_parms, template_args);
1113       pp_right_bracket (cxx_pp);
1114     }
1115 }
1116
1117 /* Print a parameter list. If this is for a member function, the
1118    member object ptr (and any other hidden args) should have
1119    already been removed.  */
1120
1121 static void
1122 dump_parameters (tree parmtypes, int flags)
1123 {
1124   int first;
1125
1126   pp_left_paren (cxx_pp);
1127
1128   for (first = 1; parmtypes != void_list_node;
1129        parmtypes = TREE_CHAIN (parmtypes))
1130     {
1131       if (!first)
1132         pp_separate_with_comma (cxx_pp);
1133       first = 0;
1134       if (!parmtypes)
1135         {
1136           pp_identifier (cxx_pp, "...");
1137           break;
1138         }
1139       dump_type (TREE_VALUE (parmtypes), flags);
1140
1141       if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1142         {
1143           pp_string (cxx_pp, " = ");
1144           dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1145         }
1146     }
1147
1148   pp_right_paren (cxx_pp);
1149 }
1150
1151 /* Print an exception specification. T is the exception specification.  */
1152
1153 static void
1154 dump_exception_spec (tree t, int flags)
1155 {
1156   if (t)
1157     {
1158       pp_string (cxx_pp, " throw (");
1159       if (TREE_VALUE (t) != NULL_TREE)
1160         while (1)
1161           {
1162             dump_type (TREE_VALUE (t), flags);
1163             t = TREE_CHAIN (t);
1164             if (!t)
1165               break;
1166             pp_separate_with_comma (cxx_pp);
1167           }
1168       pp_right_paren (cxx_pp);
1169     }
1170 }
1171
1172 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1173    and destructors properly.  */
1174
1175 static void
1176 dump_function_name (tree t, int flags)
1177 {
1178   tree name = DECL_NAME (t);
1179
1180   if (TREE_CODE (t) == TEMPLATE_DECL)
1181     t = DECL_TEMPLATE_RESULT (t);
1182
1183   /* Don't let the user see __comp_ctor et al.  */
1184   if (DECL_CONSTRUCTOR_P (t)
1185       || DECL_DESTRUCTOR_P (t))
1186     name = constructor_name (DECL_CONTEXT (t));
1187
1188   if (DECL_DESTRUCTOR_P (t))
1189     {
1190       pp_complement (cxx_pp);
1191       dump_decl (name, TFF_PLAIN_IDENTIFIER);
1192     }
1193   else if (DECL_CONV_FN_P (t))
1194     {
1195       /* This cannot use the hack that the operator's return
1196          type is stashed off of its name because it may be
1197          used for error reporting.  In the case of conflicting
1198          declarations, both will have the same name, yet
1199          the types will be different, hence the TREE_TYPE field
1200          of the first name will be clobbered by the second.  */
1201       pp_string (cxx_pp, "operator ");
1202       dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1203     }
1204   else if (IDENTIFIER_OPNAME_P (name))
1205     pp_tree_identifier (cxx_pp, name);
1206   else
1207     dump_decl (name, flags);
1208
1209   if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
1210       && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1211       && (DECL_TEMPLATE_SPECIALIZATION (t)
1212           || TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1213           || DECL_TEMPLATE_SPECIALIZATION (DECL_TI_TEMPLATE (t))
1214           || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1215     dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
1216 }
1217
1218 /* Dump the template parameters from the template info INFO under control of
1219    FLAGS. PRIMARY indicates whether this is a primary template decl, or
1220    specialization (partial or complete). For partial specializations we show
1221    the specialized parameter values. For a primary template we show no
1222    decoration.  */
1223
1224 static void
1225 dump_template_parms (tree info, int primary, int flags)
1226 {
1227   tree args = info ? TI_ARGS (info) : NULL_TREE;
1228
1229   if (primary && flags & TFF_TEMPLATE_NAME)
1230     return;
1231   flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1232   pp_template_argument_list_start (cxx_pp);
1233
1234   /* Be careful only to print things when we have them, so as not
1235          to crash producing error messages.  */
1236   if (args && !primary)
1237     {
1238       int len, ix;
1239
1240       if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
1241         args = TREE_VEC_ELT (args, TREE_VEC_LENGTH (args) - 1);
1242
1243       len = TREE_VEC_LENGTH (args);
1244
1245       for (ix = 0; ix != len; ix++)
1246         {
1247           tree arg = TREE_VEC_ELT (args, ix);
1248
1249           if (ix)
1250             pp_separate_with_comma (cxx_pp);
1251
1252           if (!arg)
1253             pp_identifier (cxx_pp, "<template parameter error>");
1254           else
1255             dump_template_argument (arg, flags);
1256         }
1257     }
1258   else if (primary)
1259     {
1260       tree tpl = TI_TEMPLATE (info);
1261       tree parms = DECL_TEMPLATE_PARMS (tpl);
1262       int len, ix;
1263
1264       parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1265       len = parms ? TREE_VEC_LENGTH (parms) : 0;
1266
1267       for (ix = 0; ix != len; ix++)
1268         {
1269           tree parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1270
1271           if (ix)
1272             pp_separate_with_comma (cxx_pp);
1273
1274           dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
1275         }
1276     }
1277   pp_template_argument_list_end (cxx_pp);
1278 }
1279
1280 /* Print out a list of initializers (subr of dump_expr).  */
1281
1282 static void
1283 dump_expr_list (tree l, int flags)
1284 {
1285   while (l)
1286     {
1287       dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1288       l = TREE_CHAIN (l);
1289       if (l)
1290         pp_separate_with_comma (cxx_pp);
1291     }
1292 }
1293
1294 /* Print out an expression E under control of FLAGS.  */
1295
1296 static void
1297 dump_expr (tree t, int flags)
1298 {
1299   if (t == 0)
1300     return;
1301
1302   switch (TREE_CODE (t))
1303     {
1304     case VAR_DECL:
1305     case PARM_DECL:
1306     case FIELD_DECL:
1307     case CONST_DECL:
1308     case FUNCTION_DECL:
1309     case TEMPLATE_DECL:
1310     case NAMESPACE_DECL:
1311     case OVERLOAD:
1312     case IDENTIFIER_NODE:
1313       dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS);
1314       break;
1315
1316     case INTEGER_CST:
1317     case STRING_CST:
1318     case REAL_CST:
1319        pp_c_constant (pp_c_base (cxx_pp), t);
1320       break;
1321
1322     case THROW_EXPR:
1323       pp_identifier (cxx_pp, "throw");
1324       dump_expr (TREE_OPERAND (t, 0), flags);
1325       break;
1326
1327     case PTRMEM_CST:
1328       pp_ampersand (cxx_pp);
1329       dump_type (PTRMEM_CST_CLASS (t), flags);
1330       pp_colon_colon (cxx_pp);
1331       pp_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1332       break;
1333
1334     case COMPOUND_EXPR:
1335       pp_left_paren (cxx_pp);
1336       dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1337       pp_separate_with_comma (cxx_pp);
1338       dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1339       pp_right_paren (cxx_pp);
1340       break;
1341
1342     case COND_EXPR:
1343       pp_left_paren (cxx_pp);
1344       dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1345       pp_string (cxx_pp, " ? ");
1346       dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1347       pp_string (cxx_pp, " : ");
1348       dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1349       pp_right_paren (cxx_pp);
1350       break;
1351
1352     case SAVE_EXPR:
1353       if (TREE_HAS_CONSTRUCTOR (t))
1354         {
1355           pp_string (cxx_pp, "new ");
1356           dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1357         }
1358       else
1359         dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1360       break;
1361
1362     case AGGR_INIT_EXPR:
1363       {
1364         tree fn = NULL_TREE;
1365
1366         if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR)
1367           fn = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
1368
1369         if (fn && TREE_CODE (fn) == FUNCTION_DECL)
1370           {
1371             if (DECL_CONSTRUCTOR_P (fn))
1372               pp_tree_identifier (cxx_pp, TYPE_IDENTIFIER (TREE_TYPE (t)));
1373             else
1374               dump_decl (fn, 0);
1375           }
1376         else
1377           dump_expr (TREE_OPERAND (t, 0), 0);
1378       }
1379       pp_left_paren (cxx_pp);
1380       if (TREE_OPERAND (t, 1))
1381         dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
1382       pp_right_paren (cxx_pp);
1383       break;
1384
1385     case CALL_EXPR:
1386       {
1387         tree fn = TREE_OPERAND (t, 0);
1388         tree args = TREE_OPERAND (t, 1);
1389
1390         if (TREE_CODE (fn) == ADDR_EXPR)
1391           fn = TREE_OPERAND (fn, 0);
1392
1393         if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE)
1394           {
1395             tree ob = TREE_VALUE (args);
1396             if (TREE_CODE (ob) == ADDR_EXPR)
1397               {
1398                 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1399                 pp_dot (cxx_pp);
1400               }
1401             else if (TREE_CODE (ob) != PARM_DECL
1402                      || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1403               {
1404                 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1405                 pp_arrow (cxx_pp);
1406               }
1407             args = TREE_CHAIN (args);
1408           }
1409         dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
1410         pp_left_paren (cxx_pp);
1411         dump_expr_list (args, flags);
1412         pp_right_paren (cxx_pp);
1413       }
1414       break;
1415
1416     case NEW_EXPR:
1417       {
1418         tree type = TREE_OPERAND (t, 1);
1419         tree init = TREE_OPERAND (t, 2);
1420         if (NEW_EXPR_USE_GLOBAL (t))
1421           pp_colon_colon (cxx_pp);
1422         pp_string (cxx_pp, "new ");
1423         if (TREE_OPERAND (t, 0))
1424           {
1425             pp_left_paren (cxx_pp);
1426             dump_expr_list (TREE_OPERAND (t, 0), flags);
1427             pp_string (cxx_pp, ") ");
1428           }
1429         if (TREE_CODE (type) == ARRAY_REF)
1430           type = build_cplus_array_type
1431             (TREE_OPERAND (type, 0),
1432              build_index_type (fold (build (MINUS_EXPR, integer_type_node,
1433                                             TREE_OPERAND (type, 1),
1434                                             integer_one_node))));
1435         dump_type (type, flags);
1436         if (init)
1437           {
1438             pp_left_paren (cxx_pp);
1439             if (TREE_CODE (init) == TREE_LIST)
1440               dump_expr_list (init, flags);
1441             else if (init == void_zero_node)
1442               /* This representation indicates an empty initializer,
1443                  e.g.: "new int()".  */
1444               ;
1445             else
1446               dump_expr (init, flags);
1447             pp_right_paren (cxx_pp);
1448           }
1449       }
1450       break;
1451
1452     case TARGET_EXPR:
1453       /* Note that this only works for G++ target exprs.  If somebody
1454          builds a general TARGET_EXPR, there's no way to represent that
1455          it initializes anything other that the parameter slot for the
1456          default argument.  Note we may have cleared out the first
1457          operand in expand_expr, so don't go killing ourselves.  */
1458       if (TREE_OPERAND (t, 1))
1459         dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1460       break;
1461
1462     case INIT_EXPR:
1463     case MODIFY_EXPR:
1464     case PLUS_EXPR:
1465     case MINUS_EXPR:
1466     case MULT_EXPR:
1467     case TRUNC_DIV_EXPR:
1468     case TRUNC_MOD_EXPR:
1469     case MIN_EXPR:
1470     case MAX_EXPR:
1471     case LSHIFT_EXPR:
1472     case RSHIFT_EXPR:
1473     case BIT_IOR_EXPR:
1474     case BIT_XOR_EXPR:
1475     case BIT_AND_EXPR:
1476     case TRUTH_ANDIF_EXPR:
1477     case TRUTH_ORIF_EXPR:
1478     case LT_EXPR:
1479     case LE_EXPR:
1480     case GT_EXPR:
1481     case GE_EXPR:
1482     case EQ_EXPR:
1483     case NE_EXPR:
1484     case EXACT_DIV_EXPR:
1485       dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags);
1486       break;
1487
1488     case CEIL_DIV_EXPR:
1489     case FLOOR_DIV_EXPR:
1490     case ROUND_DIV_EXPR:
1491       dump_binary_op ("/", t, flags);
1492       break;
1493
1494     case CEIL_MOD_EXPR:
1495     case FLOOR_MOD_EXPR:
1496     case ROUND_MOD_EXPR:
1497       dump_binary_op ("%", t, flags);
1498       break;
1499
1500     case COMPONENT_REF:
1501       {
1502         tree ob = TREE_OPERAND (t, 0);
1503         if (TREE_CODE (ob) == INDIRECT_REF)
1504           {
1505             ob = TREE_OPERAND (ob, 0);
1506             if (TREE_CODE (ob) != PARM_DECL
1507                 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1508               {
1509                 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1510                 pp_arrow (cxx_pp);
1511               }
1512           }
1513         else
1514           {
1515             dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1516             pp_dot (cxx_pp);
1517           }
1518         dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1519       }
1520       break;
1521
1522     case ARRAY_REF:
1523       dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1524       pp_left_bracket (cxx_pp);
1525       dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1526       pp_right_bracket (cxx_pp);
1527       break;
1528
1529     case CONVERT_EXPR:
1530       if (TREE_TYPE (t) && VOID_TYPE_P (TREE_TYPE (t)))
1531         {
1532           pp_left_paren (cxx_pp);
1533           dump_type (TREE_TYPE (t), flags);
1534           pp_right_paren (cxx_pp);
1535           dump_expr (TREE_OPERAND (t, 0), flags);
1536         }
1537       else
1538         dump_unary_op ("+", t, flags);
1539       break;
1540
1541     case ADDR_EXPR:
1542       if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1543           || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
1544           /* An ADDR_EXPR can have reference type.  In that case, we
1545              shouldn't print the `&' doing so indicates to the user
1546              that the expression has pointer type.  */
1547           || (TREE_TYPE (t)
1548               && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
1549         dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1550       else
1551         dump_unary_op ("&", t, flags);
1552       break;
1553
1554     case INDIRECT_REF:
1555       if (TREE_HAS_CONSTRUCTOR (t))
1556         {
1557           t = TREE_OPERAND (t, 0);
1558           my_friendly_assert (TREE_CODE (t) == CALL_EXPR, 237);
1559           dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1560           pp_left_paren (cxx_pp);
1561           dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
1562           pp_right_paren (cxx_pp);
1563         }
1564       else
1565         {
1566           if (TREE_OPERAND (t,0) != NULL_TREE
1567               && TREE_TYPE (TREE_OPERAND (t, 0))
1568               && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
1569             dump_expr (TREE_OPERAND (t, 0), flags);
1570           else
1571             dump_unary_op ("*", t, flags);
1572         }
1573       break;
1574
1575     case NEGATE_EXPR:
1576     case BIT_NOT_EXPR:
1577     case TRUTH_NOT_EXPR:
1578     case PREDECREMENT_EXPR:
1579     case PREINCREMENT_EXPR:
1580       dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags);
1581       break;
1582
1583     case POSTDECREMENT_EXPR:
1584     case POSTINCREMENT_EXPR:
1585       pp_left_paren (cxx_pp);
1586       dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1587       pp_identifier (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
1588       pp_right_paren (cxx_pp);
1589       break;
1590
1591     case NON_LVALUE_EXPR:
1592       /* FIXME: This is a KLUDGE workaround for a parsing problem.  There
1593          should be another level of INDIRECT_REF so that I don't have to do
1594          this.  */
1595       if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
1596         {
1597           tree next = TREE_TYPE (TREE_TYPE (t));
1598
1599           while (TREE_CODE (next) == POINTER_TYPE)
1600             next = TREE_TYPE (next);
1601
1602           if (TREE_CODE (next) == FUNCTION_TYPE)
1603             {
1604               if (flags & TFF_EXPR_IN_PARENS)
1605                 pp_left_paren (cxx_pp);
1606               pp_star (cxx_pp);
1607               dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1608               if (flags & TFF_EXPR_IN_PARENS)
1609                 pp_right_paren (cxx_pp);
1610               break;
1611             }
1612           /* Else fall through.  */
1613         }
1614       dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1615       break;
1616
1617     case NOP_EXPR:
1618       {
1619         tree op = TREE_OPERAND (t, 0);
1620
1621         if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
1622           {
1623             /* It is a cast, but we cannot tell whether it is a
1624                reinterpret or static cast. Use the C style notation.  */
1625             if (flags & TFF_EXPR_IN_PARENS)
1626               pp_left_paren (cxx_pp);
1627             pp_left_paren (cxx_pp);
1628             dump_type (TREE_TYPE (t), flags);
1629             pp_right_paren (cxx_pp);
1630             dump_expr (op, flags | TFF_EXPR_IN_PARENS);
1631             if (flags & TFF_EXPR_IN_PARENS)
1632               pp_right_paren (cxx_pp);
1633           }
1634         else
1635           dump_expr (op, flags);
1636         break;
1637       }
1638
1639     case EXPR_WITH_FILE_LOCATION:
1640       dump_expr (EXPR_WFL_NODE (t), flags);
1641       break;
1642
1643     case CONSTRUCTOR:
1644       if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
1645         {
1646           tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
1647
1648           if (integer_zerop (idx))
1649             {
1650               /* A NULL pointer-to-member constant.  */
1651               pp_left_paren (cxx_pp);
1652               pp_left_paren (cxx_pp);
1653               dump_type (TREE_TYPE (t), flags);
1654               pp_right_paren (cxx_pp);
1655               pp_string (cxx_pp, ")0)");
1656               break;
1657             }
1658           else if (host_integerp (idx, 0))
1659             {
1660               tree virtuals;
1661               unsigned HOST_WIDE_INT n;
1662
1663               t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
1664               t = TYPE_METHOD_BASETYPE (t);
1665               virtuals = TYPE_BINFO_VIRTUALS (TYPE_MAIN_VARIANT (t));
1666
1667               n = tree_low_cst (idx, 0);
1668
1669               /* Map vtable index back one, to allow for the null pointer to
1670                  member.  */
1671               --n;
1672
1673               while (n > 0 && virtuals)
1674                 {
1675                   --n;
1676                   virtuals = TREE_CHAIN (virtuals);
1677                 }
1678               if (virtuals)
1679                 {
1680                   dump_expr (BV_FN (virtuals),
1681                              flags | TFF_EXPR_IN_PARENS);
1682                   break;
1683                 }
1684             }
1685         }
1686       if (TREE_TYPE (t) && !CONSTRUCTOR_ELTS (t))
1687         {
1688           dump_type (TREE_TYPE (t), 0);
1689           pp_left_paren (cxx_pp);
1690           pp_right_paren (cxx_pp);
1691         }
1692       else
1693         {
1694           pp_left_brace (cxx_pp);
1695           dump_expr_list (CONSTRUCTOR_ELTS (t), flags);
1696           pp_right_brace (cxx_pp);
1697         }
1698
1699       break;
1700
1701     case OFFSET_REF:
1702       {
1703         tree ob = TREE_OPERAND (t, 0);
1704         if (is_dummy_object (ob))
1705           {
1706             t = TREE_OPERAND (t, 1);
1707             if (TREE_CODE (t) == FUNCTION_DECL)
1708               /* A::f */
1709               dump_expr (t, flags | TFF_EXPR_IN_PARENS);
1710             else if (BASELINK_P (t))
1711               dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
1712                          flags | TFF_EXPR_IN_PARENS);
1713             else
1714               dump_decl (t, flags);
1715           }
1716         else
1717           {
1718             if (TREE_CODE (ob) == INDIRECT_REF)
1719               {
1720                 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1721                 pp_string (cxx_pp, "->*");
1722               }
1723             else
1724               {
1725                 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1726                 pp_string (cxx_pp, ".*");
1727               }
1728             dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1729           }
1730         break;
1731       }
1732
1733     case TEMPLATE_PARM_INDEX:
1734       dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
1735       break;
1736
1737     case SCOPE_REF:
1738       dump_type (TREE_OPERAND (t, 0), flags);
1739       pp_colon_colon (cxx_pp);
1740       dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1741       break;
1742
1743     case CAST_EXPR:
1744       if (TREE_OPERAND (t, 0) == NULL_TREE
1745           || TREE_CHAIN (TREE_OPERAND (t, 0)))
1746         {
1747           dump_type (TREE_TYPE (t), flags);
1748           pp_left_paren (cxx_pp);
1749           dump_expr_list (TREE_OPERAND (t, 0), flags);
1750           pp_right_paren (cxx_pp);
1751         }
1752       else
1753         {
1754           pp_left_paren (cxx_pp);
1755           dump_type (TREE_TYPE (t), flags);
1756           pp_string (cxx_pp, ")(");
1757           dump_expr_list (TREE_OPERAND (t, 0), flags);
1758           pp_right_paren (cxx_pp);
1759         }
1760       break;
1761
1762     case STATIC_CAST_EXPR:
1763       pp_string (cxx_pp, "static_cast<");
1764       goto cast;
1765     case REINTERPRET_CAST_EXPR:
1766       pp_string (cxx_pp, "reinterpret_cast<");
1767       goto cast;
1768     case CONST_CAST_EXPR:
1769       pp_string (cxx_pp, "const_cast<");
1770       goto cast;
1771     case DYNAMIC_CAST_EXPR:
1772       pp_string (cxx_pp, "dynamic_cast<");
1773     cast:
1774       dump_type (TREE_TYPE (t), flags);
1775       pp_string (cxx_pp, ">(");
1776       dump_expr (TREE_OPERAND (t, 0), flags);
1777       pp_right_paren (cxx_pp);
1778       break;
1779
1780     case ARROW_EXPR:
1781       dump_expr (TREE_OPERAND (t, 0), flags);
1782       pp_arrow (cxx_pp);
1783       break;
1784
1785     case SIZEOF_EXPR:
1786     case ALIGNOF_EXPR:
1787       if (TREE_CODE (t) == SIZEOF_EXPR)
1788         pp_string (cxx_pp, "sizeof (");
1789       else
1790         {
1791           my_friendly_assert (TREE_CODE (t) == ALIGNOF_EXPR, 0);
1792           pp_string (cxx_pp, "__alignof__ (");
1793         }
1794       if (TYPE_P (TREE_OPERAND (t, 0)))
1795         dump_type (TREE_OPERAND (t, 0), flags);
1796       else
1797         dump_expr (TREE_OPERAND (t, 0), flags);
1798       pp_right_paren (cxx_pp);
1799       break;
1800
1801     case REALPART_EXPR:
1802     case IMAGPART_EXPR:
1803       pp_identifier (cxx_pp, operator_name_info[TREE_CODE (t)].name);
1804       pp_space (cxx_pp);
1805       dump_expr (TREE_OPERAND (t, 0), flags);
1806       break;
1807
1808     case DEFAULT_ARG:
1809       pp_identifier (cxx_pp, "<unparsed>");
1810       break;
1811
1812     case TRY_CATCH_EXPR:
1813     case WITH_CLEANUP_EXPR:
1814     case CLEANUP_POINT_EXPR:
1815       dump_expr (TREE_OPERAND (t, 0), flags);
1816       break;
1817
1818     case PSEUDO_DTOR_EXPR:
1819       dump_expr (TREE_OPERAND (t, 2), flags);
1820       pp_dot (cxx_pp);
1821       dump_type (TREE_OPERAND (t, 0), flags);
1822       pp_colon_colon (cxx_pp);
1823       pp_complement (cxx_pp);
1824       dump_type (TREE_OPERAND (t, 1), flags);
1825       break;
1826
1827     case TEMPLATE_ID_EXPR:
1828       dump_decl (t, flags);
1829       break;
1830
1831     case STMT_EXPR:
1832       /* We don't yet have a way of dumping statements in a
1833          human-readable format.  */
1834       pp_string (cxx_pp, "({...})");
1835       break;
1836
1837     case BIND_EXPR:
1838       pp_left_brace (cxx_pp);
1839       dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1840       pp_right_brace (cxx_pp);
1841       break;
1842
1843     case LOOP_EXPR:
1844       pp_string (cxx_pp, "while (1) { ");
1845       dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1846       pp_right_brace (cxx_pp);
1847       break;
1848
1849     case EXIT_EXPR:
1850       pp_string (cxx_pp, "if (");
1851       dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1852       pp_string (cxx_pp, ") break; ");
1853       break;
1854
1855     case BASELINK:
1856       dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS);
1857       break;
1858
1859     case EMPTY_CLASS_EXPR:
1860       dump_type (TREE_TYPE (t), flags);
1861       pp_left_paren (cxx_pp);
1862       pp_right_paren (cxx_pp);
1863       break;
1864
1865     case NON_DEPENDENT_EXPR:
1866       dump_expr (TREE_OPERAND (t, 0), flags);
1867       break;
1868
1869       /*  This list is incomplete, but should suffice for now.
1870           It is very important that `sorry' does not call
1871           `report_error_function'.  That could cause an infinite loop.  */
1872     default:
1873       pp_unsupported_tree (cxx_pp, t);
1874       /* fall through to ERROR_MARK...  */
1875     case ERROR_MARK:
1876       pp_identifier (cxx_pp, "<expression error>");
1877       break;
1878     }
1879 }
1880
1881 static void
1882 dump_binary_op (const char *opstring, tree t, int flags)
1883 {
1884   pp_left_paren (cxx_pp);
1885   dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1886   pp_space (cxx_pp);
1887   if (opstring)
1888     pp_identifier (cxx_pp, opstring);
1889   else
1890     pp_identifier (cxx_pp, "<unknown operator>");
1891   pp_space (cxx_pp);
1892   dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1893   pp_right_paren (cxx_pp);
1894 }
1895
1896 static void
1897 dump_unary_op (const char *opstring, tree t, int flags)
1898 {
1899   if (flags & TFF_EXPR_IN_PARENS)
1900     pp_left_paren (cxx_pp);
1901   pp_identifier (cxx_pp, opstring);
1902   dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1903   if (flags & TFF_EXPR_IN_PARENS)
1904     pp_right_paren (cxx_pp);
1905 }
1906
1907 /* Exported interface to stringifying types, exprs and decls under TFF_*
1908    control.  */
1909
1910 const char *
1911 type_as_string (tree typ, int flags)
1912 {
1913   pp_clear_output_area (cxx_pp);
1914   dump_type (typ, flags);
1915   return pp_formatted_text (cxx_pp);
1916 }
1917
1918 const char *
1919 expr_as_string (tree decl, int flags)
1920 {
1921   pp_clear_output_area (cxx_pp);
1922   dump_expr (decl, flags);
1923   return pp_formatted_text (cxx_pp);
1924 }
1925
1926 const char *
1927 decl_as_string (tree decl, int flags)
1928 {
1929   pp_clear_output_area (cxx_pp);
1930   dump_decl (decl, flags);
1931   return pp_formatted_text (cxx_pp);
1932 }
1933
1934 const char *
1935 context_as_string (tree context, int flags)
1936 {
1937   pp_clear_output_area (cxx_pp);
1938   dump_scope (context, flags);
1939   return pp_formatted_text (cxx_pp);
1940 }
1941
1942 /* Generate the three forms of printable names for cxx_printable_name.  */
1943
1944 const char *
1945 lang_decl_name (tree decl, int v)
1946 {
1947   if (v >= 2)
1948     return decl_as_string (decl, TFF_DECL_SPECIFIERS);
1949
1950   pp_clear_output_area (cxx_pp);
1951   if (v == 1 && DECL_CLASS_SCOPE_P (decl))
1952     {
1953       dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
1954       pp_colon_colon (cxx_pp);
1955     }
1956
1957   if (TREE_CODE (decl) == FUNCTION_DECL)
1958     dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
1959   else
1960     dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
1961
1962   return pp_formatted_text (cxx_pp);
1963 }
1964
1965 static location_t
1966 location_of (tree t)
1967 {
1968   if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
1969     t = DECL_CONTEXT (t);
1970   else if (TYPE_P (t))
1971     t = TYPE_MAIN_DECL (t);
1972   else if (TREE_CODE (t) == OVERLOAD)
1973     t = OVL_FUNCTION (t);
1974
1975   return DECL_SOURCE_LOCATION (t);
1976 }
1977
1978 /* Now the interfaces from error et al to dump_type et al. Each takes an
1979    on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
1980    function.  */
1981
1982 static const char *
1983 decl_to_string (tree decl, int verbose)
1984 {
1985   int flags = 0;
1986
1987   if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
1988       || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
1989     flags = TFF_CLASS_KEY_OR_ENUM;
1990   if (verbose)
1991     flags |= TFF_DECL_SPECIFIERS;
1992   else if (TREE_CODE (decl) == FUNCTION_DECL)
1993     flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
1994   flags |= TFF_TEMPLATE_HEADER;
1995
1996   pp_clear_output_area (cxx_pp);
1997   dump_decl (decl, flags);
1998   return pp_formatted_text (cxx_pp);
1999 }
2000
2001 static const char *
2002 expr_to_string (tree decl)
2003 {
2004   pp_clear_output_area (cxx_pp);
2005   dump_expr (decl, 0);
2006   return pp_formatted_text (cxx_pp);
2007 }
2008
2009 static const char *
2010 fndecl_to_string (tree fndecl, int verbose)
2011 {
2012   int flags;
2013
2014   flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS;
2015   if (verbose)
2016     flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2017   pp_clear_output_area (cxx_pp);
2018   dump_decl (fndecl, flags);
2019   return pp_formatted_text (cxx_pp);
2020 }
2021
2022
2023 static const char *
2024 code_to_string (enum tree_code c)
2025 {
2026   return tree_code_name [c];
2027 }
2028
2029 const char *
2030 language_to_string (enum languages c)
2031 {
2032   switch (c)
2033     {
2034     case lang_c:
2035       return "C";
2036
2037     case lang_cplusplus:
2038       return "C++";
2039
2040     case lang_java:
2041       return "Java";
2042
2043     default:
2044       abort ();
2045       return 0;
2046     }
2047 }
2048
2049 /* Return the proper printed version of a parameter to a C++ function.  */
2050
2051 static const char *
2052 parm_to_string (int p)
2053 {
2054   pp_clear_output_area (cxx_pp);
2055   if (p < 0)
2056     pp_string (cxx_pp, "'this'");
2057   else
2058     pp_decimal_int (cxx_pp, p + 1);
2059   return pp_formatted_text (cxx_pp);
2060 }
2061
2062 static const char *
2063 op_to_string (enum tree_code p)
2064 {
2065   tree id = operator_name_info[(int) p].identifier;
2066   return id ? IDENTIFIER_POINTER (id) : "<unknown>";
2067 }
2068
2069 static const char *
2070 type_to_string (tree typ, int verbose)
2071 {
2072   int flags = 0;
2073   if (verbose)
2074     flags |= TFF_CLASS_KEY_OR_ENUM;
2075   flags |= TFF_TEMPLATE_HEADER;
2076
2077   pp_clear_output_area (cxx_pp);
2078   dump_type (typ, flags);
2079   return pp_formatted_text (cxx_pp);
2080 }
2081
2082 static const char *
2083 assop_to_string (enum tree_code p)
2084 {
2085   tree id = assignment_operator_name_info[(int) p].identifier;
2086   return id ? IDENTIFIER_POINTER (id) : "{unknown}";
2087 }
2088
2089 static const char *
2090 args_to_string (tree p, int verbose)
2091 {
2092   int flags = 0;
2093   if (verbose)
2094     flags |= TFF_CLASS_KEY_OR_ENUM;
2095
2096   if (p == NULL_TREE)
2097     return "";
2098
2099   if (TYPE_P (TREE_VALUE (p)))
2100     return type_as_string (p, flags);
2101
2102   pp_clear_output_area (cxx_pp);
2103   for (; p; p = TREE_CHAIN (p))
2104     {
2105       if (TREE_VALUE (p) == null_node)
2106         pp_identifier (cxx_pp, "NULL");
2107       else
2108         dump_type (error_type (TREE_VALUE (p)), flags);
2109       if (TREE_CHAIN (p))
2110         pp_separate_with_comma (cxx_pp);
2111     }
2112   return pp_formatted_text (cxx_pp);
2113 }
2114
2115 static const char *
2116 cv_to_string (tree p, int v)
2117 {
2118   pp_clear_output_area (cxx_pp);
2119   dump_qualifiers (p, v ? before : none);
2120   return pp_formatted_text (cxx_pp);
2121 }
2122
2123 /* Langhook for print_error_function.  */
2124 void
2125 cxx_print_error_function (diagnostic_context *context, const char *file)
2126 {
2127   lhd_print_error_function (context, file);
2128   pp_base_set_prefix (context->printer, file);
2129   maybe_print_instantiation_context (context);
2130 }
2131
2132 static void
2133 cp_diagnostic_starter (diagnostic_context *context,
2134                        diagnostic_info *diagnostic)
2135 {
2136   diagnostic_report_current_module (context);
2137   cp_print_error_function (context, diagnostic);
2138   maybe_print_instantiation_context (context);
2139   pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
2140 }
2141
2142 static void
2143 cp_diagnostic_finalizer (diagnostic_context *context,
2144                          diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2145 {
2146   pp_base_destroy_prefix (context->printer);
2147 }
2148
2149 /* Print current function onto BUFFER, in the process of reporting
2150    a diagnostic message.  Called from cp_diagnostic_starter.  */
2151 static void
2152 cp_print_error_function (diagnostic_context *context,
2153                          diagnostic_info *diagnostic)
2154 {
2155   if (diagnostic_last_function_changed (context))
2156     {
2157       const char *old_prefix = context->printer->prefix;
2158       char *new_prefix = diagnostic->location.file
2159         ? file_name_as_prefix (diagnostic->location.file)
2160         : NULL;
2161
2162       pp_base_set_prefix (context->printer, new_prefix);
2163
2164       if (current_function_decl == NULL)
2165         pp_base_string (context->printer, "At global scope:");
2166       else
2167         pp_printf (context->printer, "In %s `%s':",
2168                    function_category (current_function_decl),
2169                    cxx_printable_name (current_function_decl, 2));
2170       pp_base_newline (context->printer);
2171
2172       diagnostic_set_last_function (context);
2173       pp_base_destroy_prefix (context->printer);
2174       context->printer->prefix = old_prefix;
2175     }
2176 }
2177
2178 /* Returns a description of FUNCTION using standard terminology.  */
2179 static const char *
2180 function_category (tree fn)
2181 {
2182   if (DECL_FUNCTION_MEMBER_P (fn))
2183     {
2184       if (DECL_STATIC_FUNCTION_P (fn))
2185         return "static member function";
2186       else if (DECL_COPY_CONSTRUCTOR_P (fn))
2187         return "copy constructor";
2188       else if (DECL_CONSTRUCTOR_P (fn))
2189         return "constructor";
2190       else if (DECL_DESTRUCTOR_P (fn))
2191         return "destructor";
2192       else
2193         return "member function";
2194     }
2195   else
2196     return "function";
2197 }
2198
2199 /* Report the full context of a current template instantiation,
2200    onto BUFFER.  */
2201 static void
2202 print_instantiation_full_context (diagnostic_context *context)
2203 {
2204   tree p = current_instantiation ();
2205   location_t location = input_location;
2206
2207   if (p)
2208     {
2209       if (current_function_decl != TINST_DECL (p)
2210           && current_function_decl != NULL_TREE)
2211         /* We can get here during the processing of some synthesized
2212            method.  Then, TINST_DECL (p) will be the function that's causing
2213            the synthesis.  */
2214         ;
2215       else
2216         {
2217           if (current_function_decl == TINST_DECL (p))
2218             /* Avoid redundancy with the the "In function" line.  */;
2219           else
2220             pp_verbatim (context->printer,
2221                          "%s: In instantiation of `%s':\n", location.file,
2222                          decl_as_string (TINST_DECL (p),
2223                                          TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2224
2225           location.line = TINST_LINE (p);
2226           location.file = TINST_FILE (p);
2227           p = TREE_CHAIN (p);
2228         }
2229     }
2230
2231   print_instantiation_partial_context (context, p, location);
2232 }
2233
2234 /* Same as above but less verbose.  */
2235 static void
2236 print_instantiation_partial_context (diagnostic_context *context,
2237                                      tree t, location_t loc)
2238 {
2239   for (; t; t = TREE_CHAIN (t))
2240     {
2241       pp_verbatim (context->printer, "%s:%d:   instantiated from `%s'\n",
2242                    loc.file, loc.line,
2243                    decl_as_string (TINST_DECL (t),
2244                                    TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2245       loc.line = TINST_LINE (t);
2246       loc.file = TINST_FILE (t);
2247     }
2248   pp_verbatim (context->printer, "%s:%d:   instantiated from here\n",
2249                loc.file, loc.line);
2250 }
2251
2252 /* Called from cp_thing to print the template context for an error.  */
2253 static void
2254 maybe_print_instantiation_context (diagnostic_context *context)
2255 {
2256   if (!problematic_instantiation_changed () || current_instantiation () == 0)
2257     return;
2258
2259   record_last_problematic_instantiation ();
2260   print_instantiation_full_context (context);
2261 }
2262
2263 /* Report the bare minimum context of a template instantiation.  */
2264 void
2265 print_instantiation_context (void)
2266 {
2267   print_instantiation_partial_context
2268     (global_dc, current_instantiation (), input_location);
2269   diagnostic_flush_buffer (global_dc);
2270 }
2271 \f
2272 /* Called from output_format -- during diagnostic message processing --
2273    to handle C++ specific format specifier with the following meanings:
2274    %A   function argument-list.
2275    %C   tree code.
2276    %D   declaration.
2277    %E   expression.
2278    %F   function declaration.
2279    %L   language as used in extern "lang".
2280    %O   binary operator.
2281    %P   function parameter whose position is indicated by an integer.
2282    %Q   assignment operator.
2283    %T   type.
2284    %V   cv-qualifier.  */
2285 static bool
2286 cp_printer (pretty_printer *pp, text_info *text)
2287 {
2288   int verbose = 0;
2289   const char *result;
2290 #define next_tree    va_arg (*text->args_ptr, tree)
2291 #define next_tcode   va_arg (*text->args_ptr, enum tree_code)
2292 #define next_lang    va_arg (*text->args_ptr, enum languages)
2293 #define next_int     va_arg (*text->args_ptr, int)
2294
2295   if (*text->format_spec == '+')
2296     ++text->format_spec;
2297   if (*text->format_spec == '#')
2298     {
2299       verbose = 1;
2300       ++text->format_spec;
2301     }
2302
2303   switch (*text->format_spec)
2304     {
2305     case 'A': result = args_to_string (next_tree, verbose);     break;
2306     case 'C': result = code_to_string (next_tcode);             break;
2307     case 'D': result = decl_to_string (next_tree, verbose);     break;
2308     case 'E': result = expr_to_string (next_tree);              break;
2309     case 'F': result = fndecl_to_string (next_tree, verbose);   break;
2310     case 'L': result = language_to_string (next_lang);          break;
2311     case 'O': result = op_to_string (next_tcode);               break;
2312     case 'P': result = parm_to_string (next_int);               break;
2313     case 'Q': result = assop_to_string (next_tcode);            break;
2314     case 'T': result = type_to_string (next_tree, verbose);     break;
2315     case 'V': result = cv_to_string (next_tree, verbose);       break;
2316
2317     default:
2318       return false;
2319     }
2320
2321   pp_base_string (pp, result);
2322   return true;
2323 #undef next_tree
2324 #undef next_tcode
2325 #undef next_lang
2326 #undef next_int
2327 }
2328
2329 static void
2330 pp_non_consecutive_character (cxx_pretty_printer *pp, int c)
2331 {
2332   const char *p = pp_last_position_in_text (pp);
2333
2334   if (p != NULL && *p == c)
2335     pp_space (pp);
2336   pp_character (pp, c);
2337 }
2338
2339 /* These are temporary wrapper functions which handle the historic
2340    behavior of cp_*_at.  */
2341
2342 static tree
2343 locate_error (const char *msgid, va_list ap)
2344 {
2345   tree here = 0, t;
2346   int plus = 0;
2347   const char *f;
2348
2349   for (f = msgid; *f; f++)
2350     {
2351       plus = 0;
2352       if (*f == '%')
2353         {
2354           f++;
2355           if (*f == '+')
2356             f++, plus = 1;
2357           if (*f == '#')
2358             f++;
2359
2360           switch (*f)
2361             {
2362               /* Just ignore these possibilities.  */
2363             case '%':                                           break;
2364             case 'P':
2365             case 'd':   (void) va_arg (ap, int);                break;
2366             case 's':   (void) va_arg (ap, char *);             break;
2367             case 'L':   (void) va_arg (ap, enum languages);     break;
2368             case 'C':
2369             case 'O':
2370             case 'Q':   (void) va_arg (ap, enum tree_code);     break;
2371
2372               /* These take a tree, which may be where the error is
2373                  located.  */
2374             case 'A':
2375             case 'D':
2376             case 'E':
2377             case 'F':
2378             case 'T':
2379             case 'V':
2380               t = va_arg (ap, tree);
2381               if (!here || plus)
2382                 here = t;
2383               break;
2384
2385             default:
2386               errorcount = 0;  /* damn ICE suppression */
2387               internal_error ("unexpected letter `%c' in locate_error\n", *f);
2388             }
2389         }
2390     }
2391
2392   if (here == 0)
2393     here = va_arg (ap, tree);
2394
2395   return here;
2396 }
2397
2398
2399 void
2400 cp_error_at (const char *msgid, ...)
2401 {
2402   tree here;
2403   diagnostic_info diagnostic;
2404   va_list ap;
2405
2406   va_start (ap, msgid);
2407   here = locate_error (msgid, ap);
2408   va_end (ap);
2409
2410   va_start (ap, msgid);
2411   diagnostic_set_info (&diagnostic, msgid, &ap,
2412                        location_of (here), DK_ERROR);
2413   report_diagnostic (&diagnostic);
2414   va_end (ap);
2415 }
2416
2417 void
2418 cp_warning_at (const char *msgid, ...)
2419 {
2420   tree here;
2421   diagnostic_info diagnostic;
2422   va_list ap;
2423
2424   va_start (ap, msgid);
2425   here = locate_error (msgid, ap);
2426   va_end (ap);
2427
2428   va_start (ap, msgid);
2429   diagnostic_set_info (&diagnostic, msgid, &ap,
2430                        location_of (here), DK_WARNING);
2431   report_diagnostic (&diagnostic);
2432   va_end (ap);
2433 }
2434
2435 void
2436 cp_pedwarn_at (const char *msgid, ...)
2437 {
2438   tree here;
2439   diagnostic_info diagnostic;
2440   va_list ap;
2441
2442   va_start (ap, msgid);
2443   here = locate_error (msgid, ap);
2444   va_end (ap);
2445
2446   va_start (ap, msgid);
2447   diagnostic_set_info (&diagnostic, msgid, &ap,
2448                        location_of (here), pedantic_error_kind());
2449   report_diagnostic (&diagnostic);
2450   va_end (ap);
2451 }