1 /* Subroutines common to both C and C++ pretty-printers.
2 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
3 Free Software Foundation, Inc.
4 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
27 #include "fixed-value.h"
29 #include "c-pretty-print.h"
31 #include "tree-iterator.h"
32 #include "diagnostic.h"
34 /* Translate if being used for diagnostics, but not for dump files or
36 #define M_(msgid) (pp_translate_identifiers (pp) ? _(msgid) : (msgid))
38 /* The pretty-printer code is primarily designed to closely follow
39 (GNU) C and C++ grammars. That is to be contrasted with spaghetti
40 codes we used to have in the past. Following a structured
41 approach (preferably the official grammars) is believed to make it
42 much easier to add extensions and nifty pretty-printing effects that
43 takes expression or declaration contexts into account. */
46 #define pp_c_maybe_whitespace(PP) \
48 if (pp_base (PP)->padding == pp_before) \
49 pp_c_whitespace (PP); \
53 static void pp_c_char (c_pretty_printer
*, int);
55 /* postfix-expression */
56 static void pp_c_initializer_list (c_pretty_printer
*, tree
);
57 static void pp_c_brace_enclosed_initializer_list (c_pretty_printer
*, tree
);
59 static void pp_c_multiplicative_expression (c_pretty_printer
*, tree
);
60 static void pp_c_additive_expression (c_pretty_printer
*, tree
);
61 static void pp_c_shift_expression (c_pretty_printer
*, tree
);
62 static void pp_c_relational_expression (c_pretty_printer
*, tree
);
63 static void pp_c_equality_expression (c_pretty_printer
*, tree
);
64 static void pp_c_and_expression (c_pretty_printer
*, tree
);
65 static void pp_c_exclusive_or_expression (c_pretty_printer
*, tree
);
66 static void pp_c_inclusive_or_expression (c_pretty_printer
*, tree
);
67 static void pp_c_logical_and_expression (c_pretty_printer
*, tree
);
68 static void pp_c_conditional_expression (c_pretty_printer
*, tree
);
69 static void pp_c_assignment_expression (c_pretty_printer
*, tree
);
74 /* Helper functions. */
77 pp_c_whitespace (c_pretty_printer
*pp
)
80 pp_base (pp
)->padding
= pp_none
;
84 pp_c_left_paren (c_pretty_printer
*pp
)
87 pp_base (pp
)->padding
= pp_none
;
91 pp_c_right_paren (c_pretty_printer
*pp
)
94 pp_base (pp
)->padding
= pp_none
;
98 pp_c_left_brace (c_pretty_printer
*pp
)
101 pp_base (pp
)->padding
= pp_none
;
105 pp_c_right_brace (c_pretty_printer
*pp
)
108 pp_base (pp
)->padding
= pp_none
;
112 pp_c_left_bracket (c_pretty_printer
*pp
)
114 pp_left_bracket (pp
);
115 pp_base (pp
)->padding
= pp_none
;
119 pp_c_right_bracket (c_pretty_printer
*pp
)
121 pp_right_bracket (pp
);
122 pp_base (pp
)->padding
= pp_none
;
126 pp_c_dot (c_pretty_printer
*pp
)
129 pp_base (pp
)->padding
= pp_none
;
133 pp_c_ampersand (c_pretty_printer
*pp
)
136 pp_base (pp
)->padding
= pp_none
;
140 pp_c_star (c_pretty_printer
*pp
)
143 pp_base (pp
)->padding
= pp_none
;
147 pp_c_arrow (c_pretty_printer
*pp
)
150 pp_base (pp
)->padding
= pp_none
;
154 pp_c_semicolon (c_pretty_printer
*pp
)
157 pp_base (pp
)->padding
= pp_none
;
161 pp_c_complement (c_pretty_printer
*pp
)
164 pp_base (pp
)->padding
= pp_none
;
168 pp_c_exclamation (c_pretty_printer
*pp
)
171 pp_base (pp
)->padding
= pp_none
;
174 /* Print out the external representation of CV-QUALIFIER. */
177 pp_c_cv_qualifier (c_pretty_printer
*pp
, const char *cv
)
179 const char *p
= pp_last_position_in_text (pp
);
180 /* The C programming language does not have references, but it is much
181 simpler to handle those here rather than going through the same
182 logic in the C++ pretty-printer. */
183 if (p
!= NULL
&& (*p
== '*' || *p
== '&'))
184 pp_c_whitespace (pp
);
185 pp_c_ws_string (pp
, cv
);
188 /* Pretty-print T using the type-cast notation '( type-name )'. */
191 pp_c_type_cast (c_pretty_printer
*pp
, tree t
)
193 pp_c_left_paren (pp
);
195 pp_c_right_paren (pp
);
198 /* We're about to pretty-print a pointer type as indicated by T.
199 Output a whitespace, if needed, preparing for subsequent output. */
202 pp_c_space_for_pointer_operator (c_pretty_printer
*pp
, tree t
)
204 if (POINTER_TYPE_P (t
))
206 tree pointee
= strip_pointer_operator (TREE_TYPE (t
));
207 if (TREE_CODE (pointee
) != ARRAY_TYPE
208 && TREE_CODE (pointee
) != FUNCTION_TYPE
)
209 pp_c_whitespace (pp
);
216 /* C++ cv-qualifiers are called type-qualifiers in C. Print out the
217 cv-qualifiers of T. If T is a declaration then it is the cv-qualifier
218 of its type. Take care of possible extensions.
222 type-qualifier-list type-qualifier
227 __restrict__ -- GNU C
228 address-space-qualifier -- GNU C
231 address-space-qualifier:
232 identifier -- GNU C */
235 pp_c_type_qualifier_list (c_pretty_printer
*pp
, tree t
)
239 if (!t
|| t
== error_mark_node
)
245 qualifiers
= TYPE_QUALS (t
);
246 if (qualifiers
& TYPE_QUAL_CONST
)
247 pp_c_cv_qualifier (pp
, "const");
248 if (qualifiers
& TYPE_QUAL_VOLATILE
)
249 pp_c_cv_qualifier (pp
, "volatile");
250 if (qualifiers
& TYPE_QUAL_RESTRICT
)
251 pp_c_cv_qualifier (pp
, flag_isoc99
? "restrict" : "__restrict__");
253 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (t
)))
255 const char *as
= c_addr_space_name (TYPE_ADDR_SPACE (t
));
256 pp_c_identifier (pp
, as
);
261 * type-qualifier-list(opt)
262 * type-qualifier-list(opt) pointer */
265 pp_c_pointer (c_pretty_printer
*pp
, tree t
)
267 if (!TYPE_P (t
) && TREE_CODE (t
) != TYPE_DECL
)
269 switch (TREE_CODE (t
))
272 /* It is easier to handle C++ reference types here. */
274 if (TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
)
275 pp_c_pointer (pp
, TREE_TYPE (t
));
276 if (TREE_CODE (t
) == POINTER_TYPE
)
280 pp_c_type_qualifier_list (pp
, t
);
283 /* ??? This node is now in GENERIC and so shouldn't be here. But
284 we'll fix that later. */
286 pp_declaration (pp
, DECL_EXPR_DECL (t
));
287 pp_needs_newline (pp
) = true;
291 pp_unsupported_tree (pp
, t
);
308 struct-or-union-specifier
313 simple-type-specifier:
318 pp_c_type_specifier (c_pretty_printer
*pp
, tree t
)
320 const enum tree_code code
= TREE_CODE (t
);
324 pp_c_ws_string (pp
, M_("<type-error>"));
327 case IDENTIFIER_NODE
:
328 pp_c_tree_decl_identifier (pp
, t
);
335 case FIXED_POINT_TYPE
:
339 pp_c_type_specifier (pp
, t
);
343 int prec
= TYPE_PRECISION (t
);
344 if (ALL_FIXED_POINT_MODE_P (TYPE_MODE (t
)))
345 t
= c_common_type_for_mode (TYPE_MODE (t
), TYPE_SATURATING (t
));
347 t
= c_common_type_for_mode (TYPE_MODE (t
), TYPE_UNSIGNED (t
));
350 pp_c_type_specifier (pp
, t
);
351 if (TYPE_PRECISION (t
) != prec
)
354 pp_decimal_int (pp
, prec
);
362 pp_string (pp
, (TYPE_UNSIGNED (t
)
363 ? M_("<unnamed-unsigned:")
364 : M_("<unnamed-signed:")));
367 pp_string (pp
, M_("<unnamed-float:"));
369 case FIXED_POINT_TYPE
:
370 pp_string (pp
, M_("<unnamed-fixed:"));
375 pp_decimal_int (pp
, prec
);
383 pp_id_expression (pp
, t
);
385 pp_c_ws_string (pp
, M_("<typedef-error>"));
391 if (code
== UNION_TYPE
)
392 pp_c_ws_string (pp
, "union");
393 else if (code
== RECORD_TYPE
)
394 pp_c_ws_string (pp
, "struct");
395 else if (code
== ENUMERAL_TYPE
)
396 pp_c_ws_string (pp
, "enum");
398 pp_c_ws_string (pp
, M_("<tag-error>"));
401 pp_id_expression (pp
, TYPE_NAME (t
));
403 pp_c_ws_string (pp
, M_("<anonymous>"));
407 pp_unsupported_tree (pp
, t
);
412 /* specifier-qualifier-list:
413 type-specifier specifier-qualifier-list-opt
414 type-qualifier specifier-qualifier-list-opt
417 Implementation note: Because of the non-linearities in array or
418 function declarations, this routine prints not just the
419 specifier-qualifier-list of such entities or types of such entities,
420 but also the 'pointer' production part of their declarators. The
421 remaining part is done by pp_declarator or pp_c_abstract_declarator. */
424 pp_c_specifier_qualifier_list (c_pretty_printer
*pp
, tree t
)
426 const enum tree_code code
= TREE_CODE (t
);
428 if (TREE_CODE (t
) != POINTER_TYPE
)
429 pp_c_type_qualifier_list (pp
, t
);
435 /* Get the types-specifier of this type. */
436 tree pointee
= strip_pointer_operator (TREE_TYPE (t
));
437 pp_c_specifier_qualifier_list (pp
, pointee
);
438 if (TREE_CODE (pointee
) == ARRAY_TYPE
439 || TREE_CODE (pointee
) == FUNCTION_TYPE
)
441 pp_c_whitespace (pp
);
442 pp_c_left_paren (pp
);
444 else if (!c_dialect_cxx ())
445 pp_c_whitespace (pp
);
446 pp_ptr_operator (pp
, t
);
452 pp_c_specifier_qualifier_list (pp
, TREE_TYPE (t
));
457 pp_c_specifier_qualifier_list (pp
, TREE_TYPE (t
));
458 if (code
== COMPLEX_TYPE
)
459 pp_c_ws_string (pp
, flag_isoc99
? "_Complex" : "__complex__");
460 else if (code
== VECTOR_TYPE
)
461 pp_c_ws_string (pp
, "__vector__");
465 pp_simple_type_specifier (pp
, t
);
470 /* parameter-type-list:
475 parameter-declaration
476 parameter-list , parameter-declaration
478 parameter-declaration:
479 declaration-specifiers declarator
480 declaration-specifiers abstract-declarator(opt) */
483 pp_c_parameter_type_list (c_pretty_printer
*pp
, tree t
)
485 bool want_parm_decl
= DECL_P (t
) && !(pp
->flags
& pp_c_flag_abstract
);
486 tree parms
= want_parm_decl
? DECL_ARGUMENTS (t
) : TYPE_ARG_TYPES (t
);
487 pp_c_left_paren (pp
);
488 if (parms
== void_list_node
)
489 pp_c_ws_string (pp
, "void");
493 for ( ; parms
&& parms
!= void_list_node
; parms
= TREE_CHAIN (parms
))
496 pp_separate_with (pp
, ',');
498 pp_declaration_specifiers
499 (pp
, want_parm_decl
? parms
: TREE_VALUE (parms
));
501 pp_declarator (pp
, parms
);
503 pp_abstract_declarator (pp
, TREE_VALUE (parms
));
506 pp_c_right_paren (pp
);
509 /* abstract-declarator:
511 pointer(opt) direct-abstract-declarator */
514 pp_c_abstract_declarator (c_pretty_printer
*pp
, tree t
)
516 if (TREE_CODE (t
) == POINTER_TYPE
)
518 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
519 || TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
)
520 pp_c_right_paren (pp
);
524 pp_direct_abstract_declarator (pp
, t
);
527 /* direct-abstract-declarator:
528 ( abstract-declarator )
529 direct-abstract-declarator(opt) [ assignment-expression(opt) ]
530 direct-abstract-declarator(opt) [ * ]
531 direct-abstract-declarator(opt) ( parameter-type-list(opt) ) */
534 pp_c_direct_abstract_declarator (c_pretty_printer
*pp
, tree t
)
536 switch (TREE_CODE (t
))
539 pp_abstract_declarator (pp
, t
);
543 pp_c_parameter_type_list (pp
, t
);
544 pp_direct_abstract_declarator (pp
, TREE_TYPE (t
));
548 pp_c_left_bracket (pp
);
549 if (TYPE_DOMAIN (t
) && TYPE_MAX_VALUE (TYPE_DOMAIN (t
)))
551 tree maxval
= TYPE_MAX_VALUE (TYPE_DOMAIN (t
));
552 tree type
= TREE_TYPE (maxval
);
554 if (host_integerp (maxval
, 0))
555 pp_wide_integer (pp
, tree_low_cst (maxval
, 0) + 1);
557 pp_expression (pp
, fold_build2 (PLUS_EXPR
, type
, maxval
,
558 build_int_cst (type
, 1)));
560 pp_c_right_bracket (pp
);
561 pp_direct_abstract_declarator (pp
, TREE_TYPE (t
));
564 case IDENTIFIER_NODE
:
569 case FIXED_POINT_TYPE
:
579 pp_unsupported_tree (pp
, t
);
585 specifier-qualifier-list abstract-declarator(opt) */
588 pp_c_type_id (c_pretty_printer
*pp
, tree t
)
590 pp_c_specifier_qualifier_list (pp
, t
);
591 pp_abstract_declarator (pp
, t
);
594 /* storage-class-specifier:
602 pp_c_storage_class_specifier (c_pretty_printer
*pp
, tree t
)
604 if (TREE_CODE (t
) == TYPE_DECL
)
605 pp_c_ws_string (pp
, "typedef");
608 if (DECL_REGISTER (t
))
609 pp_c_ws_string (pp
, "register");
610 else if (TREE_STATIC (t
) && TREE_CODE (t
) == VAR_DECL
)
611 pp_c_ws_string (pp
, "static");
615 /* function-specifier:
619 pp_c_function_specifier (c_pretty_printer
*pp
, tree t
)
621 if (TREE_CODE (t
) == FUNCTION_DECL
&& DECL_DECLARED_INLINE_P (t
))
622 pp_c_ws_string (pp
, "inline");
625 /* declaration-specifiers:
626 storage-class-specifier declaration-specifiers(opt)
627 type-specifier declaration-specifiers(opt)
628 type-qualifier declaration-specifiers(opt)
629 function-specifier declaration-specifiers(opt) */
632 pp_c_declaration_specifiers (c_pretty_printer
*pp
, tree t
)
634 pp_storage_class_specifier (pp
, t
);
635 pp_function_specifier (pp
, t
);
636 pp_c_specifier_qualifier_list (pp
, DECL_P (t
) ? TREE_TYPE (t
) : t
);
642 direct-declarator [ type-qualifier-list(opt) assignment-expression(opt) ]
643 direct-declarator [ static type-qualifier-list(opt) assignment-expression(opt)]
644 direct-declarator [ type-qualifier-list static assignment-expression ]
645 direct-declarator [ type-qualifier-list * ]
646 direct-declarator ( parameter-type-list )
647 direct-declarator ( identifier-list(opt) ) */
650 pp_c_direct_declarator (c_pretty_printer
*pp
, tree t
)
652 switch (TREE_CODE (t
))
659 pp_c_space_for_pointer_operator (pp
, TREE_TYPE (t
));
660 pp_c_tree_decl_identifier (pp
, t
);
665 pp_abstract_declarator (pp
, TREE_TYPE (t
));
669 pp_parameter_list (pp
, t
);
670 pp_abstract_declarator (pp
, TREE_TYPE (t
));
674 pp_c_space_for_pointer_operator (pp
, TREE_TYPE (TREE_TYPE (t
)));
675 pp_c_tree_decl_identifier (pp
, t
);
676 if (pp_c_base (pp
)->flags
& pp_c_flag_abstract
)
677 pp_abstract_declarator (pp
, TREE_TYPE (t
));
680 pp_parameter_list (pp
, t
);
681 pp_abstract_declarator (pp
, TREE_TYPE (TREE_TYPE (t
)));
687 case FIXED_POINT_TYPE
:
694 pp_unsupported_tree (pp
, t
);
701 pointer(opt) direct-declarator */
704 pp_c_declarator (c_pretty_printer
*pp
, tree t
)
706 switch (TREE_CODE (t
))
710 case FIXED_POINT_TYPE
:
723 pp_direct_declarator (pp
, t
);
728 pp_unsupported_tree (pp
, t
);
734 declaration-specifiers init-declarator-list(opt) ; */
737 pp_c_declaration (c_pretty_printer
*pp
, tree t
)
739 pp_declaration_specifiers (pp
, t
);
740 pp_c_init_declarator (pp
, t
);
743 /* Pretty-print ATTRIBUTES using GNU C extension syntax. */
746 pp_c_attributes (c_pretty_printer
*pp
, tree attributes
)
748 if (attributes
== NULL_TREE
)
751 pp_c_ws_string (pp
, "__attribute__");
752 pp_c_left_paren (pp
);
753 pp_c_left_paren (pp
);
754 for (; attributes
!= NULL_TREE
; attributes
= TREE_CHAIN (attributes
))
756 pp_tree_identifier (pp
, TREE_PURPOSE (attributes
));
757 if (TREE_VALUE (attributes
))
758 pp_c_call_argument_list (pp
, TREE_VALUE (attributes
));
760 if (TREE_CHAIN (attributes
))
761 pp_separate_with (pp
, ',');
763 pp_c_right_paren (pp
);
764 pp_c_right_paren (pp
);
767 /* function-definition:
768 declaration-specifiers declarator compound-statement */
771 pp_c_function_definition (c_pretty_printer
*pp
, tree t
)
773 pp_declaration_specifiers (pp
, t
);
774 pp_declarator (pp
, t
);
775 pp_needs_newline (pp
) = true;
776 pp_statement (pp
, DECL_SAVED_TREE (t
));
784 /* Print out a c-char. This is called solely for characters which are
785 in the *target* execution character set. We ought to convert them
786 back to the *host* execution character set before printing, but we
787 have no way to do this at present. A decent compromise is to print
788 all characters as if they were in the host execution character set,
789 and not attempt to recover any named escape characters, but render
790 all unprintables as octal escapes. If the host and target character
791 sets are the same, this produces relatively readable output. If they
792 are not the same, strings may appear as gibberish, but that's okay
793 (in fact, it may well be what the reader wants, e.g. if they are looking
794 to see if conversion to the target character set happened correctly).
796 A special case: we need to prefix \, ", and ' with backslashes. It is
797 correct to do so for the *host*'s \, ", and ', because the rest of the
798 file appears in the host character set. */
801 pp_c_char (c_pretty_printer
*pp
, int c
)
807 case '\\': pp_string (pp
, "\\\\"); break;
808 case '\'': pp_string (pp
, "\\\'"); break;
809 case '\"': pp_string (pp
, "\\\""); break;
810 default: pp_character (pp
, c
);
814 pp_scalar (pp
, "\\%03o", (unsigned) c
);
817 /* Print out a STRING literal. */
820 pp_c_string_literal (c_pretty_printer
*pp
, tree s
)
822 const char *p
= TREE_STRING_POINTER (s
);
823 int n
= TREE_STRING_LENGTH (s
) - 1;
826 for (i
= 0; i
< n
; ++i
)
827 pp_c_char (pp
, p
[i
]);
831 /* Pretty-print an INTEGER literal. */
834 pp_c_integer_constant (c_pretty_printer
*pp
, tree i
)
836 tree type
= TREE_TYPE (i
);
838 if (TREE_INT_CST_HIGH (i
) == 0)
839 pp_wide_integer (pp
, TREE_INT_CST_LOW (i
));
842 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (i
);
843 HOST_WIDE_INT high
= TREE_INT_CST_HIGH (i
);
844 if (tree_int_cst_sgn (i
) < 0)
846 pp_character (pp
, '-');
850 sprintf (pp_buffer (pp
)->digit_buffer
, HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
851 (unsigned HOST_WIDE_INT
) high
, (unsigned HOST_WIDE_INT
) low
);
852 pp_string (pp
, pp_buffer (pp
)->digit_buffer
);
854 if (TYPE_UNSIGNED (type
))
855 pp_character (pp
, 'u');
856 if (type
== long_integer_type_node
|| type
== long_unsigned_type_node
)
857 pp_character (pp
, 'l');
858 else if (type
== long_long_integer_type_node
859 || type
== long_long_unsigned_type_node
)
860 pp_string (pp
, "ll");
863 /* Print out a CHARACTER literal. */
866 pp_c_character_constant (c_pretty_printer
*pp
, tree c
)
868 tree type
= TREE_TYPE (c
);
869 if (type
== wchar_type_node
)
870 pp_character (pp
, 'L');
872 if (host_integerp (c
, TYPE_UNSIGNED (type
)))
873 pp_c_char (pp
, tree_low_cst (c
, TYPE_UNSIGNED (type
)));
875 pp_scalar (pp
, "\\x%x", (unsigned) TREE_INT_CST_LOW (c
));
879 /* Print out a BOOLEAN literal. */
882 pp_c_bool_constant (c_pretty_printer
*pp
, tree b
)
884 if (b
== boolean_false_node
)
886 if (c_dialect_cxx ())
887 pp_c_ws_string (pp
, "false");
888 else if (flag_isoc99
)
889 pp_c_ws_string (pp
, "_False");
891 pp_unsupported_tree (pp
, b
);
893 else if (b
== boolean_true_node
)
895 if (c_dialect_cxx ())
896 pp_c_ws_string (pp
, "true");
897 else if (flag_isoc99
)
898 pp_c_ws_string (pp
, "_True");
900 pp_unsupported_tree (pp
, b
);
902 else if (TREE_CODE (b
) == INTEGER_CST
)
903 pp_c_integer_constant (pp
, b
);
905 pp_unsupported_tree (pp
, b
);
908 /* Attempt to print out an ENUMERATOR. Return true on success. Else return
909 false; that means the value was obtained by a cast, in which case
910 print out the type-id part of the cast-expression -- the casted value
911 is then printed by pp_c_integer_literal. */
914 pp_c_enumeration_constant (c_pretty_printer
*pp
, tree e
)
916 bool value_is_named
= true;
917 tree type
= TREE_TYPE (e
);
920 /* Find the name of this constant. */
921 for (value
= TYPE_VALUES (type
);
922 value
!= NULL_TREE
&& !tree_int_cst_equal (TREE_VALUE (value
), e
);
923 value
= TREE_CHAIN (value
))
926 if (value
!= NULL_TREE
)
927 pp_id_expression (pp
, TREE_PURPOSE (value
));
930 /* Value must have been cast. */
931 pp_c_type_cast (pp
, type
);
932 value_is_named
= false;
935 return value_is_named
;
938 /* Print out a REAL value as a decimal-floating-constant. */
941 pp_c_floating_constant (c_pretty_printer
*pp
, tree r
)
943 real_to_decimal (pp_buffer (pp
)->digit_buffer
, &TREE_REAL_CST (r
),
944 sizeof (pp_buffer (pp
)->digit_buffer
), 0, 1);
945 pp_string (pp
, pp_buffer(pp
)->digit_buffer
);
946 if (TREE_TYPE (r
) == float_type_node
)
947 pp_character (pp
, 'f');
948 else if (TREE_TYPE (r
) == long_double_type_node
)
949 pp_character (pp
, 'l');
950 else if (TREE_TYPE (r
) == dfloat128_type_node
)
951 pp_string (pp
, "dl");
952 else if (TREE_TYPE (r
) == dfloat64_type_node
)
953 pp_string (pp
, "dd");
954 else if (TREE_TYPE (r
) == dfloat32_type_node
)
955 pp_string (pp
, "df");
958 /* Print out a FIXED value as a decimal-floating-constant. */
961 pp_c_fixed_constant (c_pretty_printer
*pp
, tree r
)
963 fixed_to_decimal (pp_buffer (pp
)->digit_buffer
, &TREE_FIXED_CST (r
),
964 sizeof (pp_buffer (pp
)->digit_buffer
));
965 pp_string (pp
, pp_buffer(pp
)->digit_buffer
);
968 /* Pretty-print a compound literal expression. GNU extensions include
972 pp_c_compound_literal (c_pretty_printer
*pp
, tree e
)
974 tree type
= TREE_TYPE (e
);
975 pp_c_type_cast (pp
, type
);
977 switch (TREE_CODE (type
))
984 pp_c_brace_enclosed_initializer_list (pp
, e
);
988 pp_unsupported_tree (pp
, e
);
993 /* Pretty-print a COMPLEX_EXPR expression. */
996 pp_c_complex_expr (c_pretty_printer
*pp
, tree e
)
998 /* Handle a few common special cases, otherwise fallback
999 to printing it as compound literal. */
1000 tree type
= TREE_TYPE (e
);
1001 tree realexpr
= TREE_OPERAND (e
, 0);
1002 tree imagexpr
= TREE_OPERAND (e
, 1);
1004 /* Cast of an COMPLEX_TYPE expression to a different COMPLEX_TYPE. */
1005 if (TREE_CODE (realexpr
) == NOP_EXPR
1006 && TREE_CODE (imagexpr
) == NOP_EXPR
1007 && TREE_TYPE (realexpr
) == TREE_TYPE (type
)
1008 && TREE_TYPE (imagexpr
) == TREE_TYPE (type
)
1009 && TREE_CODE (TREE_OPERAND (realexpr
, 0)) == REALPART_EXPR
1010 && TREE_CODE (TREE_OPERAND (imagexpr
, 0)) == IMAGPART_EXPR
1011 && TREE_OPERAND (TREE_OPERAND (realexpr
, 0), 0)
1012 == TREE_OPERAND (TREE_OPERAND (imagexpr
, 0), 0))
1014 pp_c_type_cast (pp
, type
);
1015 pp_expression (pp
, TREE_OPERAND (TREE_OPERAND (realexpr
, 0), 0));
1019 /* Cast of an scalar expression to COMPLEX_TYPE. */
1020 if ((integer_zerop (imagexpr
) || real_zerop (imagexpr
))
1021 && TREE_TYPE (realexpr
) == TREE_TYPE (type
))
1023 pp_c_type_cast (pp
, type
);
1024 if (TREE_CODE (realexpr
) == NOP_EXPR
)
1025 realexpr
= TREE_OPERAND (realexpr
, 0);
1026 pp_expression (pp
, realexpr
);
1030 pp_c_compound_literal (pp
, e
);
1036 fixed-point-constant
1037 enumeration-constant
1038 character-constant */
1041 pp_c_constant (c_pretty_printer
*pp
, tree e
)
1043 const enum tree_code code
= TREE_CODE (e
);
1049 tree type
= TREE_TYPE (e
);
1050 if (type
== boolean_type_node
)
1051 pp_c_bool_constant (pp
, e
);
1052 else if (type
== char_type_node
)
1053 pp_c_character_constant (pp
, e
);
1054 else if (TREE_CODE (type
) == ENUMERAL_TYPE
1055 && pp_c_enumeration_constant (pp
, e
))
1058 pp_c_integer_constant (pp
, e
);
1063 pp_c_floating_constant (pp
, e
);
1067 pp_c_fixed_constant (pp
, e
);
1071 pp_c_string_literal (pp
, e
);
1075 /* Sometimes, we are confused and we think a complex literal
1076 is a constant. Such thing is a compound literal which
1077 grammatically belongs to postfix-expr production. */
1078 pp_c_compound_literal (pp
, e
);
1082 pp_unsupported_tree (pp
, e
);
1087 /* Pretty-print a string such as an identifier, without changing its
1088 encoding, preceded by whitespace is necessary. */
1091 pp_c_ws_string (c_pretty_printer
*pp
, const char *str
)
1093 pp_c_maybe_whitespace (pp
);
1094 pp_string (pp
, str
);
1095 pp_base (pp
)->padding
= pp_before
;
1098 /* Pretty-print an IDENTIFIER_NODE, which may contain UTF-8 sequences
1099 that need converting to the locale encoding, preceded by whitespace
1103 pp_c_identifier (c_pretty_printer
*pp
, const char *id
)
1105 pp_c_maybe_whitespace (pp
);
1106 pp_identifier (pp
, id
);
1107 pp_base (pp
)->padding
= pp_before
;
1110 /* Pretty-print a C primary-expression.
1118 pp_c_primary_expression (c_pretty_printer
*pp
, tree e
)
1120 switch (TREE_CODE (e
))
1128 pp_c_tree_decl_identifier (pp
, e
);
1131 case IDENTIFIER_NODE
:
1132 pp_c_tree_identifier (pp
, e
);
1136 pp_c_ws_string (pp
, M_("<erroneous-expression>"));
1140 pp_c_ws_string (pp
, M_("<return-value>"));
1147 pp_c_constant (pp
, e
);
1151 pp_c_ws_string (pp
, "__builtin_memcpy");
1152 pp_c_left_paren (pp
);
1154 pp_primary_expression (pp
, TREE_OPERAND (e
, 0));
1155 pp_separate_with (pp
, ',');
1157 pp_initializer (pp
, TREE_OPERAND (e
, 1));
1158 if (TREE_OPERAND (e
, 2))
1160 pp_separate_with (pp
, ',');
1161 pp_c_expression (pp
, TREE_OPERAND (e
, 2));
1163 pp_c_right_paren (pp
);
1167 /* FIXME: Make sure we won't get into an infinite loop. */
1168 pp_c_left_paren (pp
);
1169 pp_expression (pp
, e
);
1170 pp_c_right_paren (pp
);
1175 /* Print out a C initializer -- also support C compound-literals.
1177 assignment-expression:
1178 { initializer-list }
1179 { initializer-list , } */
1182 pp_c_initializer (c_pretty_printer
*pp
, tree e
)
1184 if (TREE_CODE (e
) == CONSTRUCTOR
)
1185 pp_c_brace_enclosed_initializer_list (pp
, e
);
1187 pp_expression (pp
, e
);
1192 declarator = initializer */
1195 pp_c_init_declarator (c_pretty_printer
*pp
, tree t
)
1197 pp_declarator (pp
, t
);
1198 /* We don't want to output function definitions here. There are handled
1199 elsewhere (and the syntactic form is bogus anyway). */
1200 if (TREE_CODE (t
) != FUNCTION_DECL
&& DECL_INITIAL (t
))
1202 tree init
= DECL_INITIAL (t
);
1203 /* This C++ bit is handled here because it is easier to do so.
1204 In templates, the C++ parser builds a TREE_LIST for a
1205 direct-initialization; the TREE_PURPOSE is the variable to
1206 initialize and the TREE_VALUE is the initializer. */
1207 if (TREE_CODE (init
) == TREE_LIST
)
1209 pp_c_left_paren (pp
);
1210 pp_expression (pp
, TREE_VALUE (init
));
1211 pp_right_paren (pp
);
1218 pp_c_initializer (pp
, init
);
1223 /* initializer-list:
1224 designation(opt) initializer
1225 initializer-list , designation(opt) initializer
1232 designator-list designator
1235 [ constant-expression ]
1239 pp_c_initializer_list (c_pretty_printer
*pp
, tree e
)
1241 tree type
= TREE_TYPE (e
);
1242 const enum tree_code code
= TREE_CODE (type
);
1244 if (TREE_CODE (e
) == CONSTRUCTOR
)
1246 pp_c_constructor_elts (pp
, CONSTRUCTOR_ELTS (e
));
1256 tree init
= TREE_OPERAND (e
, 0);
1257 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
1259 if (code
== RECORD_TYPE
|| code
== UNION_TYPE
)
1262 pp_c_primary_expression (pp
, TREE_PURPOSE (init
));
1266 pp_c_left_bracket (pp
);
1267 if (TREE_PURPOSE (init
))
1268 pp_c_constant (pp
, TREE_PURPOSE (init
));
1269 pp_c_right_bracket (pp
);
1271 pp_c_whitespace (pp
);
1273 pp_c_whitespace (pp
);
1274 pp_initializer (pp
, TREE_VALUE (init
));
1275 if (TREE_CHAIN (init
))
1276 pp_separate_with (pp
, ',');
1282 if (TREE_CODE (e
) == VECTOR_CST
)
1283 pp_c_expression_list (pp
, TREE_VECTOR_CST_ELTS (e
));
1289 if (TREE_CODE (e
) == COMPLEX_CST
|| TREE_CODE (e
) == COMPLEX_EXPR
)
1291 const bool cst
= TREE_CODE (e
) == COMPLEX_CST
;
1292 pp_expression (pp
, cst
? TREE_REALPART (e
) : TREE_OPERAND (e
, 0));
1293 pp_separate_with (pp
, ',');
1294 pp_expression (pp
, cst
? TREE_IMAGPART (e
) : TREE_OPERAND (e
, 1));
1304 pp_unsupported_tree (pp
, type
);
1307 /* Pretty-print a brace-enclosed initializer-list. */
1310 pp_c_brace_enclosed_initializer_list (c_pretty_printer
*pp
, tree l
)
1312 pp_c_left_brace (pp
);
1313 pp_c_initializer_list (pp
, l
);
1314 pp_c_right_brace (pp
);
1318 /* This is a convenient function, used to bridge gap between C and C++
1325 pp_c_id_expression (c_pretty_printer
*pp
, tree t
)
1327 switch (TREE_CODE (t
))
1336 pp_c_tree_decl_identifier (pp
, t
);
1339 case IDENTIFIER_NODE
:
1340 pp_c_tree_identifier (pp
, t
);
1344 pp_unsupported_tree (pp
, t
);
1349 /* postfix-expression:
1351 postfix-expression [ expression ]
1352 postfix-expression ( argument-expression-list(opt) )
1353 postfix-expression . identifier
1354 postfix-expression -> identifier
1355 postfix-expression ++
1356 postfix-expression --
1357 ( type-name ) { initializer-list }
1358 ( type-name ) { initializer-list , } */
1361 pp_c_postfix_expression (c_pretty_printer
*pp
, tree e
)
1363 enum tree_code code
= TREE_CODE (e
);
1366 case POSTINCREMENT_EXPR
:
1367 case POSTDECREMENT_EXPR
:
1368 pp_postfix_expression (pp
, TREE_OPERAND (e
, 0));
1369 pp_string (pp
, code
== POSTINCREMENT_EXPR
? "++" : "--");
1373 pp_postfix_expression (pp
, TREE_OPERAND (e
, 0));
1374 pp_c_left_bracket (pp
);
1375 pp_expression (pp
, TREE_OPERAND (e
, 1));
1376 pp_c_right_bracket (pp
);
1381 call_expr_arg_iterator iter
;
1383 pp_postfix_expression (pp
, CALL_EXPR_FN (e
));
1384 pp_c_left_paren (pp
);
1385 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, e
)
1387 pp_expression (pp
, arg
);
1388 if (more_call_expr_args_p (&iter
))
1389 pp_separate_with (pp
, ',');
1391 pp_c_right_paren (pp
);
1395 case UNORDERED_EXPR
:
1396 pp_c_ws_string (pp
, flag_isoc99
1398 : "__builtin_isunordered");
1402 pp_c_ws_string (pp
, flag_isoc99
1404 : "!__builtin_isunordered");
1408 pp_c_ws_string (pp
, flag_isoc99
1410 : "!__builtin_isgreaterequal");
1414 pp_c_ws_string (pp
, flag_isoc99
1416 : "!__builtin_isgreater");
1420 pp_c_ws_string (pp
, flag_isoc99
1422 : "!__builtin_islessequal");
1426 pp_c_ws_string (pp
, flag_isoc99
1428 : "!__builtin_isless");
1432 pp_c_ws_string (pp
, flag_isoc99
1434 : "!__builtin_islessgreater");
1438 pp_c_ws_string (pp
, flag_isoc99
1440 : "__builtin_islessgreater");
1444 pp_c_left_paren (pp
);
1445 pp_expression (pp
, TREE_OPERAND (e
, 0));
1446 pp_separate_with (pp
, ',');
1447 pp_expression (pp
, TREE_OPERAND (e
, 1));
1448 pp_c_right_paren (pp
);
1452 pp_c_ws_string (pp
, "__builtin_abs");
1453 pp_c_left_paren (pp
);
1454 pp_expression (pp
, TREE_OPERAND (e
, 0));
1455 pp_c_right_paren (pp
);
1460 tree object
= TREE_OPERAND (e
, 0);
1461 if (TREE_CODE (object
) == INDIRECT_REF
)
1463 pp_postfix_expression (pp
, TREE_OPERAND (object
, 0));
1468 pp_postfix_expression (pp
, object
);
1471 pp_expression (pp
, TREE_OPERAND (e
, 1));
1477 tree type
= TREE_TYPE (e
);
1479 type
= signed_or_unsigned_type_for (TYPE_UNSIGNED (type
), type
);
1481 && tree_int_cst_equal (TYPE_SIZE (type
), TREE_OPERAND (e
, 1)))
1483 HOST_WIDE_INT bitpos
= tree_low_cst (TREE_OPERAND (e
, 2), 0);
1484 HOST_WIDE_INT size
= tree_low_cst (TYPE_SIZE (type
), 0);
1485 if ((bitpos
% size
) == 0)
1487 pp_c_left_paren (pp
);
1488 pp_c_left_paren (pp
);
1489 pp_type_id (pp
, type
);
1491 pp_c_right_paren (pp
);
1492 pp_c_ampersand (pp
);
1493 pp_expression (pp
, TREE_OPERAND (e
, 0));
1494 pp_c_right_paren (pp
);
1495 pp_c_left_bracket (pp
);
1496 pp_wide_integer (pp
, bitpos
/ size
);
1497 pp_c_right_bracket (pp
);
1501 pp_unsupported_tree (pp
, e
);
1507 pp_c_compound_literal (pp
, e
);
1511 pp_c_complex_expr (pp
, e
);
1514 case COMPOUND_LITERAL_EXPR
:
1515 e
= DECL_INITIAL (COMPOUND_LITERAL_EXPR_DECL (e
));
1518 pp_initializer (pp
, e
);
1522 pp_c_ws_string (pp
, "__builtin_va_arg");
1523 pp_c_left_paren (pp
);
1524 pp_assignment_expression (pp
, TREE_OPERAND (e
, 0));
1525 pp_separate_with (pp
, ',');
1526 pp_type_id (pp
, TREE_TYPE (e
));
1527 pp_c_right_paren (pp
);
1531 if (TREE_CODE (TREE_OPERAND (e
, 0)) == FUNCTION_DECL
)
1533 pp_c_id_expression (pp
, TREE_OPERAND (e
, 0));
1536 /* else fall through. */
1539 pp_primary_expression (pp
, e
);
1544 /* Print out an expression-list; E is expected to be a TREE_LIST. */
1547 pp_c_expression_list (c_pretty_printer
*pp
, tree e
)
1549 for (; e
!= NULL_TREE
; e
= TREE_CHAIN (e
))
1551 pp_expression (pp
, TREE_VALUE (e
));
1553 pp_separate_with (pp
, ',');
1557 /* Print out V, which contains the elements of a constructor. */
1560 pp_c_constructor_elts (c_pretty_printer
*pp
, VEC(constructor_elt
,gc
) *v
)
1562 unsigned HOST_WIDE_INT ix
;
1565 FOR_EACH_CONSTRUCTOR_VALUE (v
, ix
, value
)
1567 pp_expression (pp
, value
);
1568 if (ix
!= VEC_length (constructor_elt
, v
) - 1)
1569 pp_separate_with (pp
, ',');
1573 /* Print out an expression-list in parens, as if it were the argument
1574 list to a function. */
1577 pp_c_call_argument_list (c_pretty_printer
*pp
, tree t
)
1579 pp_c_left_paren (pp
);
1580 if (t
&& TREE_CODE (t
) == TREE_LIST
)
1581 pp_c_expression_list (pp
, t
);
1582 pp_c_right_paren (pp
);
1585 /* unary-expression:
1589 unary-operator cast-expression
1590 sizeof unary-expression
1593 unary-operator: one of
1598 __alignof__ unary-expression
1599 __alignof__ ( type-id )
1600 __real__ unary-expression
1601 __imag__ unary-expression */
1604 pp_c_unary_expression (c_pretty_printer
*pp
, tree e
)
1606 enum tree_code code
= TREE_CODE (e
);
1609 case PREINCREMENT_EXPR
:
1610 case PREDECREMENT_EXPR
:
1611 pp_string (pp
, code
== PREINCREMENT_EXPR
? "++" : "--");
1612 pp_c_unary_expression (pp
, TREE_OPERAND (e
, 0));
1619 case TRUTH_NOT_EXPR
:
1621 /* String literal are used by address. */
1622 if (code
== ADDR_EXPR
&& TREE_CODE (TREE_OPERAND (e
, 0)) != STRING_CST
)
1624 else if (code
== INDIRECT_REF
)
1626 else if (code
== NEGATE_EXPR
)
1628 else if (code
== BIT_NOT_EXPR
|| code
== CONJ_EXPR
)
1630 else if (code
== TRUTH_NOT_EXPR
)
1631 pp_exclamation (pp
);
1632 pp_c_cast_expression (pp
, TREE_OPERAND (e
, 0));
1637 pp_c_ws_string (pp
, code
== REALPART_EXPR
? "__real__" : "__imag__");
1638 pp_c_whitespace (pp
);
1639 pp_unary_expression (pp
, TREE_OPERAND (e
, 0));
1643 pp_postfix_expression (pp
, e
);
1650 ( type-name ) cast-expression */
1653 pp_c_cast_expression (c_pretty_printer
*pp
, tree e
)
1655 switch (TREE_CODE (e
))
1658 case FIX_TRUNC_EXPR
:
1660 case VIEW_CONVERT_EXPR
:
1661 pp_c_type_cast (pp
, TREE_TYPE (e
));
1662 pp_c_cast_expression (pp
, TREE_OPERAND (e
, 0));
1666 pp_unary_expression (pp
, e
);
1670 /* multiplicative-expression:
1672 multiplicative-expression * cast-expression
1673 multiplicative-expression / cast-expression
1674 multiplicative-expression % cast-expression */
1677 pp_c_multiplicative_expression (c_pretty_printer
*pp
, tree e
)
1679 enum tree_code code
= TREE_CODE (e
);
1683 case TRUNC_DIV_EXPR
:
1684 case TRUNC_MOD_EXPR
:
1685 pp_multiplicative_expression (pp
, TREE_OPERAND (e
, 0));
1686 pp_c_whitespace (pp
);
1687 if (code
== MULT_EXPR
)
1689 else if (code
== TRUNC_DIV_EXPR
)
1693 pp_c_whitespace (pp
);
1694 pp_c_cast_expression (pp
, TREE_OPERAND (e
, 1));
1698 pp_c_cast_expression (pp
, e
);
1703 /* additive-expression:
1704 multiplicative-expression
1705 additive-expression + multiplicative-expression
1706 additive-expression - multiplicative-expression */
1709 pp_c_additive_expression (c_pretty_printer
*pp
, tree e
)
1711 enum tree_code code
= TREE_CODE (e
);
1714 case POINTER_PLUS_EXPR
:
1717 pp_c_additive_expression (pp
, TREE_OPERAND (e
, 0));
1718 pp_c_whitespace (pp
);
1719 if (code
== PLUS_EXPR
|| code
== POINTER_PLUS_EXPR
)
1723 pp_c_whitespace (pp
);
1724 pp_multiplicative_expression (pp
, TREE_OPERAND (e
, 1));
1728 pp_multiplicative_expression (pp
, e
);
1733 /* additive-expression:
1735 shift-expression << additive-expression
1736 shift-expression >> additive-expression */
1739 pp_c_shift_expression (c_pretty_printer
*pp
, tree e
)
1741 enum tree_code code
= TREE_CODE (e
);
1746 pp_c_shift_expression (pp
, TREE_OPERAND (e
, 0));
1747 pp_c_whitespace (pp
);
1748 pp_string (pp
, code
== LSHIFT_EXPR
? "<<" : ">>");
1749 pp_c_whitespace (pp
);
1750 pp_c_additive_expression (pp
, TREE_OPERAND (e
, 1));
1754 pp_c_additive_expression (pp
, e
);
1758 /* relational-expression:
1760 relational-expression < shift-expression
1761 relational-expression > shift-expression
1762 relational-expression <= shift-expression
1763 relational-expression >= shift-expression */
1766 pp_c_relational_expression (c_pretty_printer
*pp
, tree e
)
1768 enum tree_code code
= TREE_CODE (e
);
1775 pp_c_relational_expression (pp
, TREE_OPERAND (e
, 0));
1776 pp_c_whitespace (pp
);
1777 if (code
== LT_EXPR
)
1779 else if (code
== GT_EXPR
)
1781 else if (code
== LE_EXPR
)
1782 pp_string (pp
, "<=");
1783 else if (code
== GE_EXPR
)
1784 pp_string (pp
, ">=");
1785 pp_c_whitespace (pp
);
1786 pp_c_shift_expression (pp
, TREE_OPERAND (e
, 1));
1790 pp_c_shift_expression (pp
, e
);
1795 /* equality-expression:
1796 relational-expression
1797 equality-expression == relational-expression
1798 equality-equality != relational-expression */
1801 pp_c_equality_expression (c_pretty_printer
*pp
, tree e
)
1803 enum tree_code code
= TREE_CODE (e
);
1808 pp_c_equality_expression (pp
, TREE_OPERAND (e
, 0));
1809 pp_c_whitespace (pp
);
1810 pp_string (pp
, code
== EQ_EXPR
? "==" : "!=");
1811 pp_c_whitespace (pp
);
1812 pp_c_relational_expression (pp
, TREE_OPERAND (e
, 1));
1816 pp_c_relational_expression (pp
, e
);
1823 AND-expression & equality-equality */
1826 pp_c_and_expression (c_pretty_printer
*pp
, tree e
)
1828 if (TREE_CODE (e
) == BIT_AND_EXPR
)
1830 pp_c_and_expression (pp
, TREE_OPERAND (e
, 0));
1831 pp_c_whitespace (pp
);
1833 pp_c_whitespace (pp
);
1834 pp_c_equality_expression (pp
, TREE_OPERAND (e
, 1));
1837 pp_c_equality_expression (pp
, e
);
1840 /* exclusive-OR-expression:
1842 exclusive-OR-expression ^ AND-expression */
1845 pp_c_exclusive_or_expression (c_pretty_printer
*pp
, tree e
)
1847 if (TREE_CODE (e
) == BIT_XOR_EXPR
1848 || TREE_CODE (e
) == TRUTH_XOR_EXPR
)
1850 pp_c_exclusive_or_expression (pp
, TREE_OPERAND (e
, 0));
1851 if (TREE_CODE (e
) == BIT_XOR_EXPR
)
1852 pp_c_maybe_whitespace (pp
);
1854 pp_c_whitespace (pp
);
1856 pp_c_whitespace (pp
);
1857 pp_c_and_expression (pp
, TREE_OPERAND (e
, 1));
1860 pp_c_and_expression (pp
, e
);
1863 /* inclusive-OR-expression:
1864 exclusive-OR-expression
1865 inclusive-OR-expression | exclusive-OR-expression */
1868 pp_c_inclusive_or_expression (c_pretty_printer
*pp
, tree e
)
1870 if (TREE_CODE (e
) == BIT_IOR_EXPR
)
1872 pp_c_exclusive_or_expression (pp
, TREE_OPERAND (e
, 0));
1873 pp_c_whitespace (pp
);
1875 pp_c_whitespace (pp
);
1876 pp_c_exclusive_or_expression (pp
, TREE_OPERAND (e
, 1));
1879 pp_c_exclusive_or_expression (pp
, e
);
1882 /* logical-AND-expression:
1883 inclusive-OR-expression
1884 logical-AND-expression && inclusive-OR-expression */
1887 pp_c_logical_and_expression (c_pretty_printer
*pp
, tree e
)
1889 if (TREE_CODE (e
) == TRUTH_ANDIF_EXPR
1890 || TREE_CODE (e
) == TRUTH_AND_EXPR
)
1892 pp_c_logical_and_expression (pp
, TREE_OPERAND (e
, 0));
1893 pp_c_whitespace (pp
);
1894 pp_string (pp
, "&&");
1895 pp_c_whitespace (pp
);
1896 pp_c_inclusive_or_expression (pp
, TREE_OPERAND (e
, 1));
1899 pp_c_inclusive_or_expression (pp
, e
);
1902 /* logical-OR-expression:
1903 logical-AND-expression
1904 logical-OR-expression || logical-AND-expression */
1907 pp_c_logical_or_expression (c_pretty_printer
*pp
, tree e
)
1909 if (TREE_CODE (e
) == TRUTH_ORIF_EXPR
1910 || TREE_CODE (e
) == TRUTH_OR_EXPR
)
1912 pp_c_logical_or_expression (pp
, TREE_OPERAND (e
, 0));
1913 pp_c_whitespace (pp
);
1914 pp_string (pp
, "||");
1915 pp_c_whitespace (pp
);
1916 pp_c_logical_and_expression (pp
, TREE_OPERAND (e
, 1));
1919 pp_c_logical_and_expression (pp
, e
);
1922 /* conditional-expression:
1923 logical-OR-expression
1924 logical-OR-expression ? expression : conditional-expression */
1927 pp_c_conditional_expression (c_pretty_printer
*pp
, tree e
)
1929 if (TREE_CODE (e
) == COND_EXPR
)
1931 pp_c_logical_or_expression (pp
, TREE_OPERAND (e
, 0));
1932 pp_c_whitespace (pp
);
1934 pp_c_whitespace (pp
);
1935 pp_expression (pp
, TREE_OPERAND (e
, 1));
1936 pp_c_whitespace (pp
);
1938 pp_c_whitespace (pp
);
1939 pp_c_conditional_expression (pp
, TREE_OPERAND (e
, 2));
1942 pp_c_logical_or_expression (pp
, e
);
1946 /* assignment-expression:
1947 conditional-expression
1948 unary-expression assignment-operator assignment-expression
1950 assignment-expression: one of
1951 = *= /= %= += -= >>= <<= &= ^= |= */
1954 pp_c_assignment_expression (c_pretty_printer
*pp
, tree e
)
1956 if (TREE_CODE (e
) == MODIFY_EXPR
1957 || TREE_CODE (e
) == INIT_EXPR
)
1959 pp_c_unary_expression (pp
, TREE_OPERAND (e
, 0));
1960 pp_c_whitespace (pp
);
1963 pp_c_expression (pp
, TREE_OPERAND (e
, 1));
1966 pp_c_conditional_expression (pp
, e
);
1970 assignment-expression
1971 expression , assignment-expression
1973 Implementation note: instead of going through the usual recursion
1974 chain, I take the liberty of dispatching nodes to the appropriate
1975 functions. This makes some redundancy, but it worths it. That also
1976 prevents a possible infinite recursion between pp_c_primary_expression ()
1977 and pp_c_expression (). */
1980 pp_c_expression (c_pretty_printer
*pp
, tree e
)
1982 switch (TREE_CODE (e
))
1985 pp_c_integer_constant (pp
, e
);
1989 pp_c_floating_constant (pp
, e
);
1993 pp_c_fixed_constant (pp
, e
);
1997 pp_c_string_literal (pp
, e
);
2000 case IDENTIFIER_NODE
:
2009 pp_primary_expression (pp
, e
);
2012 case POSTINCREMENT_EXPR
:
2013 case POSTDECREMENT_EXPR
:
2022 case UNORDERED_EXPR
:
2031 case COMPOUND_LITERAL_EXPR
:
2033 pp_postfix_expression (pp
, e
);
2041 case TRUTH_NOT_EXPR
:
2042 case PREINCREMENT_EXPR
:
2043 case PREDECREMENT_EXPR
:
2046 pp_c_unary_expression (pp
, e
);
2050 case FIX_TRUNC_EXPR
:
2052 case VIEW_CONVERT_EXPR
:
2053 pp_c_cast_expression (pp
, e
);
2057 case TRUNC_MOD_EXPR
:
2058 case TRUNC_DIV_EXPR
:
2059 pp_multiplicative_expression (pp
, e
);
2064 pp_c_shift_expression (pp
, e
);
2071 pp_c_relational_expression (pp
, e
);
2075 pp_c_and_expression (pp
, e
);
2079 case TRUTH_XOR_EXPR
:
2080 pp_c_exclusive_or_expression (pp
, e
);
2084 pp_c_inclusive_or_expression (pp
, e
);
2087 case TRUTH_ANDIF_EXPR
:
2088 case TRUTH_AND_EXPR
:
2089 pp_c_logical_and_expression (pp
, e
);
2092 case TRUTH_ORIF_EXPR
:
2094 pp_c_logical_or_expression (pp
, e
);
2099 pp_c_equality_expression (pp
, e
);
2103 pp_conditional_expression (pp
, e
);
2106 case POINTER_PLUS_EXPR
:
2109 pp_c_additive_expression (pp
, e
);
2114 pp_assignment_expression (pp
, e
);
2118 pp_c_left_paren (pp
);
2119 pp_expression (pp
, TREE_OPERAND (e
, 0));
2120 pp_separate_with (pp
, ',');
2121 pp_assignment_expression (pp
, TREE_OPERAND (e
, 1));
2122 pp_c_right_paren (pp
);
2125 case NON_LVALUE_EXPR
:
2127 pp_expression (pp
, TREE_OPERAND (e
, 0));
2131 pp_postfix_expression (pp
, TREE_OPERAND (e
, 1));
2136 /* We don't yet have a way of dumping statements in a
2137 human-readable format. */
2138 pp_string (pp
, "({...})");
2142 pp_unsupported_tree (pp
, e
);
2152 pp_c_statement (c_pretty_printer
*pp
, tree stmt
)
2157 if (pp_needs_newline (pp
))
2158 pp_newline_and_indent (pp
, 0);
2160 dump_generic_node (pp_base (pp
), stmt
, pp_indentation (pp
), 0, true);
2164 /* Initialize the PRETTY-PRINTER for handling C codes. */
2167 pp_c_pretty_printer_init (c_pretty_printer
*pp
)
2169 pp
->offset_list
= 0;
2171 pp
->declaration
= pp_c_declaration
;
2172 pp
->declaration_specifiers
= pp_c_declaration_specifiers
;
2173 pp
->declarator
= pp_c_declarator
;
2174 pp
->direct_declarator
= pp_c_direct_declarator
;
2175 pp
->type_specifier_seq
= pp_c_specifier_qualifier_list
;
2176 pp
->abstract_declarator
= pp_c_abstract_declarator
;
2177 pp
->direct_abstract_declarator
= pp_c_direct_abstract_declarator
;
2178 pp
->ptr_operator
= pp_c_pointer
;
2179 pp
->parameter_list
= pp_c_parameter_type_list
;
2180 pp
->type_id
= pp_c_type_id
;
2181 pp
->simple_type_specifier
= pp_c_type_specifier
;
2182 pp
->function_specifier
= pp_c_function_specifier
;
2183 pp
->storage_class_specifier
= pp_c_storage_class_specifier
;
2185 pp
->statement
= pp_c_statement
;
2187 pp
->constant
= pp_c_constant
;
2188 pp
->id_expression
= pp_c_id_expression
;
2189 pp
->primary_expression
= pp_c_primary_expression
;
2190 pp
->postfix_expression
= pp_c_postfix_expression
;
2191 pp
->unary_expression
= pp_c_unary_expression
;
2192 pp
->initializer
= pp_c_initializer
;
2193 pp
->multiplicative_expression
= pp_c_multiplicative_expression
;
2194 pp
->conditional_expression
= pp_c_conditional_expression
;
2195 pp
->assignment_expression
= pp_c_assignment_expression
;
2196 pp
->expression
= pp_c_expression
;
2200 /* Print the tree T in full, on file FILE. */
2203 print_c_tree (FILE *file
, tree t
)
2205 static c_pretty_printer pp_rec
;
2206 static bool initialized
= 0;
2207 c_pretty_printer
*pp
= &pp_rec
;
2212 pp_construct (pp_base (pp
), NULL
, 0);
2213 pp_c_pretty_printer_init (pp
);
2214 pp_needs_newline (pp
) = true;
2216 pp_base (pp
)->buffer
->stream
= file
;
2218 pp_statement (pp
, t
);
2224 /* Print the tree T in full, on stderr. */
2227 debug_c_tree (tree t
)
2229 print_c_tree (stderr
, t
);
2230 fputc ('\n', stderr
);
2233 /* Output the DECL_NAME of T. If T has no DECL_NAME, output a string made
2234 up of T's memory address. */
2237 pp_c_tree_decl_identifier (c_pretty_printer
*pp
, tree t
)
2241 gcc_assert (DECL_P (t
));
2244 name
= IDENTIFIER_POINTER (DECL_NAME (t
));
2247 static char xname
[8];
2248 sprintf (xname
, "<U%4x>", ((unsigned)((uintptr_t)(t
) & 0xffff)));
2252 pp_c_identifier (pp
, name
);