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