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 (host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0))
 725             OB_PUTI (tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0) + 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 || integer_zerop (t))
1481               OB_PUTS ("false");
1482             else if (t == boolean_true_node)
1483               OB_PUTS ("true");
1484           }
1485         else if (type == char_type_node)
1486           {
1487             OB_PUTC ('\'');
1488             dump_char (tree_low_cst (t, 0));
1489             OB_PUTC ('\'');
1490           }
1491         else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (t)
1492                  != (TREE_INT_CST_LOW (t) >> (HOST_BITS_PER_WIDE_INT - 1)))
1493           {
1494             tree val = t;
1495
1496             if (tree_int_cst_sgn (val) < 0)
1497               {
1498                 OB_PUTC ('-');
1499                 val = build_int_2 (~TREE_INT_CST_LOW (val),
1500                                    -TREE_INT_CST_HIGH (val));
1501               }
1502             /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
1503                systems?  */
1504             {
1505               static char format[10]; /* "%x%09999x\0" */
1506               if (!format[0])
1507                 sprintf (format, "%%x%%0%dx", HOST_BITS_PER_INT / 4);
1508               sprintf (digit_buffer, format, TREE_INT_CST_HIGH (val),
1509                        TREE_INT_CST_LOW (val));
1510               OB_PUTCP (digit_buffer);
1511             }
1512           }
1513         else
1514           OB_PUTI (TREE_INT_CST_LOW (t));
1515       }
1516       break;
1517
1518     case REAL_CST:
1519 #ifndef REAL_IS_NOT_DOUBLE
1520       sprintf (digit_buffer, "%g", TREE_REAL_CST (t));
1521 #else
1522       {
1523         const unsigned char *p = (const unsigned char *) &TREE_REAL_CST (t);
1524         size_t i;
1525         strcpy (digit_buffer, "0x");
1526         for (i = 0; i < sizeof TREE_REAL_CST (t); i++)
1527           sprintf (digit_buffer + 2 + 2*i, "%02x", *p++);
1528       }
1529 #endif
1530       OB_PUTCP (digit_buffer);
1531       break;
1532
1533     case PTRMEM_CST:
1534       OB_PUTC ('&');
1535       dump_type (PTRMEM_CST_CLASS (t), flags);
1536       OB_PUTS ("::");
1537       OB_PUTID (DECL_NAME (PTRMEM_CST_MEMBER (t)));
1538       break;
1539
1540     case STRING_CST:
1541       {
1542         const char *p = TREE_STRING_POINTER (t);
1543         int len = TREE_STRING_LENGTH (t) - 1;
1544         int i;
1545
1546         OB_PUTC ('\"');
1547         for (i = 0; i < len; i++)
1548           dump_char (p[i]);
1549         OB_PUTC ('\"');
1550       }
1551       break;
1552
1553     case COMPOUND_EXPR:
1554       OB_PUTC ('(');
1555       dump_expr (TREE_OPERAND (t, 0), flags | TS_EXPR_PARENS);
1556       OB_PUTS (", ");
1557       dump_expr (TREE_OPERAND (t, 1), flags | TS_EXPR_PARENS);
1558       OB_PUTC (')');
1559       break;
1560
1561     case COND_EXPR:
1562       OB_PUTC ('(');
1563       dump_expr (TREE_OPERAND (t, 0), flags | TS_EXPR_PARENS);
1564       OB_PUTS (" ? ");
1565       dump_expr (TREE_OPERAND (t, 1), flags | TS_EXPR_PARENS);
1566       OB_PUTS (" : ");
1567       dump_expr (TREE_OPERAND (t, 2), flags | TS_EXPR_PARENS);
1568       OB_PUTC (')');
1569       break;
1570
1571     case SAVE_EXPR:
1572       if (TREE_HAS_CONSTRUCTOR (t))
1573         {
1574           OB_PUTS ("new ");
1575           dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1576         }
1577       else
1578         {
1579           dump_expr (TREE_OPERAND (t, 0), flags | TS_EXPR_PARENS);
1580         }
1581       break;
1582
1583     case AGGR_INIT_EXPR:
1584       {
1585         tree fn = NULL_TREE;
1586
1587         if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR)
1588           fn = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
1589
1590         if (fn && TREE_CODE (fn) == FUNCTION_DECL)
1591           {
1592             if (DECL_CONSTRUCTOR_P (fn))
1593               OB_PUTID (TYPE_IDENTIFIER (TREE_TYPE (t)));
1594             else
1595               dump_decl (fn, 0);
1596           }
1597         else
1598           dump_expr (TREE_OPERAND (t, 0), 0);
1599       }
1600       OB_PUTC ('(');
1601       if (TREE_OPERAND (t, 1))
1602         dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
1603       OB_PUTC (')');
1604       break;
1605
1606     case CALL_EXPR:
1607       {
1608         tree fn = TREE_OPERAND (t, 0);
1609         tree args = TREE_OPERAND (t, 1);
1610
1611         if (TREE_CODE (fn) == ADDR_EXPR)
1612           fn = TREE_OPERAND (fn, 0);
1613
1614         if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE)
1615           {
1616             tree ob = TREE_VALUE (args);
1617             if (TREE_CODE (ob) == ADDR_EXPR)
1618               {
1619                 dump_expr (TREE_OPERAND (ob, 0), flags | TS_EXPR_PARENS);
1620                 OB_PUTC ('.');
1621               }
1622             else if (TREE_CODE (ob) != PARM_DECL
1623                      || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1624               {
1625                 dump_expr (ob, flags | TS_EXPR_PARENS);
1626                 OB_PUTS ("->");
1627               }
1628             args = TREE_CHAIN (args);
1629           }
1630         dump_expr (fn, flags | TS_EXPR_PARENS);
1631         OB_PUTC ('(');
1632         dump_expr_list (args, flags);
1633         OB_PUTC (')');
1634       }
1635       break;
1636
1637     case NEW_EXPR:
1638       {
1639         tree type = TREE_OPERAND (t, 1);
1640         if (NEW_EXPR_USE_GLOBAL (t))
1641           OB_PUTS ("::");
1642         OB_PUTS ("new ");
1643         if (TREE_OPERAND (t, 0))
1644           {
1645             OB_PUTC ('(');
1646             dump_expr_list (TREE_OPERAND (t, 0), flags);
1647             OB_PUTS (") ");
1648           }
1649         if (TREE_CODE (type) == ARRAY_REF)
1650           type = build_cplus_array_type
1651             (TREE_OPERAND (type, 0),
1652              build_index_type (fold (build (MINUS_EXPR, integer_type_node,
1653                                             TREE_OPERAND (type, 1),
1654                                             integer_one_node))));
1655         dump_type (type, flags);
1656         if (TREE_OPERAND (t, 2))
1657           {
1658             OB_PUTC ('(');
1659             dump_expr_list (TREE_OPERAND (t, 2), flags);
1660             OB_PUTC (')');
1661           }
1662       }
1663       break;
1664
1665     case TARGET_EXPR:
1666       /* Note that this only works for G++ target exprs.  If somebody
1667          builds a general TARGET_EXPR, there's no way to represent that
1668          it initializes anything other that the parameter slot for the
1669          default argument.  Note we may have cleared out the first
1670          operand in expand_expr, so don't go killing ourselves.  */
1671       if (TREE_OPERAND (t, 1))
1672         dump_expr (TREE_OPERAND (t, 1), flags | TS_EXPR_PARENS);
1673       break;
1674
1675     case INIT_EXPR:
1676     case MODIFY_EXPR:
1677     case PLUS_EXPR:
1678     case MINUS_EXPR:
1679     case MULT_EXPR:
1680     case TRUNC_DIV_EXPR:
1681     case TRUNC_MOD_EXPR:
1682     case MIN_EXPR:
1683     case MAX_EXPR:
1684     case LSHIFT_EXPR:
1685     case RSHIFT_EXPR:
1686     case BIT_IOR_EXPR:
1687     case BIT_XOR_EXPR:
1688     case BIT_AND_EXPR:
1689     case BIT_ANDTC_EXPR:
1690     case TRUTH_ANDIF_EXPR:
1691     case TRUTH_ORIF_EXPR:
1692     case LT_EXPR:
1693     case LE_EXPR:
1694     case GT_EXPR:
1695     case GE_EXPR:
1696     case EQ_EXPR:
1697     case NE_EXPR:
1698     case EXACT_DIV_EXPR:
1699       dump_binary_op (opname_tab[(int) TREE_CODE (t)], t, flags);
1700       break;
1701
1702     case CEIL_DIV_EXPR:
1703     case FLOOR_DIV_EXPR:
1704     case ROUND_DIV_EXPR:
1705       dump_binary_op ("/", t, flags);
1706       break;
1707
1708     case CEIL_MOD_EXPR:
1709     case FLOOR_MOD_EXPR:
1710     case ROUND_MOD_EXPR:
1711       dump_binary_op ("%", t, flags);
1712       break;
1713
1714     case COMPONENT_REF:
1715       {
1716         tree ob = TREE_OPERAND (t, 0);
1717         if (TREE_CODE (ob) == INDIRECT_REF)
1718           {
1719             ob = TREE_OPERAND (ob, 0);
1720             if (TREE_CODE (ob) != PARM_DECL
1721                 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1722               {
1723                 dump_expr (ob, flags | TS_EXPR_PARENS);
1724                 OB_PUTS ("->");
1725               }
1726           }
1727         else
1728           {
1729             dump_expr (ob, flags | TS_EXPR_PARENS);
1730             OB_PUTC ('.');
1731           }
1732         dump_expr (TREE_OPERAND (t, 1), flags & ~TS_EXPR_PARENS);
1733       }
1734       break;
1735
1736     case ARRAY_REF:
1737       dump_expr (TREE_OPERAND (t, 0), flags | TS_EXPR_PARENS);
1738       OB_PUTC ('[');
1739       dump_expr (TREE_OPERAND (t, 1), flags | TS_EXPR_PARENS);
1740       OB_PUTC (']');
1741       break;
1742
1743     case CONVERT_EXPR:
1744       if (same_type_p (TREE_TYPE (t), void_type_node))
1745         {
1746           OB_PUTS ("(void)");
1747           dump_expr (TREE_OPERAND (t, 0), flags);
1748         }
1749       else
1750         dump_unary_op ("+", t, flags);
1751       break;
1752
1753     case ADDR_EXPR:
1754       if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1755           || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST)
1756         dump_expr (TREE_OPERAND (t, 0), flags | TS_EXPR_PARENS);
1757       else
1758         dump_unary_op ("&", t, flags);
1759       break;
1760
1761     case INDIRECT_REF:
1762       if (TREE_HAS_CONSTRUCTOR (t))
1763         {
1764           t = TREE_OPERAND (t, 0);
1765           my_friendly_assert (TREE_CODE (t) == CALL_EXPR, 237);
1766           dump_expr (TREE_OPERAND (t, 0), flags | TS_EXPR_PARENS);
1767           OB_PUTC ('(');
1768           dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)), flags);
1769           OB_PUTC (')');
1770         }
1771       else
1772         {
1773           if (TREE_OPERAND (t,0) != NULL_TREE
1774               && TREE_TYPE (TREE_OPERAND (t, 0))
1775               && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
1776             dump_expr (TREE_OPERAND (t, 0), flags);
1777           else
1778             dump_unary_op ("*", t, flags);
1779         }
1780       break;
1781
1782     case NEGATE_EXPR:
1783     case BIT_NOT_EXPR:
1784     case TRUTH_NOT_EXPR:
1785     case PREDECREMENT_EXPR:
1786     case PREINCREMENT_EXPR:
1787       dump_unary_op (opname_tab [(int)TREE_CODE (t)], t, flags);
1788       break;
1789
1790     case POSTDECREMENT_EXPR:
1791     case POSTINCREMENT_EXPR:
1792       OB_PUTC ('(');
1793       dump_expr (TREE_OPERAND (t, 0), flags | TS_EXPR_PARENS);
1794       OB_PUTCP (opname_tab[(int)TREE_CODE (t)]);
1795       OB_PUTC (')');
1796       break;
1797
1798     case NON_LVALUE_EXPR:
1799       /* FIXME: This is a KLUDGE workaround for a parsing problem.  There
1800          should be another level of INDIRECT_REF so that I don't have to do
1801          this.  */
1802       if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
1803         {
1804           tree next = TREE_TYPE (TREE_TYPE (t));
1805
1806           while (TREE_CODE (next) == POINTER_TYPE)
1807             next = TREE_TYPE (next);
1808
1809           if (TREE_CODE (next) == FUNCTION_TYPE)
1810             {
1811               if (flags & TS_EXPR_PARENS)
1812                 OB_PUTC ('(');
1813               OB_PUTC ('*');
1814               dump_expr (TREE_OPERAND (t, 0), flags & ~TS_EXPR_PARENS);
1815               if (flags & TS_EXPR_PARENS)
1816                 OB_PUTC (')');
1817               break;
1818             }
1819           /* else FALLTHRU */
1820         }
1821       dump_expr (TREE_OPERAND (t, 0), flags | TS_EXPR_PARENS);
1822       break;
1823
1824     case NOP_EXPR:
1825       dump_expr (TREE_OPERAND (t, 0), flags);
1826       break;
1827
1828     case EXPR_WITH_FILE_LOCATION:
1829       dump_expr (EXPR_WFL_NODE (t), flags);
1830       break;
1831
1832     case CONSTRUCTOR:
1833       if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
1834         {
1835           tree idx = build_component_ref (t, index_identifier, NULL_TREE, 0);
1836
1837           if (integer_all_onesp (idx))
1838             {
1839               tree pfn = PFN_FROM_PTRMEMFUNC (t);
1840               dump_unary_op ("&", pfn, flags | TS_EXPR_PARENS);
1841               break;
1842             }
1843           else if (TREE_CODE (idx) == INTEGER_CST
1844                    && tree_int_cst_equal (idx, integer_zero_node))
1845             {
1846               /* A NULL pointer-to-member constant.  */
1847               OB_PUTS ("((");
1848               dump_type (TREE_TYPE (t), flags);
1849               OB_PUTS (") 0)");
1850               break;
1851             }
1852           else if (host_integerp (idx, 0))
1853             {
1854               tree virtuals;
1855               unsigned HOST_WIDE_INT n;
1856
1857               t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
1858               t = TYPE_METHOD_BASETYPE (t);
1859               virtuals = TYPE_BINFO_VIRTUALS (TYPE_MAIN_VARIANT (t));
1860
1861               n = tree_low_cst (idx, 0);
1862
1863               /* Map vtable index back one, to allow for the null pointer to
1864                  member.  */
1865               --n;
1866
1867               while (n > 0 && virtuals)
1868                 {
1869                   --n;
1870                   virtuals = TREE_CHAIN (virtuals);
1871                 }
1872               if (virtuals)
1873                 {
1874                   dump_expr (TREE_VALUE (virtuals),
1875                              flags | TS_EXPR_PARENS);
1876                   break;
1877                 }
1878             }
1879         }
1880       OB_PUTC ('{');
1881       dump_expr_list (CONSTRUCTOR_ELTS (t), flags);
1882       OB_PUTC ('}');
1883       break;
1884
1885     case OFFSET_REF:
1886       {
1887         tree ob = TREE_OPERAND (t, 0);
1888         if (is_dummy_object (ob))
1889           {
1890             t = TREE_OPERAND (t, 1);
1891             if (TREE_CODE (t) == FUNCTION_DECL)
1892               /* A::f */
1893               dump_expr (t, flags | TS_EXPR_PARENS);
1894             else if (BASELINK_P (t))
1895               dump_expr (OVL_CURRENT (TREE_VALUE (t)), flags | TS_EXPR_PARENS);
1896             else
1897               dump_decl (t, flags);
1898           }
1899         else
1900           {
1901             if (TREE_CODE (ob) == INDIRECT_REF)
1902               {
1903                 dump_expr (TREE_OPERAND (ob, 0), flags | TS_EXPR_PARENS);
1904                 OB_PUTS (" ->* ");
1905               }
1906             else
1907               {
1908                 dump_expr (ob, flags | TS_EXPR_PARENS);
1909                 OB_PUTS (" .* ");
1910               }
1911             dump_expr (TREE_OPERAND (t, 1), flags | TS_EXPR_PARENS);
1912           }
1913         break;
1914       }
1915
1916     case TEMPLATE_PARM_INDEX:
1917       dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TS_DECL_TYPE);
1918       break;
1919
1920     case IDENTIFIER_NODE:
1921       OB_PUTID (t);
1922       break;
1923
1924     case SCOPE_REF:
1925       dump_type (TREE_OPERAND (t, 0), flags);
1926       OB_PUTS ("::");
1927       dump_expr (TREE_OPERAND (t, 1), flags | TS_EXPR_PARENS);
1928       break;
1929
1930     case CAST_EXPR:
1931       if (TREE_OPERAND (t, 0) == NULL_TREE
1932           || TREE_CHAIN (TREE_OPERAND (t, 0)))
1933         {
1934           dump_type (TREE_TYPE (t), flags);
1935           OB_PUTC ('(');
1936           dump_expr_list (TREE_OPERAND (t, 0), flags);
1937           OB_PUTC (')');
1938         }
1939       else
1940         {
1941           OB_PUTC ('(');
1942           dump_type (TREE_TYPE (t), flags);
1943           OB_PUTC (')');
1944           OB_PUTC ('(');
1945           dump_expr_list (TREE_OPERAND (t, 0), flags);
1946           OB_PUTC (')');
1947         }
1948       break;
1949
1950     case LOOKUP_EXPR:
1951       OB_PUTID (TREE_OPERAND (t, 0));
1952       break;
1953
1954     case ARROW_EXPR:
1955       dump_expr (TREE_OPERAND (t, 0), flags);
1956       OB_PUTS ("->");
1957       break;
1958
1959     case SIZEOF_EXPR:
1960     case ALIGNOF_EXPR:
1961       if (TREE_CODE (t) == SIZEOF_EXPR)
1962         OB_PUTS ("sizeof (");
1963       else
1964         {
1965           my_friendly_assert (TREE_CODE (t) == ALIGNOF_EXPR, 0);
1966           OB_PUTS ("__alignof__ (");
1967         }
1968       if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (t, 0))) == 't')
1969         dump_type (TREE_OPERAND (t, 0), flags);
1970       else
1971         dump_unary_op ("*", t, flags | TS_EXPR_PARENS);
1972       OB_PUTC (')');
1973       break;
1974
1975     case DEFAULT_ARG:
1976       OB_PUTS ("{unparsed}");
1977       break;
1978
1979     case TRY_CATCH_EXPR:
1980     case WITH_CLEANUP_EXPR:
1981     case CLEANUP_POINT_EXPR:
1982       dump_expr (TREE_OPERAND (t, 0), flags);
1983       break;
1984
1985     case PSEUDO_DTOR_EXPR:
1986       dump_expr (TREE_OPERAND (t, 2), flags);
1987       OB_PUTS (".");
1988       dump_type (TREE_OPERAND (t, 0), flags);
1989       OB_PUTS ("::~");
1990       dump_type (TREE_OPERAND (t, 1), flags);
1991       break;
1992
1993     case TEMPLATE_ID_EXPR:
1994       dump_decl (t, flags);
1995       break;
1996
1997     case STMT_EXPR:
1998       /* We don't yet have a way of dumping statements in a
1999          human-readable format.  */
2000       OB_PUTS ("{ ... }");
2001       break;
2002
2003     case BIND_EXPR:
2004       OB_PUTS ("{ ");
2005       dump_expr (TREE_OPERAND (t, 1), flags & ~TS_EXPR_PARENS);
2006       OB_PUTS ("} ");
2007       break;
2008
2009     case LOOP_EXPR:
2010       OB_PUTS ("while (1) { ");
2011       dump_expr (TREE_OPERAND (t, 0), flags & ~TS_EXPR_PARENS);
2012       OB_PUTS ("} ");
2013       break;
2014
2015     case EXIT_EXPR:
2016       OB_PUTS ("if (");
2017       dump_expr (TREE_OPERAND (t, 0), flags & ~TS_EXPR_PARENS);
2018       OB_PUTS (") break; ");
2019       break;
2020
2021     case TREE_LIST:
2022       if (TREE_VALUE (t) && TREE_CODE (TREE_VALUE (t)) == FUNCTION_DECL)
2023         {
2024           OB_PUTID (DECL_NAME (TREE_VALUE (t)));
2025           break;
2026         }
2027       /* else fall through */
2028
2029       /*  This list is incomplete, but should suffice for now.
2030           It is very important that `sorry' does not call
2031           `report_error_function'.  That could cause an infinite loop.  */
2032     default:
2033       sorry ("`%s' not supported by dump_expr",
2034              tree_code_name[(int) TREE_CODE (t)]);
2035
2036       /* fall through to ERROR_MARK...  */
2037     case ERROR_MARK:
2038       OB_PUTCP ("{expression error}");
2039       break;
2040     }
2041 }
2042
2043 static void
2044 dump_binary_op (opstring, t, flags)
2045      const char *opstring;
2046      tree t;
2047      enum tree_string_flags flags;
2048 {
2049   OB_PUTC ('(');
2050   dump_expr (TREE_OPERAND (t, 0), flags | TS_EXPR_PARENS);
2051   OB_PUTC (' ');
2052   if (opstring)
2053     OB_PUTCP (opstring);
2054   else
2055     OB_PUTS ("<unknown operator>");
2056   OB_PUTC (' ');
2057   dump_expr (TREE_OPERAND (t, 1), flags | TS_EXPR_PARENS);
2058   OB_PUTC (')');
2059 }
2060
2061 static void
2062 dump_unary_op (opstring, t, flags)
2063      const char *opstring;
2064      tree t;
2065      enum tree_string_flags flags;
2066 {
2067   if (flags & TS_EXPR_PARENS)
2068     OB_PUTC ('(');
2069   OB_PUTCP (opstring);
2070   dump_expr (TREE_OPERAND (t, 0), flags & ~TS_EXPR_PARENS);
2071   if (flags & TS_EXPR_PARENS)
2072     OB_PUTC (')');
2073 }
2074
2075 /* Exported interface to stringifying types, exprs and decls under TS_*
2076    control.  */
2077
2078 const char *
2079 type_as_string (typ, flags)
2080      tree typ;
2081      enum tree_string_flags flags;
2082 {
2083   OB_INIT ();
2084
2085   dump_type (typ, flags);
2086
2087   OB_FINISH ();
2088
2089   return (char *)obstack_base (&scratch_obstack);
2090 }
2091
2092 const char *
2093 expr_as_string (decl, flags)
2094      tree decl;
2095      enum tree_string_flags flags;
2096 {
2097   OB_INIT ();
2098
2099   dump_expr (decl, flags);
2100
2101   OB_FINISH ();
2102
2103   return (char *)obstack_base (&scratch_obstack);
2104 }
2105
2106 const char *
2107 decl_as_string (decl, flags)
2108      tree decl;
2109      enum tree_string_flags flags;
2110 {
2111   OB_INIT ();
2112
2113   dump_decl (decl, flags);
2114
2115   OB_FINISH ();
2116
2117   return (char *)obstack_base (&scratch_obstack);
2118 }
2119
2120 const char *
2121 context_as_string (context, flags)
2122      tree context;
2123      enum tree_string_flags flags;
2124 {
2125   OB_INIT ();
2126
2127   dump_scope (context, flags);
2128
2129   OB_FINISH ();
2130
2131   return (char *)obstack_base (&scratch_obstack);
2132 }
2133
2134 /* Generate the three forms of printable names for lang_printable_name.  */
2135
2136 const char *
2137 lang_decl_name (decl, v)
2138      tree decl;
2139      int v;
2140 {
2141   if (v >= 2)
2142     return decl_as_string (decl, TS_DECL_TYPE);
2143
2144   OB_INIT ();
2145
2146   if (v == 1 && DECL_CLASS_SCOPE_P (decl))
2147     {
2148       dump_type (CP_DECL_CONTEXT (decl), TS_PLAIN);
2149       OB_PUTS ("::");
2150     }
2151
2152   if (TREE_CODE (decl) == FUNCTION_DECL)
2153     dump_function_name (decl, TS_PLAIN);
2154   else
2155     dump_decl (DECL_NAME (decl), TS_PLAIN);
2156
2157   OB_FINISH ();
2158
2159   return (char *)obstack_base (&scratch_obstack);
2160 }
2161
2162 const char *
2163 cp_file_of (t)
2164      tree t;
2165 {
2166   if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
2167     return DECL_SOURCE_FILE (DECL_CONTEXT (t));
2168   else if (TREE_CODE_CLASS (TREE_CODE (t)) == 't')
2169     return DECL_SOURCE_FILE (TYPE_MAIN_DECL (t));
2170   else if (TREE_CODE (t) == OVERLOAD)
2171     return DECL_SOURCE_FILE (OVL_FUNCTION (t));
2172   else
2173     return DECL_SOURCE_FILE (t);
2174 }
2175
2176 int
2177 cp_line_of (t)
2178      tree t;
2179 {
2180   int line = 0;
2181   if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
2182     line = DECL_SOURCE_LINE (DECL_CONTEXT (t));
2183   if (TREE_CODE (t) == TYPE_DECL && DECL_ARTIFICIAL (t)
2184       && TYPE_MAIN_DECL (TREE_TYPE (t)))
2185     t = TREE_TYPE (t);
2186
2187   if (TREE_CODE_CLASS (TREE_CODE (t)) == 't')
2188     line = DECL_SOURCE_LINE (TYPE_MAIN_DECL (t));
2189   else if (TREE_CODE (t) == OVERLOAD)
2190     line = DECL_SOURCE_LINE (OVL_FUNCTION (t));
2191   else
2192     line = DECL_SOURCE_LINE (t);
2193
2194   if (line == 0)
2195     return lineno;
2196
2197   return line;
2198 }
2199
2200 /* Now the interfaces from cp_error et al to dump_type et al. Each takes an
2201    on/off VERBOSE flag and supply the appropriate TS_ flags to a dump_
2202    function.  */
2203
2204 static const char *
2205 decl_to_string (decl, verbose)
2206      tree decl;
2207      int verbose;
2208 {
2209   enum tree_string_flags flags = 0;
2210
2211   if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2212       || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2213     flags = TS_AGGR_TAGS;
2214   if (verbose)
2215     flags |= TS_DECL_TYPE | TS_DECORATE | TS_PARM_DEFAULTS;
2216   else if (TREE_CODE (decl) == FUNCTION_DECL)
2217     flags |= TS_DECL_TYPE | TS_FUNC_NORETURN;
2218   flags |= TS_TEMPLATE_PREFIX;
2219
2220   OB_INIT ();
2221
2222   dump_decl (decl, flags);
2223
2224   OB_FINISH ();
2225
2226   return (char *)obstack_base (&scratch_obstack);
2227 }
2228
2229 static const char *
2230 expr_to_string (decl, verbose)
2231      tree decl;
2232      int verbose ATTRIBUTE_UNUSED;
2233 {
2234   OB_INIT ();
2235
2236   dump_expr (decl, 0);
2237
2238   OB_FINISH ();
2239
2240   return (char *)obstack_base (&scratch_obstack);
2241 }
2242
2243 static const char *
2244 fndecl_to_string (fndecl, verbose)
2245      tree fndecl;
2246      int verbose;
2247 {
2248   enum tree_string_flags flags;
2249
2250   flags = TS_FUNC_THROW | TS_DECL_TYPE;
2251   if (verbose)
2252     flags |= TS_PARM_DEFAULTS;
2253   OB_INIT ();
2254
2255   dump_decl (fndecl, flags);
2256
2257   OB_FINISH ();
2258
2259   return (char *)obstack_base (&scratch_obstack);
2260 }
2261
2262
2263 static const char *
2264 code_to_string (c, v)
2265      enum tree_code c;
2266      int v ATTRIBUTE_UNUSED;
2267 {
2268   return tree_code_name [c];
2269 }
2270
2271 static const char *
2272 language_to_string (c, v)
2273      enum languages c;
2274      int v ATTRIBUTE_UNUSED;
2275 {
2276   switch (c)
2277     {
2278     case lang_c:
2279       return "C";
2280
2281     case lang_cplusplus:
2282       return "C++";
2283
2284     case lang_java:
2285       return "Java";
2286
2287     default:
2288       my_friendly_abort (355);
2289       return 0;
2290     }
2291 }
2292
2293 /* Return the proper printed version of a parameter to a C++ function.  */
2294
2295 static const char *
2296 parm_to_string (p, v)
2297      int p;
2298      int v ATTRIBUTE_UNUSED;
2299 {
2300   if (p < 0)
2301     return "`this'";
2302
2303   sprintf (digit_buffer, "%d", p+1);
2304   return digit_buffer;
2305 }
2306
2307 static const char *
2308 op_to_string (p, v)
2309      enum tree_code p;
2310      int v ATTRIBUTE_UNUSED;
2311 {
2312   static char buf[] = "operator                ";
2313
2314   if (p == 0)
2315     return "{unknown}";
2316
2317   strcpy (buf + 8, opname_tab [p]);
2318   return buf;
2319 }
2320
2321 static const char *
2322 type_to_string (typ, verbose)
2323      tree typ;
2324      int verbose;
2325 {
2326   enum tree_string_flags flags;
2327
2328   flags = 0;
2329   if (verbose)
2330     flags |= TS_AGGR_TAGS;
2331   flags |= TS_TEMPLATE_PREFIX;
2332
2333   OB_INIT ();
2334
2335   dump_type (typ, flags);
2336
2337   OB_FINISH ();
2338
2339   return (char *)obstack_base (&scratch_obstack);
2340 }
2341
2342 static const char *
2343 assop_to_string (p, v)
2344      enum tree_code p;
2345      int v ATTRIBUTE_UNUSED;
2346 {
2347   static char buf[] = "operator                ";
2348
2349   if (p == 0)
2350     return "{unknown}";
2351
2352   strcpy (buf + 9, assignop_tab [p]);
2353   return buf;
2354 }
2355
2356 static const char *
2357 args_to_string (p, verbose)
2358      tree p;
2359      int verbose;
2360 {
2361   enum tree_string_flags flags = 0;
2362   if (verbose)
2363     flags |= TS_AGGR_TAGS;
2364
2365   if (p == NULL_TREE)
2366     return "";
2367
2368   if (TREE_CODE_CLASS (TREE_CODE (TREE_VALUE (p))) == 't')
2369     return type_as_string (p, flags);
2370
2371   OB_INIT ();
2372   for (; p; p = TREE_CHAIN (p))
2373     {
2374       if (TREE_VALUE (p) == null_node)
2375         OB_PUTS ("NULL");
2376       else
2377         dump_type (error_type (TREE_VALUE (p)), flags);
2378       if (TREE_CHAIN (p))
2379         OB_PUTS (", ");
2380     }
2381   OB_FINISH ();
2382   return (char *)obstack_base (&scratch_obstack);
2383 }
2384
2385 static const char *
2386 cv_to_string (p, v)
2387      tree p;
2388      int v ATTRIBUTE_UNUSED;
2389 {
2390   OB_INIT ();
2391
2392   dump_qualifiers (p, before);
2393
2394   OB_FINISH ();
2395
2396   return (char *)obstack_base (&scratch_obstack);
2397 }