gcc/cp/error.c

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