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