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