gcc/cp/error.c

   1 /* Call-backs for C++ error reporting.
   2    This code is non-reentrant.
   3    Copyright (C) 1993, 1994, 1995, 1996 Free Software Foundation, Inc.
   4
   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 <stdio.h>
  24 #ifdef HAVE_STDLIB_H
  25 #include <stdlib.h>
  26 #endif
  27 #include "tree.h"
  28 #include "cp-tree.h"
  29 #include "obstack.h"
  30 #include <ctype.h>
  31
  32 typedef char* cp_printer ();
  33
  34 #define A args_as_string
  35 #define C code_as_string
  36 #define D decl_as_string
  37 #define E expr_as_string
  38 #define L language_as_string
  39 #define O op_as_string
  40 #define P parm_as_string
  41 #define Q assop_as_string
  42 #define T type_as_string
  43 #define V cv_as_string
  44
  45 #define _ (cp_printer *) 0
  46 cp_printer * cp_printers[256] =
  47 {
  48 /*0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F */
  49   _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* 0x00 */
  50   _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* 0x10 */
  51   _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* 0x20 */
  52   _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* 0x30 */
  53   _, A, _, C, D, E, _, _, _, _, _, _, L, _, _, O, /* 0x40 */
  54   P, Q, _, _, T, _, V, _, _, _, _, _, _, _, _, _, /* 0x50 */
  55   _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* 0x60 */
  56   _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* 0x70 */
  57 };
  58 #undef C
  59 #undef D
  60 #undef E
  61 #undef L
  62 #undef O
  63 #undef P
  64 #undef Q
  65 #undef T
  66 #undef V
  67 #undef _
  68
  69 #define obstack_chunk_alloc xmalloc
  70 #define obstack_chunk_free free
  71
  72 /* Obstack where we build text strings for overloading, etc.  */
  73 static struct obstack scratch_obstack;
  74 static char *scratch_firstobj;
  75
  76 # define OB_INIT() (scratch_firstobj ? (obstack_free (&scratch_obstack, scratch_firstobj), 0) : 0)
  77 # define OB_PUTC(C) (obstack_1grow (&scratch_obstack, (C)))
  78 # define OB_PUTC2(C1,C2)        \
  79   (obstack_1grow (&scratch_obstack, (C1)), obstack_1grow (&scratch_obstack, (C2)))
  80 # define OB_PUTS(S) (obstack_grow (&scratch_obstack, (S), sizeof (S) - 1))
  81 # define OB_PUTID(ID)  \
  82   (obstack_grow (&scratch_obstack, IDENTIFIER_POINTER (ID),     \
  83                  IDENTIFIER_LENGTH (ID)))
  84 # define OB_PUTCP(S) (obstack_grow (&scratch_obstack, (S), strlen (S)))
  85 # define OB_FINISH() (obstack_1grow (&scratch_obstack, '\0'))
  86 # define OB_PUTI(CST) do { sprintf (digit_buffer, "%d", (CST)); \
  87                            OB_PUTCP (digit_buffer); } while (0)
  88 # define OB_UNPUT(N) obstack_blank (&scratch_obstack, - (N));
  89
  90 # define NEXT_CODE(t) (TREE_CODE (TREE_TYPE (t)))
  91
  92 enum pad { none, before, after };
  93
  94 static void dump_type PROTO((tree, int));
  95 static void dump_decl PROTO((tree, int));
  96 static void dump_function_decl PROTO((tree, int));
  97 static void dump_expr PROTO((tree, int));
  98 static void dump_unary_op PROTO((char *, tree, int));
  99 static void dump_binary_op PROTO((char *, tree));
 100 static void dump_aggr_type PROTO((tree, int));
 101 static void dump_type_prefix PROTO((tree, int));
 102 static void dump_type_suffix PROTO((tree, int));
 103 static void dump_function_name PROTO((tree));
 104 static void dump_expr_list PROTO((tree));
 105 static void dump_global_iord PROTO((tree));
 106 static void dump_readonly_or_volatile PROTO((tree, enum pad));
 107 static void dump_char PROTO((int));
 108 static char *aggr_variety PROTO((tree));
 109 static tree ident_fndecl PROTO((tree));
 110
 111 void
 112 init_error ()
 113 {
 114   gcc_obstack_init (&scratch_obstack);
 115   scratch_firstobj = (char *)obstack_alloc (&scratch_obstack, 0);
 116 }
 117
 118 static void
 119 dump_readonly_or_volatile (t, p)
 120      tree t;
 121      enum pad p;
 122 {
 123   if (TYPE_READONLY (t) || TYPE_VOLATILE (t))
 124     {
 125       if (p == before) OB_PUTC (' ');
 126       if (TYPE_READONLY (t))
 127         OB_PUTS ("const");
 128       if (TYPE_READONLY (t) && TYPE_VOLATILE (t))
 129         OB_PUTC (' ');
 130       if (TYPE_VOLATILE (t))
 131         OB_PUTS ("volatile");
 132       if (p == after) OB_PUTC (' ');
 133     }
 134 }
 135
 136 /* This must be large enough to hold any printed integer or floating-point
 137    value.  */
 138 static char digit_buffer[128];
 139
 140 /* Dump into the obstack a human-readable equivalent of TYPE.  */
 141
 142 static void
 143 dump_type (t, v)
 144      tree t;
 145      int v;                     /* verbose? */
 146 {
 147   if (t == NULL_TREE)
 148     return;
 149
 150   if (TYPE_PTRMEMFUNC_P (t))
 151     goto offset_type;
 152
 153   switch (TREE_CODE (t))
 154     {
 155     case ERROR_MARK:
 156       OB_PUTS ("{error}");
 157       break;
 158
 159     case UNKNOWN_TYPE:
 160       OB_PUTS ("{unknown type}");
 161       break;
 162
 163     case TREE_LIST:
 164       /* i.e. function taking no arguments */
 165       if (t != void_list_node)
 166         {
 167           dump_type (TREE_VALUE (t), v);
 168           /* Can this happen other than for default arguments? */
 169           if (TREE_PURPOSE (t) && v)
 170             {
 171               OB_PUTS (" = ");
 172               dump_expr (TREE_PURPOSE (t), 0);
 173             }
 174           if (TREE_CHAIN (t))
 175             {
 176               if (TREE_CHAIN (t) != void_list_node)
 177                 {
 178                   OB_PUTC2 (',', ' ');
 179                   dump_type (TREE_CHAIN (t), v);
 180                 }
 181             }
 182           else OB_PUTS (" ...");
 183         }
 184       break;
 185
 186     case IDENTIFIER_NODE:
 187       OB_PUTID (t);
 188       break;
 189
 190     case TREE_VEC:
 191       dump_type (BINFO_TYPE (t), v);
 192       break;
 193
 194     case RECORD_TYPE:
 195     case UNION_TYPE:
 196     case ENUMERAL_TYPE:
 197       if (TYPE_LANG_SPECIFIC (t)
 198           && (IS_SIGNATURE_POINTER (t) || IS_SIGNATURE_REFERENCE (t)))
 199         {
 200           if (TYPE_READONLY (t) | TYPE_VOLATILE (t))
 201             dump_readonly_or_volatile (t, after);
 202           dump_type (SIGNATURE_TYPE (t), v);
 203           if (IS_SIGNATURE_POINTER (t))
 204             OB_PUTC ('*');
 205           else
 206             OB_PUTC ('&');
 207         }
 208       else
 209         dump_aggr_type (t, v);
 210       break;
 211
 212     case TYPE_DECL:
 213     case TEMPLATE_DECL:
 214       dump_decl (t, v);
 215       break;
 216
 217     case COMPLEX_TYPE:
 218       OB_PUTS ("complex ");
 219       dump_type (TREE_TYPE (t), v);
 220       break;
 221
 222     case INTEGER_TYPE:
 223       if (!TREE_UNSIGNED (TYPE_MAIN_VARIANT (t)) && TREE_UNSIGNED (t))
 224         OB_PUTS ("unsigned ");
 225       else if (TREE_UNSIGNED (TYPE_MAIN_VARIANT (t)) && !TREE_UNSIGNED (t))
 226         OB_PUTS ("signed ");
 227
 228       /* fall through.  */
 229     case REAL_TYPE:
 230     case VOID_TYPE:
 231     case BOOLEAN_TYPE:
 232       dump_readonly_or_volatile (t, after);
 233       OB_PUTID (TYPE_IDENTIFIER (t));
 234       break;
 235
 236     case TEMPLATE_TEMPLATE_PARM:
 237       if (!CLASSTYPE_TEMPLATE_INFO (t))
 238         {
 239           /* For parameters inside template signature. */
 240           if (TYPE_IDENTIFIER (t))
 241             OB_PUTID (TYPE_IDENTIFIER (t));
 242           else
 243             OB_PUTS ("{anonymous template template parm}");
 244         }
 245       else
 246         {
 247           int i;
 248           tree args = CLASSTYPE_TI_ARGS (t);
 249           OB_PUTID (TYPE_IDENTIFIER (t));
 250           OB_PUTC ('<');
 251           for (i = 0; i < TREE_VEC_LENGTH (args); i++)
 252             {
 253               tree arg = TREE_VEC_ELT (args, i);
 254               if (TREE_CODE_CLASS (TREE_CODE (arg)) == 't'
 255                   || TREE_CODE (arg) == TEMPLATE_DECL)
 256                 dump_type (arg, 0);
 257               else
 258                 dump_expr (arg, 0);
 259               if (i < TREE_VEC_LENGTH (args)-1)
 260                 OB_PUTC2 (',', ' ');
 261             }
 262           OB_PUTC ('>');
 263         }
 264       break;
 265
 266     case TEMPLATE_TYPE_PARM:
 267       dump_readonly_or_volatile (t, after);
 268       if (TYPE_IDENTIFIER (t))
 269         OB_PUTID (TYPE_IDENTIFIER (t));
 270       else
 271         OB_PUTS ("{anonymous template type parm}");
 272       break;
 273
 274       /* This is not always necessary for pointers and such, but doing this
 275          reduces code size.  */
 276     case ARRAY_TYPE:
 277     case POINTER_TYPE:
 278     case REFERENCE_TYPE:
 279     case OFFSET_TYPE:
 280     offset_type:
 281     case FUNCTION_TYPE:
 282     case METHOD_TYPE:
 283       dump_type_prefix (t, v);
 284       dump_type_suffix (t, v);
 285       break;
 286
 287     case TYPENAME_TYPE:
 288       OB_PUTS ("typename ");
 289       dump_type (TYPE_CONTEXT (t), 0);
 290       OB_PUTS ("::");
 291       OB_PUTID (TYPE_IDENTIFIER (t));
 292       break;
 293
 294     default:
 295       sorry ("`%s' not supported by dump_type",
 296              tree_code_name[(int) TREE_CODE (t)]);
 297     }
 298 }
 299
 300 static char *
 301 aggr_variety (t)
 302      tree t;
 303 {
 304   if (TREE_CODE (t) == ENUMERAL_TYPE)
 305     return "enum";
 306   else if (TREE_CODE (t) == UNION_TYPE)
 307     return "union";
 308   else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
 309     return "class";
 310   else if (TYPE_LANG_SPECIFIC (t) && IS_SIGNATURE (t))
 311     return "signature";
 312   else
 313     return "struct";
 314 }
 315
 316 /* Print out a class declaration, in the form `class foo'.  */
 317
 318 static void
 319 dump_aggr_type (t, v)
 320      tree t;
 321      int v;                     /* verbose? */
 322 {
 323   tree name;
 324   char *variety = aggr_variety (t);
 325
 326   dump_readonly_or_volatile (t, after);
 327
 328   if (v > 0)
 329     {
 330       OB_PUTCP (variety);
 331       OB_PUTC (' ');
 332     }
 333
 334   name = TYPE_NAME (t);
 335
 336   if (name && DECL_CONTEXT (name))
 337     {
 338       /* FUNCTION_DECL or RECORD_TYPE */
 339       dump_decl (DECL_CONTEXT (name), 0);
 340       OB_PUTC2 (':', ':');
 341     }
 342
 343   /* kludge around weird behavior on g++.brendan/line1.C */
 344   if (name && TREE_CODE (name) != IDENTIFIER_NODE)
 345     name = DECL_NAME (name);
 346
 347   if (name == 0 || ANON_AGGRNAME_P (name))
 348     {
 349       OB_PUTS ("{anonymous");
 350       if (!v)
 351         {
 352           OB_PUTC (' ');
 353           OB_PUTCP (variety);
 354         }
 355       OB_PUTC ('}');
 356     }
 357   else
 358     OB_PUTID (name);
 359 }
 360
 361 /* Dump into the obstack the initial part of the output for a given type.
 362    This is necessary when dealing with things like functions returning
 363    functions.  Examples:
 364
 365    return type of `int (* fee ())()': pointer -> function -> int.  Both
 366    pointer (and reference and offset) and function (and member) types must
 367    deal with prefix and suffix.
 368
 369    Arrays must also do this for DECL nodes, like int a[], and for things like
 370    int *[]&.  */
 371
 372 static void
 373 dump_type_prefix (t, v)
 374      tree t;
 375      int v;                     /* verbosity */
 376 {
 377   if (TYPE_PTRMEMFUNC_P (t))
 378     {
 379       t = TYPE_PTRMEMFUNC_FN_TYPE (t);
 380       goto offset_type;
 381     }
 382
 383   switch (TREE_CODE (t))
 384     {
 385     case POINTER_TYPE:
 386       {
 387         tree sub = TREE_TYPE (t);
 388
 389         dump_type_prefix (sub, v);
 390         /* A tree for a member pointer looks like pointer to offset,
 391            so let the OFFSET_TYPE case handle it.  */
 392         if (TREE_CODE (sub) != OFFSET_TYPE)
 393           {
 394             switch (TREE_CODE (sub))
 395               {
 396                 /* We don't want int ( *)() */
 397               case FUNCTION_TYPE:
 398               case METHOD_TYPE:
 399                 break;
 400
 401               case ARRAY_TYPE:
 402                 OB_PUTC2 (' ', '(');
 403                 break;
 404
 405               case POINTER_TYPE:
 406                 /* We don't want "char * *" */
 407                 if (! (TYPE_READONLY (sub) || TYPE_VOLATILE (sub)))
 408                   break;
 409                 /* But we do want "char *const *" */
 410
 411               default:
 412                 OB_PUTC (' ');
 413               }
 414             OB_PUTC ('*');
 415             dump_readonly_or_volatile (t, none);
 416           }
 417       }
 418       break;
 419
 420     case REFERENCE_TYPE:
 421       {
 422         tree sub = TREE_TYPE (t);
 423         dump_type_prefix (sub, v);
 424
 425         switch (TREE_CODE (sub))
 426           {
 427           case ARRAY_TYPE:
 428             OB_PUTC2 (' ', '(');
 429             break;
 430
 431           case POINTER_TYPE:
 432             /* We don't want "char * &" */
 433             if (! (TYPE_READONLY (sub) || TYPE_VOLATILE (sub)))
 434               break;
 435             /* But we do want "char *const &" */
 436
 437           default:
 438             OB_PUTC (' ');
 439           }
 440       }
 441       OB_PUTC ('&');
 442       dump_readonly_or_volatile (t, none);
 443       break;
 444
 445     case OFFSET_TYPE:
 446     offset_type:
 447       dump_type_prefix (TREE_TYPE (t), v);
 448       if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
 449         {
 450           OB_PUTC (' ');
 451           dump_type (TYPE_OFFSET_BASETYPE (t), 0);
 452           OB_PUTC2 (':', ':');
 453         }
 454       OB_PUTC ('*');
 455       dump_readonly_or_volatile (t, none);
 456       break;
 457
 458       /* Can only be reached through function pointer -- this would not be
 459          correct if FUNCTION_DECLs used it.  */
 460     case FUNCTION_TYPE:
 461       dump_type_prefix (TREE_TYPE (t), v);
 462       OB_PUTC2 (' ', '(');
 463       break;
 464
 465     case METHOD_TYPE:
 466       dump_type_prefix (TREE_TYPE (t), v);
 467       OB_PUTC2 (' ', '(');
 468       dump_aggr_type (TYPE_METHOD_BASETYPE (t), 0);
 469       OB_PUTC2 (':', ':');
 470       break;
 471
 472     case ARRAY_TYPE:
 473       dump_type_prefix (TREE_TYPE (t), v);
 474       break;
 475
 476     case ENUMERAL_TYPE:
 477     case ERROR_MARK:
 478     case IDENTIFIER_NODE:
 479     case INTEGER_TYPE:
 480     case BOOLEAN_TYPE:
 481     case REAL_TYPE:
 482     case RECORD_TYPE:
 483     case TEMPLATE_TYPE_PARM:
 484     case TEMPLATE_TEMPLATE_PARM:
 485     case TREE_LIST:
 486     case TYPE_DECL:
 487     case TREE_VEC:
 488     case UNION_TYPE:
 489     case UNKNOWN_TYPE:
 490     case VOID_TYPE:
 491     case TYPENAME_TYPE:
 492     case COMPLEX_TYPE:
 493       dump_type (t, v);
 494       break;
 495
 496     default:
 497       sorry ("`%s' not supported by dump_type_prefix",
 498              tree_code_name[(int) TREE_CODE (t)]);
 499     }
 500 }
 501
 502 static void
 503 dump_type_suffix (t, v)
 504      tree t;
 505      int v;                     /* verbose? */
 506 {
 507   if (TYPE_PTRMEMFUNC_P (t))
 508     t = TYPE_PTRMEMFUNC_FN_TYPE (t);
 509
 510   switch (TREE_CODE (t))
 511     {
 512     case POINTER_TYPE:
 513     case REFERENCE_TYPE:
 514     case OFFSET_TYPE:
 515       if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
 516         OB_PUTC (')');
 517       dump_type_suffix (TREE_TYPE (t), v);
 518       break;
 519
 520       /* Can only be reached through function pointer */
 521     case FUNCTION_TYPE:
 522     case METHOD_TYPE:
 523       {
 524         tree arg;
 525         OB_PUTC2 (')', '(');
 526         arg = TYPE_ARG_TYPES (t);
 527         if (TREE_CODE (t) == METHOD_TYPE)
 528           arg = TREE_CHAIN (arg);
 529
 530         if (arg)
 531           dump_type (arg, v);
 532         else
 533           OB_PUTS ("...");
 534         OB_PUTC (')');
 535         if (TREE_CODE (t) == METHOD_TYPE)
 536           dump_readonly_or_volatile
 537             (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))), before);
 538         dump_type_suffix (TREE_TYPE (t), v);
 539         break;
 540       }
 541
 542     case ARRAY_TYPE:
 543       OB_PUTC ('[');
 544       if (TYPE_DOMAIN (t))
 545         {
 546           if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (t))) == INTEGER_CST)
 547             OB_PUTI (TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (t))) + 1);
 548           else if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (t))) == MINUS_EXPR)
 549             dump_expr (TREE_OPERAND (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0), 0);
 550           else
 551             dump_expr (fold (build_binary_op
 552                              (PLUS_EXPR, TYPE_MAX_VALUE (TYPE_DOMAIN (t)),
 553                               integer_one_node, 1)), 0);
 554         }
 555       OB_PUTC (']');
 556       dump_type_suffix (TREE_TYPE (t), v);
 557       break;
 558
 559     case ENUMERAL_TYPE:
 560     case ERROR_MARK:
 561     case IDENTIFIER_NODE:
 562     case INTEGER_TYPE:
 563     case BOOLEAN_TYPE:
 564     case REAL_TYPE:
 565     case RECORD_TYPE:
 566     case TEMPLATE_TYPE_PARM:
 567     case TEMPLATE_TEMPLATE_PARM:
 568     case TREE_LIST:
 569     case TYPE_DECL:
 570     case TREE_VEC:
 571     case UNION_TYPE:
 572     case UNKNOWN_TYPE:
 573     case VOID_TYPE:
 574     case TYPENAME_TYPE:
 575     case COMPLEX_TYPE:
 576       break;
 577
 578     default:
 579       sorry ("`%s' not supported by dump_type_suffix",
 580              tree_code_name[(int) TREE_CODE (t)]);
 581     }
 582 }
 583
 584 /* Return a function declaration which corresponds to the IDENTIFIER_NODE
 585    argument.  */
 586
 587 static tree
 588 ident_fndecl (t)
 589      tree t;
 590 {
 591   tree n = lookup_name (t, 0);
 592
 593   if (n == NULL_TREE)
 594     return NULL_TREE;
 595
 596   if (TREE_CODE (n) == FUNCTION_DECL)
 597     return n;
 598   else if (TREE_CODE (n) == TREE_LIST
 599            && TREE_CODE (TREE_VALUE (n)) == FUNCTION_DECL)
 600     return TREE_VALUE (n);
 601
 602   my_friendly_abort (66);
 603   return NULL_TREE;
 604 }
 605
 606 #ifndef NO_DOLLAR_IN_LABEL
 607 #  define GLOBAL_THING "_GLOBAL_$"
 608 #else
 609 #  ifndef NO_DOT_IN_LABEL
 610 #    define GLOBAL_THING "_GLOBAL_."
 611 #  else
 612 #    define GLOBAL_THING "_GLOBAL__"
 613 #  endif
 614 #endif
 615
 616 #define GLOBAL_IORD_P(NODE) \
 617   ! strncmp (IDENTIFIER_POINTER(NODE), GLOBAL_THING, sizeof (GLOBAL_THING) - 1)
 618
 619 static void
 620 dump_global_iord (t)
 621      tree t;
 622 {
 623   char *name = IDENTIFIER_POINTER (t);
 624
 625   OB_PUTS ("(static ");
 626   if (name [sizeof (GLOBAL_THING) - 1] == 'I')
 627     OB_PUTS ("initializers");
 628   else if (name [sizeof (GLOBAL_THING) - 1] == 'D')
 629     OB_PUTS ("destructors");
 630   else
 631     my_friendly_abort (352);
 632
 633   OB_PUTS (" for ");
 634   OB_PUTCP (input_filename);
 635   OB_PUTC (')');
 636 }
 637
 638 static void
 639 dump_decl (t, v)
 640      tree t;
 641      int v;                     /* verbosity */
 642 {
 643   if (t == NULL_TREE)
 644     return;
 645
 646   switch (TREE_CODE (t))
 647     {
 648     case ERROR_MARK:
 649       OB_PUTS (" /* decl error */ ");
 650       break;
 651
 652     case TYPE_DECL:
 653       {
 654         /* Don't say 'typedef class A' */
 655         if (DECL_ARTIFICIAL (t))
 656           {
 657             dump_type (TREE_TYPE (t), v);
 658             break;
 659           }
 660       }
 661       if (v > 0)
 662         OB_PUTS ("typedef ");
 663       goto general;
 664       break;
 665
 666     case VAR_DECL:
 667       if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
 668         {
 669           OB_PUTS ("vtable for ");
 670           dump_type (DECL_CONTEXT (t), v);
 671           break;
 672         }
 673       /* else fall through */
 674     case FIELD_DECL:
 675     case PARM_DECL:
 676     general:
 677       if (v > 0)
 678         {
 679           dump_type_prefix (TREE_TYPE (t), v);
 680           OB_PUTC (' ');
 681           dump_readonly_or_volatile (t, after);
 682         }
 683       /* DECL_CLASS_CONTEXT isn't being set in some cases.  Hmm...  */
 684       if (DECL_CONTEXT (t)
 685           && TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (t))) == 't')
 686         {
 687           dump_type (DECL_CONTEXT (t), 0);
 688           OB_PUTC2 (':', ':');
 689         }
 690       if (DECL_NAME (t))
 691         dump_decl (DECL_NAME (t), v);
 692       else
 693         OB_PUTS ("{anon}");
 694       if (v > 0)
 695         dump_type_suffix (TREE_TYPE (t), v);
 696       break;
 697
 698     case NAMESPACE_DECL:
 699       OB_PUTID (DECL_NAME (t));
 700       break;
 701
 702     case ARRAY_REF:
 703       dump_decl (TREE_OPERAND (t, 0), v);
 704       OB_PUTC ('[');
 705       dump_decl (TREE_OPERAND (t, 1), v);
 706       OB_PUTC (']');
 707       break;
 708
 709       /* So that we can do dump_decl in dump_aggr_type and have it work for
 710          both class and function scope.  */
 711     case RECORD_TYPE:
 712     case UNION_TYPE:
 713     case ENUMERAL_TYPE:
 714       dump_type (t, v);
 715       break;
 716
 717     case TYPE_EXPR:
 718       my_friendly_abort (69);
 719       break;
 720
 721       /* These special cases are duplicated here so that other functions
 722          can feed identifiers to cp_error and get them demangled properly.  */
 723     case IDENTIFIER_NODE:
 724       { tree f;
 725         if (DESTRUCTOR_NAME_P (t)
 726             && (f = ident_fndecl (t))
 727             && DECL_LANGUAGE (f) == lang_cplusplus)
 728           {
 729             OB_PUTC ('~');
 730             dump_decl (DECL_NAME (f), 0);
 731           }
 732         else if (IDENTIFIER_TYPENAME_P (t))
 733           {
 734             OB_PUTS ("operator ");
 735             /* Not exactly IDENTIFIER_TYPE_VALUE.  */
 736             dump_type (TREE_TYPE (t), 0);
 737             break;
 738           }
 739         else if (IDENTIFIER_OPNAME_P (t))
 740           {
 741             char *name_string = operator_name_string (t);
 742             OB_PUTS ("operator ");
 743             OB_PUTCP (name_string);
 744           }
 745         else
 746           OB_PUTID (t);
 747       }
 748       break;
 749
 750     case FUNCTION_DECL:
 751       if (GLOBAL_IORD_P (DECL_ASSEMBLER_NAME (t)))
 752         dump_global_iord (DECL_ASSEMBLER_NAME (t));
 753       else if (! DECL_LANG_SPECIFIC (t))
 754         OB_PUTS ("{internal}");
 755       else
 756         dump_function_decl (t, v);
 757       break;
 758
 759     case TEMPLATE_DECL:
 760       {
 761         tree orig_args = DECL_TEMPLATE_PARMS (t);
 762         tree args;
 763         int i;
 764         for (args = orig_args = nreverse (orig_args);
 765              args;
 766              args = TREE_CHAIN (args))
 767           {
 768             int len = TREE_VEC_LENGTH (TREE_VALUE (args));
 769
 770             OB_PUTS ("template <");
 771             for (i = 0; i < len; i++)
 772               {
 773                 tree arg = TREE_VEC_ELT (TREE_VALUE (args), i);
 774                 tree defval = TREE_PURPOSE (arg);
 775                 arg = TREE_VALUE (arg);
 776                 if (TREE_CODE (arg) == TYPE_DECL)
 777                   {
 778                     if (DECL_NAME (arg))
 779                       {
 780                         OB_PUTS ("class ");
 781                         OB_PUTID (DECL_NAME (arg));
 782                       }
 783                     else
 784                       OB_PUTS ("class");
 785                   }
 786                 else
 787                   dump_decl (arg, 1);
 788
 789                 if (defval)
 790                   {
 791                     OB_PUTS (" = ");
 792                     if (TREE_CODE (arg) == TYPE_DECL)
 793                       dump_type (defval, 1);
 794                     else
 795                       dump_decl (defval, 1);
 796                   }
 797
 798                 OB_PUTC2 (',', ' ');
 799               }
 800             if (len != 0)
 801               OB_UNPUT (2);
 802             OB_PUTC2 ('>', ' ');
 803           }
 804         nreverse(orig_args);
 805
 806         if (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
 807           dump_type (TREE_TYPE (t), v);
 808         else if (TREE_TYPE (t) == NULL_TREE)
 809            my_friendly_abort (353);
 810         else switch (NEXT_CODE (t))
 811           {
 812           case METHOD_TYPE:
 813           case FUNCTION_TYPE:
 814             dump_function_decl (t, v);
 815             break;
 816
 817           default:
 818             /* This case can occur with some illegal code.  */
 819             dump_type (TREE_TYPE (t), v);
 820           }
 821       }
 822       break;
 823
 824     case TEMPLATE_ID_EXPR:
 825       {
 826         tree args;
 827         tree name = TREE_OPERAND (t, 0);
 828         if (is_overloaded_fn (name))
 829           name = DECL_NAME (get_first_fn (name));
 830         dump_decl (name, v);
 831         OB_PUTC ('<');
 832         for (args = TREE_OPERAND (t, 1); args; args = TREE_CHAIN (args))
 833           {
 834             if (TREE_CODE_CLASS (TREE_CODE (TREE_VALUE (args))) == 't'
 835                 || TREE_CODE (TREE_VALUE (args)) == TEMPLATE_DECL)
 836               dump_type (TREE_VALUE (args), 0);
 837             else
 838               dump_expr (TREE_VALUE (args), 0);
 839             if (TREE_CHAIN (args))
 840               OB_PUTC2 (',', ' ');
 841           }
 842         OB_PUTC ('>');
 843       }
 844       break;
 845
 846     case LOOKUP_EXPR:
 847       OB_PUTID (TREE_OPERAND (t, 0));
 848       break;
 849
 850     case LABEL_DECL:
 851       OB_PUTID (DECL_NAME (t));
 852       break;
 853
 854     case CONST_DECL:
 855       if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
 856           || (DECL_INITIAL (t) &&
 857               TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_CONST_PARM))
 858         goto general;
 859       else if (DECL_NAME (t))
 860         dump_decl (DECL_NAME (t), v);
 861       else if (DECL_INITIAL (t))
 862         dump_expr (DECL_INITIAL (t), 0);
 863       else
 864         OB_PUTS ("enumerator");
 865       break;
 866
 867     case USING_DECL:
 868       OB_PUTS ("using ");
 869       dump_type (DECL_INITIAL (t), 0);
 870       OB_PUTS ("::");
 871       OB_PUTID (DECL_NAME (t));
 872       break;
 873
 874     default:
 875       sorry ("`%s' not supported by dump_decl",
 876              tree_code_name[(int) TREE_CODE (t)]);
 877     }
 878 }
 879
 880 /* Pretty printing for announce_function.  T is the declaration of the
 881    function we are interested in seeing.  V is non-zero if we should print
 882    the type that this function returns.  */
 883
 884 static void
 885 dump_function_decl (t, v)
 886      tree t;
 887      int v;
 888 {
 889   tree name;
 890   tree fntype;
 891   tree parmtypes;
 892   tree cname = NULL_TREE;
 893
 894   if (TREE_CODE (t) == TEMPLATE_DECL)
 895     t = DECL_TEMPLATE_RESULT (t);
 896
 897   name = DECL_ASSEMBLER_NAME (t);
 898   fntype = TREE_TYPE (t);
 899   parmtypes = TYPE_ARG_TYPES (fntype);
 900
 901   /* Friends have DECL_CLASS_CONTEXT set, but not DECL_CONTEXT.  */
 902   if (DECL_CONTEXT (t))
 903     cname = DECL_CLASS_CONTEXT (t);
 904   /* this is for partially instantiated template methods */
 905   else if (TREE_CODE (fntype) == METHOD_TYPE)
 906     cname = TREE_TYPE (TREE_VALUE (parmtypes));
 907
 908   v = (v > 0);
 909
 910   if (v)
 911     {
 912       if (DECL_STATIC_FUNCTION_P (t))
 913         OB_PUTS ("static ");
 914
 915       if (! IDENTIFIER_TYPENAME_P (name)
 916           && ! DECL_CONSTRUCTOR_P (t)
 917           && ! DESTRUCTOR_NAME_P (name))
 918         {
 919           dump_type_prefix (TREE_TYPE (fntype), 1);
 920           OB_PUTC (' ');
 921         }
 922     }
 923
 924   if (cname)
 925     {
 926       dump_type (cname, 0);
 927       OB_PUTC2 (':', ':');
 928       if (TREE_CODE (fntype) == METHOD_TYPE && parmtypes)
 929         parmtypes = TREE_CHAIN (parmtypes);
 930       if (DECL_CONSTRUCTOR_FOR_VBASE_P (t))
 931         /* Skip past "in_charge" identifier.  */
 932         parmtypes = TREE_CHAIN (parmtypes);
 933     }
 934
 935   if (DESTRUCTOR_NAME_P (name) && DECL_LANGUAGE (t) == lang_cplusplus)
 936     parmtypes = TREE_CHAIN (parmtypes);
 937
 938   dump_function_name (t);
 939
 940   OB_PUTC ('(');
 941
 942   if (parmtypes)
 943     dump_type (parmtypes, v);
 944   else
 945     OB_PUTS ("...");
 946
 947   OB_PUTC (')');
 948
 949   if (v && ! IDENTIFIER_TYPENAME_P (name))
 950     dump_type_suffix (TREE_TYPE (fntype), 1);
 951
 952   if (TREE_CODE (fntype) == METHOD_TYPE)
 953     {
 954       if (IS_SIGNATURE (cname))
 955         /* We look at the type pointed to by the `optr' field of `this.'  */
 956         dump_readonly_or_volatile
 957           (TREE_TYPE (TREE_TYPE (TYPE_FIELDS (TREE_VALUE (TYPE_ARG_TYPES (fntype))))), before);
 958       else
 959         dump_readonly_or_volatile
 960           (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))), before);
 961     }
 962 }
 963
 964 /* Handle the function name for a FUNCTION_DECL node, grokking operators
 965    and destructors properly.  */
 966
 967 static void
 968 dump_function_name (t)
 969      tree t;
 970 {
 971   tree name = DECL_NAME (t);
 972
 973   /* There ought to be a better way to find out whether or not something is
 974      a destructor.  */
 975   if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (t))
 976       && DECL_LANGUAGE (t) == lang_cplusplus)
 977     {
 978       OB_PUTC ('~');
 979       dump_decl (name, 0);
 980     }
 981   else if (IDENTIFIER_TYPENAME_P (name))
 982     {
 983       /* This cannot use the hack that the operator's return
 984          type is stashed off of its name because it may be
 985          used for error reporting.  In the case of conflicting
 986          declarations, both will have the same name, yet
 987          the types will be different, hence the TREE_TYPE field
 988          of the first name will be clobbered by the second.  */
 989       OB_PUTS ("operator ");
 990       dump_type (TREE_TYPE (TREE_TYPE (t)), 0);
 991     }
 992   else if (IDENTIFIER_OPNAME_P (name))
 993     {
 994       char *name_string = operator_name_string (name);
 995       OB_PUTS ("operator ");
 996       OB_PUTCP (name_string);
 997     }
 998   else
 999     dump_decl (name, 0);
