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