1 /* Subroutines common to both C and C++ pretty-printers.
2 Copyright (C) 2002, 2003, 2004, 2005 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, 51 Franklin Street, Fifth Floor, 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 pp_c_type_specifier (pp
, t
);
324 int prec
= TYPE_PRECISION (t
);
325 t
= c_common_type_for_mode (TYPE_MODE (t
), TYPE_UNSIGNED (t
));
328 pp_c_type_specifier (pp
, t
);
329 if (TYPE_PRECISION (t
) != prec
)
332 pp_decimal_int (pp
, prec
);
340 pp_string (pp
, (TYPE_UNSIGNED (t
)
341 ? "<unnamed-unsigned:"
342 : "<unnamed-signed:"));
345 pp_string (pp
, "<unnamed-float:");
350 pp_decimal_int (pp
, prec
);
358 pp_id_expression (pp
, t
);
360 pp_c_identifier (pp
, "<typedef-error>");
366 if (code
== UNION_TYPE
)
367 pp_c_identifier (pp
, "union");
368 else if (code
== RECORD_TYPE
)
369 pp_c_identifier (pp
, "struct");
370 else if (code
== ENUMERAL_TYPE
)
371 pp_c_identifier (pp
, "enum");
373 pp_c_identifier (pp
, "<tag-error>");
376 pp_id_expression (pp
, TYPE_NAME (t
));
378 pp_c_identifier (pp
, "<anonymous>");
382 pp_unsupported_tree (pp
, t
);
387 /* specifier-qualifier-list:
388 type-specifier specifier-qualifier-list-opt
389 type-qualifier specifier-qualifier-list-opt
392 Implementation note: Because of the non-linearities in array or
393 function declarations, this routine prints not just the
394 specifier-qualifier-list of such entities or types of such entities,
395 but also the 'pointer' production part of their declarators. The
396 remaining part is done by pp_declarator or pp_c_abstract_declarator. */
399 pp_c_specifier_qualifier_list (c_pretty_printer
*pp
, tree t
)
401 const enum tree_code code
= TREE_CODE (t
);
403 if (TREE_CODE (t
) != POINTER_TYPE
)
404 pp_c_type_qualifier_list (pp
, t
);
410 /* Get the types-specifier of this type. */
411 tree pointee
= strip_pointer_operator (TREE_TYPE (t
));
412 pp_c_specifier_qualifier_list (pp
, pointee
);
413 if (TREE_CODE (pointee
) == ARRAY_TYPE
414 || TREE_CODE (pointee
) == FUNCTION_TYPE
)
416 pp_c_whitespace (pp
);
417 pp_c_left_paren (pp
);
419 else if (!c_dialect_cxx ())
420 pp_c_whitespace (pp
);
421 pp_ptr_operator (pp
, t
);
427 pp_c_specifier_qualifier_list (pp
, TREE_TYPE (t
));
432 pp_c_specifier_qualifier_list (pp
, TREE_TYPE (t
));
433 if (code
== COMPLEX_TYPE
)
434 pp_c_identifier (pp
, flag_isoc99
? "_Complex" : "__complex__");
435 else if (code
== VECTOR_TYPE
)
436 pp_c_identifier (pp
, "__vector__");
440 pp_simple_type_specifier (pp
, t
);
445 /* parameter-type-list:
450 parameter-declaration
451 parameter-list , parameter-declaration
453 parameter-declaration:
454 declaration-specifiers declarator
455 declaration-specifiers abstract-declarator(opt) */
458 pp_c_parameter_type_list (c_pretty_printer
*pp
, tree t
)
460 bool want_parm_decl
= DECL_P (t
) && !(pp
->flags
& pp_c_flag_abstract
);
461 tree parms
= want_parm_decl
? DECL_ARGUMENTS (t
) : TYPE_ARG_TYPES (t
);
462 pp_c_left_paren (pp
);
463 if (parms
== void_list_node
)
464 pp_c_identifier (pp
, "void");
468 for ( ; parms
&& parms
!= void_list_node
; parms
= TREE_CHAIN (parms
))
471 pp_separate_with (pp
, ',');
473 pp_declaration_specifiers
474 (pp
, want_parm_decl
? parms
: TREE_VALUE (parms
));
476 pp_declarator (pp
, parms
);
478 pp_abstract_declarator (pp
, TREE_VALUE (parms
));
481 pp_c_right_paren (pp
);
484 /* abstract-declarator:
486 pointer(opt) direct-abstract-declarator */
489 pp_c_abstract_declarator (c_pretty_printer
*pp
, tree t
)
491 if (TREE_CODE (t
) == POINTER_TYPE
)
493 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
494 || TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
)
495 pp_c_right_paren (pp
);
499 pp_direct_abstract_declarator (pp
, t
);
502 /* direct-abstract-declarator:
503 ( abstract-declarator )
504 direct-abstract-declarator(opt) [ assignment-expression(opt) ]
505 direct-abstract-declarator(opt) [ * ]
506 direct-abstract-declarator(opt) ( parameter-type-list(opt) ) */
509 pp_c_direct_abstract_declarator (c_pretty_printer
*pp
, tree t
)
511 switch (TREE_CODE (t
))
514 pp_abstract_declarator (pp
, t
);
518 pp_c_parameter_type_list (pp
, t
);
519 pp_direct_abstract_declarator (pp
, TREE_TYPE (t
));
523 pp_c_left_bracket (pp
);
524 if (TYPE_DOMAIN (t
) && TYPE_MAX_VALUE (TYPE_DOMAIN (t
)))
525 pp_expression (pp
, TYPE_MAX_VALUE (TYPE_DOMAIN (t
)));
526 pp_c_right_bracket (pp
);
527 pp_direct_abstract_declarator (pp
, TREE_TYPE (t
));
530 case IDENTIFIER_NODE
:
544 pp_unsupported_tree (pp
, t
);
550 specifier-qualifier-list abstract-declarator(opt) */
553 pp_c_type_id (c_pretty_printer
*pp
, tree t
)
555 pp_c_specifier_qualifier_list (pp
, t
);
556 pp_abstract_declarator (pp
, t
);
559 /* storage-class-specifier:
567 pp_c_storage_class_specifier (c_pretty_printer
*pp
, tree t
)
569 if (TREE_CODE (t
) == TYPE_DECL
)
570 pp_c_identifier (pp
, "typedef");
573 if (DECL_REGISTER (t
))
574 pp_c_identifier (pp
, "register");
575 else if (TREE_STATIC (t
) && TREE_CODE (t
) == VAR_DECL
)
576 pp_c_identifier (pp
, "static");
580 /* function-specifier:
584 pp_c_function_specifier (c_pretty_printer
*pp
, tree t
)
586 if (TREE_CODE (t
) == FUNCTION_DECL
&& DECL_DECLARED_INLINE_P (t
))
587 pp_c_identifier (pp
, "inline");
590 /* declaration-specifiers:
591 storage-class-specifier declaration-specifiers(opt)
592 type-specifier declaration-specifiers(opt)
593 type-qualifier declaration-specifiers(opt)
594 function-specifier declaration-specifiers(opt) */
597 pp_c_declaration_specifiers (c_pretty_printer
*pp
, tree t
)
599 pp_storage_class_specifier (pp
, t
);
600 pp_function_specifier (pp
, t
);
601 pp_c_specifier_qualifier_list (pp
, DECL_P (t
) ? TREE_TYPE (t
) : t
);
607 direct-declarator [ type-qualifier-list(opt) assignment-expression(opt) ]
608 direct-declarator [ static type-qualifier-list(opt) assignment-expression(opt)]
609 direct-declarator [ type-qualifier-list static assignment-expression ]
610 direct-declarator [ type-qualifier-list * ]
611 direct-declarator ( parameter-type-list )
612 direct-declarator ( identifier-list(opt) ) */
615 pp_c_direct_declarator (c_pretty_printer
*pp
, tree t
)
617 switch (TREE_CODE (t
))
624 pp_c_space_for_pointer_operator (pp
, TREE_TYPE (t
));
625 pp_c_tree_decl_identifier (pp
, t
);
630 pp_abstract_declarator (pp
, TREE_TYPE (t
));
634 pp_parameter_list (pp
, t
);
635 pp_abstract_declarator (pp
, TREE_TYPE (t
));
639 pp_c_space_for_pointer_operator (pp
, TREE_TYPE (TREE_TYPE (t
)));
640 pp_c_tree_decl_identifier (pp
, t
);
641 if (pp_c_base (pp
)->flags
& pp_c_flag_abstract
)
642 pp_abstract_declarator (pp
, TREE_TYPE (t
));
645 pp_parameter_list (pp
, t
);
646 pp_abstract_declarator (pp
, TREE_TYPE (TREE_TYPE (t
)));
658 pp_unsupported_tree (pp
, t
);
665 pointer(opt) direct-declarator */
668 pp_c_declarator (c_pretty_printer
*pp
, tree t
)
670 switch (TREE_CODE (t
))
686 pp_direct_declarator (pp
, t
);
691 pp_unsupported_tree (pp
, t
);
697 declaration-specifiers init-declarator-list(opt) ; */
700 pp_c_declaration (c_pretty_printer
*pp
, tree t
)
702 pp_declaration_specifiers (pp
, t
);
703 pp_c_init_declarator (pp
, t
);
706 /* Pretty-print ATTRIBUTES using GNU C extension syntax. */
709 pp_c_attributes (c_pretty_printer
*pp
, tree attributes
)
711 if (attributes
== NULL_TREE
)
714 pp_c_identifier (pp
, "__attribute__");
715 pp_c_left_paren (pp
);
716 pp_c_left_paren (pp
);
717 for (; attributes
!= NULL_TREE
; attributes
= TREE_CHAIN (attributes
))
719 pp_tree_identifier (pp
, TREE_PURPOSE (attributes
));
720 if (TREE_VALUE (attributes
))
721 pp_c_call_argument_list (pp
, TREE_VALUE (attributes
));
723 if (TREE_CHAIN (attributes
))
724 pp_separate_with (pp
, ',');
726 pp_c_right_paren (pp
);
727 pp_c_right_paren (pp
);
730 /* function-definition:
731 declaration-specifiers declarator compound-statement */
734 pp_c_function_definition (c_pretty_printer
*pp
, tree t
)
736 pp_declaration_specifiers (pp
, t
);
737 pp_declarator (pp
, t
);
738 pp_needs_newline (pp
) = true;
739 pp_statement (pp
, DECL_SAVED_TREE (t
));
747 /* Print out a c-char. This is called solely for characters which are
748 in the *target* execution character set. We ought to convert them
749 back to the *host* execution character set before printing, but we
750 have no way to do this at present. A decent compromise is to print
751 all characters as if they were in the host execution character set,
752 and not attempt to recover any named escape characters, but render
753 all unprintables as octal escapes. If the host and target character
754 sets are the same, this produces relatively readable output. If they
755 are not the same, strings may appear as gibberish, but that's okay
756 (in fact, it may well be what the reader wants, e.g. if they are looking
757 to see if conversion to the target character set happened correctly).
759 A special case: we need to prefix \, ", and ' with backslashes. It is
760 correct to do so for the *host*'s \, ", and ', because the rest of the
761 file appears in the host character set. */
764 pp_c_char (c_pretty_printer
*pp
, int c
)
770 case '\\': pp_string (pp
, "\\\\"); break;
771 case '\'': pp_string (pp
, "\\\'"); break;
772 case '\"': pp_string (pp
, "\\\""); break;
773 default: pp_character (pp
, c
);
777 pp_scalar (pp
, "\\%03o", (unsigned) c
);
780 /* Print out a STRING literal. */
783 pp_c_string_literal (c_pretty_printer
*pp
, tree s
)
785 const char *p
= TREE_STRING_POINTER (s
);
786 int n
= TREE_STRING_LENGTH (s
) - 1;
789 for (i
= 0; i
< n
; ++i
)
790 pp_c_char (pp
, p
[i
]);
794 /* Pretty-print an INTEGER literal. */
797 pp_c_integer_constant (c_pretty_printer
*pp
, tree i
)
799 tree type
= TREE_TYPE (i
);
801 if (TREE_INT_CST_HIGH (i
) == 0)
802 pp_wide_integer (pp
, TREE_INT_CST_LOW (i
));
805 if (tree_int_cst_sgn (i
) < 0)
807 pp_character (pp
, '-');
808 i
= build_int_cst_wide (NULL_TREE
,
809 -TREE_INT_CST_LOW (i
),
810 ~TREE_INT_CST_HIGH (i
)
811 + !TREE_INT_CST_LOW (i
));
813 sprintf (pp_buffer (pp
)->digit_buffer
,
814 HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
815 TREE_INT_CST_HIGH (i
), TREE_INT_CST_LOW (i
));
816 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);
818 if (TYPE_UNSIGNED (type
))
819 pp_character (pp
, 'u');
820 if (type
== long_integer_type_node
|| type
== long_unsigned_type_node
)
821 pp_character (pp
, 'l');
822 else if (type
== long_long_integer_type_node
823 || type
== long_long_unsigned_type_node
)
824 pp_string (pp
, "ll");
827 /* Print out a CHARACTER literal. */
830 pp_c_character_constant (c_pretty_printer
*pp
, tree c
)
832 tree type
= TREE_TYPE (c
);
833 if (type
== wchar_type_node
)
834 pp_character (pp
, 'L');
836 if (host_integerp (c
, TYPE_UNSIGNED (type
)))
837 pp_c_char (pp
, tree_low_cst (c
, TYPE_UNSIGNED (type
)));
839 pp_scalar (pp
, "\\x%x", (unsigned) TREE_INT_CST_LOW (c
));
843 /* Print out a BOOLEAN literal. */
846 pp_c_bool_constant (c_pretty_printer
*pp
, tree b
)
848 if (b
== boolean_false_node
)
850 if (c_dialect_cxx ())
851 pp_c_identifier (pp
, "false");
852 else if (flag_isoc99
)
853 pp_c_identifier (pp
, "_False");
855 pp_unsupported_tree (pp
, b
);
857 else if (b
== boolean_true_node
)
859 if (c_dialect_cxx ())
860 pp_c_identifier (pp
, "true");
861 else if (flag_isoc99
)
862 pp_c_identifier (pp
, "_True");
864 pp_unsupported_tree (pp
, b
);
866 else if (TREE_CODE (b
) == INTEGER_CST
)
867 pp_c_integer_constant (pp
, b
);
869 pp_unsupported_tree (pp
, b
);
872 /* Attempt to print out an ENUMERATOR. Return true on success. Else return
873 false; that means the value was obtained by a cast, in which case
874 print out the type-id part of the cast-expression -- the casted value
875 is then printed by pp_c_integer_literal. */
878 pp_c_enumeration_constant (c_pretty_printer
*pp
, tree e
)
880 bool value_is_named
= true;
881 tree type
= TREE_TYPE (e
);
884 /* Find the name of this constant. */
885 for (value
= TYPE_VALUES (type
);
886 value
!= NULL_TREE
&& !tree_int_cst_equal (TREE_VALUE (value
), e
);
887 value
= TREE_CHAIN (value
))
890 if (value
!= NULL_TREE
)
891 pp_id_expression (pp
, TREE_PURPOSE (value
));
894 /* Value must have been cast. */
895 pp_c_type_cast (pp
, type
);
896 value_is_named
= false;
899 return value_is_named
;
902 /* Print out a REAL value as a decimal-floating-constant. */
905 pp_c_floating_constant (c_pretty_printer
*pp
, tree r
)
907 real_to_decimal (pp_buffer (pp
)->digit_buffer
, &TREE_REAL_CST (r
),
908 sizeof (pp_buffer (pp
)->digit_buffer
), 0, 1);
909 pp_string (pp
, pp_buffer(pp
)->digit_buffer
);
910 if (TREE_TYPE (r
) == float_type_node
)
911 pp_character (pp
, 'f');
912 else if (TREE_TYPE (r
) == long_double_type_node
)
913 pp_character (pp
, 'l');
916 /* Pretty-print a compound literal expression. GNU extensions include
920 pp_c_compound_literal (c_pretty_printer
*pp
, tree e
)
922 tree type
= TREE_TYPE (e
);
923 pp_c_type_cast (pp
, type
);
925 switch (TREE_CODE (type
))
932 pp_c_brace_enclosed_initializer_list (pp
, e
);
936 pp_unsupported_tree (pp
, e
);
945 character-constant */
948 pp_c_constant (c_pretty_printer
*pp
, tree e
)
950 const enum tree_code code
= TREE_CODE (e
);
956 tree type
= TREE_TYPE (e
);
957 if (type
== boolean_type_node
)
958 pp_c_bool_constant (pp
, e
);
959 else if (type
== char_type_node
)
960 pp_c_character_constant (pp
, e
);
961 else if (TREE_CODE (type
) == ENUMERAL_TYPE
962 && pp_c_enumeration_constant (pp
, e
))
965 pp_c_integer_constant (pp
, e
);
970 pp_c_floating_constant (pp
, e
);
974 pp_c_string_literal (pp
, e
);
978 pp_unsupported_tree (pp
, e
);
983 /* Pretty-print an IDENTIFIER_NODE, preceded by whitespace is necessary. */
986 pp_c_identifier (c_pretty_printer
*pp
, const char *id
)
988 pp_c_maybe_whitespace (pp
);
989 pp_identifier (pp
, id
);
990 pp_base (pp
)->padding
= pp_before
;
993 /* Pretty-print a C primary-expression.
1001 pp_c_primary_expression (c_pretty_printer
*pp
, tree e
)
1003 switch (TREE_CODE (e
))
1011 pp_c_tree_decl_identifier (pp
, e
);
1014 case IDENTIFIER_NODE
:
1015 pp_c_tree_identifier (pp
, e
);
1019 pp_c_identifier (pp
, "<erroneous-expression>");
1023 pp_c_identifier (pp
, "<return-value>");
1029 pp_c_constant (pp
, e
);
1033 pp_c_identifier (pp
, "__builtin_memcpy");
1034 pp_c_left_paren (pp
);
1036 pp_primary_expression (pp
, TREE_OPERAND (e
, 0));
1037 pp_separate_with (pp
, ',');
1039 pp_initializer (pp
, TREE_OPERAND (e
, 1));
1040 if (TREE_OPERAND (e
, 2))
1042 pp_separate_with (pp
, ',');
1043 pp_c_expression (pp
, TREE_OPERAND (e
, 2));
1045 pp_c_right_paren (pp
);
1049 /* FIXME: Make sure we won't get into an infinie loop. */
1050 pp_c_left_paren (pp
);
1051 pp_expression (pp
, e
);
1052 pp_c_right_paren (pp
);
1057 /* Print out a C initializer -- also support C compound-literals.
1059 assignment-expression:
1060 { initializer-list }
1061 { initializer-list , } */
1064 pp_c_initializer (c_pretty_printer
*pp
, tree e
)
1066 if (TREE_CODE (e
) == CONSTRUCTOR
)
1067 pp_c_brace_enclosed_initializer_list (pp
, e
);
1069 pp_expression (pp
, e
);
1074 declarator = initializer */
1077 pp_c_init_declarator (c_pretty_printer
*pp
, tree t
)
1079 pp_declarator (pp
, t
);
1080 /* We don't want to output function definitions here. There are handled
1081 elsewhere (and the syntactic form is bogus anyway). */
1082 if (TREE_CODE (t
) != FUNCTION_DECL
&& DECL_INITIAL (t
))
1084 tree init
= DECL_INITIAL (t
);
1085 /* This C++ bit is handled here because it is easier to do so.
1086 In templates, the C++ parser builds a TREE_LIST for a
1087 direct-initialization; the TREE_PURPOSE is the variable to
1088 initialize and the TREE_VALUE is the initializer. */
1089 if (TREE_CODE (init
) == TREE_LIST
)
1091 pp_c_left_paren (pp
);
1092 pp_expression (pp
, TREE_VALUE (init
));
1093 pp_right_paren (pp
);
1100 pp_c_initializer (pp
, init
);
1105 /* initializer-list:
1106 designation(opt) initializer
1107 initializer-list , designation(opt) initializer
1114 designator-list designator
1117 [ constant-expression ]
1121 pp_c_initializer_list (c_pretty_printer
*pp
, tree e
)
1123 tree type
= TREE_TYPE (e
);
1124 const enum tree_code code
= TREE_CODE (type
);
1132 tree init
= TREE_OPERAND (e
, 0);
1133 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
1135 if (code
== RECORD_TYPE
|| code
== UNION_TYPE
)
1138 pp_c_primary_expression (pp
, TREE_PURPOSE (init
));
1142 pp_c_left_bracket (pp
);
1143 if (TREE_PURPOSE (init
))
1144 pp_c_constant (pp
, TREE_PURPOSE (init
));
1145 pp_c_right_bracket (pp
);
1147 pp_c_whitespace (pp
);
1149 pp_c_whitespace (pp
);
1150 pp_initializer (pp
, TREE_VALUE (init
));
1151 if (TREE_CHAIN (init
))
1152 pp_separate_with (pp
, ',');
1158 if (TREE_CODE (e
) == VECTOR_CST
)
1159 pp_c_expression_list (pp
, TREE_VECTOR_CST_ELTS (e
));
1160 else if (TREE_CODE (e
) == CONSTRUCTOR
)
1161 pp_c_constructor_elts (pp
, CONSTRUCTOR_ELTS (e
));
1167 if (TREE_CODE (e
) == CONSTRUCTOR
)
1168 pp_c_constructor_elts (pp
, CONSTRUCTOR_ELTS (e
));
1169 else if (TREE_CODE (e
) == COMPLEX_CST
|| TREE_CODE (e
) == COMPLEX_EXPR
)
1171 const bool cst
= TREE_CODE (e
) == COMPLEX_CST
;
1172 pp_expression (pp
, cst
? TREE_REALPART (e
) : TREE_OPERAND (e
, 0));
1173 pp_separate_with (pp
, ',');
1174 pp_expression (pp
, cst
? TREE_IMAGPART (e
) : TREE_OPERAND (e
, 1));
1184 pp_unsupported_tree (pp
, type
);
1187 /* Pretty-print a brace-enclosed initializer-list. */
1190 pp_c_brace_enclosed_initializer_list (c_pretty_printer
*pp
, tree l
)
1192 pp_c_left_brace (pp
);
1193 pp_c_initializer_list (pp
, l
);
1194 pp_c_right_brace (pp
);
1198 /* This is a convenient function, used to bridge gap between C and C++
1205 pp_c_id_expression (c_pretty_printer
*pp
, tree t
)
1207 switch (TREE_CODE (t
))
1216 pp_c_tree_decl_identifier (pp
, t
);
1219 case IDENTIFIER_NODE
:
1220 pp_c_tree_identifier (pp
, t
);
1224 pp_unsupported_tree (pp
, t
);
1229 /* postfix-expression:
1231 postfix-expression [ expression ]
1232 postfix-expression ( argument-expression-list(opt) )
1233 postfix-expression . identifier
1234 postfix-expression -> identifier
1235 postfix-expression ++
1236 postfix-expression --
1237 ( type-name ) { initializer-list }
1238 ( type-name ) { initializer-list , } */
1241 pp_c_postfix_expression (c_pretty_printer
*pp
, tree e
)
1243 enum tree_code code
= TREE_CODE (e
);
1246 case POSTINCREMENT_EXPR
:
1247 case POSTDECREMENT_EXPR
:
1248 pp_postfix_expression (pp
, TREE_OPERAND (e
, 0));
1249 pp_identifier (pp
, code
== POSTINCREMENT_EXPR
? "++" : "--");
1253 pp_postfix_expression (pp
, TREE_OPERAND (e
, 0));
1254 pp_c_left_bracket (pp
);
1255 pp_expression (pp
, TREE_OPERAND (e
, 1));
1256 pp_c_right_bracket (pp
);
1260 pp_postfix_expression (pp
, TREE_OPERAND (e
, 0));
1261 pp_c_call_argument_list (pp
, TREE_OPERAND (e
, 1));
1264 case UNORDERED_EXPR
:
1265 pp_c_identifier (pp
, flag_isoc99
1267 : "__builtin_isunordered");
1271 pp_c_identifier (pp
, flag_isoc99
1273 : "!__builtin_isunordered");
1277 pp_c_identifier (pp
, flag_isoc99
1279 : "!__builtin_isgreaterequal");
1283 pp_c_identifier (pp
, flag_isoc99
1285 : "!__builtin_isgreater");
1289 pp_c_identifier (pp
, flag_isoc99
1291 : "!__builtin_islessequal");
1295 pp_c_identifier (pp
, flag_isoc99
1297 : "!__builtin_isless");
1301 pp_c_identifier (pp
, flag_isoc99
1303 : "!__builtin_islessgreater");
1307 pp_c_identifier (pp
, flag_isoc99
1309 : "__builtin_islessgreater");
1313 pp_c_left_paren (pp
);
1314 pp_expression (pp
, TREE_OPERAND (e
, 0));
1315 pp_separate_with (pp
, ',');
1316 pp_expression (pp
, TREE_OPERAND (e
, 1));
1317 pp_c_right_paren (pp
);
1321 pp_c_identifier (pp
, "__builtin_abs");
1322 pp_c_left_paren (pp
);
1323 pp_expression (pp
, TREE_OPERAND (e
, 0));
1324 pp_c_right_paren (pp
);
1329 tree object
= TREE_OPERAND (e
, 0);
1330 if (TREE_CODE (object
) == INDIRECT_REF
)
1332 pp_postfix_expression (pp
, TREE_OPERAND (object
, 0));
1337 pp_postfix_expression (pp
, object
);
1340 pp_expression (pp
, TREE_OPERAND (e
, 1));
1347 pp_c_compound_literal (pp
, e
);
1350 case COMPOUND_LITERAL_EXPR
:
1351 e
= DECL_INITIAL (COMPOUND_LITERAL_EXPR_DECL (e
));
1354 pp_initializer (pp
, e
);
1358 pp_c_identifier (pp
, "__builtin_va_arg");
1359 pp_c_left_paren (pp
);
1360 pp_assignment_expression (pp
, TREE_OPERAND (e
, 0));
1361 pp_separate_with (pp
, ',');
1362 pp_type_id (pp
, TREE_TYPE (e
));
1363 pp_c_right_paren (pp
);
1367 if (TREE_CODE (TREE_OPERAND (e
, 0)) == FUNCTION_DECL
)
1369 pp_c_id_expression (pp
, TREE_OPERAND (e
, 0));
1372 /* else fall through. */
1375 pp_primary_expression (pp
, e
);
1380 /* Print out an expression-list; E is expected to be a TREE_LIST. */
1383 pp_c_expression_list (c_pretty_printer
*pp
, tree e
)
1385 for (; e
!= NULL_TREE
; e
= TREE_CHAIN (e
))
1387 pp_expression (pp
, TREE_VALUE (e
));
1389 pp_separate_with (pp
, ',');
1393 /* Print out V, which contains the elements of a constructor. */
1396 pp_c_constructor_elts (c_pretty_printer
*pp
, VEC(constructor_elt
,gc
) *v
)
1398 unsigned HOST_WIDE_INT ix
;
1401 FOR_EACH_CONSTRUCTOR_VALUE (v
, ix
, value
)
1403 pp_expression (pp
, value
);
1404 if (ix
!= VEC_length (constructor_elt
, v
) - 1)
1405 pp_separate_with (pp
, ',');
1409 /* Print out an expression-list in parens, as in a function call. */
1412 pp_c_call_argument_list (c_pretty_printer
*pp
, tree t
)
1414 pp_c_left_paren (pp
);
1415 if (t
&& TREE_CODE (t
) == TREE_LIST
)
1416 pp_c_expression_list (pp
, t
);
1417 pp_c_right_paren (pp
);
1420 /* unary-expression:
1424 unary-operator cast-expression
1425 sizeof unary-expression
1428 unary-operator: one of
1433 __alignof__ unary-expression
1434 __alignof__ ( type-id )
1435 __real__ unary-expression
1436 __imag__ unary-expression */
1439 pp_c_unary_expression (c_pretty_printer
*pp
, tree e
)
1441 enum tree_code code
= TREE_CODE (e
);
1444 case PREINCREMENT_EXPR
:
1445 case PREDECREMENT_EXPR
:
1446 pp_identifier (pp
, code
== PREINCREMENT_EXPR
? "++" : "--");
1447 pp_c_unary_expression (pp
, TREE_OPERAND (e
, 0));
1454 case TRUTH_NOT_EXPR
:
1456 /* String literal are used by address. */
1457 if (code
== ADDR_EXPR
&& TREE_CODE (TREE_OPERAND (e
, 0)) != STRING_CST
)
1459 else if (code
== INDIRECT_REF
)
1461 else if (code
== NEGATE_EXPR
)
1463 else if (code
== BIT_NOT_EXPR
|| code
== CONJ_EXPR
)
1465 else if (code
== TRUTH_NOT_EXPR
)
1466 pp_exclamation (pp
);
1467 pp_c_cast_expression (pp
, TREE_OPERAND (e
, 0));
1472 pp_c_identifier (pp
, code
== REALPART_EXPR
? "__real__" : "__imag__");
1473 pp_c_whitespace (pp
);
1474 pp_unary_expression (pp
, TREE_OPERAND (e
, 0));
1478 pp_postfix_expression (pp
, e
);
1485 ( type-name ) cast-expression */
1488 pp_c_cast_expression (c_pretty_printer
*pp
, tree e
)
1490 switch (TREE_CODE (e
))
1493 case FIX_TRUNC_EXPR
:
1495 pp_c_type_cast (pp
, TREE_TYPE (e
));
1496 pp_c_cast_expression (pp
, TREE_OPERAND (e
, 0));
1500 pp_unary_expression (pp
, e
);
1504 /* multiplicative-expression:
1506 multiplicative-expression * cast-expression
1507 multiplicative-expression / cast-expression
1508 multiplicative-expression % cast-expression */
1511 pp_c_multiplicative_expression (c_pretty_printer
*pp
, tree e
)
1513 enum tree_code code
= TREE_CODE (e
);
1517 case TRUNC_DIV_EXPR
:
1518 case TRUNC_MOD_EXPR
:
1519 pp_multiplicative_expression (pp
, TREE_OPERAND (e
, 0));
1520 pp_c_whitespace (pp
);
1521 if (code
== MULT_EXPR
)
1523 else if (code
== TRUNC_DIV_EXPR
)
1527 pp_c_whitespace (pp
);
1528 pp_c_cast_expression (pp
, TREE_OPERAND (e
, 1));
1532 pp_c_cast_expression (pp
, e
);
1537 /* additive-expression:
1538 multiplicative-expression
1539 additive-expression + multiplicative-expression
1540 additive-expression - multiplicative-expression */
1543 pp_c_additive_expression (c_pretty_printer
*pp
, tree e
)
1545 enum tree_code code
= TREE_CODE (e
);
1550 pp_c_additive_expression (pp
, TREE_OPERAND (e
, 0));
1551 pp_c_whitespace (pp
);
1552 if (code
== PLUS_EXPR
)
1556 pp_c_whitespace (pp
);
1557 pp_multiplicative_expression (pp
, TREE_OPERAND (e
, 1));
1561 pp_multiplicative_expression (pp
, e
);
1566 /* additive-expression:
1568 shift-expression << additive-expression
1569 shift-expression >> additive-expression */
1572 pp_c_shift_expression (c_pretty_printer
*pp
, tree e
)
1574 enum tree_code code
= TREE_CODE (e
);
1579 pp_c_shift_expression (pp
, TREE_OPERAND (e
, 0));
1580 pp_c_whitespace (pp
);
1581 pp_identifier (pp
, code
== LSHIFT_EXPR
? "<<" : ">>");
1582 pp_c_whitespace (pp
);
1583 pp_c_additive_expression (pp
, TREE_OPERAND (e
, 1));
1587 pp_c_additive_expression (pp
, e
);
1591 /* relational-expression:
1593 relational-expression < shift-expression
1594 relational-expression > shift-expression
1595 relational-expression <= shift-expression
1596 relational-expression >= shift-expression */
1599 pp_c_relational_expression (c_pretty_printer
*pp
, tree e
)
1601 enum tree_code code
= TREE_CODE (e
);
1608 pp_c_relational_expression (pp
, TREE_OPERAND (e
, 0));
1609 pp_c_whitespace (pp
);
1610 if (code
== LT_EXPR
)
1612 else if (code
== GT_EXPR
)
1614 else if (code
== LE_EXPR
)
1615 pp_identifier (pp
, "<=");
1616 else if (code
== GE_EXPR
)
1617 pp_identifier (pp
, ">=");
1618 pp_c_whitespace (pp
);
1619 pp_c_shift_expression (pp
, TREE_OPERAND (e
, 1));
1623 pp_c_shift_expression (pp
, e
);
1628 /* equality-expression:
1629 relational-expression
1630 equality-expression == relational-expression
1631 equality-equality != relational-expression */
1634 pp_c_equality_expression (c_pretty_printer
*pp
, tree e
)
1636 enum tree_code code
= TREE_CODE (e
);
1641 pp_c_equality_expression (pp
, TREE_OPERAND (e
, 0));
1642 pp_c_whitespace (pp
);
1643 pp_identifier (pp
, code
== EQ_EXPR
? "==" : "!=");
1644 pp_c_whitespace (pp
);
1645 pp_c_relational_expression (pp
, TREE_OPERAND (e
, 1));
1649 pp_c_relational_expression (pp
, e
);
1656 AND-expression & equality-equality */
1659 pp_c_and_expression (c_pretty_printer
*pp
, tree e
)
1661 if (TREE_CODE (e
) == BIT_AND_EXPR
)
1663 pp_c_and_expression (pp
, TREE_OPERAND (e
, 0));
1664 pp_c_whitespace (pp
);
1666 pp_c_whitespace (pp
);
1667 pp_c_equality_expression (pp
, TREE_OPERAND (e
, 1));
1670 pp_c_equality_expression (pp
, e
);
1673 /* exclusive-OR-expression:
1675 exclusive-OR-expression ^ AND-expression */
1678 pp_c_exclusive_or_expression (c_pretty_printer
*pp
, tree e
)
1680 if (TREE_CODE (e
) == BIT_XOR_EXPR
)
1682 pp_c_exclusive_or_expression (pp
, TREE_OPERAND (e
, 0));
1683 pp_c_maybe_whitespace (pp
);
1685 pp_c_whitespace (pp
);
1686 pp_c_and_expression (pp
, TREE_OPERAND (e
, 1));
1689 pp_c_and_expression (pp
, e
);
1692 /* inclusive-OR-expression:
1693 exclusive-OR-expression
1694 inclusive-OR-expression | exclusive-OR-expression */
1697 pp_c_inclusive_or_expression (c_pretty_printer
*pp
, tree e
)
1699 if (TREE_CODE (e
) == BIT_IOR_EXPR
)
1701 pp_c_exclusive_or_expression (pp
, TREE_OPERAND (e
, 0));
1702 pp_c_whitespace (pp
);
1704 pp_c_whitespace (pp
);
1705 pp_c_exclusive_or_expression (pp
, TREE_OPERAND (e
, 1));
1708 pp_c_exclusive_or_expression (pp
, e
);
1711 /* logical-AND-expression:
1712 inclusive-OR-expression
1713 logical-AND-expression && inclusive-OR-expression */
1716 pp_c_logical_and_expression (c_pretty_printer
*pp
, tree e
)
1718 if (TREE_CODE (e
) == TRUTH_ANDIF_EXPR
)
1720 pp_c_logical_and_expression (pp
, TREE_OPERAND (e
, 0));
1721 pp_c_whitespace (pp
);
1722 pp_identifier (pp
, "&&");
1723 pp_c_whitespace (pp
);
1724 pp_c_inclusive_or_expression (pp
, TREE_OPERAND (e
, 1));
1727 pp_c_inclusive_or_expression (pp
, e
);
1730 /* logical-OR-expression:
1731 logical-AND-expression
1732 logical-OR-expression || logical-AND-expression */
1735 pp_c_logical_or_expression (c_pretty_printer
*pp
, tree e
)
1737 if (TREE_CODE (e
) == TRUTH_ORIF_EXPR
)
1739 pp_c_logical_or_expression (pp
, TREE_OPERAND (e
, 0));
1740 pp_c_whitespace (pp
);
1741 pp_identifier (pp
, "||");
1742 pp_c_whitespace (pp
);
1743 pp_c_logical_and_expression (pp
, TREE_OPERAND (e
, 1));
1746 pp_c_logical_and_expression (pp
, e
);
1749 /* conditional-expression:
1750 logical-OR-expression
1751 logical-OR-expression ? expression : conditional-expression */
1754 pp_c_conditional_expression (c_pretty_printer
*pp
, tree e
)
1756 if (TREE_CODE (e
) == COND_EXPR
)
1758 pp_c_logical_or_expression (pp
, TREE_OPERAND (e
, 0));
1759 pp_c_whitespace (pp
);
1761 pp_c_whitespace (pp
);
1762 pp_expression (pp
, TREE_OPERAND (e
, 1));
1763 pp_c_whitespace (pp
);
1765 pp_c_whitespace (pp
);
1766 pp_c_conditional_expression (pp
, TREE_OPERAND (e
, 2));
1769 pp_c_logical_or_expression (pp
, e
);
1773 /* assignment-expression:
1774 conditional-expression
1775 unary-expression assignment-operator assignment-expression
1777 assignment-expression: one of
1778 = *= /= %= += -= >>= <<= &= ^= |= */
1781 pp_c_assignment_expression (c_pretty_printer
*pp
, tree e
)
1783 if (TREE_CODE (e
) == MODIFY_EXPR
|| TREE_CODE (e
) == INIT_EXPR
)
1785 pp_c_unary_expression (pp
, TREE_OPERAND (e
, 0));
1786 pp_c_whitespace (pp
);
1789 pp_c_expression (pp
, TREE_OPERAND (e
, 1));
1792 pp_c_conditional_expression (pp
, e
);
1796 assignment-expression
1797 expression , assignment-expression
1799 Implementation note: instead of going through the usual recursion
1800 chain, I take the liberty of dispatching nodes to the appropriate
1801 functions. This makes some redundancy, but it worths it. That also
1802 prevents a possible infinite recursion between pp_c_primary_expression ()
1803 and pp_c_expression (). */
1806 pp_c_expression (c_pretty_printer
*pp
, tree e
)
1808 switch (TREE_CODE (e
))
1811 pp_c_integer_constant (pp
, e
);
1815 pp_c_floating_constant (pp
, e
);
1819 pp_c_string_literal (pp
, e
);
1822 case IDENTIFIER_NODE
:
1831 pp_primary_expression (pp
, e
);
1834 case POSTINCREMENT_EXPR
:
1835 case POSTDECREMENT_EXPR
:
1843 case UNORDERED_EXPR
:
1852 case COMPOUND_LITERAL_EXPR
:
1854 pp_postfix_expression (pp
, e
);
1862 case TRUTH_NOT_EXPR
:
1863 case PREINCREMENT_EXPR
:
1864 case PREDECREMENT_EXPR
:
1867 pp_c_unary_expression (pp
, e
);
1871 case FIX_TRUNC_EXPR
:
1873 pp_c_cast_expression (pp
, e
);
1877 case TRUNC_MOD_EXPR
:
1878 case TRUNC_DIV_EXPR
:
1879 pp_multiplicative_expression (pp
, e
);
1884 pp_c_shift_expression (pp
, e
);
1891 pp_c_relational_expression (pp
, e
);
1895 pp_c_and_expression (pp
, e
);
1899 pp_c_exclusive_or_expression (pp
, e
);
1903 pp_c_inclusive_or_expression (pp
, e
);
1906 case TRUTH_ANDIF_EXPR
:
1907 pp_c_logical_and_expression (pp
, e
);
1910 case TRUTH_ORIF_EXPR
:
1911 pp_c_logical_or_expression (pp
, e
);
1916 pp_c_equality_expression (pp
, e
);
1920 pp_conditional_expression (pp
, e
);
1925 pp_c_additive_expression (pp
, e
);
1930 pp_assignment_expression (pp
, e
);
1934 pp_c_left_paren (pp
);
1935 pp_expression (pp
, TREE_OPERAND (e
, 0));
1936 pp_separate_with (pp
, ',');
1937 pp_assignment_expression (pp
, TREE_OPERAND (e
, 1));
1938 pp_c_right_paren (pp
);
1942 case NON_LVALUE_EXPR
:
1944 pp_expression (pp
, TREE_OPERAND (e
, 0));
1948 pp_postfix_expression (pp
, TREE_OPERAND (e
, 1));
1952 pp_unsupported_tree (pp
, e
);
1962 pp_c_statement (c_pretty_printer
*pp
, tree stmt
)
1967 if (pp_needs_newline (pp
))
1968 pp_newline_and_indent (pp
, 0);
1970 dump_generic_node (pp_base (pp
), stmt
, pp_indentation (pp
), 0, true);
1974 /* Initialize the PRETTY-PRINTER for handling C codes. */
1977 pp_c_pretty_printer_init (c_pretty_printer
*pp
)
1979 pp
->offset_list
= 0;
1981 pp
->declaration
= pp_c_declaration
;
1982 pp
->declaration_specifiers
= pp_c_declaration_specifiers
;
1983 pp
->declarator
= pp_c_declarator
;
1984 pp
->direct_declarator
= pp_c_direct_declarator
;
1985 pp
->type_specifier_seq
= pp_c_specifier_qualifier_list
;
1986 pp
->abstract_declarator
= pp_c_abstract_declarator
;
1987 pp
->direct_abstract_declarator
= pp_c_direct_abstract_declarator
;
1988 pp
->ptr_operator
= pp_c_pointer
;
1989 pp
->parameter_list
= pp_c_parameter_type_list
;
1990 pp
->type_id
= pp_c_type_id
;
1991 pp
->simple_type_specifier
= pp_c_type_specifier
;
1992 pp
->function_specifier
= pp_c_function_specifier
;
1993 pp
->storage_class_specifier
= pp_c_storage_class_specifier
;
1995 pp
->statement
= pp_c_statement
;
1997 pp
->id_expression
= pp_c_id_expression
;
1998 pp
->primary_expression
= pp_c_primary_expression
;
1999 pp
->postfix_expression
= pp_c_postfix_expression
;
2000 pp
->unary_expression
= pp_c_unary_expression
;
2001 pp
->initializer
= pp_c_initializer
;
2002 pp
->multiplicative_expression
= pp_c_multiplicative_expression
;
2003 pp
->conditional_expression
= pp_c_conditional_expression
;
2004 pp
->assignment_expression
= pp_c_assignment_expression
;
2005 pp
->expression
= pp_c_expression
;
2009 /* Print the tree T in full, on file FILE. */
2012 print_c_tree (FILE *file
, tree t
)
2014 static c_pretty_printer pp_rec
;
2015 static bool initialized
= 0;
2016 c_pretty_printer
*pp
= &pp_rec
;
2021 pp_construct (pp_base (pp
), NULL
, 0);
2022 pp_c_pretty_printer_init (pp
);
2023 pp_needs_newline (pp
) = true;
2025 pp_base (pp
)->buffer
->stream
= file
;
2027 pp_statement (pp
, t
);
2033 /* Print the tree T in full, on stderr. */
2036 debug_c_tree (tree t
)
2038 print_c_tree (stderr
, t
);
2039 fputc ('\n', stderr
);
2042 /* Output the DECL_NAME of T. If T has no DECL_NAME, output a string made
2043 up of T's memory address. */
2046 pp_c_tree_decl_identifier (c_pretty_printer
*pp
, tree t
)
2050 gcc_assert (DECL_P (t
));
2053 name
= IDENTIFIER_POINTER (DECL_NAME (t
));
2056 static char xname
[8];
2057 sprintf (xname
, "<U%4x>", ((unsigned)((unsigned long)(t
) & 0xffff)));
2061 pp_c_identifier (pp
, name
);