1000
1001   if (DECL_LANG_SPECIFIC (t) && DECL_USE_TEMPLATE (t))
1002     {
1003       tree args = DECL_TEMPLATE_INFO (t) ? DECL_TI_ARGS (t) : NULL_TREE;
1004
1005       if (args != NULL_TREE
1006           && DECL_CONTEXT (t) != NULL_TREE
1007           && uses_template_parms (DECL_CONTEXT (t))
1008           /* This next clause checks that there is only one level of
1009              template arguments.  In that case, they are the
1010              arguments for the class context.  */
1011           && (TREE_CODE (args) == TREE_LIST
1012               || (TREE_CODE (args) == TREE_VEC
1013                   && TREE_VEC_ELT (args, 0) != NULL_TREE
1014                   && TREE_CODE (TREE_VEC_ELT (args, 0)) != TREE_VEC)))
1015         /* We have something like this:
1016
1017            template <class T> struct S { void f(); };
1018
1019            and we are printing S<int>::f().  This is a template
1020            instantiation, but we don't print anything after the f.  */
1021         ;
1022       else
1023         {
1024           OB_PUTC ('<');
1025
1026           /* Be careful only to print things when we have them, so as not
1027              to crash producing error messages.  */
1028           if (args)
1029             {
1030               if (TREE_CODE (args) == TREE_LIST)
1031                 {
1032                   tree arg;
1033                   int need_comma = 0;
1034
1035                   for (arg = args; arg; arg = TREE_CHAIN (arg))
1036                     {
1037                       tree a = TREE_VALUE (arg);
1038
1039                       if (need_comma)
1040                         OB_PUTS (", ");
1041
1042                       if (a)
1043                         {
1044                           if (TREE_CODE_CLASS (TREE_CODE (a)) == 't'
1045                               || TREE_CODE (a) == TEMPLATE_DECL)
1046                             dump_type (a, 0);
1047                           else
1048                             dump_expr (a, 0);
1049                         }
1050
1051                       need_comma = 1;
1052                     }
1053                 }
1054               else if (TREE_CODE (args) == TREE_VEC)
1055                 {
1056                   int i;
1057                   int need_comma = 0;
1058
1059                   if (TREE_VEC_LENGTH (args) > 0
1060                       && TREE_CODE (TREE_VEC_ELT (args, 0)) == TREE_VEC)
1061                     args = TREE_VEC_ELT (args,
1062                                          TREE_VEC_LENGTH (args) - 1);
1063
1064                   for (i = 0; i < TREE_VEC_LENGTH (args); i++)
1065                     {
1066                       tree a = TREE_VEC_ELT (args, i);
1067
1068                       if (need_comma)
1069                         OB_PUTS (", ");
1070
1071                       if (a)
1072                         {
1073                           if (TREE_CODE_CLASS (TREE_CODE (a)) == 't'
1074                               || TREE_CODE (a) == TEMPLATE_DECL)
1075                             dump_type (a, 0);
1076                           else
1077                             dump_expr (a, 0);
1078                         }
1079
1080                       need_comma = 1;
1081                     }
1082                 }
1083             }
1084           OB_PUTC ('>');
1085         }
1086     }
1087 }
1088
1089 static void
1090 dump_char (c)
1091      int c;
1092 {
1093   switch (c)
1094     {
1095     case TARGET_NEWLINE:
1096       OB_PUTS ("\\n");
1097       break;
1098     case TARGET_TAB:
1099       OB_PUTS ("\\t");
1100       break;
1101     case TARGET_VT:
1102       OB_PUTS ("\\v");
1103       break;
1104     case TARGET_BS:
1105       OB_PUTS ("\\b");
1106       break;
1107     case TARGET_CR:
1108       OB_PUTS ("\\r");
1109       break;
1110     case TARGET_FF:
1111       OB_PUTS ("\\f");
1112       break;
1113     case TARGET_BELL:
1114       OB_PUTS ("\\a");
1115       break;
1116     case '\\':
1117       OB_PUTS ("\\\\");
1118       break;
1119     case '\'':
1120       OB_PUTS ("\\'");
1121       break;
1122     case '\"':
1123       OB_PUTS ("\\\"");
1124       break;
1125     default:
1126       if (isprint (c))
1127         OB_PUTC (c);
1128       else
1129         {
1130           sprintf (digit_buffer, "\\%03o", (int) c);
1131           OB_PUTCP (digit_buffer);
1132         }
1133     }
1134 }
1135
1136 /* Print out a list of initializers (subr of dump_expr) */
1137
1138 static void
1139 dump_expr_list (l)
1140      tree l;
1141 {
1142   while (l)
1143     {
1144       dump_expr (TREE_VALUE (l), 0);
1145       if (TREE_CHAIN (l))
1146         OB_PUTC2 (',', ' ');
1147       l = TREE_CHAIN (l);
1148     }
1149 }
1150
1151 /* Print out an expression */
1152
1153 static void
1154 dump_expr (t, nop)
1155      tree t;
1156      int nop;                   /* suppress parens */
1157 {
1158   switch (TREE_CODE (t))
1159     {
1160     case VAR_DECL:
1161     case PARM_DECL:
1162     case FIELD_DECL:
1163     case CONST_DECL:
1164     case FUNCTION_DECL:
1165     case TEMPLATE_DECL:
1166       dump_decl (t, -1);
1167       break;
1168
1169     case INTEGER_CST:
1170       {
1171         tree type = TREE_TYPE (t);
1172         my_friendly_assert (type != 0, 81);
1173
1174         /* If it's an enum, output its tag, rather than its value.  */
1175         if (TREE_CODE (type) == ENUMERAL_TYPE)
1176           {
1177             char *p = enum_name_string (t, type);
1178             OB_PUTCP (p);
1179           }
1180         else if (type == boolean_type_node)
1181           {
1182             if (t == boolean_false_node
1183                 || (TREE_INT_CST_LOW (t) == 0
1184                     && TREE_INT_CST_HIGH (t) == 0))
1185               OB_PUTS ("false");
1186             else if (t == boolean_true_node)
1187               OB_PUTS ("true");
1188           }
1189         else if (type == char_type_node)
1190           {
1191             OB_PUTC ('\'');
1192             dump_char (TREE_INT_CST_LOW (t));
1193             OB_PUTC ('\'');
1194           }
1195         else if (TREE_INT_CST_HIGH (t)
1196                  != (TREE_INT_CST_LOW (t) >> (HOST_BITS_PER_WIDE_INT - 1)))
1197           {
1198             tree val = t;
1199             if (TREE_INT_CST_HIGH (val) < 0)
1200               {
1201                 OB_PUTC ('-');
1202                 val = build_int_2 (~TREE_INT_CST_LOW (val),
1203                                    -TREE_INT_CST_HIGH (val));
1204               }
1205             /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
1206                systems?  */
1207             {
1208               static char format[10]; /* "%x%09999x\0" */
1209               if (!format[0])
1210                 sprintf (format, "%%x%%0%dx", HOST_BITS_PER_INT / 4);
1211               sprintf (digit_buffer, format, TREE_INT_CST_HIGH (val),
1212                        TREE_INT_CST_LOW (val));
1213               OB_PUTCP (digit_buffer);
1214             }
1215           }
1216         else
1217           OB_PUTI (TREE_INT_CST_LOW (t));
1218       }
1219       break;
1220
1221     case REAL_CST:
1222 #ifndef REAL_IS_NOT_DOUBLE
1223       sprintf (digit_buffer, "%g", TREE_REAL_CST (t));
1224 #else
1225       {
1226         unsigned char *p = (unsigned char *) &TREE_REAL_CST (t);
1227         size_t i;
1228         strcpy (digit_buffer, "0x");
1229         for (i = 0; i < sizeof TREE_REAL_CST (t); i++)
1230           sprintf (digit_buffer + 2 + 2*i, "%02x", *p++);
1231       }
1232 #endif
1233       OB_PUTCP (digit_buffer);
1234       break;
1235
1236     case STRING_CST:
1237       {
1238         char *p = TREE_STRING_POINTER (t);
1239         int len = TREE_STRING_LENGTH (t) - 1;
1240         int i;
1241
1242         OB_PUTC ('\"');
1243         for (i = 0; i < len; i++)
1244           dump_char (p[i]);
1245         OB_PUTC ('\"');
1246       }
1247       break;
1248
1249     case COMPOUND_EXPR:
1250       dump_binary_op (",", t);
1251       break;
1252
1253     case COND_EXPR:
1254       OB_PUTC ('(');
1255       dump_expr (TREE_OPERAND (t, 0), 0);
1256       OB_PUTS (" ? ");
1257       dump_expr (TREE_OPERAND (t, 1), 0);
1258       OB_PUTS (" : ");
1259       dump_expr (TREE_OPERAND (t, 2), 0);
1260       OB_PUTC (')');
1261       break;
1262
1263     case SAVE_EXPR:
1264       if (TREE_HAS_CONSTRUCTOR (t))
1265         {
1266           OB_PUTS ("new ");
1267           dump_type (TREE_TYPE (TREE_TYPE (t)), 0);
1268           PARM_DECL_EXPR (t) = 1;
1269         }
1270       else
1271         {
1272           dump_expr (TREE_OPERAND (t, 0), 0);
1273         }
1274       break;
1275
1276     case AGGR_INIT_EXPR:
1277       OB_PUTID (TYPE_IDENTIFIER (TREE_TYPE (t)));
1278       OB_PUTC ('(');
1279       if (TREE_OPERAND (t, 1))
1280         dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)));
1281       OB_PUTC (')');
1282       break;
1283
1284     case CALL_EXPR:
1285       {
1286         tree fn = TREE_OPERAND (t, 0);
1287         tree args = TREE_OPERAND (t, 1);
1288
1289         if (TREE_CODE (fn) == ADDR_EXPR)
1290           fn = TREE_OPERAND (fn, 0);
1291
1292         if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE)
1293           {
1294             tree ob = TREE_VALUE (args);
1295             if (TREE_CODE (ob) == ADDR_EXPR)
1296               {
1297                 dump_expr (TREE_OPERAND (ob, 0), 0);
1298                 OB_PUTC ('.');
1299               }
1300             else if (TREE_CODE (ob) != PARM_DECL
1301                      || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1302               {
1303                 dump_expr (ob, 0);
1304                 OB_PUTC2 ('-', '>');
1305               }
1306             args = TREE_CHAIN (args);
1307           }
1308         dump_expr (fn, 0);
1309         OB_PUTC ('(');
1310         dump_expr_list (args);
1311         OB_PUTC (')');
1312       }
1313       break;
1314
1315     case TARGET_EXPR:
1316       /* Note that this only works for G++ target exprs.  If somebody
1317          builds a general TARGET_EXPR, there's no way to represent that
1318          it initializes anything other that the parameter slot for the
1319          default argument.  Note we may have cleared out the first
1320          operand in expand_expr, so don't go killing ourselves.  */
1321       if (TREE_OPERAND (t, 1))
1322         dump_expr (TREE_OPERAND (t, 1), 0);
1323       break;
1324
1325     case MODIFY_EXPR:
1326     case PLUS_EXPR:
1327     case MINUS_EXPR:
1328     case MULT_EXPR:
1329     case TRUNC_DIV_EXPR:
1330     case TRUNC_MOD_EXPR:
1331     case MIN_EXPR:
1332     case MAX_EXPR:
1333     case LSHIFT_EXPR:
1334     case RSHIFT_EXPR:
1335     case BIT_IOR_EXPR:
1336     case BIT_XOR_EXPR:
1337     case BIT_AND_EXPR:
1338     case BIT_ANDTC_EXPR:
1339     case TRUTH_ANDIF_EXPR:
1340     case TRUTH_ORIF_EXPR:
1341     case LT_EXPR:
1342     case LE_EXPR:
1343     case GT_EXPR:
1344     case GE_EXPR:
1345     case EQ_EXPR:
1346     case NE_EXPR:
1347       dump_binary_op (opname_tab[(int) TREE_CODE (t)], t);
1348       break;
1349
1350     case CEIL_DIV_EXPR:
1351     case FLOOR_DIV_EXPR:
1352     case ROUND_DIV_EXPR:
1353       dump_binary_op ("/", t);
1354       break;
1355
1356     case CEIL_MOD_EXPR:
1357     case FLOOR_MOD_EXPR:
1358     case ROUND_MOD_EXPR:
1359       dump_binary_op ("%", t);
1360       break;
1361
1362     case COMPONENT_REF:
1363       {
1364         tree ob = TREE_OPERAND (t, 0);
1365         if (TREE_CODE (ob) == INDIRECT_REF)
1366           {
1367             ob = TREE_OPERAND (ob, 0);
1368             if (TREE_CODE (ob) != PARM_DECL
1369                 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1370               {
1371                 dump_expr (ob, 0);
1372                 OB_PUTC2 ('-', '>');
1373               }
1374           }
1375         else
1376           {
1377             dump_expr (ob, 0);
1378             OB_PUTC ('.');
1379           }
1380         dump_expr (TREE_OPERAND (t, 1), 1);
1381       }
1382       break;
1383
1384     case ARRAY_REF:
1385       dump_expr (TREE_OPERAND (t, 0), 0);
1386       OB_PUTC ('[');
1387       dump_expr (TREE_OPERAND (t, 1), 0);
1388       OB_PUTC (']');
1389       break;
1390
1391     case CONVERT_EXPR:
1392       dump_unary_op ("+", t, nop);
1393       break;
1394
1395     case ADDR_EXPR:
1396       if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1397           || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST)
1398         dump_expr (TREE_OPERAND (t, 0), 0);
1399       else
1400         dump_unary_op ("&", t, nop);
1401       break;
1402
1403     case INDIRECT_REF:
1404       if (TREE_HAS_CONSTRUCTOR (t))
1405         {
1406           t = TREE_OPERAND (t, 0);
1407           my_friendly_assert (TREE_CODE (t) == CALL_EXPR, 237);
1408           dump_expr (TREE_OPERAND (t, 0), 0);
1409           OB_PUTC ('(');
1410           dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)));
1411           OB_PUTC (')');
1412         }
1413       else
1414         {
1415           if (TREE_OPERAND (t,0) != NULL_TREE
1416               && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
1417             dump_expr (TREE_OPERAND (t, 0), nop);
1418           else
1419             dump_unary_op ("*", t, nop);
1420         }
1421       break;
1422
1423     case NEGATE_EXPR:
1424     case BIT_NOT_EXPR:
1425     case TRUTH_NOT_EXPR:
1426     case PREDECREMENT_EXPR:
1427     case PREINCREMENT_EXPR:
1428       dump_unary_op (opname_tab [(int)TREE_CODE (t)], t, nop);
1429       break;
1430
1431     case POSTDECREMENT_EXPR:
1432     case POSTINCREMENT_EXPR:
1433       OB_PUTC ('(');
1434       dump_expr (TREE_OPERAND (t, 0), 0);
1435       OB_PUTCP (opname_tab[(int)TREE_CODE (t)]);
1436       OB_PUTC (')');
1437       break;
1438
1439     case NON_LVALUE_EXPR:
1440       /* FIXME: This is a KLUDGE workaround for a parsing problem.  There
1441          should be another level of INDIRECT_REF so that I don't have to do
1442          this.  */
1443       if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
1444         {
1445           tree next = TREE_TYPE (TREE_TYPE (t));
1446
1447           while (TREE_CODE (next) == POINTER_TYPE)
1448             next = TREE_TYPE (next);
1449
1450           if (TREE_CODE (next) == FUNCTION_TYPE)
1451             {
1452               if (!nop) OB_PUTC ('(');
1453               OB_PUTC ('*');
1454               dump_expr (TREE_OPERAND (t, 0), 1);
1455               if (!nop) OB_PUTC (')');
1456               break;
1457             }
1458           /* else FALLTHRU */
1459         }
1460       dump_expr (TREE_OPERAND (t, 0), 0);
1461       break;
1462
1463     case NOP_EXPR:
1464       dump_expr (TREE_OPERAND (t, 0), nop);
1465       break;
1466
1467     case CONSTRUCTOR:
1468       if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
1469         {
1470           tree idx = build_component_ref (t, index_identifier, NULL_TREE, 0);
1471
1472           if (integer_all_onesp (idx))
1473             {
1474               tree pfn = PFN_FROM_PTRMEMFUNC (t);
1475               dump_expr (pfn, 0);
1476               break;
1477             }
1478           if (TREE_CODE (idx) == INTEGER_CST
1479               && TREE_INT_CST_HIGH (idx) == 0)
1480             {
1481               tree virtuals;
1482               unsigned HOST_WIDE_INT n;
1483
1484               t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
1485               t = TYPE_METHOD_BASETYPE (t);
1486               virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
1487
1488               n = TREE_INT_CST_LOW (idx);
1489
1490               /* Map vtable index back one, to allow for the null pointer to
1491                  member.  */
1492               --n;
1493
1494               while (n > 0 && virtuals)
1495                 {
1496                   --n;
1497                   virtuals = TREE_CHAIN (virtuals);
1498                 }
1499               if (virtuals)
1500                 {
1501                   dump_expr (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (virtuals)), 0);
1502                   break;
1503                 }
1504             }
1505         }
1506       OB_PUTC ('{');
1507       dump_expr_list (CONSTRUCTOR_ELTS (t));
1508       OB_PUTC ('}');
1509       break;
1510
1511     case OFFSET_REF:
1512       {
1513         tree ob = TREE_OPERAND (t, 0);
1514         if (TREE_CODE (ob) == NOP_EXPR
1515             && TREE_OPERAND (ob, 0) == error_mark_node
1516             && TREE_CODE (TREE_OPERAND (t, 1)) == FUNCTION_DECL)
1517             /* A::f */
1518           dump_expr (TREE_OPERAND (t, 1), 0);
1519         else
1520           {
1521             dump_expr (TREE_OPERAND (t, 0), 0);
1522             OB_PUTS (" .* ");
1523             dump_expr (TREE_OPERAND (t, 1), 0);
1524           }
1525         break;
1526       }
1527
1528     case TEMPLATE_CONST_PARM:
1529       {
1530         int l = current_template_parms ?
1531           list_length (current_template_parms) : 0;
1532
1533         if (l >= TEMPLATE_CONST_LEVEL (t))
1534           {
1535             int i;
1536             tree parms = current_template_parms;
1537             tree r;
1538
1539             for (i = 0; i < l - TEMPLATE_CONST_LEVEL (t); ++i)
1540               {
1541                 parms = TREE_CHAIN (parms);
1542                 my_friendly_assert (parms != NULL_TREE, 0);
1543               }
1544
1545             r = TREE_VEC_ELT (TREE_VALUE (parms),
1546                               TEMPLATE_CONST_IDX (t));
1547             dump_decl (TREE_VALUE (r), -1);
1548           }
1549         else
1550           {
1551             OB_PUTS ("<tparm ");
1552             OB_PUTI (TEMPLATE_CONST_IDX (t));
1553             OB_PUTS (">");
1554           }
1555       }
1556       break;
1557
1558     case IDENTIFIER_NODE:
1559       OB_PUTID (t);
1560       break;
1561
1562     case SCOPE_REF:
1563       dump_type (TREE_OPERAND (t, 0), 0);
1564       OB_PUTS ("::");
1565       dump_expr (TREE_OPERAND (t, 1), 0);
1566       break;
1567
1568     case CAST_EXPR:
1569       if (TREE_OPERAND (t, 0) == NULL_TREE
1570           || TREE_CHAIN (TREE_OPERAND (t, 0)))
1571         {
1572           dump_type (TREE_TYPE (t), 0);
1573           OB_PUTC ('(');
1574           dump_expr_list (TREE_OPERAND (t, 0));
1575           OB_PUTC (')');
1576         }
1577       else
1578         {
1579           OB_PUTC ('(');
1580           dump_type (TREE_TYPE (t), 0);
1581           OB_PUTC (')');
1582           OB_PUTC ('(');
1583           dump_expr_list (TREE_OPERAND (t, 0));
1584           OB_PUTC (')');
1585         }
1586       break;
1587
1588     case LOOKUP_EXPR:
1589       OB_PUTID (TREE_OPERAND (t, 0));
1590       break;
1591
1592     case SIZEOF_EXPR:
1593     case ALIGNOF_EXPR:
1594       if (TREE_CODE (t) == SIZEOF_EXPR)
1595         OB_PUTS ("sizeof (");
1596       else
1597         {
1598           my_friendly_assert (TREE_CODE (t) == ALIGNOF_EXPR, 0);
1599           OB_PUTS ("__alignof__ (");
1600         }
1601       if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (t, 0))) == 't')
1602         dump_type (TREE_OPERAND (t, 0), 0);
1603       else
1604         dump_unary_op ("*", t, 0);
1605       OB_PUTC (')');
1606       break;
1607
1608     case DEFAULT_ARG:
1609       OB_PUTS ("{unparsed}");
1610       break;
1611
1612     case TRY_CATCH_EXPR:
1613     case WITH_CLEANUP_EXPR:
1614     case CLEANUP_POINT_EXPR:
1615       dump_expr (TREE_OPERAND (t, 0), nop);
1616       break;
1617
1618     case TREE_LIST:
1619       if (TREE_VALUE (t) && TREE_CODE (TREE_VALUE (t)) == FUNCTION_DECL)
1620         {
1621           OB_PUTID (DECL_NAME (TREE_VALUE (t)));
1622           break;
1623         }
1624       /* else fall through */
1625
1626       /*  This list is incomplete, but should suffice for now.
1627           It is very important that `sorry' does not call
1628           `report_error_function'.  That could cause an infinite loop.  */
1629     default:
1630       sorry ("`%s' not supported by dump_expr",
1631              tree_code_name[(int) TREE_CODE (t)]);
1632
1633       /* fall through to ERROR_MARK...  */
1634     case ERROR_MARK:
1635       OB_PUTCP ("{error}");
1636       break;
1637     }
1638 }
1639
1640 static void
1641 dump_binary_op (opstring, t)
1642      char *opstring;
1643      tree t;
1644 {
1645   OB_PUTC ('(');
1646   dump_expr (TREE_OPERAND (t, 0), 1);
1647   OB_PUTC (' ');
1648   OB_PUTCP (opstring);
1649   OB_PUTC (' ');
1650   dump_expr (TREE_OPERAND (t, 1), 1);
1651   OB_PUTC (')');
1652 }
1653
1654 static void
1655 dump_unary_op (opstring, t, nop)
1656      char *opstring;
1657      tree t;
1658      int nop;
1659 {
1660   if (!nop) OB_PUTC ('(');
1661   OB_PUTCP (opstring);
1662   dump_expr (TREE_OPERAND (t, 0), 1);
1663   if (!nop) OB_PUTC (')');
1664 }
1665
1666 char *
1667 fndecl_as_string (fndecl, print_ret_type_p)
1668      tree fndecl;
1669      int print_ret_type_p;
1670 {
1671   return decl_as_string (fndecl, print_ret_type_p);
1672 }
1673
1674 /* Same, but handle a _TYPE.
1675    Called from convert_to_reference, mangle_class_name_for_template,
1676    build_unary_op, and GNU_xref_decl.  */
1677
1678 char *
1679 type_as_string (typ, v)
1680      tree typ;
1681      int v;
1682 {
1683   OB_INIT ();
1684
1685   dump_type (typ, v);
1686
1687   OB_FINISH ();
1688
1689   return (char *)obstack_base (&scratch_obstack);
1690 }
1691
1692 char *
1693 expr_as_string (decl, v)
1694      tree decl;
1695      int v;
1696 {
1697   OB_INIT ();
1698
1699   dump_expr (decl, 1);
1700
1701   OB_FINISH ();
1702
1703   return (char *)obstack_base (&scratch_obstack);
1704 }
1705
1706 /* A cross between type_as_string and fndecl_as_string.
1707    Only called from substitute_nice_name.  */
1708
1709 char *
1710 decl_as_string (decl, v)
1711      tree decl;
1712      int v;
1713 {
1714   OB_INIT ();
1715
1716   dump_decl (decl, v);
1717
1718   OB_FINISH ();
1719
1720   return (char *)obstack_base (&scratch_obstack);
1721 }
1722
1723 /* Generate the three forms of printable names for lang_printable_name.  */
1724
1725 char *
1726 lang_decl_name (decl, v)
1727      tree decl;
1728      int v;
1729 {
1730   if (v >= 2)
1731     return decl_as_string (decl, 1);
1732
1733   OB_INIT ();
1734
1735   if (v == 1 && DECL_CONTEXT (decl)
1736       && TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (decl))) == 't')
1737     {
1738       tree cname;
1739       if (TREE_CODE (decl) == FUNCTION_DECL)
1740         cname = DECL_CLASS_CONTEXT (decl);
1741       else
1742         cname = DECL_CONTEXT (decl);
1743       dump_type (cname, 0);
1744       OB_PUTC2 (':', ':');
1745     }
1746
1747   if (TREE_CODE (decl) == FUNCTION_DECL)
1748     dump_function_name (decl);
1749   else
1750     dump_decl (DECL_NAME (decl), 0);
1751
1752   OB_FINISH ();
1753
1754   return (char *)obstack_base (&scratch_obstack);
1755 }
1756
1757
1758 char *
1759 cp_file_of (t)
1760      tree t;
1761 {
1762   if (TREE_CODE (t) == PARM_DECL)
1763     return DECL_SOURCE_FILE (DECL_CONTEXT (t));
1764   else if (TREE_CODE_CLASS (TREE_CODE (t)) == 't')
1765     return DECL_SOURCE_FILE (TYPE_MAIN_DECL (t));
1766   else
1767     return DECL_SOURCE_FILE (t);
1768 }
1769
1770 int
1771 cp_line_of (t)
1772      tree t;
1773 {
1774   int line = 0;
1775   if (TREE_CODE (t) == PARM_DECL)
1776     line = DECL_SOURCE_LINE (DECL_CONTEXT (t));
1777   if (TREE_CODE (t) == TYPE_DECL && DECL_ARTIFICIAL (t))
1778     t = TREE_TYPE (t);
1779
1780   if (TREE_CODE_CLASS (TREE_CODE (t)) == 't')
1781     line = DECL_SOURCE_LINE (TYPE_MAIN_DECL (t));
1782   else
1783     line = DECL_SOURCE_LINE (t);
1784
1785   if (line == 0)
1786     return lineno;
1787
1788   return line;
1789 }
1790
1791 char *
1792 code_as_string (c, v)
1793      enum tree_code c;
1794      int v;
1795 {
1796   return tree_code_name [c];
1797 }
1798
1799 char *
1800 language_as_string (c, v)
1801      enum languages c;
1802      int v;
1803 {
1804   switch (c)
1805     {
1806     case lang_c:
1807       return "C";
1808
1809     case lang_cplusplus:
1810       return "C++";
1811
1812     default:
1813       my_friendly_abort (355);
1814       return 0;
1815     }
1816 }
1817
1818 /* Return the proper printed version of a parameter to a C++ function.  */
1819
1820 char *
1821 parm_as_string (p, v)
1822      int p, v;
1823 {
1824   if (p < 0)
1825     return "`this'";
1826
1827   sprintf (digit_buffer, "%d", p+1);
1828   return digit_buffer;
1829 }
1830
1831 char *
1832 op_as_string (p, v)
1833      enum tree_code p;
1834      int v;
1835 {
1836   static char buf[] = "operator                ";
1837
1838   if (p == 0)
1839     return "{unknown}";
1840
1841   strcpy (buf + 9, opname_tab [p]);
1842   return buf;
1843 }
1844
1845 char *
1846 assop_as_string (p, v)
1847      enum tree_code p;
1848      int v;
1849 {
1850   static char buf[] = "operator                ";
1851
1852   if (p == 0)
1853     return "{unknown}";
1854
1855   strcpy (buf + 9, assignop_tab [p]);
1856   return buf;
1857 }
1858
1859 char *
1860 args_as_string (p, v)
1861      tree p;
1862      int v;
1863 {
1864   if (p == NULL_TREE)
1865     return "";
1866
1867   if (TREE_CODE_CLASS (TREE_CODE (TREE_VALUE (p))) == 't')
1868     return type_as_string (p, v);
1869
1870   OB_INIT ();
1871   for (; p; p = TREE_CHAIN (p))
1872     {
1873       if (TREE_VALUE (p) == null_node)
1874         OB_PUTS ("NULL");
1875       else
1876         dump_type (error_type (TREE_VALUE (p)), v);
1877       if (TREE_CHAIN (p))
1878         OB_PUTS (", ");
1879     }
1880   OB_FINISH ();
1881   return (char *)obstack_base (&scratch_obstack);
1882 }
1883
1884 char *
1885 cv_as_string (p, v)
1886      tree p;
1887      int v;
1888 {
1889   OB_INIT ();
1890
1891   dump_readonly_or_volatile (p, before);
1892
1893   OB_FINISH ();
1894
1895   return (char *)obstack_base (&scratch_obstack);
1896 }