1 /* Subroutines common to both C and C++ pretty-printers.
2 Copyright (C) 2002 Free Software Foundation, Inc.
3 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
25 #include "c-pretty-print.h"
28 static void pp_c_char PARAMS ((c_pretty_print_info *, int));
29 static void pp_c_character_literal PARAMS ((c_pretty_print_info *, tree));
30 static void pp_c_bool_literal PARAMS ((c_pretty_print_info *, tree));
31 static bool pp_c_enumerator PARAMS ((c_pretty_print_info *, tree));
32 static void pp_c_integer_literal PARAMS ((c_pretty_print_info *, tree));
33 static void pp_c_real_literal PARAMS ((c_pretty_print_info *, tree));
34 static void pp_c_string_literal PARAMS ((c_pretty_print_info *, tree));
36 static void pp_c_primary_expression PARAMS ((c_pretty_print_info *, tree));
38 /* postfix-expression */
39 static void pp_c_initializer_list PARAMS ((c_pretty_print_info *, tree));
41 static void pp_c_unary_expression PARAMS ((c_pretty_print_info *, tree));
42 static void pp_c_multiplicative_expression PARAMS ((c_pretty_print_info *,
44 static void pp_c_additive_expression PARAMS ((c_pretty_print_info *, tree));
45 static void pp_c_shift_expression PARAMS ((c_pretty_print_info *, tree));
46 static void pp_c_relational_expression PARAMS ((c_pretty_print_info *, tree));
47 static void pp_c_equality_expression PARAMS ((c_pretty_print_info *, tree));
48 static void pp_c_and_expression PARAMS ((c_pretty_print_info *, tree));
49 static void pp_c_exclusive_or_expression PARAMS ((c_pretty_print_info *,
51 static void pp_c_inclusive_or_expression PARAMS ((c_pretty_print_info *,
53 static void pp_c_logical_and_expression PARAMS ((c_pretty_print_info *, tree));
54 static void pp_c_conditional_expression PARAMS ((c_pretty_print_info *, tree));
55 static void pp_c_assignment_expression PARAMS ((c_pretty_print_info *, tree));
59 /* Print out CV-qualifiers. Take care of possible extension. */
61 pp_c_cv_qualifier (ppi, cv)
62 c_pretty_print_info *ppi;
65 if (cv & TYPE_QUAL_CONST)
66 pp_c_identifier (ppi, "const");
67 if (cv & TYPE_QUAL_VOLATILE)
68 pp_c_identifier (ppi, "volatile");
69 if (cv & TYPE_QUAL_RESTRICT)
70 pp_c_identifier (ppi, flag_isoc99 ? "restrict" : "__restrict__");
76 /* Print out a c-char. */
79 c_pretty_print_info *ppi;
85 pp_identifier (ppi, "\\n");
88 pp_identifier (ppi, "\\t");
91 pp_identifier (ppi, "\\v");
94 pp_identifier (ppi, "\\b");
97 pp_identifier (ppi, "\\r");
100 pp_identifier (ppi, "\\f");
103 pp_identifier (ppi, "\\a");
106 pp_identifier (ppi, "\\\\");
109 pp_identifier (ppi, "\\'");
112 pp_identifier (ppi, "\\\"");
116 pp_character (ppi, c);
118 pp_format_integer (ppi, "\\%03o", (unsigned) c);
123 /* Print out a STRING literal. */
125 pp_c_string_literal (ppi, s)
126 c_pretty_print_info *ppi;
129 const char *p = TREE_STRING_POINTER (s);
130 int n = TREE_STRING_LENGTH (s) - 1;
132 pp_doublequote (ppi);
133 for (i = 0; i < n; ++i)
134 pp_c_char (ppi, p[i]);
135 pp_doublequote (ppi);
138 /* Print out a CHARACTER literal. */
140 pp_c_character_literal (ppi, c)
141 c_pretty_print_info *ppi;
145 pp_c_char (ppi, tree_low_cst (c, 0));
149 /* Print out a BOOLEAN literal. */
151 pp_c_bool_literal (ppi, b)
152 c_pretty_print_info *ppi;
155 if (b == boolean_false_node || integer_zerop (b))
157 if (c_language == clk_cplusplus)
158 pp_c_identifier (ppi, "false");
159 else if (c_language == clk_c && flag_isoc99)
160 pp_c_identifier (ppi, "_False");
162 pp_unsupported_tree (ppi, b);
164 else if (b == boolean_true_node)
166 if (c_language == clk_cplusplus)
167 pp_c_identifier (ppi, "true");
168 else if (c_language == clk_c && flag_isoc99)
169 pp_c_identifier (ppi, "_True");
171 pp_unsupported_tree (ppi, b);
174 pp_unsupported_tree (ppi, b);
177 /* Attempt to print out an ENUMERATOR. Return true on success. Else return
178 false; that means the value was obtained by a cast, in which case
179 print out the type-id part of the cast-expression -- the casted value
180 is then printed by pp_c_integer_literal. */
182 pp_c_enumerator (ppi, e)
183 c_pretty_print_info *ppi;
186 tree type = TREE_TYPE (e);
189 /* Find the name of this constant. */
190 for (value = TYPE_VALUES (type);
191 value != NULL_TREE && !tree_int_cst_equal (TREE_VALUE (value), e);
192 value = TREE_CHAIN (value))
195 if (value != NULL_TREE)
196 pp_c_tree_identifier (ppi, TREE_PURPOSE (value));
199 /* Value must have been cast. */
200 pp_c_left_paren (ppi);
201 pp_type_id (ppi, type);
202 pp_c_right_paren (ppi);
209 /* Print out an INTEGER constant value. */
211 pp_c_integer_literal (ppi, i)
212 c_pretty_print_info *ppi;
215 tree type = TREE_TYPE (i);
217 if (type == boolean_type_node)
218 pp_c_bool_literal (ppi, i);
219 else if (type == char_type_node)
220 pp_c_character_literal (ppi, i);
221 else if (TREE_CODE (type) == ENUMERAL_TYPE
222 && pp_c_enumerator (ppi, i))
226 if (host_integerp (i, 0))
227 pp_wide_integer (ppi, TREE_INT_CST_LOW (i));
230 if (tree_int_cst_sgn (i) < 0)
232 static char format[10]; /* "%x%09999x\0" */
234 sprintf (format, "%%x%%0%dx", HOST_BITS_PER_INT / 4);
236 pp_c_char (ppi, '-');
237 i = build_int_2 (-TREE_INT_CST_LOW (i),
238 ~TREE_INT_CST_HIGH (i) + !TREE_INT_CST_LOW (i));
239 sprintf (pp_buffer (ppi)->digit_buffer, format,
240 TREE_INT_CST_HIGH (i), TREE_INT_CST_LOW (i));
241 pp_identifier (ppi, pp_buffer (ppi)->digit_buffer);
248 /* Print out a REAL value. */
250 pp_c_real_literal (ppi, r)
251 c_pretty_print_info *ppi;
254 REAL_VALUE_TO_DECIMAL (TREE_REAL_CST (r), "%.16g",
255 pp_buffer (ppi)->digit_buffer);
256 pp_identifier (ppi, pp_buffer(ppi)->digit_buffer);
261 pp_c_literal (ppi, e)
262 c_pretty_print_info *ppi;
265 switch (TREE_CODE (e))
268 pp_c_integer_literal (ppi, e);
272 pp_c_real_literal (ppi, e);
276 pp_c_string_literal (ppi, e);
280 pp_unsupported_tree (ppi, e);
285 /* Pretty-print a C primary-expression. */
287 pp_c_primary_expression (ppi, e)
288 c_pretty_print_info *ppi;
291 switch (TREE_CODE (e))
301 case IDENTIFIER_NODE:
302 pp_c_tree_identifier (ppi, e);
306 pp_c_identifier (ppi, "<erroneous-expression>");
310 pp_c_identifier (ppi, "<return-value>");
316 pp_c_literal (ppi, e);
320 pp_c_left_paren (ppi);
321 pp_c_identifier (ppi, "__builtin_memcpy");
322 pp_c_left_paren (ppi);
324 pp_c_primary_expression (ppi, TREE_OPERAND (e, 0));
325 pp_separate_with (ppi, ',');
327 pp_initializer (ppi, TREE_OPERAND (e, 1));
328 if (TREE_OPERAND (e, 2))
330 pp_separate_with (ppi, ',');
331 pp_c_expression (ppi, TREE_OPERAND (e, 2));
333 pp_c_right_paren (ppi);
336 pp_c_left_paren (ppi);
337 pp_statement (ppi, STMT_EXPR_STMT (e));
338 pp_c_right_paren (ppi);
342 /* Make sure this call won't cause any infinite loop. */
343 pp_c_left_paren (ppi);
344 pp_c_expression (ppi, e);
345 pp_c_right_paren (ppi);
350 /* Print out a C initializer -- also support C compound-literals. */
352 pp_c_initializer (ppi, e)
353 c_pretty_print_info *ppi;
356 if (TREE_CODE (e) == CONSTRUCTOR)
358 enum tree_code code = TREE_CODE (TREE_TYPE (e));
359 if (code == RECORD_TYPE || code == UNION_TYPE || code == ARRAY_TYPE)
362 pp_c_initializer_list (ppi, e);
363 pp_right_brace (ppi);
366 pp_unsupported_tree (ppi, TREE_OPERAND (e, 1));
369 pp_assignment_expression (ppi, e);
373 pp_c_initializer_list (ppi, e)
374 c_pretty_print_info *ppi;
377 tree type = TREE_TYPE (e);
378 const enum tree_code code = TREE_CODE (type);
380 if (code == RECORD_TYPE || code == UNION_TYPE || code == ARRAY_TYPE)
382 tree init = TREE_OPERAND (e, 1);
383 for (; init != NULL_TREE; init = TREE_CHAIN (init))
385 if (code == RECORD_TYPE || code == UNION_TYPE)
388 pp_c_primary_expression (ppi, TREE_PURPOSE (init));
392 pp_c_left_bracket (ppi);
393 if (TREE_PURPOSE (init))
394 pp_c_literal (ppi, TREE_PURPOSE (init));
395 pp_c_right_bracket (ppi);
397 pp_c_whitespace (ppi);
399 pp_c_whitespace (ppi);
400 pp_initializer (ppi, TREE_VALUE (init));
401 if (TREE_CHAIN (init))
402 pp_separate_with (ppi, ',');
406 pp_unsupported_tree (ppi, type);
410 pp_c_postfix_expression (ppi, e)
411 c_pretty_print_info *ppi;
414 enum tree_code code = TREE_CODE (e);
417 case POSTINCREMENT_EXPR:
418 case POSTDECREMENT_EXPR:
419 pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
420 pp_identifier (ppi, code == POSTINCREMENT_EXPR ? "++" : "--");
424 pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
429 pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
430 pp_c_left_bracket (ppi);
431 pp_c_expression (ppi, TREE_OPERAND (e, 1));
432 pp_c_right_bracket (ppi);
436 pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
437 pp_c_left_paren (ppi);
438 pp_c_expression_list (ppi, TREE_OPERAND (e, 1));
439 pp_c_right_paren (ppi);
444 pp_c_identifier (ppi,
445 code == ABS_EXPR ? "__builtin_abs" : "__builtin_ffs");
446 pp_c_left_paren (ppi);
447 pp_c_expression (ppi, TREE_OPERAND (e, 0));
448 pp_c_right_paren (ppi);
453 tree object = TREE_OPERAND (e, 0);
454 if (TREE_CODE (object) == INDIRECT_REF)
456 pp_postfix_expression (ppi, TREE_OPERAND (object, 0));
461 pp_postfix_expression (ppi, object);
464 pp_c_expression (ppi, TREE_OPERAND (e, 1));
471 pp_c_left_paren (ppi);
472 pp_type_id (ppi, TREE_TYPE (e));
473 pp_c_right_paren (ppi);
476 if (code == COMPLEX_CST)
478 pp_c_expression (ppi, TREE_REALPART (e));
479 pp_separate_with (ppi, ',');
480 pp_c_expression (ppi, TREE_IMAGPART (e));
482 else if (code == VECTOR_CST)
483 pp_c_expression_list (ppi, TREE_VECTOR_CST_ELTS (e));
484 else if (code == COMPLEX_EXPR)
486 pp_c_expression (ppi, TREE_OPERAND (e, 0));
487 pp_separate_with (ppi, ',');
488 pp_c_expression (ppi, TREE_OPERAND (e, 1));
491 pp_right_brace (ppi);
494 case COMPOUND_LITERAL_EXPR:
495 e = DECL_INITIAL (e);
498 pp_initializer (ppi, e);
504 pp_identifier (ppi, "__location__");
505 pp_right_paren (ppi);
509 pp_identifier (ppi, "file");
512 pp_c_whitespace (ppi);
513 pp_c_expression (ppi, SRCLOC_FILE (e));
514 pp_separate_with (ppi, ',');
516 pp_identifier (ppi, "line");
519 pp_c_whitespace (ppi);
520 pp_c_expression (ppi, SRCLOC_LINE (e));
521 pp_right_brace (ppi);
526 pp_c_identifier (ppi, "__builtin_va_arg");
527 pp_c_left_paren (ppi);
528 pp_assignment_expression (ppi, TREE_OPERAND (e, 0));
529 pp_separate_with (ppi, ',');
530 pp_type_id (ppi, TREE_TYPE (e));
531 pp_c_right_paren (ppi);
535 pp_primary_expression (ppi, e);
540 /* Print out an expression-list; E is expected to be a TREE_LIST */
542 pp_c_expression_list (ppi, e)
543 c_pretty_print_info *ppi;
546 for (; e != NULL_TREE; e = TREE_CHAIN (e))
548 pp_c_assignment_expression (ppi, TREE_VALUE (e));
550 pp_separate_with (ppi, ',');
555 pp_c_unary_expression (ppi, e)
556 c_pretty_print_info *ppi;
559 enum tree_code code = TREE_CODE (e);
562 case PREINCREMENT_EXPR:
563 case PREDECREMENT_EXPR:
564 pp_identifier (ppi, code == PREINCREMENT_EXPR ? "++" : "--");
565 pp_c_unary_expression (ppi, TREE_OPERAND (e, 0));
575 if (code == ADDR_EXPR)
577 else if (code == INDIRECT_REF)
579 else if (code == NEGATE_EXPR)
581 else if (code == BIT_NOT_EXPR || code == CONJ_EXPR)
583 else if (code == TRUTH_NOT_EXPR)
584 pp_exclamation (ppi);
585 pp_c_cast_expression (ppi, TREE_OPERAND (e, 0));
590 pp_c_identifier (ppi, code == SIZEOF_EXPR ? "sizeof" : "__alignof__");
591 pp_c_whitespace (ppi);
592 if (TYPE_P (TREE_OPERAND (e, 0)))
594 pp_c_left_paren (ppi);
595 pp_type_id (ppi, TREE_OPERAND (e, 0));
596 pp_c_right_paren (ppi);
599 pp_c_unary_expression (ppi, TREE_OPERAND (e, 0));
604 pp_c_identifier (ppi, code == REALPART_EXPR ? "__real__" : "__imag__");
605 pp_c_whitespace (ppi);
606 pp_unary_expression (ppi, TREE_OPERAND (e, 0));
610 pp_postfix_expression (ppi, e);
616 pp_c_cast_expression (ppi, e)
617 c_pretty_print_info *ppi;
620 if (TREE_CODE (e) == CONVERT_EXPR || TREE_CODE (e) == FLOAT_EXPR)
622 pp_c_left_paren (ppi);
623 pp_type_id (ppi, TREE_TYPE (e));
624 pp_c_right_paren (ppi);
625 pp_c_cast_expression (ppi, TREE_OPERAND (e, 0));
628 pp_unary_expression (ppi, e);
632 pp_c_multiplicative_expression (ppi, e)
633 c_pretty_print_info *ppi;
636 enum tree_code code = TREE_CODE (e);
642 pp_c_multiplicative_expression (ppi, TREE_OPERAND (e, 0));
643 pp_c_whitespace (ppi);
644 if (code == MULT_EXPR)
646 else if (code == TRUNC_DIV_EXPR)
650 pp_c_whitespace (ppi);
651 pp_c_cast_expression (ppi, TREE_OPERAND (e, 1));
655 pp_c_cast_expression (ppi, e);
661 pp_c_additive_expression (ppi, e)
662 c_pretty_print_info *ppi;
665 enum tree_code code = TREE_CODE (e);
670 pp_c_additive_expression (ppi, TREE_OPERAND (e, 0));
671 pp_c_whitespace (ppi);
672 if (code == PLUS_EXPR)
676 pp_c_whitespace (ppi);
677 pp_multiplicative_expression (ppi, TREE_OPERAND (e, 1));
681 pp_multiplicative_expression (ppi, e);
687 pp_c_shift_expression (ppi, e)
688 c_pretty_print_info *ppi;
691 enum tree_code code = TREE_CODE (e);
696 pp_c_shift_expression (ppi, TREE_OPERAND (e, 0));
697 pp_c_whitespace (ppi);
698 pp_identifier (ppi, code == LSHIFT_EXPR ? "<<" : ">>");
699 pp_c_whitespace (ppi);
700 pp_c_additive_expression (ppi, TREE_OPERAND (e, 1));
704 pp_c_additive_expression (ppi, e);
709 pp_c_relational_expression (ppi, e)
710 c_pretty_print_info *ppi;
713 enum tree_code code = TREE_CODE (e);
720 pp_c_relational_expression (ppi, TREE_OPERAND (e, 0));
721 pp_c_whitespace (ppi);
724 else if (code == GT_EXPR)
726 else if (code == LE_EXPR)
727 pp_identifier (ppi, "<=");
728 else if (code == GE_EXPR)
729 pp_identifier (ppi, ">=");
730 pp_c_whitespace (ppi);
731 pp_c_shift_expression (ppi, TREE_OPERAND (e, 1));
735 pp_c_shift_expression (ppi, e);
741 pp_c_equality_expression (ppi, e)
742 c_pretty_print_info *ppi;
745 enum tree_code code = TREE_CODE (e);
750 pp_c_equality_expression (ppi, TREE_OPERAND (e, 0));
751 pp_c_maybe_whitespace (ppi);
752 pp_identifier (ppi, code == EQ_EXPR ? "==" : "!=");
753 pp_c_whitespace (ppi);
754 pp_c_relational_expression (ppi, TREE_OPERAND (e, 1));
758 pp_c_relational_expression (ppi, e);
764 pp_c_and_expression (ppi, e)
765 c_pretty_print_info *ppi;
768 if (TREE_CODE (e) == BIT_AND_EXPR)
770 pp_c_and_expression (ppi, TREE_OPERAND (e, 0));
771 pp_c_maybe_whitespace (ppi);
773 pp_c_whitespace (ppi);
774 pp_c_equality_expression (ppi, TREE_OPERAND (e, 1));
777 pp_c_equality_expression (ppi, e);
781 pp_c_exclusive_or_expression (ppi, e)
782 c_pretty_print_info *ppi;
785 if (TREE_CODE (e) == BIT_XOR_EXPR)
787 pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 0));
788 pp_c_maybe_whitespace (ppi);
790 pp_c_whitespace (ppi);
791 pp_c_and_expression (ppi, TREE_OPERAND (e, 1));
794 pp_c_and_expression (ppi, e);
798 pp_c_inclusive_or_expression (ppi, e)
799 c_pretty_print_info *ppi;
802 if (TREE_CODE (e) == BIT_IOR_EXPR)
804 pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 0));
805 pp_c_maybe_whitespace (ppi);
807 pp_c_whitespace (ppi);
808 pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 1));
811 pp_c_exclusive_or_expression (ppi, e);
815 pp_c_logical_and_expression (ppi, e)
816 c_pretty_print_info *ppi;
819 if (TREE_CODE (e) == TRUTH_ANDIF_EXPR)
821 pp_c_logical_and_expression (ppi, TREE_OPERAND (e, 0));
822 pp_c_maybe_whitespace (ppi);
823 pp_identifier (ppi, "&&");
824 pp_c_whitespace (ppi);
825 pp_c_inclusive_or_expression (ppi, TREE_OPERAND (e, 1));
828 pp_c_inclusive_or_expression (ppi, e);
832 pp_c_logical_or_expression (ppi, e)
833 c_pretty_print_info *ppi;
836 if (TREE_CODE (e) == TRUTH_ORIF_EXPR)
838 pp_c_logical_or_expression (ppi, TREE_OPERAND (e, 0));
839 pp_c_maybe_whitespace (ppi);
840 pp_identifier (ppi, "||");
841 pp_c_whitespace (ppi);
842 pp_c_logical_and_expression (ppi, TREE_OPERAND (e, 1));
845 pp_c_logical_and_expression (ppi, e);
849 pp_c_conditional_expression (ppi, e)
850 c_pretty_print_info *ppi;
853 if (TREE_CODE (e) == COND_EXPR)
855 pp_c_logical_or_expression (ppi, TREE_OPERAND (e, 0));
856 pp_c_maybe_whitespace (ppi);
858 pp_c_whitespace (ppi);
859 pp_c_expression (ppi, TREE_OPERAND (e, 1));
860 pp_c_maybe_whitespace (ppi);
862 pp_c_whitespace (ppi);
863 pp_c_conditional_expression (ppi, TREE_OPERAND (e, 2));
866 pp_c_logical_or_expression (ppi, e);
870 /* Pretty-print a C assignment-expression. */
872 pp_c_assignment_expression (ppi, e)
873 c_pretty_print_info *ppi;
876 if (TREE_CODE (e) == MODIFY_EXPR || TREE_CODE (e) == INIT_EXPR)
878 pp_c_unary_expression (ppi, TREE_OPERAND (e, 0));
879 pp_c_maybe_whitespace (ppi);
882 pp_c_assignment_expression (ppi, TREE_OPERAND (e, 1));
885 pp_c_conditional_expression (ppi, e);
888 /* Pretty-print an expression. */
890 pp_c_expression (ppi, e)
891 c_pretty_print_info *ppi;
894 switch (TREE_CODE (e))
897 pp_c_integer_literal (ppi, e);
901 pp_c_real_literal (ppi, e);
905 pp_c_string_literal (ppi, e);
918 pp_c_primary_expression (ppi, e);
921 case POSTINCREMENT_EXPR:
922 case POSTDECREMENT_EXPR:
932 case COMPOUND_LITERAL_EXPR:
935 pp_c_postfix_expression (ppi, e);
944 case PREINCREMENT_EXPR:
945 case PREDECREMENT_EXPR:
950 pp_c_unary_expression (ppi, e);
955 pp_c_cast_expression (ppi, e);
961 pp_c_multiplicative_expression (ppi, e);
966 pp_c_shift_expression (ppi, e);
973 pp_c_relational_expression (ppi, e);
977 pp_c_and_expression (ppi, e);
981 pp_c_exclusive_or_expression (ppi, e);
985 pp_c_inclusive_or_expression (ppi, e);
988 case TRUTH_ANDIF_EXPR:
989 pp_c_logical_and_expression (ppi, e);
992 case TRUTH_ORIF_EXPR:
993 pp_c_logical_or_expression (ppi, e);
997 pp_c_conditional_expression (ppi, e);
1002 pp_c_assignment_expression (ppi, e);
1006 pp_c_expression (ppi, TREE_OPERAND (e, 0));
1010 pp_c_left_paren (ppi);
1011 pp_c_expression (ppi, TREE_OPERAND (e, 0));
1012 pp_separate_with (ppi, ',');
1013 pp_assignment_expression (ppi, TREE_OPERAND (e, 1));
1014 pp_c_right_paren (ppi);
1019 pp_unsupported_tree (ppi, e);
1027 pp_c_statement (ppi, stmt)
1028 c_pretty_print_info *ppi;
1031 const enum tree_code code = TREE_CODE (stmt);
1037 if (code == LABEL_STMT)
1038 pp_tree_identifier (ppi, DECL_NAME (LABEL_STMT_LABEL (stmt)));
1039 else if (code == LABEL_STMT)
1041 if (CASE_LOW (stmt) == NULL_TREE)
1042 pp_identifier (ppi, "default");
1045 pp_c_identifier (ppi, "case");
1046 pp_c_whitespace (ppi);
1047 pp_conditional_expression (ppi, CASE_LOW (stmt));
1048 if (CASE_HIGH (stmt))
1050 pp_identifier (ppi, "...");
1051 pp_conditional_expression (ppi, CASE_HIGH (stmt));
1056 pp_newline_and_indent (ppi, 3);
1060 pp_left_brace (ppi);
1061 pp_newline_and_indent (ppi, 3);
1062 for (stmt = COMPOUND_BODY (stmt); stmt; stmt = TREE_CHAIN (stmt))
1063 pp_c_statement (ppi, stmt);
1064 pp_newline_and_indent (ppi, -3);
1065 pp_right_brace (ppi);
1072 pp_c_expression (ppi, code == EXPR_STMT
1073 ? EXPR_STMT_EXPR (stmt)
1074 : CLEANUP_EXPR (stmt));
1080 pp_c_identifier (ppi, "if");
1081 pp_whitespace (ppi);
1082 pp_c_left_paren (ppi);
1083 pp_c_expression (ppi, IF_COND (stmt));
1084 pp_right_paren (ppi);
1085 pp_newline_and_indent (ppi, 3);
1086 pp_statement (ppi, THEN_CLAUSE (stmt));
1087 pp_newline_and_indent (ppi, -3);
1088 if (ELSE_CLAUSE (stmt))
1090 tree else_clause = ELSE_CLAUSE (stmt);
1091 pp_c_identifier (ppi, "else");
1092 if (TREE_CODE (else_clause) == IF_STMT)
1093 pp_c_whitespace (ppi);
1095 pp_newline_and_indent (ppi, 3);
1096 pp_statement (ppi, else_clause);
1097 if (TREE_CODE (else_clause) != IF_STMT)
1098 pp_newline_and_indent (ppi, -3);
1104 pp_c_identifier (ppi, "switch");
1105 pp_whitespace (ppi);
1106 pp_c_left_paren (ppi);
1107 pp_c_expression (ppi, SWITCH_COND (stmt));
1108 pp_right_paren (ppi);
1109 pp_newline_and_indent (ppi, 3);
1110 pp_statement (ppi, SWITCH_BODY (stmt));
1111 pp_newline_and_indent (ppi, -3);
1115 pp_c_identifier (ppi, "while");
1116 pp_whitespace (ppi);
1117 pp_c_left_paren (ppi);
1118 pp_c_expression (ppi, WHILE_COND (stmt));
1119 pp_right_paren (ppi);
1120 pp_newline_and_indent (ppi, 3);
1121 pp_statement (ppi, WHILE_BODY (stmt));
1122 pp_newline_and_indent (ppi, -3);
1126 pp_c_identifier (ppi, "do");
1127 pp_newline_and_indent (ppi, 3);
1128 pp_statement (ppi, DO_BODY (stmt));
1129 pp_newline_and_indent (ppi, -3);
1130 pp_c_identifier (ppi, "while");
1131 pp_whitespace (ppi);
1132 pp_c_left_paren (ppi);
1133 pp_c_expression (ppi, DO_COND (stmt));
1134 pp_c_right_paren (ppi);
1140 pp_c_identifier (ppi, "for");
1141 pp_whitespace (ppi);
1142 pp_c_left_paren (ppi);
1143 pp_statement (ppi, FOR_INIT_STMT (stmt));
1144 pp_c_whitespace (ppi);
1145 if (FOR_COND (stmt))
1146 pp_c_expression (ppi, FOR_COND (stmt));
1148 pp_c_whitespace (ppi);
1149 if (FOR_EXPR (stmt))
1150 pp_c_expression (ppi, FOR_EXPR (stmt));
1151 pp_right_paren (ppi);
1152 pp_newline_and_indent (ppi, 3);
1153 pp_statement (ppi, FOR_BODY (stmt));
1154 pp_newline_and_indent (ppi, -3);
1160 pp_identifier (ppi, code == BREAK_STMT ? "break" : "continue");
1168 tree e = code == RETURN_STMT
1169 ? RETURN_EXPR (stmt)
1170 : GOTO_DESTINATION (stmt);
1173 pp_c_identifier (ppi, code == RETURN_STMT ? "return" : "goto");
1175 pp_c_expression (ppi, e);
1182 if (!SCOPE_NULLIFIED_P (stmt) && SCOPE_NO_CLEANUPS_P (stmt))
1184 if (SCOPE_BEGIN_P (stmt))
1186 pp_left_brace (ppi);
1187 pp_newline_and_indent (ppi, 3);
1189 else if (SCOPE_END_P (stmt))
1191 pp_right_brace (ppi);
1192 pp_newline_and_indent (ppi, -3);
1198 pp_declaration (ppi, DECL_STMT_DECL (stmt));
1205 bool has_volatile_p = ASM_VOLATILE_P (stmt);
1206 bool is_extended = has_volatile_p || ASM_INPUTS (stmt)
1207 || ASM_OUTPUTS (stmt) || ASM_CLOBBERS (stmt);
1208 pp_c_identifier (ppi, is_extended ? "__asm__" : "asm");
1210 pp_c_identifier (ppi, "__volatile__");
1211 pp_whitespace (ppi);
1212 pp_c_left_paren (ppi);
1213 pp_c_string_literal (ppi, ASM_STRING (stmt));
1216 pp_whitespace (ppi);
1217 pp_separate_with (ppi, ':');
1218 if (ASM_OUTPUTS (stmt))
1219 pp_c_expression (ppi, ASM_OUTPUTS (stmt));
1220 pp_whitespace (ppi);
1221 pp_separate_with (ppi, ':');
1222 if (ASM_INPUTS (stmt))
1223 pp_c_expression (ppi, ASM_INPUTS (stmt));
1224 pp_whitespace (ppi);
1225 pp_separate_with (ppi, ':');
1226 if (ASM_CLOBBERS (stmt))
1227 pp_c_expression (ppi, ASM_CLOBBERS (stmt));
1229 pp_right_paren (ppi);
1235 pp_c_identifier (ppi, "__FILE__");
1236 pp_whitespace (ppi);
1238 pp_c_whitespace (ppi);
1239 pp_c_identifier (ppi, FILE_STMT_FILENAME (stmt));
1245 pp_unsupported_tree (ppi, stmt);