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