contrib/gcc/cp/error.c

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