1 /* Subroutines common to both C and C++ pretty-printers.
2 Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
3 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
24 #include "coretypes.h"
27 #include "c-pretty-print.h"
29 #include "tree-iterator.h"
30 #include "diagnostic.h"
32 /* The pretty-printer code is primarily designed to closely follow
33 (GNU) C and C++ grammars. That is to be contrasted with spaghetti
34 codes we used to have in the past. Following a structured
35 approach (preferably the official grammars) is believed to make it
36 much easier to add extensions and nifty pretty-printing effects that
37 takes expression or declaration contexts into account. */
40 #define pp_c_maybe_whitespace(PP) \
42 if (pp_base (PP)->padding == pp_before) \
43 pp_c_whitespace (PP); \
47 static void pp_c_char (c_pretty_printer *, int);
49 /* postfix-expression */
50 static void pp_c_initializer_list (c_pretty_printer *, tree);
51 static void pp_c_brace_enclosed_initializer_list (c_pretty_printer *, tree);
53 static void pp_c_multiplicative_expression (c_pretty_printer *, tree);
54 static void pp_c_additive_expression (c_pretty_printer *, tree);
55 static void pp_c_shift_expression (c_pretty_printer *, tree);
56 static void pp_c_relational_expression (c_pretty_printer *, tree);
57 static void pp_c_equality_expression (c_pretty_printer *, tree);
58 static void pp_c_and_expression (c_pretty_printer *, tree);
59 static void pp_c_exclusive_or_expression (c_pretty_printer *, tree);
60 static void pp_c_inclusive_or_expression (c_pretty_printer *, tree);
61 static void pp_c_logical_and_expression (c_pretty_printer *, tree);
62 static void pp_c_conditional_expression (c_pretty_printer *, tree);
63 static void pp_c_assignment_expression (c_pretty_printer *, tree);
68 /* Helper functions. */
71 pp_c_whitespace (c_pretty_printer *pp)
74 pp_base (pp)->padding = pp_none;
78 pp_c_left_paren (c_pretty_printer *pp)
81 pp_base (pp)->padding = pp_none;
85 pp_c_right_paren (c_pretty_printer *pp)
88 pp_base (pp)->padding = pp_none;
92 pp_c_left_brace (c_pretty_printer *pp)
95 pp_base (pp)->padding = pp_none;
99 pp_c_right_brace (c_pretty_printer *pp)
102 pp_base (pp)->padding = pp_none;
106 pp_c_left_bracket (c_pretty_printer *pp)
108 pp_left_bracket (pp);
109 pp_base (pp)->padding = pp_none;
113 pp_c_right_bracket (c_pretty_printer *pp)
115 pp_right_bracket (pp);
116 pp_base (pp)->padding = pp_none;
120 pp_c_dot (c_pretty_printer *pp)
123 pp_base (pp)->padding = pp_none;
127 pp_c_ampersand (c_pretty_printer *pp)
130 pp_base (pp)->padding = pp_none;
134 pp_c_star (c_pretty_printer *pp)
137 pp_base (pp)->padding = pp_none;
141 pp_c_arrow (c_pretty_printer *pp)
144 pp_base (pp)->padding = pp_none;
148 pp_c_semicolon (c_pretty_printer *pp)
151 pp_base (pp)->padding = pp_none;
155 pp_c_complement (c_pretty_printer *pp)
158 pp_base (pp)->padding = pp_none;
162 pp_c_exclamation (c_pretty_printer *pp)
165 pp_base (pp)->padding = pp_none;
168 /* Print out the external representation of CV-QUALIFIER. */
171 pp_c_cv_qualifier (c_pretty_printer *pp, const char *cv)
173 const char *p = pp_last_position_in_text (pp);
174 /* The C programming language does not have references, but it is much
175 simpler to handle those here rather than going through the same
176 logic in the C++ pretty-printer. */
177 if (p != NULL && (*p == '*' || *p == '&'))
178 pp_c_whitespace (pp);
179 pp_c_identifier (pp, cv);
182 /* Pretty-print T using the type-cast notation '( type-name )'. */
185 pp_c_type_cast (c_pretty_printer *pp, tree t)
187 pp_c_left_paren (pp);
189 pp_c_right_paren (pp);
192 /* We're about to pretty-print a pointer type as indicated by T.
193 Output a whitespace, if needed, preparing for subsequent output. */
196 pp_c_space_for_pointer_operator (c_pretty_printer *pp, tree t)
198 if (POINTER_TYPE_P (t))
200 tree pointee = strip_pointer_operator (TREE_TYPE (t));
201 if (TREE_CODE (pointee) != ARRAY_TYPE
202 && TREE_CODE (pointee) != FUNCTION_TYPE)
203 pp_c_whitespace (pp);
210 /* C++ cv-qualifiers are called type-qualifiers in C. Print out the
211 cv-qualifiers of T. If T is a declaration then it is the cv-qualifier
212 of its type. Take care of possible extensions.
216 type-qualifier-list type-qualifier
221 __restrict__ -- GNU C
225 pp_c_type_qualifier_list (c_pretty_printer *pp, tree t)
232 qualifiers = TYPE_QUALS (t);
233 if (qualifiers & TYPE_QUAL_CONST)
234 pp_c_cv_qualifier (pp, "const");
235 if (qualifiers & TYPE_QUAL_VOLATILE)
236 pp_c_cv_qualifier (pp, "volatile");
237 if (qualifiers & TYPE_QUAL_RESTRICT)
238 pp_c_cv_qualifier (pp, flag_isoc99 ? "restrict" : "__restrict__");
242 * type-qualifier-list(opt)
243 * type-qualifier-list(opt) pointer */
246 pp_c_pointer (c_pretty_printer *pp, tree t)
248 if (!TYPE_P (t) && TREE_CODE (t) != TYPE_DECL)
250 switch (TREE_CODE (t))
253 /* It is easier to handle C++ reference types here. */
255 if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE)
256 pp_c_pointer (pp, TREE_TYPE (t));
257 if (TREE_CODE (t) == POINTER_TYPE)
261 pp_c_type_qualifier_list (pp, t);
264 /* ??? This node is now in GENERIC and so shouldn't be here. But
265 we'll fix that later. */
267 pp_declaration (pp, DECL_EXPR_DECL (t));
268 pp_needs_newline (pp) = true;
272 pp_unsupported_tree (pp, t);
289 struct-or-union-specifier
294 simple-type-specifier:
299 pp_c_type_specifier (c_pretty_printer *pp, tree t)
301 const enum tree_code code = TREE_CODE (t);
305 pp_c_identifier (pp, "<type-error>");
308 case IDENTIFIER_NODE:
309 pp_c_tree_decl_identifier (pp, t);
320 t = c_common_type_for_mode (TYPE_MODE (t), TYPE_UNSIGNED (t));
321 pp_c_type_specifier (pp, t);
326 pp_id_expression (pp, t);
328 pp_c_identifier (pp, "<typedef-error>");
334 if (code == UNION_TYPE)
335 pp_c_identifier (pp, "union");
336 else if (code == RECORD_TYPE)
337 pp_c_identifier (pp, "struct");
338 else if (code == ENUMERAL_TYPE)
339 pp_c_identifier (pp, "enum");
341 pp_c_identifier (pp, "<tag-error>");
344 pp_id_expression (pp, TYPE_NAME (t));
346 pp_c_identifier (pp, "<anonymous>");
350 pp_unsupported_tree (pp, t);
355 /* specifier-qualifier-list:
356 type-specifier specifier-qualifier-list-opt
357 type-qualifier specifier-qualifier-list-opt
360 Implementation note: Because of the non-linearities in array or
361 function declarations, this routine prints not just the
362 specifier-qualifier-list of such entities or types of such entities,
363 but also the 'pointer' production part of their declarators. The
364 remaining part is done by pp_declarator or pp_c_abstract_declarator. */
367 pp_c_specifier_qualifier_list (c_pretty_printer *pp, tree t)
369 const enum tree_code code = TREE_CODE (t);
371 if (TREE_CODE (t) != POINTER_TYPE)
372 pp_c_type_qualifier_list (pp, t);
378 /* Get the types-specifier of this type. */
379 tree pointee = strip_pointer_operator (TREE_TYPE (t));
380 pp_c_specifier_qualifier_list (pp, pointee);
381 if (TREE_CODE (pointee) == ARRAY_TYPE
382 || TREE_CODE (pointee) == FUNCTION_TYPE)
384 pp_c_whitespace (pp);
385 pp_c_left_paren (pp);
387 else if (!c_dialect_cxx ())
388 pp_c_whitespace (pp);
389 pp_ptr_operator (pp, t);
395 pp_c_specifier_qualifier_list (pp, TREE_TYPE (t));
400 pp_c_specifier_qualifier_list (pp, TREE_TYPE (t));
401 if (code == COMPLEX_TYPE)
402 pp_c_identifier (pp, flag_isoc99 ? "_Complex" : "__complex__");
403 else if (code == VECTOR_TYPE)
404 pp_c_identifier (pp, "__vector__");
408 pp_simple_type_specifier (pp, t);
413 /* parameter-type-list:
418 parameter-declaration
419 parameter-list , parameter-declaration
421 parameter-declaration:
422 declaration-specifiers declarator
423 declaration-specifiers abstract-declarator(opt) */
426 pp_c_parameter_type_list (c_pretty_printer *pp, tree t)
428 bool want_parm_decl = DECL_P (t) && !(pp->flags & pp_c_flag_abstract);
429 tree parms = want_parm_decl ? DECL_ARGUMENTS (t) : TYPE_ARG_TYPES (t);
430 pp_c_left_paren (pp);
431 if (parms == void_list_node)
432 pp_c_identifier (pp, "void");
436 for ( ; parms && parms != void_list_node; parms = TREE_CHAIN (parms))
439 pp_separate_with (pp, ',');
441 pp_declaration_specifiers
442 (pp, want_parm_decl ? parms : TREE_VALUE (parms));
444 pp_declarator (pp, parms);
446 pp_abstract_declarator (pp, TREE_VALUE (parms));
449 pp_c_right_paren (pp);
452 /* abstract-declarator:
454 pointer(opt) direct-abstract-declarator */
457 pp_c_abstract_declarator (c_pretty_printer *pp, tree t)
459 if (TREE_CODE (t) == POINTER_TYPE)
461 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
462 || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
463 pp_c_right_paren (pp);
467 pp_direct_abstract_declarator (pp, t);
470 /* direct-abstract-declarator:
471 ( abstract-declarator )
472 direct-abstract-declarator(opt) [ assignment-expression(opt) ]
473 direct-abstract-declarator(opt) [ * ]
474 direct-abstract-declarator(opt) ( parameter-type-list(opt) ) */
477 pp_c_direct_abstract_declarator (c_pretty_printer *pp, tree t)
479 switch (TREE_CODE (t))
482 pp_abstract_declarator (pp, t);
486 pp_c_parameter_type_list (pp, t);
487 pp_direct_abstract_declarator (pp, TREE_TYPE (t));
491 pp_c_left_bracket (pp);
492 if (TYPE_DOMAIN (t) && TYPE_MAX_VALUE (TYPE_DOMAIN (t)))
493 pp_expression (pp, TYPE_MAX_VALUE (TYPE_DOMAIN (t)));
494 pp_c_right_bracket (pp);
495 pp_direct_abstract_declarator (pp, TREE_TYPE (t));
498 case IDENTIFIER_NODE:
512 pp_unsupported_tree (pp, t);
518 specifier-qualifier-list abstract-declarator(opt) */
521 pp_c_type_id (c_pretty_printer *pp, tree t)
523 pp_c_specifier_qualifier_list (pp, t);
524 pp_abstract_declarator (pp, t);
527 /* storage-class-specifier:
535 pp_c_storage_class_specifier (c_pretty_printer *pp, tree t)
537 if (TREE_CODE (t) == TYPE_DECL)
538 pp_c_identifier (pp, "typedef");
541 if (DECL_REGISTER (t))
542 pp_c_identifier (pp, "register");
543 else if (TREE_STATIC (t) && TREE_CODE (t) == VAR_DECL)
544 pp_c_identifier (pp, "static");
548 /* function-specifier:
552 pp_c_function_specifier (c_pretty_printer *pp, tree t)
554 if (TREE_CODE (t) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (t))
555 pp_c_identifier (pp, "inline");
558 /* declaration-specifiers:
559 storage-class-specifier declaration-specifiers(opt)
560 type-specifier declaration-specifiers(opt)
561 type-qualifier declaration-specifiers(opt)
562 function-specifier declaration-specifiers(opt) */
565 pp_c_declaration_specifiers (c_pretty_printer *pp, tree t)
567 pp_storage_class_specifier (pp, t);
568 pp_function_specifier (pp, t);
569 pp_c_specifier_qualifier_list (pp, DECL_P (t) ? TREE_TYPE (t) : t);
575 direct-declarator [ type-qualifier-list(opt) assignment-expression(opt) ]
576 direct-declarator [ static type-qualifier-list(opt) assignment-expression(opt)]
577 direct-declarator [ type-qualifier-list static assignment-expression ]
578 direct-declarator [ type-qualifier-list * ]
579 direct-declarator ( parameter-type-list )
580 direct-declarator ( identifier-list(opt) ) */
583 pp_c_direct_declarator (c_pretty_printer *pp, tree t)
585 switch (TREE_CODE (t))
592 pp_c_space_for_pointer_operator (pp, TREE_TYPE (t));
593 pp_c_tree_decl_identifier (pp, t);
598 pp_abstract_declarator (pp, TREE_TYPE (t));
602 pp_parameter_list (pp, t);
603 pp_abstract_declarator (pp, TREE_TYPE (t));
607 pp_c_space_for_pointer_operator (pp, TREE_TYPE (TREE_TYPE (t)));
608 pp_c_tree_decl_identifier (pp, t);
609 if (pp_c_base (pp)->flags & pp_c_flag_abstract)
610 pp_abstract_declarator (pp, TREE_TYPE (t));
613 pp_parameter_list (pp, t);
614 pp_abstract_declarator (pp, TREE_TYPE (TREE_TYPE (t)));
626 pp_unsupported_tree (pp, t);
633 pointer(opt) direct-declarator */
636 pp_c_declarator (c_pretty_printer *pp, tree t)
638 switch (TREE_CODE (t))
654 pp_direct_declarator (pp, t);
659 pp_unsupported_tree (pp, t);
665 declaration-specifiers init-declarator-list(opt) ; */
668 pp_c_declaration (c_pretty_printer *pp, tree t)
670 pp_declaration_specifiers (pp, t);
671 pp_c_init_declarator (pp, t);
674 /* Pretty-print ATTRIBUTES using GNU C extension syntax. */
677 pp_c_attributes (c_pretty_printer *pp, tree attributes)
679 if (attributes == NULL_TREE)
682 pp_c_identifier (pp, "__attribute__");
683 pp_c_left_paren (pp);
684 pp_c_left_paren (pp);
685 for (; attributes != NULL_TREE; attributes = TREE_CHAIN (attributes))
687 pp_tree_identifier (pp, TREE_PURPOSE (attributes));
688 if (TREE_VALUE (attributes))
689 pp_c_call_argument_list (pp, TREE_VALUE (attributes));
691 if (TREE_CHAIN (attributes))
692 pp_separate_with (pp, ',');
694 pp_c_right_paren (pp);
695 pp_c_right_paren (pp);
698 /* function-definition:
699 declaration-specifiers declarator compound-statement */
702 pp_c_function_definition (c_pretty_printer *pp, tree t)
704 pp_declaration_specifiers (pp, t);
705 pp_declarator (pp, t);
706 pp_needs_newline (pp) = true;
707 pp_statement (pp, DECL_SAVED_TREE (t));
715 /* Print out a c-char. */
718 pp_c_char (c_pretty_printer *pp, int c)
723 pp_string (pp, "\\n");
726 pp_string (pp, "\\t");
729 pp_string (pp, "\\v");
732 pp_string (pp, "\\b");
735 pp_string (pp, "\\r");
738 pp_string (pp, "\\f");
741 pp_string (pp, "\\a");
744 pp_string (pp, "\\\\");
747 pp_string (pp, "\\'");
750 pp_string (pp, "\\\"");
754 pp_character (pp, c);
756 pp_scalar (pp, "\\%03o", (unsigned) c);
761 /* Print out a STRING literal. */
764 pp_c_string_literal (c_pretty_printer *pp, tree s)
766 const char *p = TREE_STRING_POINTER (s);
767 int n = TREE_STRING_LENGTH (s) - 1;
770 for (i = 0; i < n; ++i)
771 pp_c_char (pp, p[i]);
775 /* Pretty-print an INTEGER literal. */
778 pp_c_integer_constant (c_pretty_printer *pp, tree i)
780 tree type = TREE_TYPE (i);
782 if (TREE_INT_CST_HIGH (i) == 0)
783 pp_wide_integer (pp, TREE_INT_CST_LOW (i));
786 if (tree_int_cst_sgn (i) < 0)
789 i = build_int_cst_wide (NULL_TREE,
790 -TREE_INT_CST_LOW (i),
791 ~TREE_INT_CST_HIGH (i)
792 + !TREE_INT_CST_LOW (i));
794 sprintf (pp_buffer (pp)->digit_buffer,
795 HOST_WIDE_INT_PRINT_DOUBLE_HEX,
796 TREE_INT_CST_HIGH (i), TREE_INT_CST_LOW (i));
797 pp_string (pp, pp_buffer (pp)->digit_buffer);
799 if (TYPE_UNSIGNED (type))
800 pp_character (pp, 'u');
801 if (type == long_integer_type_node || type == long_unsigned_type_node)
802 pp_character (pp, 'l');
803 else if (type == long_long_integer_type_node
804 || type == long_long_unsigned_type_node)
805 pp_string (pp, "ll");
808 /* Print out a CHARACTER literal. */
811 pp_c_character_constant (c_pretty_printer *pp, tree c)
813 tree type = TREE_TYPE (c);
814 if (type == wchar_type_node)
815 pp_character (pp, 'L');
817 if (host_integerp (c, TYPE_UNSIGNED (type)))
818 pp_c_char (pp, tree_low_cst (c, TYPE_UNSIGNED (type)));
820 pp_scalar (pp, "\\x%x", (unsigned) TREE_INT_CST_LOW (c));
824 /* Print out a BOOLEAN literal. */
827 pp_c_bool_constant (c_pretty_printer *pp, tree b)
829 if (b == boolean_false_node)
831 if (c_dialect_cxx ())
832 pp_c_identifier (pp, "false");
833 else if (flag_isoc99)
834 pp_c_identifier (pp, "_False");
836 pp_unsupported_tree (pp, b);
838 else if (b == boolean_true_node)
840 if (c_dialect_cxx ())
841 pp_c_identifier (pp, "true");
842 else if (flag_isoc99)
843 pp_c_identifier (pp, "_True");
845 pp_unsupported_tree (pp, b);
847 else if (TREE_CODE (b) == INTEGER_CST)
848 pp_c_integer_constant (pp, b);
850 pp_unsupported_tree (pp, b);
853 /* Attempt to print out an ENUMERATOR. Return true on success. Else return
854 false; that means the value was obtained by a cast, in which case
855 print out the type-id part of the cast-expression -- the casted value
856 is then printed by pp_c_integer_literal. */
859 pp_c_enumeration_constant (c_pretty_printer *pp, tree e)
861 bool value_is_named = true;
862 tree type = TREE_TYPE (e);
865 /* Find the name of this constant. */
866 for (value = TYPE_VALUES (type);
867 value != NULL_TREE && !tree_int_cst_equal (TREE_VALUE (value), e);
868 value = TREE_CHAIN (value))
871 if (value != NULL_TREE)
872 pp_id_expression (pp, TREE_PURPOSE (value));
875 /* Value must have been cast. */
876 pp_c_type_cast (pp, type);
877 value_is_named = false;
880 return value_is_named;
883 /* Print out a REAL value as a decimal-floating-constant. */
886 pp_c_floating_constant (c_pretty_printer *pp, tree r)
888 real_to_decimal (pp_buffer (pp)->digit_buffer, &TREE_REAL_CST (r),
889 sizeof (pp_buffer (pp)->digit_buffer), 0, 1);
890 pp_string (pp, pp_buffer(pp)->digit_buffer);
891 if (TREE_TYPE (r) == float_type_node)
892 pp_character (pp, 'f');
893 else if (TREE_TYPE (r) == long_double_type_node)
894 pp_character (pp, 'l');
897 /* Pretty-print a compound literal expression. GNU extensions include
901 pp_c_compound_literal (c_pretty_printer *pp, tree e)
903 tree type = TREE_TYPE (e);
904 pp_c_type_cast (pp, type);
906 switch (TREE_CODE (type))
913 pp_c_brace_enclosed_initializer_list (pp, e);
917 pp_unsupported_tree (pp, e);
926 character-constant */
929 pp_c_constant (c_pretty_printer *pp, tree e)
931 const enum tree_code code = TREE_CODE (e);
937 tree type = TREE_TYPE (e);
938 if (type == boolean_type_node)
939 pp_c_bool_constant (pp, e);
940 else if (type == char_type_node)
941 pp_c_character_constant (pp, e);
942 else if (TREE_CODE (type) == ENUMERAL_TYPE
943 && pp_c_enumeration_constant (pp, e))
946 pp_c_integer_constant (pp, e);
951 pp_c_floating_constant (pp, e);
955 pp_c_string_literal (pp, e);
959 pp_unsupported_tree (pp, e);
964 /* Pretty-print an IDENTIFIER_NODE, preceded by whitespace is necessary. */
967 pp_c_identifier (c_pretty_printer *pp, const char *id)
969 pp_c_maybe_whitespace (pp);
970 pp_identifier (pp, id);
971 pp_base (pp)->padding = pp_before;
974 /* Pretty-print a C primary-expression.
982 pp_c_primary_expression (c_pretty_printer *pp, tree e)
984 switch (TREE_CODE (e))
992 pp_c_tree_decl_identifier (pp, e);
995 case IDENTIFIER_NODE:
996 pp_c_tree_identifier (pp, e);
1000 pp_c_identifier (pp, "<erroneous-expression>");
1004 pp_c_identifier (pp, "<return-value>");
1010 pp_c_constant (pp, e);
1014 pp_c_identifier (pp, "__builtin_memcpy");
1015 pp_c_left_paren (pp);
1017 pp_primary_expression (pp, TREE_OPERAND (e, 0));
1018 pp_separate_with (pp, ',');
1020 pp_initializer (pp, TREE_OPERAND (e, 1));
1021 if (TREE_OPERAND (e, 2))
1023 pp_separate_with (pp, ',');
1024 pp_c_expression (pp, TREE_OPERAND (e, 2));
1026 pp_c_right_paren (pp);
1030 pp_c_left_paren (pp);
1031 pp_statement (pp, STMT_EXPR_STMT (e));
1032 pp_c_right_paren (pp);
1036 /* FIXME: Make sure we won't get into an infinie loop. */
1037 pp_c_left_paren (pp);
1038 pp_expression (pp, e);
1039 pp_c_right_paren (pp);
1044 /* Print out a C initializer -- also support C compound-literals.
1046 assignment-expression:
1047 { initializer-list }
1048 { initializer-list , } */
1051 pp_c_initializer (c_pretty_printer *pp, tree e)
1053 if (TREE_CODE (e) == CONSTRUCTOR)
1054 pp_c_brace_enclosed_initializer_list (pp, e);
1056 pp_expression (pp, e);
1061 declarator = initializer */
1064 pp_c_init_declarator (c_pretty_printer *pp, tree t)
1066 pp_declarator (pp, t);
1067 /* We don't want to output function definitions here. There are handled
1068 elsewhere (and the syntactic form is bogus anyway). */
1069 if (TREE_CODE (t) != FUNCTION_DECL && DECL_INITIAL (t))
1071 tree init = DECL_INITIAL (t);
1072 /* This C++ bit is handled here because it is easier to do so.
1073 In templates, the C++ parser builds a TREE_LIST for a
1074 direct-initialization; the TREE_PURPOSE is the variable to
1075 initialize and the TREE_VALUE is the initializer. */
1076 if (TREE_CODE (init) == TREE_LIST)
1078 pp_c_left_paren (pp);
1079 pp_expression (pp, TREE_VALUE (init));
1080 pp_right_paren (pp);
1087 pp_c_initializer (pp, init);
1092 /* initializer-list:
1093 designation(opt) initializer
1094 initializer-list , designation(opt) initializer
1101 designator-list designator
1104 [ constant-expression ]
1108 pp_c_initializer_list (c_pretty_printer *pp, tree e)
1110 tree type = TREE_TYPE (e);
1111 const enum tree_code code = TREE_CODE (type);
1119 tree init = TREE_OPERAND (e, 0);
1120 for (; init != NULL_TREE; init = TREE_CHAIN (init))
1122 if (code == RECORD_TYPE || code == UNION_TYPE)
1125 pp_c_primary_expression (pp, TREE_PURPOSE (init));
1129 pp_c_left_bracket (pp);
1130 if (TREE_PURPOSE (init))
1131 pp_c_constant (pp, TREE_PURPOSE (init));
1132 pp_c_right_bracket (pp);
1134 pp_c_whitespace (pp);
1136 pp_c_whitespace (pp);
1137 pp_initializer (pp, TREE_VALUE (init));
1138 if (TREE_CHAIN (init))
1139 pp_separate_with (pp, ',');
1145 if (TREE_CODE (e) == VECTOR_CST)
1146 pp_c_expression_list (pp, TREE_VECTOR_CST_ELTS (e));
1147 else if (TREE_CODE (e) == CONSTRUCTOR)
1148 pp_c_expression_list (pp, CONSTRUCTOR_ELTS (e));
1154 if (TREE_CODE (e) == CONSTRUCTOR)
1155 pp_c_expression_list (pp, CONSTRUCTOR_ELTS (e));
1156 else if (TREE_CODE (e) == COMPLEX_CST || TREE_CODE (e) == COMPLEX_EXPR)
1158 const bool cst = TREE_CODE (e) == COMPLEX_CST;
1159 pp_expression (pp, cst ? TREE_REALPART (e) : TREE_OPERAND (e, 0));
1160 pp_separate_with (pp, ',');
1161 pp_expression (pp, cst ? TREE_IMAGPART (e) : TREE_OPERAND (e, 1));
1171 pp_unsupported_tree (pp, type);
1174 /* Pretty-print a brace-enclosed initializer-list. */
1177 pp_c_brace_enclosed_initializer_list (c_pretty_printer *pp, tree l)
1179 pp_c_left_brace (pp);
1180 pp_c_initializer_list (pp, l);
1181 pp_c_right_brace (pp);
1185 /* This is a convenient function, used to bridge gap between C and C++
1192 pp_c_id_expression (c_pretty_printer *pp, tree t)
1194 switch (TREE_CODE (t))
1203 pp_c_tree_decl_identifier (pp, t);
1206 case IDENTIFIER_NODE:
1207 pp_c_tree_identifier (pp, t);
1211 pp_unsupported_tree (pp, t);
1216 /* postfix-expression:
1218 postfix-expression [ expression ]
1219 postfix-expression ( argument-expression-list(opt) )
1220 postfix-expression . identifier
1221 postfix-expression -> identifier
1222 postfix-expression ++
1223 postfix-expression --
1224 ( type-name ) { initializer-list }
1225 ( type-name ) { initializer-list , } */
1228 pp_c_postfix_expression (c_pretty_printer *pp, tree e)
1230 enum tree_code code = TREE_CODE (e);
1233 case POSTINCREMENT_EXPR:
1234 case POSTDECREMENT_EXPR:
1235 pp_postfix_expression (pp, TREE_OPERAND (e, 0));
1236 pp_identifier (pp, code == POSTINCREMENT_EXPR ? "++" : "--");
1240 pp_postfix_expression (pp, TREE_OPERAND (e, 0));
1245 pp_postfix_expression (pp, TREE_OPERAND (e, 0));
1246 pp_c_left_bracket (pp);
1247 pp_expression (pp, TREE_OPERAND (e, 1));
1248 pp_c_right_bracket (pp);
1252 pp_postfix_expression (pp, TREE_OPERAND (e, 0));
1253 pp_c_call_argument_list (pp, TREE_OPERAND (e, 1));
1256 case UNORDERED_EXPR:
1257 pp_c_identifier (pp, flag_isoc99
1259 : "__builtin_isunordered");
1263 pp_c_identifier (pp, flag_isoc99
1265 : "!__builtin_isunordered");
1269 pp_c_identifier (pp, flag_isoc99
1271 : "!__builtin_isgreaterequal");
1275 pp_c_identifier (pp, flag_isoc99
1277 : "!__builtin_isgreater");
1281 pp_c_identifier (pp, flag_isoc99
1283 : "!__builtin_islessequal");
1287 pp_c_identifier (pp, flag_isoc99
1289 : "!__builtin_isless");
1293 pp_c_identifier (pp, flag_isoc99
1295 : "!__builtin_islessgreater");
1299 pp_c_identifier (pp, flag_isoc99
1301 : "__builtin_islessgreater");
1305 pp_c_left_paren (pp);
1306 pp_expression (pp, TREE_OPERAND (e, 0));
1307 pp_separate_with (pp, ',');
1308 pp_expression (pp, TREE_OPERAND (e, 1));
1309 pp_c_right_paren (pp);
1313 pp_c_identifier (pp, "__builtin_abs");
1314 pp_c_left_paren (pp);
1315 pp_expression (pp, TREE_OPERAND (e, 0));
1316 pp_c_right_paren (pp);
1321 tree object = TREE_OPERAND (e, 0);
1322 if (TREE_CODE (object) == INDIRECT_REF)
1324 pp_postfix_expression (pp, TREE_OPERAND (object, 0));
1329 pp_postfix_expression (pp, object);
1332 pp_expression (pp, TREE_OPERAND (e, 1));
1339 pp_c_compound_literal (pp, e);
1342 case COMPOUND_LITERAL_EXPR:
1343 e = DECL_INITIAL (COMPOUND_LITERAL_EXPR_DECL (e));
1346 pp_initializer (pp, e);
1350 pp_c_identifier (pp, "__builtin_va_arg");
1351 pp_c_left_paren (pp);
1352 pp_assignment_expression (pp, TREE_OPERAND (e, 0));
1353 pp_separate_with (pp, ',');
1354 pp_type_id (pp, TREE_TYPE (e));
1355 pp_c_right_paren (pp);
1359 if (TREE_CODE (TREE_OPERAND (e, 0)) == FUNCTION_DECL)
1361 pp_c_id_expression (pp, TREE_OPERAND (e, 0));
1364 /* else fall through. */
1367 pp_primary_expression (pp, e);
1372 /* Print out an expression-list; E is expected to be a TREE_LIST. */
1375 pp_c_expression_list (c_pretty_printer *pp, tree e)
1377 for (; e != NULL_TREE; e = TREE_CHAIN (e))
1379 pp_expression (pp, TREE_VALUE (e));
1381 pp_separate_with (pp, ',');
1385 /* Print out an expression-list in parens, as in a function call. */
1388 pp_c_call_argument_list (c_pretty_printer *pp, tree t)
1390 pp_c_left_paren (pp);
1391 if (t && TREE_CODE (t) == TREE_LIST)
1392 pp_c_expression_list (pp, t);
1393 pp_c_right_paren (pp);
1396 /* unary-expression:
1400 unary-operator cast-expression
1401 sizeof unary-expression
1404 unary-operator: one of
1409 __alignof__ unary-expression
1410 __alignof__ ( type-id )
1411 __real__ unary-expression
1412 __imag__ unary-expression */
1415 pp_c_unary_expression (c_pretty_printer *pp, tree e)
1417 enum tree_code code = TREE_CODE (e);
1420 case PREINCREMENT_EXPR:
1421 case PREDECREMENT_EXPR:
1422 pp_identifier (pp, code == PREINCREMENT_EXPR ? "++" : "--");
1423 pp_c_unary_expression (pp, TREE_OPERAND (e, 0));
1430 case TRUTH_NOT_EXPR:
1432 /* String literal are used by address. */
1433 if (code == ADDR_EXPR && TREE_CODE (TREE_OPERAND (e, 0)) != STRING_CST)
1435 else if (code == INDIRECT_REF)
1437 else if (code == NEGATE_EXPR)
1439 else if (code == BIT_NOT_EXPR || code == CONJ_EXPR)
1441 else if (code == TRUTH_NOT_EXPR)
1442 pp_exclamation (pp);
1443 pp_c_cast_expression (pp, TREE_OPERAND (e, 0));
1448 pp_c_identifier (pp, code == SIZEOF_EXPR ? "sizeof" : "__alignof__");
1449 pp_c_whitespace (pp);
1450 if (TYPE_P (TREE_OPERAND (e, 0)))
1451 pp_c_type_cast (pp, TREE_OPERAND (e, 0));
1453 pp_unary_expression (pp, TREE_OPERAND (e, 0));
1458 pp_c_identifier (pp, code == REALPART_EXPR ? "__real__" : "__imag__");
1459 pp_c_whitespace (pp);
1460 pp_unary_expression (pp, TREE_OPERAND (e, 0));
1464 pp_postfix_expression (pp, e);
1471 ( type-name ) cast-expression */
1474 pp_c_cast_expression (c_pretty_printer *pp, tree e)
1476 switch (TREE_CODE (e))
1479 case FIX_TRUNC_EXPR:
1481 pp_c_type_cast (pp, TREE_TYPE (e));
1482 pp_c_cast_expression (pp, TREE_OPERAND (e, 0));
1486 pp_unary_expression (pp, e);
1490 /* multiplicative-expression:
1492 multiplicative-expression * cast-expression
1493 multiplicative-expression / cast-expression
1494 multiplicative-expression % cast-expression */
1497 pp_c_multiplicative_expression (c_pretty_printer *pp, tree e)
1499 enum tree_code code = TREE_CODE (e);
1503 case TRUNC_DIV_EXPR:
1504 case TRUNC_MOD_EXPR:
1505 pp_multiplicative_expression (pp, TREE_OPERAND (e, 0));
1506 pp_c_whitespace (pp);
1507 if (code == MULT_EXPR)
1509 else if (code == TRUNC_DIV_EXPR)
1513 pp_c_whitespace (pp);
1514 pp_c_cast_expression (pp, TREE_OPERAND (e, 1));
1518 pp_c_cast_expression (pp, e);
1523 /* additive-expression:
1524 multiplicative-expression
1525 additive-expression + multiplicative-expression
1526 additive-expression - multiplicative-expression */
1529 pp_c_additive_expression (c_pretty_printer *pp, tree e)
1531 enum tree_code code = TREE_CODE (e);
1536 pp_c_additive_expression (pp, TREE_OPERAND (e, 0));
1537 pp_c_whitespace (pp);
1538 if (code == PLUS_EXPR)
1542 pp_c_whitespace (pp);
1543 pp_multiplicative_expression (pp, TREE_OPERAND (e, 1));
1547 pp_multiplicative_expression (pp, e);
1552 /* additive-expression:
1554 shift-expression << additive-expression
1555 shift-expression >> additive-expression */
1558 pp_c_shift_expression (c_pretty_printer *pp, tree e)
1560 enum tree_code code = TREE_CODE (e);
1565 pp_c_shift_expression (pp, TREE_OPERAND (e, 0));
1566 pp_c_whitespace (pp);
1567 pp_identifier (pp, code == LSHIFT_EXPR ? "<<" : ">>");
1568 pp_c_whitespace (pp);
1569 pp_c_additive_expression (pp, TREE_OPERAND (e, 1));
1573 pp_c_additive_expression (pp, e);
1577 /* relational-expression:
1579 relational-expression < shift-expression
1580 relational-expression > shift-expression
1581 relational-expression <= shift-expression
1582 relational-expression >= shift-expression */
1585 pp_c_relational_expression (c_pretty_printer *pp, tree e)
1587 enum tree_code code = TREE_CODE (e);
1594 pp_c_relational_expression (pp, TREE_OPERAND (e, 0));
1595 pp_c_whitespace (pp);
1596 if (code == LT_EXPR)
1598 else if (code == GT_EXPR)
1600 else if (code == LE_EXPR)
1601 pp_identifier (pp, "<=");
1602 else if (code == GE_EXPR)
1603 pp_identifier (pp, ">=");
1604 pp_c_whitespace (pp);
1605 pp_c_shift_expression (pp, TREE_OPERAND (e, 1));
1609 pp_c_shift_expression (pp, e);
1614 /* equality-expression:
1615 relational-expression
1616 equality-expression == relational-expression
1617 equality-equality != relational-expression */
1620 pp_c_equality_expression (c_pretty_printer *pp, tree e)
1622 enum tree_code code = TREE_CODE (e);
1627 pp_c_equality_expression (pp, TREE_OPERAND (e, 0));
1628 pp_c_whitespace (pp);
1629 pp_identifier (pp, code == EQ_EXPR ? "==" : "!=");
1630 pp_c_whitespace (pp);
1631 pp_c_relational_expression (pp, TREE_OPERAND (e, 1));
1635 pp_c_relational_expression (pp, e);
1642 AND-expression & equality-equality */
1645 pp_c_and_expression (c_pretty_printer *pp, tree e)
1647 if (TREE_CODE (e) == BIT_AND_EXPR)
1649 pp_c_and_expression (pp, TREE_OPERAND (e, 0));
1650 pp_c_whitespace (pp);
1652 pp_c_whitespace (pp);
1653 pp_c_equality_expression (pp, TREE_OPERAND (e, 1));
1656 pp_c_equality_expression (pp, e);
1659 /* exclusive-OR-expression:
1661 exclusive-OR-expression ^ AND-expression */
1664 pp_c_exclusive_or_expression (c_pretty_printer *pp, tree e)
1666 if (TREE_CODE (e) == BIT_XOR_EXPR)
1668 pp_c_exclusive_or_expression (pp, TREE_OPERAND (e, 0));
1669 pp_c_maybe_whitespace (pp);
1671 pp_c_whitespace (pp);
1672 pp_c_and_expression (pp, TREE_OPERAND (e, 1));
1675 pp_c_and_expression (pp, e);
1678 /* inclusive-OR-expression:
1679 exclusive-OR-expression
1680 inclusive-OR-expression | exclusive-OR-expression */
1683 pp_c_inclusive_or_expression (c_pretty_printer *pp, tree e)
1685 if (TREE_CODE (e) == BIT_IOR_EXPR)
1687 pp_c_exclusive_or_expression (pp, TREE_OPERAND (e, 0));
1688 pp_c_whitespace (pp);
1690 pp_c_whitespace (pp);
1691 pp_c_exclusive_or_expression (pp, TREE_OPERAND (e, 1));
1694 pp_c_exclusive_or_expression (pp, e);
1697 /* logical-AND-expression:
1698 inclusive-OR-expression
1699 logical-AND-expression && inclusive-OR-expression */
1702 pp_c_logical_and_expression (c_pretty_printer *pp, tree e)
1704 if (TREE_CODE (e) == TRUTH_ANDIF_EXPR)
1706 pp_c_logical_and_expression (pp, TREE_OPERAND (e, 0));
1707 pp_c_whitespace (pp);
1708 pp_identifier (pp, "&&");
1709 pp_c_whitespace (pp);
1710 pp_c_inclusive_or_expression (pp, TREE_OPERAND (e, 1));
1713 pp_c_inclusive_or_expression (pp, e);
1716 /* logical-OR-expression:
1717 logical-AND-expression
1718 logical-OR-expression || logical-AND-expression */
1721 pp_c_logical_or_expression (c_pretty_printer *pp, tree e)
1723 if (TREE_CODE (e) == TRUTH_ORIF_EXPR)
1725 pp_c_logical_or_expression (pp, TREE_OPERAND (e, 0));
1726 pp_c_whitespace (pp);
1727 pp_identifier (pp, "||");
1728 pp_c_whitespace (pp);
1729 pp_c_logical_and_expression (pp, TREE_OPERAND (e, 1));
1732 pp_c_logical_and_expression (pp, e);
1735 /* conditional-expression:
1736 logical-OR-expression
1737 logical-OR-expression ? expression : conditional-expression */
1740 pp_c_conditional_expression (c_pretty_printer *pp, tree e)
1742 if (TREE_CODE (e) == COND_EXPR)
1744 pp_c_logical_or_expression (pp, TREE_OPERAND (e, 0));
1745 pp_c_whitespace (pp);
1747 pp_c_whitespace (pp);
1748 pp_expression (pp, TREE_OPERAND (e, 1));
1749 pp_c_whitespace (pp);
1751 pp_c_whitespace (pp);
1752 pp_c_conditional_expression (pp, TREE_OPERAND (e, 2));
1755 pp_c_logical_or_expression (pp, e);
1759 /* assignment-expression:
1760 conditional-expression
1761 unary-expression assignment-operator assignment-expression
1763 assignment-expression: one of
1764 = *= /= %= += -= >>= <<= &= ^= |= */
1767 pp_c_assignment_expression (c_pretty_printer *pp, tree e)
1769 if (TREE_CODE (e) == MODIFY_EXPR || TREE_CODE (e) == INIT_EXPR)
1771 pp_c_unary_expression (pp, TREE_OPERAND (e, 0));
1772 pp_c_whitespace (pp);
1775 pp_c_expression (pp, TREE_OPERAND (e, 1));
1778 pp_c_conditional_expression (pp, e);
1782 assignment-expression
1783 expression , assignment-expression
1785 Implementation note: instead of going through the usual recursion
1786 chain, I take the liberty of dispatching nodes to the appropriate
1787 functions. This makes some redundancy, but it worths it. That also
1788 prevents a possible infinite recursion between pp_c_primary_expression ()
1789 and pp_c_expression (). */
1792 pp_c_expression (c_pretty_printer *pp, tree e)
1794 switch (TREE_CODE (e))
1797 pp_c_integer_constant (pp, e);
1801 pp_c_floating_constant (pp, e);
1805 pp_c_string_literal (pp, e);
1808 case IDENTIFIER_NODE:
1818 pp_primary_expression (pp, e);
1821 case POSTINCREMENT_EXPR:
1822 case POSTDECREMENT_EXPR:
1831 case UNORDERED_EXPR:
1840 case COMPOUND_LITERAL_EXPR:
1842 pp_postfix_expression (pp, e);
1850 case TRUTH_NOT_EXPR:
1851 case PREINCREMENT_EXPR:
1852 case PREDECREMENT_EXPR:
1857 pp_c_unary_expression (pp, e);
1861 case FIX_TRUNC_EXPR:
1863 pp_c_cast_expression (pp, e);
1867 case TRUNC_MOD_EXPR:
1868 case TRUNC_DIV_EXPR:
1869 pp_multiplicative_expression (pp, e);
1874 pp_c_shift_expression (pp, e);
1881 pp_c_relational_expression (pp, e);
1885 pp_c_and_expression (pp, e);
1889 pp_c_exclusive_or_expression (pp, e);
1893 pp_c_inclusive_or_expression (pp, e);
1896 case TRUTH_ANDIF_EXPR:
1897 pp_c_logical_and_expression (pp, e);
1900 case TRUTH_ORIF_EXPR:
1901 pp_c_logical_or_expression (pp, e);
1906 pp_c_equality_expression (pp, e);
1910 pp_conditional_expression (pp, e);
1915 pp_c_additive_expression (pp, e);
1920 pp_assignment_expression (pp, e);
1924 pp_c_left_paren (pp);
1925 pp_expression (pp, TREE_OPERAND (e, 0));
1926 pp_separate_with (pp, ',');
1927 pp_assignment_expression (pp, TREE_OPERAND (e, 1));
1928 pp_c_right_paren (pp);
1932 case NON_LVALUE_EXPR:
1934 pp_expression (pp, TREE_OPERAND (e, 0));
1938 pp_postfix_expression (pp, TREE_OPERAND (e, 1));
1942 pp_unsupported_tree (pp, e);
1954 expression-statement
1960 pp_c_statement (c_pretty_printer *pp, tree stmt)
1962 enum tree_code code;
1967 if (pp_needs_newline (pp))
1968 pp_newline_and_indent (pp, 0);
1970 code = TREE_CODE (stmt);
1973 /* expression-statement:
1974 expression(opt) ; */
1976 pp_expression (pp, EXPR_STMT_EXPR (stmt));
1977 pp_c_semicolon (pp);
1978 pp_needs_newline (pp) = true;
1982 pp_c_identifier (pp, "switch");
1984 pp_c_left_paren (pp);
1985 pp_expression (pp, SWITCH_COND (stmt));
1986 pp_c_right_paren (pp);
1987 pp_indentation (pp) += 3;
1988 pp_needs_newline (pp) = true;
1989 pp_statement (pp, SWITCH_BODY (stmt));
1990 pp_newline_and_indent (pp, -3);
1993 /* iteration-statement:
1994 while ( expression ) statement
1995 do statement while ( expression ) ;
1996 for ( expression(opt) ; expression(opt) ; expression(opt) ) statement
1997 for ( declaration expression(opt) ; expression(opt) ) statement */
1999 pp_c_identifier (pp, "while");
2001 pp_c_left_paren (pp);
2002 pp_expression (pp, WHILE_COND (stmt));
2003 pp_c_right_paren (pp);
2004 pp_newline_and_indent (pp, 3);
2005 pp_statement (pp, WHILE_BODY (stmt));
2006 pp_indentation (pp) -= 3;
2007 pp_needs_newline (pp) = true;
2011 pp_c_identifier (pp, "do");
2012 pp_newline_and_indent (pp, 3);
2013 pp_statement (pp, DO_BODY (stmt));
2014 pp_newline_and_indent (pp, -3);
2015 pp_c_identifier (pp, "while");
2017 pp_c_left_paren (pp);
2018 pp_expression (pp, DO_COND (stmt));
2019 pp_c_right_paren (pp);
2020 pp_c_semicolon (pp);
2021 pp_needs_newline (pp) = true;
2025 pp_c_identifier (pp, "for");
2027 pp_c_left_paren (pp);
2028 if (FOR_INIT_STMT (stmt))
2029 pp_statement (pp, FOR_INIT_STMT (stmt));
2031 pp_c_semicolon (pp);
2032 pp_needs_newline (pp) = false;
2033 pp_c_whitespace (pp);
2034 if (FOR_COND (stmt))
2035 pp_expression (pp, FOR_COND (stmt));
2036 pp_c_semicolon (pp);
2037 pp_needs_newline (pp) = false;
2038 pp_c_whitespace (pp);
2039 if (FOR_EXPR (stmt))
2040 pp_expression (pp, FOR_EXPR (stmt));
2041 pp_c_right_paren (pp);
2042 pp_newline_and_indent (pp, 3);
2043 pp_statement (pp, FOR_BODY (stmt));
2044 pp_indentation (pp) -= 3;
2045 pp_needs_newline (pp) = true;
2051 return expression(opt) ; */
2054 pp_identifier (pp, code == BREAK_STMT ? "break" : "continue");
2055 pp_c_semicolon (pp);
2056 pp_needs_newline (pp) = true;
2060 dump_generic_node (pp_base (pp), stmt, pp_indentation (pp), 0, true);
2066 /* Initialize the PRETTY-PRINTER for handling C codes. */
2069 pp_c_pretty_printer_init (c_pretty_printer *pp)
2071 pp->offset_list = 0;
2073 pp->declaration = pp_c_declaration;
2074 pp->declaration_specifiers = pp_c_declaration_specifiers;
2075 pp->declarator = pp_c_declarator;
2076 pp->direct_declarator = pp_c_direct_declarator;
2077 pp->type_specifier_seq = pp_c_specifier_qualifier_list;
2078 pp->abstract_declarator = pp_c_abstract_declarator;
2079 pp->direct_abstract_declarator = pp_c_direct_abstract_declarator;
2080 pp->ptr_operator = pp_c_pointer;
2081 pp->parameter_list = pp_c_parameter_type_list;
2082 pp->type_id = pp_c_type_id;
2083 pp->simple_type_specifier = pp_c_type_specifier;
2084 pp->function_specifier = pp_c_function_specifier;
2085 pp->storage_class_specifier = pp_c_storage_class_specifier;
2087 pp->statement = pp_c_statement;
2089 pp->id_expression = pp_c_id_expression;
2090 pp->primary_expression = pp_c_primary_expression;
2091 pp->postfix_expression = pp_c_postfix_expression;
2092 pp->unary_expression = pp_c_unary_expression;
2093 pp->initializer = pp_c_initializer;
2094 pp->multiplicative_expression = pp_c_multiplicative_expression;
2095 pp->conditional_expression = pp_c_conditional_expression;
2096 pp->assignment_expression = pp_c_assignment_expression;
2097 pp->expression = pp_c_expression;
2101 /* Print the tree T in full, on file FILE. */
2104 print_c_tree (FILE *file, tree t)
2106 static c_pretty_printer pp_rec;
2107 static bool initialized = 0;
2108 c_pretty_printer *pp = &pp_rec;
2113 pp_construct (pp_base (pp), NULL, 0);
2114 pp_c_pretty_printer_init (pp);
2115 pp_needs_newline (pp) = true;
2117 pp_base (pp)->buffer->stream = file;
2119 pp_statement (pp, t);
2125 /* Print the tree T in full, on stderr. */
2128 debug_c_tree (tree t)
2130 print_c_tree (stderr, t);
2131 fputc ('\n', stderr);
2134 /* Output the DECL_NAME of T. If T has no DECL_NAME, output a string made
2135 up of T's memory address. */
2138 pp_c_tree_decl_identifier (c_pretty_printer *pp, tree t)
2142 gcc_assert (DECL_P (t));
2145 name = IDENTIFIER_POINTER (DECL_NAME (t));
2148 static char xname[8];
2149 sprintf (xname, "<U%4x>", ((unsigned)((unsigned long)(t) & 0xffff)));
2153 pp_c_identifier (pp, name);