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