source: trunk/third/gcc/cp/error.c @ 8834

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