gcc/cp/error.c

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