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