1 /* Subroutines common to both C and C++ pretty-printers.
2 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007 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 3, 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 COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
26 #include "c-pretty-print.h"
28 #include "tree-iterator.h"
29 #include "diagnostic.h"
31 /* The pretty-printer code is primarily designed to closely follow
32 (GNU) C and C++ grammars. That is to be contrasted with spaghetti
33 codes we used to have in the past. Following a structured
34 approach (preferably the official grammars) is believed to make it
35 much easier to add extensions and nifty pretty-printing effects that
36 takes expression or declaration contexts into account. */
39 #define pp_c_maybe_whitespace(PP) \
41 if (pp_base (PP)->padding == pp_before) \
42 pp_c_whitespace (PP); \
46 static void pp_c_char (c_pretty_printer *, int);
48 /* postfix-expression */
49 static void pp_c_initializer_list (c_pretty_printer *, tree);
50 static void pp_c_brace_enclosed_initializer_list (c_pretty_printer *, tree);
52 static void pp_c_multiplicative_expression (c_pretty_printer *, tree);
53 static void pp_c_additive_expression (c_pretty_printer *, tree);
54 static void pp_c_shift_expression (c_pretty_printer *, tree);
55 static void pp_c_relational_expression (c_pretty_printer *, tree);
56 static void pp_c_equality_expression (c_pretty_printer *, tree);
57 static void pp_c_and_expression (c_pretty_printer *, tree);
58 static void pp_c_exclusive_or_expression (c_pretty_printer *, tree);
59 static void pp_c_inclusive_or_expression (c_pretty_printer *, tree);
60 static void pp_c_logical_and_expression (c_pretty_printer *, tree);
61 static void pp_c_conditional_expression (c_pretty_printer *, tree);
62 static void pp_c_assignment_expression (c_pretty_printer *, tree);
67 /* Helper functions. */
70 pp_c_whitespace (c_pretty_printer *pp)
73 pp_base (pp)->padding = pp_none;
77 pp_c_left_paren (c_pretty_printer *pp)
80 pp_base (pp)->padding = pp_none;
84 pp_c_right_paren (c_pretty_printer *pp)
87 pp_base (pp)->padding = pp_none;
91 pp_c_left_brace (c_pretty_printer *pp)
94 pp_base (pp)->padding = pp_none;
98 pp_c_right_brace (c_pretty_printer *pp)
101 pp_base (pp)->padding = pp_none;
105 pp_c_left_bracket (c_pretty_printer *pp)
107 pp_left_bracket (pp);
108 pp_base (pp)->padding = pp_none;
112 pp_c_right_bracket (c_pretty_printer *pp)
114 pp_right_bracket (pp);
115 pp_base (pp)->padding = pp_none;
119 pp_c_dot (c_pretty_printer *pp)
122 pp_base (pp)->padding = pp_none;
126 pp_c_ampersand (c_pretty_printer *pp)
129 pp_base (pp)->padding = pp_none;
133 pp_c_star (c_pretty_printer *pp)
136 pp_base (pp)->padding = pp_none;
140 pp_c_arrow (c_pretty_printer *pp)
143 pp_base (pp)->padding = pp_none;
147 pp_c_semicolon (c_pretty_printer *pp)
150 pp_base (pp)->padding = pp_none;
154 pp_c_complement (c_pretty_printer *pp)
157 pp_base (pp)->padding = pp_none;
161 pp_c_exclamation (c_pretty_printer *pp)
164 pp_base (pp)->padding = pp_none;
167 /* Print out the external representation of CV-QUALIFIER. */
170 pp_c_cv_qualifier (c_pretty_printer *pp, const char *cv)
172 const char *p = pp_last_position_in_text (pp);
173 /* The C programming language does not have references, but it is much
174 simpler to handle those here rather than going through the same
175 logic in the C++ pretty-printer. */
176 if (p != NULL && (*p == '*' || *p == '&'))
177 pp_c_whitespace (pp);
178 pp_c_identifier (pp, cv);
181 /* Pretty-print T using the type-cast notation '( type-name )'. */
184 pp_c_type_cast (c_pretty_printer *pp, tree t)
186 pp_c_left_paren (pp);
188 pp_c_right_paren (pp);
191 /* We're about to pretty-print a pointer type as indicated by T.
192 Output a whitespace, if needed, preparing for subsequent output. */
195 pp_c_space_for_pointer_operator (c_pretty_printer *pp, tree t)
197 if (POINTER_TYPE_P (t))
199 tree pointee = strip_pointer_operator (TREE_TYPE (t));
200 if (TREE_CODE (pointee) != ARRAY_TYPE
201 && TREE_CODE (pointee) != FUNCTION_TYPE)
202 pp_c_whitespace (pp);
209 /* C++ cv-qualifiers are called type-qualifiers in C. Print out the
210 cv-qualifiers of T. If T is a declaration then it is the cv-qualifier
211 of its type. Take care of possible extensions.
215 type-qualifier-list type-qualifier
220 __restrict__ -- GNU C
224 pp_c_type_qualifier_list (c_pretty_printer *pp, tree t)
231 qualifiers = TYPE_QUALS (t);
232 if (qualifiers & TYPE_QUAL_CONST)
233 pp_c_cv_qualifier (pp, "const");
234 if (qualifiers & TYPE_QUAL_VOLATILE)
235 pp_c_cv_qualifier (pp, "volatile");
236 if (qualifiers & TYPE_QUAL_RESTRICT)
237 pp_c_cv_qualifier (pp, flag_isoc99 ? "restrict" : "__restrict__");
241 * type-qualifier-list(opt)
242 * type-qualifier-list(opt) pointer */
245 pp_c_pointer (c_pretty_printer *pp, tree t)
247 if (!TYPE_P (t) && TREE_CODE (t) != TYPE_DECL)
249 switch (TREE_CODE (t))
252 /* It is easier to handle C++ reference types here. */
254 if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE)
255 pp_c_pointer (pp, TREE_TYPE (t));
256 if (TREE_CODE (t) == POINTER_TYPE)
260 pp_c_type_qualifier_list (pp, t);
263 /* ??? This node is now in GENERIC and so shouldn't be here. But
264 we'll fix that later. */
266 pp_declaration (pp, DECL_EXPR_DECL (t));
267 pp_needs_newline (pp) = true;
271 pp_unsupported_tree (pp, t);
288 struct-or-union-specifier
293 simple-type-specifier:
298 pp_c_type_specifier (c_pretty_printer *pp, tree t)
300 const enum tree_code code = TREE_CODE (t);
304 pp_c_identifier (pp, "<type-error>");
307 case IDENTIFIER_NODE:
308 pp_c_tree_decl_identifier (pp, t);
318 pp_c_type_specifier (pp, t);
322 int prec = TYPE_PRECISION (t);
323 t = c_common_type_for_mode (TYPE_MODE (t), TYPE_UNSIGNED (t));
326 pp_c_type_specifier (pp, t);
327 if (TYPE_PRECISION (t) != prec)
330 pp_decimal_int (pp, prec);
338 pp_string (pp, (TYPE_UNSIGNED (t)
339 ? "<unnamed-unsigned:"
340 : "<unnamed-signed:"));
343 pp_string (pp, "<unnamed-float:");
348 pp_decimal_int (pp, prec);
356 pp_id_expression (pp, t);
358 pp_c_identifier (pp, "<typedef-error>");
364 if (code == UNION_TYPE)
365 pp_c_identifier (pp, "union");
366 else if (code == RECORD_TYPE)
367 pp_c_identifier (pp, "struct");
368 else if (code == ENUMERAL_TYPE)
369 pp_c_identifier (pp, "enum");
371 pp_c_identifier (pp, "<tag-error>");
374 pp_id_expression (pp, TYPE_NAME (t));
376 pp_c_identifier (pp, "<anonymous>");
380 pp_unsupported_tree (pp, t);
385 /* specifier-qualifier-list:
386 type-specifier specifier-qualifier-list-opt
387 type-qualifier specifier-qualifier-list-opt
390 Implementation note: Because of the non-linearities in array or
391 function declarations, this routine prints not just the
392 specifier-qualifier-list of such entities or types of such entities,
393 but also the 'pointer' production part of their declarators. The
394 remaining part is done by pp_declarator or pp_c_abstract_declarator. */
397 pp_c_specifier_qualifier_list (c_pretty_printer *pp, tree t)
399 const enum tree_code code = TREE_CODE (t);
401 if (TREE_CODE (t) != POINTER_TYPE)
402 pp_c_type_qualifier_list (pp, t);
408 /* Get the types-specifier of this type. */
409 tree pointee = strip_pointer_operator (TREE_TYPE (t));
410 pp_c_specifier_qualifier_list (pp, pointee);
411 if (TREE_CODE (pointee) == ARRAY_TYPE
412 || TREE_CODE (pointee) == FUNCTION_TYPE)
414 pp_c_whitespace (pp);
415 pp_c_left_paren (pp);
417 else if (!c_dialect_cxx ())
418 pp_c_whitespace (pp);
419 pp_ptr_operator (pp, t);
425 pp_c_specifier_qualifier_list (pp, TREE_TYPE (t));
430 pp_c_specifier_qualifier_list (pp, TREE_TYPE (t));
431 if (code == COMPLEX_TYPE)
432 pp_c_identifier (pp, flag_isoc99 ? "_Complex" : "__complex__");
433 else if (code == VECTOR_TYPE)
434 pp_c_identifier (pp, "__vector__");
438 pp_simple_type_specifier (pp, t);
443 /* parameter-type-list:
448 parameter-declaration
449 parameter-list , parameter-declaration
451 parameter-declaration:
452 declaration-specifiers declarator
453 declaration-specifiers abstract-declarator(opt) */
456 pp_c_parameter_type_list (c_pretty_printer *pp, tree t)
458 bool want_parm_decl = DECL_P (t) && !(pp->flags & pp_c_flag_abstract);
459 tree parms = want_parm_decl ? DECL_ARGUMENTS (t) : TYPE_ARG_TYPES (t);
460 pp_c_left_paren (pp);
461 if (parms == void_list_node)
462 pp_c_identifier (pp, "void");
466 for ( ; parms && parms != void_list_node; parms = TREE_CHAIN (parms))
469 pp_separate_with (pp, ',');
471 pp_declaration_specifiers
472 (pp, want_parm_decl ? parms : TREE_VALUE (parms));
474 pp_declarator (pp, parms);
476 pp_abstract_declarator (pp, TREE_VALUE (parms));
479 pp_c_right_paren (pp);
482 /* abstract-declarator:
484 pointer(opt) direct-abstract-declarator */
487 pp_c_abstract_declarator (c_pretty_printer *pp, tree t)
489 if (TREE_CODE (t) == POINTER_TYPE)
491 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
492 || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
493 pp_c_right_paren (pp);
497 pp_direct_abstract_declarator (pp, t);
500 /* direct-abstract-declarator:
501 ( abstract-declarator )
502 direct-abstract-declarator(opt) [ assignment-expression(opt) ]
503 direct-abstract-declarator(opt) [ * ]
504 direct-abstract-declarator(opt) ( parameter-type-list(opt) ) */
507 pp_c_direct_abstract_declarator (c_pretty_printer *pp, tree t)
509 switch (TREE_CODE (t))
512 pp_abstract_declarator (pp, t);
516 pp_c_parameter_type_list (pp, t);
517 pp_direct_abstract_declarator (pp, TREE_TYPE (t));
521 pp_c_left_bracket (pp);
522 if (TYPE_DOMAIN (t) && TYPE_MAX_VALUE (TYPE_DOMAIN (t)))
524 tree maxval = TYPE_MAX_VALUE (TYPE_DOMAIN (t));
525 tree type = TREE_TYPE (maxval);
527 if (host_integerp (maxval, 0))
528 pp_wide_integer (pp, tree_low_cst (maxval, 0) + 1);
530 pp_expression (pp, fold_build2 (PLUS_EXPR, type, maxval,
531 build_int_cst (type, 1)));
533 pp_c_right_bracket (pp);
534 pp_direct_abstract_declarator (pp, TREE_TYPE (t));
537 case IDENTIFIER_NODE:
551 pp_unsupported_tree (pp, t);
557 specifier-qualifier-list abstract-declarator(opt) */
560 pp_c_type_id (c_pretty_printer *pp, tree t)
562 pp_c_specifier_qualifier_list (pp, t);
563 pp_abstract_declarator (pp, t);
566 /* storage-class-specifier:
574 pp_c_storage_class_specifier (c_pretty_printer *pp, tree t)
576 if (TREE_CODE (t) == TYPE_DECL)
577 pp_c_identifier (pp, "typedef");
580 if (DECL_REGISTER (t))
581 pp_c_identifier (pp, "register");
582 else if (TREE_STATIC (t) && TREE_CODE (t) == VAR_DECL)
583 pp_c_identifier (pp, "static");
587 /* function-specifier:
591 pp_c_function_specifier (c_pretty_printer *pp, tree t)
593 if (TREE_CODE (t) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (t))
594 pp_c_identifier (pp, "inline");
597 /* declaration-specifiers:
598 storage-class-specifier declaration-specifiers(opt)
599 type-specifier declaration-specifiers(opt)
600 type-qualifier declaration-specifiers(opt)
601 function-specifier declaration-specifiers(opt) */
604 pp_c_declaration_specifiers (c_pretty_printer *pp, tree t)
606 pp_storage_class_specifier (pp, t);
607 pp_function_specifier (pp, t);
608 pp_c_specifier_qualifier_list (pp, DECL_P (t) ? TREE_TYPE (t) : t);
614 direct-declarator [ type-qualifier-list(opt) assignment-expression(opt) ]
615 direct-declarator [ static type-qualifier-list(opt) assignment-expression(opt)]
616 direct-declarator [ type-qualifier-list static assignment-expression ]
617 direct-declarator [ type-qualifier-list * ]
618 direct-declarator ( parameter-type-list )
619 direct-declarator ( identifier-list(opt) ) */
622 pp_c_direct_declarator (c_pretty_printer *pp, tree t)
624 switch (TREE_CODE (t))
631 pp_c_space_for_pointer_operator (pp, TREE_TYPE (t));
632 pp_c_tree_decl_identifier (pp, t);
637 pp_abstract_declarator (pp, TREE_TYPE (t));
641 pp_parameter_list (pp, t);
642 pp_abstract_declarator (pp, TREE_TYPE (t));
646 pp_c_space_for_pointer_operator (pp, TREE_TYPE (TREE_TYPE (t)));
647 pp_c_tree_decl_identifier (pp, t);
648 if (pp_c_base (pp)->flags & pp_c_flag_abstract)
649 pp_abstract_declarator (pp, TREE_TYPE (t));
652 pp_parameter_list (pp, t);
653 pp_abstract_declarator (pp, TREE_TYPE (TREE_TYPE (t)));
665 pp_unsupported_tree (pp, t);
672 pointer(opt) direct-declarator */
675 pp_c_declarator (c_pretty_printer *pp, tree t)
677 switch (TREE_CODE (t))
693 pp_direct_declarator (pp, t);
698 pp_unsupported_tree (pp, t);
704 declaration-specifiers init-declarator-list(opt) ; */
707 pp_c_declaration (c_pretty_printer *pp, tree t)
709 pp_declaration_specifiers (pp, t);
710 pp_c_init_declarator (pp, t);
713 /* Pretty-print ATTRIBUTES using GNU C extension syntax. */
716 pp_c_attributes (c_pretty_printer *pp, tree attributes)
718 if (attributes == NULL_TREE)
721 pp_c_identifier (pp, "__attribute__");
722 pp_c_left_paren (pp);
723 pp_c_left_paren (pp);
724 for (; attributes != NULL_TREE; attributes = TREE_CHAIN (attributes))
726 pp_tree_identifier (pp, TREE_PURPOSE (attributes));
727 if (TREE_VALUE (attributes))
728 pp_c_call_argument_list (pp, TREE_VALUE (attributes));
730 if (TREE_CHAIN (attributes))
731 pp_separate_with (pp, ',');
733 pp_c_right_paren (pp);
734 pp_c_right_paren (pp);
737 /* function-definition:
738 declaration-specifiers declarator compound-statement */
741 pp_c_function_definition (c_pretty_printer *pp, tree t)
743 pp_declaration_specifiers (pp, t);
744 pp_declarator (pp, t);
745 pp_needs_newline (pp) = true;
746 pp_statement (pp, DECL_SAVED_TREE (t));
754 /* Print out a c-char. This is called solely for characters which are
755 in the *target* execution character set. We ought to convert them
756 back to the *host* execution character set before printing, but we
757 have no way to do this at present. A decent compromise is to print
758 all characters as if they were in the host execution character set,
759 and not attempt to recover any named escape characters, but render
760 all unprintables as octal escapes. If the host and target character
761 sets are the same, this produces relatively readable output. If they
762 are not the same, strings may appear as gibberish, but that's okay
763 (in fact, it may well be what the reader wants, e.g. if they are looking
764 to see if conversion to the target character set happened correctly).
766 A special case: we need to prefix \, ", and ' with backslashes. It is
767 correct to do so for the *host*'s \, ", and ', because the rest of the
768 file appears in the host character set. */
771 pp_c_char (c_pretty_printer *pp, int c)
777 case '\\': pp_string (pp, "\\\\"); break;
778 case '\'': pp_string (pp, "\\\'"); break;
779 case '\"': pp_string (pp, "\\\""); break;
780 default: pp_character (pp, c);
784 pp_scalar (pp, "\\%03o", (unsigned) c);
787 /* Print out a STRING literal. */
790 pp_c_string_literal (c_pretty_printer *pp, tree s)
792 const char *p = TREE_STRING_POINTER (s);
793 int n = TREE_STRING_LENGTH (s) - 1;
796 for (i = 0; i < n; ++i)
797 pp_c_char (pp, p[i]);
801 /* Pretty-print an INTEGER literal. */
804 pp_c_integer_constant (c_pretty_printer *pp, tree i)
806 tree type = TREE_TYPE (i);
808 if (TREE_INT_CST_HIGH (i) == 0)
809 pp_wide_integer (pp, TREE_INT_CST_LOW (i));
812 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (i);
813 HOST_WIDE_INT high = TREE_INT_CST_HIGH (i);
814 if (tree_int_cst_sgn (i) < 0)
816 pp_character (pp, '-');
820 sprintf (pp_buffer (pp)->digit_buffer,
821 HOST_WIDE_INT_PRINT_DOUBLE_HEX, high, low);
822 pp_string (pp, pp_buffer (pp)->digit_buffer);
824 if (TYPE_UNSIGNED (type))
825 pp_character (pp, 'u');
826 if (type == long_integer_type_node || type == long_unsigned_type_node)
827 pp_character (pp, 'l');
828 else if (type == long_long_integer_type_node
829 || type == long_long_unsigned_type_node)
830 pp_string (pp, "ll");
833 /* Print out a CHARACTER literal. */
836 pp_c_character_constant (c_pretty_printer *pp, tree c)
838 tree type = TREE_TYPE (c);
839 if (type == wchar_type_node)
840 pp_character (pp, 'L');
842 if (host_integerp (c, TYPE_UNSIGNED (type)))
843 pp_c_char (pp, tree_low_cst (c, TYPE_UNSIGNED (type)));
845 pp_scalar (pp, "\\x%x", (unsigned) TREE_INT_CST_LOW (c));
849 /* Print out a BOOLEAN literal. */
852 pp_c_bool_constant (c_pretty_printer *pp, tree b)
854 if (b == boolean_false_node)
856 if (c_dialect_cxx ())
857 pp_c_identifier (pp, "false");
858 else if (flag_isoc99)
859 pp_c_identifier (pp, "_False");
861 pp_unsupported_tree (pp, b);
863 else if (b == boolean_true_node)
865 if (c_dialect_cxx ())
866 pp_c_identifier (pp, "true");
867 else if (flag_isoc99)
868 pp_c_identifier (pp, "_True");
870 pp_unsupported_tree (pp, b);
872 else if (TREE_CODE (b) == INTEGER_CST)
873 pp_c_integer_constant (pp, b);
875 pp_unsupported_tree (pp, b);
878 /* Attempt to print out an ENUMERATOR. Return true on success. Else return
879 false; that means the value was obtained by a cast, in which case
880 print out the type-id part of the cast-expression -- the casted value
881 is then printed by pp_c_integer_literal. */
884 pp_c_enumeration_constant (c_pretty_printer *pp, tree e)
886 bool value_is_named = true;
887 tree type = TREE_TYPE (e);
890 /* Find the name of this constant. */
891 for (value = TYPE_VALUES (type);
892 value != NULL_TREE && !tree_int_cst_equal (TREE_VALUE (value), e);
893 value = TREE_CHAIN (value))
896 if (value != NULL_TREE)
897 pp_id_expression (pp, TREE_PURPOSE (value));
900 /* Value must have been cast. */
901 pp_c_type_cast (pp, type);
902 value_is_named = false;
905 return value_is_named;
908 /* Print out a REAL value as a decimal-floating-constant. */
911 pp_c_floating_constant (c_pretty_printer *pp, tree r)
913 real_to_decimal (pp_buffer (pp)->digit_buffer, &TREE_REAL_CST (r),
914 sizeof (pp_buffer (pp)->digit_buffer), 0, 1);
915 pp_string (pp, pp_buffer(pp)->digit_buffer);
916 if (TREE_TYPE (r) == float_type_node)
917 pp_character (pp, 'f');
918 else if (TREE_TYPE (r) == long_double_type_node)
919 pp_character (pp, 'l');
920 else if (TREE_TYPE (r) == dfloat128_type_node)
921 pp_string (pp, "dl");
922 else if (TREE_TYPE (r) == dfloat64_type_node)
923 pp_string (pp, "dd");
924 else if (TREE_TYPE (r) == dfloat32_type_node)
925 pp_string (pp, "df");
928 /* Pretty-print a compound literal expression. GNU extensions include
932 pp_c_compound_literal (c_pretty_printer *pp, tree e)
934 tree type = TREE_TYPE (e);
935 pp_c_type_cast (pp, type);
937 switch (TREE_CODE (type))
944 pp_c_brace_enclosed_initializer_list (pp, e);
948 pp_unsupported_tree (pp, e);
957 character-constant */
960 pp_c_constant (c_pretty_printer *pp, tree e)
962 const enum tree_code code = TREE_CODE (e);
968 tree type = TREE_TYPE (e);
969 if (type == boolean_type_node)
970 pp_c_bool_constant (pp, e);
971 else if (type == char_type_node)
972 pp_c_character_constant (pp, e);
973 else if (TREE_CODE (type) == ENUMERAL_TYPE
974 && pp_c_enumeration_constant (pp, e))
977 pp_c_integer_constant (pp, e);
982 pp_c_floating_constant (pp, e);
986 pp_c_string_literal (pp, e);
990 pp_unsupported_tree (pp, e);
995 /* Pretty-print an IDENTIFIER_NODE, preceded by whitespace is necessary. */
998 pp_c_identifier (c_pretty_printer *pp, const char *id)
1000 pp_c_maybe_whitespace (pp);
1001 pp_identifier (pp, id);
1002 pp_base (pp)->padding = pp_before;
1005 /* Pretty-print a C primary-expression.
1013 pp_c_primary_expression (c_pretty_printer *pp, tree e)
1015 switch (TREE_CODE (e))
1023 pp_c_tree_decl_identifier (pp, e);
1026 case IDENTIFIER_NODE:
1027 pp_c_tree_identifier (pp, e);
1031 pp_c_identifier (pp, "<erroneous-expression>");
1035 pp_c_identifier (pp, "<return-value>");
1041 pp_c_constant (pp, e);
1045 pp_c_identifier (pp, "__builtin_memcpy");
1046 pp_c_left_paren (pp);
1048 pp_primary_expression (pp, TREE_OPERAND (e, 0));
1049 pp_separate_with (pp, ',');
1051 pp_initializer (pp, TREE_OPERAND (e, 1));
1052 if (TREE_OPERAND (e, 2))
1054 pp_separate_with (pp, ',');
1055 pp_c_expression (pp, TREE_OPERAND (e, 2));
1057 pp_c_right_paren (pp);
1061 /* FIXME: Make sure we won't get into an infinie loop. */
1062 pp_c_left_paren (pp);
1063 pp_expression (pp, e);
1064 pp_c_right_paren (pp);
1069 /* Print out a C initializer -- also support C compound-literals.
1071 assignment-expression:
1072 { initializer-list }
1073 { initializer-list , } */
1076 pp_c_initializer (c_pretty_printer *pp, tree e)
1078 if (TREE_CODE (e) == CONSTRUCTOR)
1079 pp_c_brace_enclosed_initializer_list (pp, e);
1081 pp_expression (pp, e);
1086 declarator = initializer */
1089 pp_c_init_declarator (c_pretty_printer *pp, tree t)
1091 pp_declarator (pp, t);
1092 /* We don't want to output function definitions here. There are handled
1093 elsewhere (and the syntactic form is bogus anyway). */
1094 if (TREE_CODE (t) != FUNCTION_DECL && DECL_INITIAL (t))
1096 tree init = DECL_INITIAL (t);
1097 /* This C++ bit is handled here because it is easier to do so.
1098 In templates, the C++ parser builds a TREE_LIST for a
1099 direct-initialization; the TREE_PURPOSE is the variable to
1100 initialize and the TREE_VALUE is the initializer. */
1101 if (TREE_CODE (init) == TREE_LIST)
1103 pp_c_left_paren (pp);
1104 pp_expression (pp, TREE_VALUE (init));
1105 pp_right_paren (pp);
1112 pp_c_initializer (pp, init);
1117 /* initializer-list:
1118 designation(opt) initializer
1119 initializer-list , designation(opt) initializer
1126 designator-list designator
1129 [ constant-expression ]
1133 pp_c_initializer_list (c_pretty_printer *pp, tree e)
1135 tree type = TREE_TYPE (e);
1136 const enum tree_code code = TREE_CODE (type);
1144 tree init = TREE_OPERAND (e, 0);
1145 for (; init != NULL_TREE; init = TREE_CHAIN (init))
1147 if (code == RECORD_TYPE || code == UNION_TYPE)
1150 pp_c_primary_expression (pp, TREE_PURPOSE (init));
1154 pp_c_left_bracket (pp);
1155 if (TREE_PURPOSE (init))
1156 pp_c_constant (pp, TREE_PURPOSE (init));
1157 pp_c_right_bracket (pp);
1159 pp_c_whitespace (pp);
1161 pp_c_whitespace (pp);
1162 pp_initializer (pp, TREE_VALUE (init));
1163 if (TREE_CHAIN (init))
1164 pp_separate_with (pp, ',');
1170 if (TREE_CODE (e) == VECTOR_CST)
1171 pp_c_expression_list (pp, TREE_VECTOR_CST_ELTS (e));
1172 else if (TREE_CODE (e) == CONSTRUCTOR)
1173 pp_c_constructor_elts (pp, CONSTRUCTOR_ELTS (e));
1179 if (TREE_CODE (e) == CONSTRUCTOR)
1180 pp_c_constructor_elts (pp, CONSTRUCTOR_ELTS (e));
1181 else if (TREE_CODE (e) == COMPLEX_CST || TREE_CODE (e) == COMPLEX_EXPR)
1183 const bool cst = TREE_CODE (e) == COMPLEX_CST;
1184 pp_expression (pp, cst ? TREE_REALPART (e) : TREE_OPERAND (e, 0));
1185 pp_separate_with (pp, ',');
1186 pp_expression (pp, cst ? TREE_IMAGPART (e) : TREE_OPERAND (e, 1));
1196 pp_unsupported_tree (pp, type);
1199 /* Pretty-print a brace-enclosed initializer-list. */
1202 pp_c_brace_enclosed_initializer_list (c_pretty_printer *pp, tree l)
1204 pp_c_left_brace (pp);
1205 pp_c_initializer_list (pp, l);
1206 pp_c_right_brace (pp);
1210 /* This is a convenient function, used to bridge gap between C and C++
1217 pp_c_id_expression (c_pretty_printer *pp, tree t)
1219 switch (TREE_CODE (t))
1228 pp_c_tree_decl_identifier (pp, t);
1231 case IDENTIFIER_NODE:
1232 pp_c_tree_identifier (pp, t);
1236 pp_unsupported_tree (pp, t);
1241 /* postfix-expression:
1243 postfix-expression [ expression ]
1244 postfix-expression ( argument-expression-list(opt) )
1245 postfix-expression . identifier
1246 postfix-expression -> identifier
1247 postfix-expression ++
1248 postfix-expression --
1249 ( type-name ) { initializer-list }
1250 ( type-name ) { initializer-list , } */
1253 pp_c_postfix_expression (c_pretty_printer *pp, tree e)
1255 enum tree_code code = TREE_CODE (e);
1258 case POSTINCREMENT_EXPR:
1259 case POSTDECREMENT_EXPR:
1260 pp_postfix_expression (pp, TREE_OPERAND (e, 0));
1261 pp_identifier (pp, code == POSTINCREMENT_EXPR ? "++" : "--");
1265 pp_postfix_expression (pp, TREE_OPERAND (e, 0));
1266 pp_c_left_bracket (pp);
1267 pp_expression (pp, TREE_OPERAND (e, 1));
1268 pp_c_right_bracket (pp);
1273 call_expr_arg_iterator iter;
1275 pp_postfix_expression (pp, CALL_EXPR_FN (e));
1276 pp_c_left_paren (pp);
1277 FOR_EACH_CALL_EXPR_ARG (arg, iter, e)
1279 pp_expression (pp, arg);
1280 if (more_call_expr_args_p (&iter))
1281 pp_separate_with (pp, ',');
1283 pp_c_right_paren (pp);
1287 case UNORDERED_EXPR:
1288 pp_c_identifier (pp, flag_isoc99
1290 : "__builtin_isunordered");
1294 pp_c_identifier (pp, flag_isoc99
1296 : "!__builtin_isunordered");
1300 pp_c_identifier (pp, flag_isoc99
1302 : "!__builtin_isgreaterequal");
1306 pp_c_identifier (pp, flag_isoc99
1308 : "!__builtin_isgreater");
1312 pp_c_identifier (pp, flag_isoc99
1314 : "!__builtin_islessequal");
1318 pp_c_identifier (pp, flag_isoc99
1320 : "!__builtin_isless");
1324 pp_c_identifier (pp, flag_isoc99
1326 : "!__builtin_islessgreater");
1330 pp_c_identifier (pp, flag_isoc99
1332 : "__builtin_islessgreater");
1336 pp_c_left_paren (pp);
1337 pp_expression (pp, TREE_OPERAND (e, 0));
1338 pp_separate_with (pp, ',');
1339 pp_expression (pp, TREE_OPERAND (e, 1));
1340 pp_c_right_paren (pp);
1344 pp_c_identifier (pp, "__builtin_abs");
1345 pp_c_left_paren (pp);
1346 pp_expression (pp, TREE_OPERAND (e, 0));
1347 pp_c_right_paren (pp);
1352 tree object = TREE_OPERAND (e, 0);
1353 if (TREE_CODE (object) == INDIRECT_REF)
1355 pp_postfix_expression (pp, TREE_OPERAND (object, 0));
1360 pp_postfix_expression (pp, object);
1363 pp_expression (pp, TREE_OPERAND (e, 1));
1370 pp_c_compound_literal (pp, e);
1373 case COMPOUND_LITERAL_EXPR:
1374 e = DECL_INITIAL (COMPOUND_LITERAL_EXPR_DECL (e));
1377 pp_initializer (pp, e);
1381 pp_c_identifier (pp, "__builtin_va_arg");
1382 pp_c_left_paren (pp);
1383 pp_assignment_expression (pp, TREE_OPERAND (e, 0));
1384 pp_separate_with (pp, ',');
1385 pp_type_id (pp, TREE_TYPE (e));
1386 pp_c_right_paren (pp);
1390 if (TREE_CODE (TREE_OPERAND (e, 0)) == FUNCTION_DECL)
1392 pp_c_id_expression (pp, TREE_OPERAND (e, 0));
1395 /* else fall through. */
1398 pp_primary_expression (pp, e);
1403 /* Print out an expression-list; E is expected to be a TREE_LIST. */
1406 pp_c_expression_list (c_pretty_printer *pp, tree e)
1408 for (; e != NULL_TREE; e = TREE_CHAIN (e))
1410 pp_expression (pp, TREE_VALUE (e));
1412 pp_separate_with (pp, ',');
1416 /* Print out V, which contains the elements of a constructor. */
1419 pp_c_constructor_elts (c_pretty_printer *pp, VEC(constructor_elt,gc) *v)
1421 unsigned HOST_WIDE_INT ix;
1424 FOR_EACH_CONSTRUCTOR_VALUE (v, ix, value)
1426 pp_expression (pp, value);
1427 if (ix != VEC_length (constructor_elt, v) - 1)
1428 pp_separate_with (pp, ',');
1432 /* Print out an expression-list in parens, as if it were the argument
1433 list to a function. */
1436 pp_c_call_argument_list (c_pretty_printer *pp, tree t)
1438 pp_c_left_paren (pp);
1439 if (t && TREE_CODE (t) == TREE_LIST)
1440 pp_c_expression_list (pp, t);
1441 pp_c_right_paren (pp);
1444 /* unary-expression:
1448 unary-operator cast-expression
1449 sizeof unary-expression
1452 unary-operator: one of
1457 __alignof__ unary-expression
1458 __alignof__ ( type-id )
1459 __real__ unary-expression
1460 __imag__ unary-expression */
1463 pp_c_unary_expression (c_pretty_printer *pp, tree e)
1465 enum tree_code code = TREE_CODE (e);
1468 case PREINCREMENT_EXPR:
1469 case PREDECREMENT_EXPR:
1470 pp_identifier (pp, code == PREINCREMENT_EXPR ? "++" : "--");
1471 pp_c_unary_expression (pp, TREE_OPERAND (e, 0));
1478 case TRUTH_NOT_EXPR:
1480 /* String literal are used by address. */
1481 if (code == ADDR_EXPR && TREE_CODE (TREE_OPERAND (e, 0)) != STRING_CST)
1483 else if (code == INDIRECT_REF)
1485 else if (code == NEGATE_EXPR)
1487 else if (code == BIT_NOT_EXPR || code == CONJ_EXPR)
1489 else if (code == TRUTH_NOT_EXPR)
1490 pp_exclamation (pp);
1491 pp_c_cast_expression (pp, TREE_OPERAND (e, 0));
1496 pp_c_identifier (pp, code == REALPART_EXPR ? "__real__" : "__imag__");
1497 pp_c_whitespace (pp);
1498 pp_unary_expression (pp, TREE_OPERAND (e, 0));
1502 pp_postfix_expression (pp, e);
1509 ( type-name ) cast-expression */
1512 pp_c_cast_expression (c_pretty_printer *pp, tree e)
1514 switch (TREE_CODE (e))
1517 case FIX_TRUNC_EXPR:
1520 pp_c_type_cast (pp, TREE_TYPE (e));
1521 pp_c_cast_expression (pp, TREE_OPERAND (e, 0));
1525 pp_unary_expression (pp, e);
1529 /* multiplicative-expression:
1531 multiplicative-expression * cast-expression
1532 multiplicative-expression / cast-expression
1533 multiplicative-expression % cast-expression */
1536 pp_c_multiplicative_expression (c_pretty_printer *pp, tree e)
1538 enum tree_code code = TREE_CODE (e);
1542 case TRUNC_DIV_EXPR:
1543 case TRUNC_MOD_EXPR:
1544 pp_multiplicative_expression (pp, TREE_OPERAND (e, 0));
1545 pp_c_whitespace (pp);
1546 if (code == MULT_EXPR)
1548 else if (code == TRUNC_DIV_EXPR)
1552 pp_c_whitespace (pp);
1553 pp_c_cast_expression (pp, TREE_OPERAND (e, 1));
1557 pp_c_cast_expression (pp, e);
1562 /* additive-expression:
1563 multiplicative-expression
1564 additive-expression + multiplicative-expression
1565 additive-expression - multiplicative-expression */
1568 pp_c_additive_expression (c_pretty_printer *pp, tree e)
1570 enum tree_code code = TREE_CODE (e);
1575 pp_c_additive_expression (pp, TREE_OPERAND (e, 0));
1576 pp_c_whitespace (pp);
1577 if (code == PLUS_EXPR)
1581 pp_c_whitespace (pp);
1582 pp_multiplicative_expression (pp, TREE_OPERAND (e, 1));
1586 pp_multiplicative_expression (pp, e);
1591 /* additive-expression:
1593 shift-expression << additive-expression
1594 shift-expression >> additive-expression */
1597 pp_c_shift_expression (c_pretty_printer *pp, tree e)
1599 enum tree_code code = TREE_CODE (e);
1604 pp_c_shift_expression (pp, TREE_OPERAND (e, 0));
1605 pp_c_whitespace (pp);
1606 pp_identifier (pp, code == LSHIFT_EXPR ? "<<" : ">>");
1607 pp_c_whitespace (pp);
1608 pp_c_additive_expression (pp, TREE_OPERAND (e, 1));
1612 pp_c_additive_expression (pp, e);
1616 /* relational-expression:
1618 relational-expression < shift-expression
1619 relational-expression > shift-expression
1620 relational-expression <= shift-expression
1621 relational-expression >= shift-expression */
1624 pp_c_relational_expression (c_pretty_printer *pp, tree e)
1626 enum tree_code code = TREE_CODE (e);
1633 pp_c_relational_expression (pp, TREE_OPERAND (e, 0));
1634 pp_c_whitespace (pp);
1635 if (code == LT_EXPR)
1637 else if (code == GT_EXPR)
1639 else if (code == LE_EXPR)
1640 pp_identifier (pp, "<=");
1641 else if (code == GE_EXPR)
1642 pp_identifier (pp, ">=");
1643 pp_c_whitespace (pp);
1644 pp_c_shift_expression (pp, TREE_OPERAND (e, 1));
1648 pp_c_shift_expression (pp, e);
1653 /* equality-expression:
1654 relational-expression
1655 equality-expression == relational-expression
1656 equality-equality != relational-expression */
1659 pp_c_equality_expression (c_pretty_printer *pp, tree e)
1661 enum tree_code code = TREE_CODE (e);
1666 pp_c_equality_expression (pp, TREE_OPERAND (e, 0));
1667 pp_c_whitespace (pp);
1668 pp_identifier (pp, code == EQ_EXPR ? "==" : "!=");
1669 pp_c_whitespace (pp);
1670 pp_c_relational_expression (pp, TREE_OPERAND (e, 1));
1674 pp_c_relational_expression (pp, e);
1681 AND-expression & equality-equality */
1684 pp_c_and_expression (c_pretty_printer *pp, tree e)
1686 if (TREE_CODE (e) == BIT_AND_EXPR)
1688 pp_c_and_expression (pp, TREE_OPERAND (e, 0));
1689 pp_c_whitespace (pp);
1691 pp_c_whitespace (pp);
1692 pp_c_equality_expression (pp, TREE_OPERAND (e, 1));
1695 pp_c_equality_expression (pp, e);
1698 /* exclusive-OR-expression:
1700 exclusive-OR-expression ^ AND-expression */
1703 pp_c_exclusive_or_expression (c_pretty_printer *pp, tree e)
1705 if (TREE_CODE (e) == BIT_XOR_EXPR)
1707 pp_c_exclusive_or_expression (pp, TREE_OPERAND (e, 0));
1708 pp_c_maybe_whitespace (pp);
1710 pp_c_whitespace (pp);
1711 pp_c_and_expression (pp, TREE_OPERAND (e, 1));
1714 pp_c_and_expression (pp, e);
1717 /* inclusive-OR-expression:
1718 exclusive-OR-expression
1719 inclusive-OR-expression | exclusive-OR-expression */
1722 pp_c_inclusive_or_expression (c_pretty_printer *pp, tree e)
1724 if (TREE_CODE (e) == BIT_IOR_EXPR)
1726 pp_c_exclusive_or_expression (pp, TREE_OPERAND (e, 0));
1727 pp_c_whitespace (pp);
1729 pp_c_whitespace (pp);
1730 pp_c_exclusive_or_expression (pp, TREE_OPERAND (e, 1));
1733 pp_c_exclusive_or_expression (pp, e);
1736 /* logical-AND-expression:
1737 inclusive-OR-expression
1738 logical-AND-expression && inclusive-OR-expression */
1741 pp_c_logical_and_expression (c_pretty_printer *pp, tree e)
1743 if (TREE_CODE (e) == TRUTH_ANDIF_EXPR)
1745 pp_c_logical_and_expression (pp, TREE_OPERAND (e, 0));
1746 pp_c_whitespace (pp);
1747 pp_identifier (pp, "&&");
1748 pp_c_whitespace (pp);
1749 pp_c_inclusive_or_expression (pp, TREE_OPERAND (e, 1));
1752 pp_c_inclusive_or_expression (pp, e);
1755 /* logical-OR-expression:
1756 logical-AND-expression
1757 logical-OR-expression || logical-AND-expression */
1760 pp_c_logical_or_expression (c_pretty_printer *pp, tree e)
1762 if (TREE_CODE (e) == TRUTH_ORIF_EXPR)
1764 pp_c_logical_or_expression (pp, TREE_OPERAND (e, 0));
1765 pp_c_whitespace (pp);
1766 pp_identifier (pp, "||");
1767 pp_c_whitespace (pp);
1768 pp_c_logical_and_expression (pp, TREE_OPERAND (e, 1));
1771 pp_c_logical_and_expression (pp, e);
1774 /* conditional-expression:
1775 logical-OR-expression
1776 logical-OR-expression ? expression : conditional-expression */
1779 pp_c_conditional_expression (c_pretty_printer *pp, tree e)
1781 if (TREE_CODE (e) == COND_EXPR)
1783 pp_c_logical_or_expression (pp, TREE_OPERAND (e, 0));
1784 pp_c_whitespace (pp);
1786 pp_c_whitespace (pp);
1787 pp_expression (pp, TREE_OPERAND (e, 1));
1788 pp_c_whitespace (pp);
1790 pp_c_whitespace (pp);
1791 pp_c_conditional_expression (pp, TREE_OPERAND (e, 2));
1794 pp_c_logical_or_expression (pp, e);
1798 /* assignment-expression:
1799 conditional-expression
1800 unary-expression assignment-operator assignment-expression
1802 assignment-expression: one of
1803 = *= /= %= += -= >>= <<= &= ^= |= */
1806 pp_c_assignment_expression (c_pretty_printer *pp, tree e)
1808 if (TREE_CODE (e) == MODIFY_EXPR
1809 || TREE_CODE (e) == GIMPLE_MODIFY_STMT
1810 || TREE_CODE (e) == INIT_EXPR)
1812 pp_c_unary_expression (pp, GENERIC_TREE_OPERAND (e, 0));
1813 pp_c_whitespace (pp);
1816 pp_c_expression (pp, GENERIC_TREE_OPERAND (e, 1));
1819 pp_c_conditional_expression (pp, e);
1823 assignment-expression
1824 expression , assignment-expression
1826 Implementation note: instead of going through the usual recursion
1827 chain, I take the liberty of dispatching nodes to the appropriate
1828 functions. This makes some redundancy, but it worths it. That also
1829 prevents a possible infinite recursion between pp_c_primary_expression ()
1830 and pp_c_expression (). */
1833 pp_c_expression (c_pretty_printer *pp, tree e)
1835 switch (TREE_CODE (e))
1838 pp_c_integer_constant (pp, e);
1842 pp_c_floating_constant (pp, e);
1846 pp_c_string_literal (pp, e);
1849 case IDENTIFIER_NODE:
1858 pp_primary_expression (pp, e);
1861 case POSTINCREMENT_EXPR:
1862 case POSTDECREMENT_EXPR:
1870 case UNORDERED_EXPR:
1879 case COMPOUND_LITERAL_EXPR:
1881 pp_postfix_expression (pp, e);
1889 case TRUTH_NOT_EXPR:
1890 case PREINCREMENT_EXPR:
1891 case PREDECREMENT_EXPR:
1894 pp_c_unary_expression (pp, e);
1898 case FIX_TRUNC_EXPR:
1901 pp_c_cast_expression (pp, e);
1905 case TRUNC_MOD_EXPR:
1906 case TRUNC_DIV_EXPR:
1907 pp_multiplicative_expression (pp, e);
1912 pp_c_shift_expression (pp, e);
1919 pp_c_relational_expression (pp, e);
1923 pp_c_and_expression (pp, e);
1927 pp_c_exclusive_or_expression (pp, e);
1931 pp_c_inclusive_or_expression (pp, e);
1934 case TRUTH_ANDIF_EXPR:
1935 pp_c_logical_and_expression (pp, e);
1938 case TRUTH_ORIF_EXPR:
1939 pp_c_logical_or_expression (pp, e);
1944 pp_c_equality_expression (pp, e);
1948 pp_conditional_expression (pp, e);
1953 pp_c_additive_expression (pp, e);
1957 case GIMPLE_MODIFY_STMT:
1959 pp_assignment_expression (pp, e);
1963 pp_c_left_paren (pp);
1964 pp_expression (pp, TREE_OPERAND (e, 0));
1965 pp_separate_with (pp, ',');
1966 pp_assignment_expression (pp, TREE_OPERAND (e, 1));
1967 pp_c_right_paren (pp);
1970 case NON_LVALUE_EXPR:
1972 pp_expression (pp, TREE_OPERAND (e, 0));
1976 pp_postfix_expression (pp, TREE_OPERAND (e, 1));
1980 pp_unsupported_tree (pp, e);
1990 pp_c_statement (c_pretty_printer *pp, tree stmt)
1995 if (pp_needs_newline (pp))
1996 pp_newline_and_indent (pp, 0);
1998 dump_generic_node (pp_base (pp), stmt, pp_indentation (pp), 0, true);
2002 /* Initialize the PRETTY-PRINTER for handling C codes. */
2005 pp_c_pretty_printer_init (c_pretty_printer *pp)
2007 pp->offset_list = 0;
2009 pp->declaration = pp_c_declaration;
2010 pp->declaration_specifiers = pp_c_declaration_specifiers;
2011 pp->declarator = pp_c_declarator;
2012 pp->direct_declarator = pp_c_direct_declarator;
2013 pp->type_specifier_seq = pp_c_specifier_qualifier_list;
2014 pp->abstract_declarator = pp_c_abstract_declarator;
2015 pp->direct_abstract_declarator = pp_c_direct_abstract_declarator;
2016 pp->ptr_operator = pp_c_pointer;
2017 pp->parameter_list = pp_c_parameter_type_list;
2018 pp->type_id = pp_c_type_id;
2019 pp->simple_type_specifier = pp_c_type_specifier;
2020 pp->function_specifier = pp_c_function_specifier;
2021 pp->storage_class_specifier = pp_c_storage_class_specifier;
2023 pp->statement = pp_c_statement;
2025 pp->constant = pp_c_constant;
2026 pp->id_expression = pp_c_id_expression;
2027 pp->primary_expression = pp_c_primary_expression;
2028 pp->postfix_expression = pp_c_postfix_expression;
2029 pp->unary_expression = pp_c_unary_expression;
2030 pp->initializer = pp_c_initializer;
2031 pp->multiplicative_expression = pp_c_multiplicative_expression;
2032 pp->conditional_expression = pp_c_conditional_expression;
2033 pp->assignment_expression = pp_c_assignment_expression;
2034 pp->expression = pp_c_expression;
2038 /* Print the tree T in full, on file FILE. */
2041 print_c_tree (FILE *file, tree t)
2043 static c_pretty_printer pp_rec;
2044 static bool initialized = 0;
2045 c_pretty_printer *pp = &pp_rec;
2050 pp_construct (pp_base (pp), NULL, 0);
2051 pp_c_pretty_printer_init (pp);
2052 pp_needs_newline (pp) = true;
2054 pp_base (pp)->buffer->stream = file;
2056 pp_statement (pp, t);
2062 /* Print the tree T in full, on stderr. */
2065 debug_c_tree (tree t)
2067 print_c_tree (stderr, t);
2068 fputc ('\n', stderr);
2071 /* Output the DECL_NAME of T. If T has no DECL_NAME, output a string made
2072 up of T's memory address. */
2075 pp_c_tree_decl_identifier (c_pretty_printer *pp, tree t)
2079 gcc_assert (DECL_P (t));
2082 name = IDENTIFIER_POINTER (DECL_NAME (t));
2085 static char xname[8];
2086 sprintf (xname, "<U%4x>", ((unsigned)((unsigned long)(t) & 0xffff)));
2090 pp_c_identifier (pp, name);