2004-07-28 Eric Christopher <echristo@redhat.com>
[official-gcc.git] / gcc / c-pretty-print.c
blob3ddef7a23852d0d660d8d44b1aba9526b3ecffe5
1 /* Subroutines common to both C and C++ pretty-printers.
2 Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
3 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
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
15 for more details.
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
20 02111-1307, USA. */
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "real.h"
27 #include "c-pretty-print.h"
28 #include "c-tree.h"
29 #include "tree-iterator.h"
30 #include "diagnostic.h"
32 /* The pretty-printer code is primarily designed to closely follow
33 (GNU) C and C++ grammars. That is to be contrasted with spaghetti
34 codes we used to have in the past. Following a structured
35 approach (preferably the official grammars) is believed to make it
36 much easier to add extensions and nifty pretty-printing effects that
37 takes expression or declaration contexts into account. */
40 #define pp_c_maybe_whitespace(PP) \
41 do { \
42 if (pp_base (PP)->padding == pp_before) \
43 pp_c_whitespace (PP); \
44 } while (0)
46 /* literal */
47 static void pp_c_char (c_pretty_printer *, int);
49 /* postfix-expression */
50 static void pp_c_initializer_list (c_pretty_printer *, tree);
51 static void pp_c_brace_enclosed_initializer_list (c_pretty_printer *, tree);
53 static void pp_c_multiplicative_expression (c_pretty_printer *, tree);
54 static void pp_c_additive_expression (c_pretty_printer *, tree);
55 static void pp_c_shift_expression (c_pretty_printer *, tree);
56 static void pp_c_relational_expression (c_pretty_printer *, tree);
57 static void pp_c_equality_expression (c_pretty_printer *, tree);
58 static void pp_c_and_expression (c_pretty_printer *, tree);
59 static void pp_c_exclusive_or_expression (c_pretty_printer *, tree);
60 static void pp_c_inclusive_or_expression (c_pretty_printer *, tree);
61 static void pp_c_logical_and_expression (c_pretty_printer *, tree);
62 static void pp_c_conditional_expression (c_pretty_printer *, tree);
63 static void pp_c_assignment_expression (c_pretty_printer *, tree);
65 /* declarations. */
68 /* Helper functions. */
70 void
71 pp_c_whitespace (c_pretty_printer *pp)
73 pp_space (pp);
74 pp_base (pp)->padding = pp_none;
77 void
78 pp_c_left_paren (c_pretty_printer *pp)
80 pp_left_paren (pp);
81 pp_base (pp)->padding = pp_none;
84 void
85 pp_c_right_paren (c_pretty_printer *pp)
87 pp_right_paren (pp);
88 pp_base (pp)->padding = pp_none;
91 void
92 pp_c_left_brace (c_pretty_printer *pp)
94 pp_left_brace (pp);
95 pp_base (pp)->padding = pp_none;
98 void
99 pp_c_right_brace (c_pretty_printer *pp)
101 pp_right_brace (pp);
102 pp_base (pp)->padding = pp_none;
105 void
106 pp_c_left_bracket (c_pretty_printer *pp)
108 pp_left_bracket (pp);
109 pp_base (pp)->padding = pp_none;
112 void
113 pp_c_right_bracket (c_pretty_printer *pp)
115 pp_right_bracket (pp);
116 pp_base (pp)->padding = pp_none;
119 void
120 pp_c_dot (c_pretty_printer *pp)
122 pp_dot (pp);
123 pp_base (pp)->padding = pp_none;
126 void
127 pp_c_ampersand (c_pretty_printer *pp)
129 pp_ampersand (pp);
130 pp_base (pp)->padding = pp_none;
133 void
134 pp_c_star (c_pretty_printer *pp)
136 pp_star (pp);
137 pp_base (pp)->padding = pp_none;
140 void
141 pp_c_arrow (c_pretty_printer *pp)
143 pp_arrow (pp);
144 pp_base (pp)->padding = pp_none;
147 void
148 pp_c_semicolon (c_pretty_printer *pp)
150 pp_semicolon (pp);
151 pp_base (pp)->padding = pp_none;
154 void
155 pp_c_complement (c_pretty_printer *pp)
157 pp_complement (pp);
158 pp_base (pp)->padding = pp_none;
161 void
162 pp_c_exclamation (c_pretty_printer *pp)
164 pp_exclamation (pp);
165 pp_base (pp)->padding = pp_none;
168 /* Print out the external representation of CV-QUALIFIER. */
170 static void
171 pp_c_cv_qualifier (c_pretty_printer *pp, const char *cv)
173 const char *p = pp_last_position_in_text (pp);
174 /* The C programming language does not have references, but it is much
175 simpler to handle those here rather than going through the same
176 logic in the C++ pretty-printer. */
177 if (p != NULL && (*p == '*' || *p == '&'))
178 pp_c_whitespace (pp);
179 pp_c_identifier (pp, cv);
182 /* Pretty-print T using the type-cast notation '( type-name )'. */
184 static void
185 pp_c_type_cast (c_pretty_printer *pp, tree t)
187 pp_c_left_paren (pp);
188 pp_type_id (pp, t);
189 pp_c_right_paren (pp);
192 /* We're about to pretty-print a pointer type as indicated by T.
193 Output a whitespace, if needed, preparing for subsequent output. */
195 void
196 pp_c_space_for_pointer_operator (c_pretty_printer *pp, tree t)
198 if (POINTER_TYPE_P (t))
200 tree pointee = strip_pointer_operator (TREE_TYPE (t));
201 if (TREE_CODE (pointee) != ARRAY_TYPE
202 && TREE_CODE (pointee) != FUNCTION_TYPE)
203 pp_c_whitespace (pp);
208 /* Declarations. */
210 /* C++ cv-qualifiers are called type-qualifiers in C. Print out the
211 cv-qualifiers of T. If T is a declaration then it is the cv-qualifier
212 of its type. Take care of possible extensions.
214 type-qualifier-list:
215 type-qualifier
216 type-qualifier-list type-qualifier
218 type-qualifier:
219 const
220 restrict -- C99
221 __restrict__ -- GNU C
222 volatile */
224 void
225 pp_c_type_qualifier_list (c_pretty_printer *pp, tree t)
227 int qualifiers;
229 if (!TYPE_P (t))
230 t = TREE_TYPE (t);
232 qualifiers = TYPE_QUALS (t);
233 if (qualifiers & TYPE_QUAL_CONST)
234 pp_c_cv_qualifier (pp, "const");
235 if (qualifiers & TYPE_QUAL_VOLATILE)
236 pp_c_cv_qualifier (pp, "volatile");
237 if (qualifiers & TYPE_QUAL_RESTRICT)
238 pp_c_cv_qualifier (pp, flag_isoc99 ? "restrict" : "__restrict__");
241 /* pointer:
242 * type-qualifier-list(opt)
243 * type-qualifier-list(opt) pointer */
245 static void
246 pp_c_pointer (c_pretty_printer *pp, tree t)
248 if (!TYPE_P (t) && TREE_CODE (t) != TYPE_DECL)
249 t = TREE_TYPE (t);
250 switch (TREE_CODE (t))
252 case POINTER_TYPE:
253 /* It is easier to handle C++ reference types here. */
254 case REFERENCE_TYPE:
255 if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE)
256 pp_c_pointer (pp, TREE_TYPE (t));
257 if (TREE_CODE (t) == POINTER_TYPE)
258 pp_c_star (pp);
259 else
260 pp_c_ampersand (pp);
261 pp_c_type_qualifier_list (pp, t);
262 break;
264 /* ??? This node is now in GENERIC and so shouldn't be here. But
265 we'll fix that later. */
266 case DECL_EXPR:
267 pp_declaration (pp, DECL_EXPR_DECL (t));
268 pp_needs_newline (pp) = true;
269 break;
271 default:
272 pp_unsupported_tree (pp, t);
276 /* type-specifier:
277 void
278 char
279 short
281 long
282 float
283 double
284 signed
285 unsigned
286 _Bool -- C99
287 _Complex -- C99
288 _Imaginary -- C99
289 struct-or-union-specifier
290 enum-specifier
291 typedef-name.
293 GNU extensions.
294 simple-type-specifier:
295 __complex__
296 __vector__ */
298 void
299 pp_c_type_specifier (c_pretty_printer *pp, tree t)
301 const enum tree_code code = TREE_CODE (t);
302 switch (code)
304 case ERROR_MARK:
305 pp_c_identifier (pp, "<type-error>");
306 break;
308 case IDENTIFIER_NODE:
309 pp_c_tree_decl_identifier (pp, t);
310 break;
312 case VOID_TYPE:
313 case BOOLEAN_TYPE:
314 case CHAR_TYPE:
315 case INTEGER_TYPE:
316 case REAL_TYPE:
317 if (TYPE_NAME (t))
318 t = TYPE_NAME (t);
319 else
320 t = c_common_type_for_mode (TYPE_MODE (t), TYPE_UNSIGNED (t));
321 pp_c_type_specifier (pp, t);
322 break;
324 case TYPE_DECL:
325 if (DECL_NAME (t))
326 pp_id_expression (pp, t);
327 else
328 pp_c_identifier (pp, "<typedef-error>");
329 break;
331 case UNION_TYPE:
332 case RECORD_TYPE:
333 case ENUMERAL_TYPE:
334 if (code == UNION_TYPE)
335 pp_c_identifier (pp, "union");
336 else if (code == RECORD_TYPE)
337 pp_c_identifier (pp, "struct");
338 else if (code == ENUMERAL_TYPE)
339 pp_c_identifier (pp, "enum");
340 else
341 pp_c_identifier (pp, "<tag-error>");
343 if (TYPE_NAME (t))
344 pp_id_expression (pp, TYPE_NAME (t));
345 else
346 pp_c_identifier (pp, "<anonymous>");
347 break;
349 default:
350 pp_unsupported_tree (pp, t);
351 break;
355 /* specifier-qualifier-list:
356 type-specifier specifier-qualifier-list-opt
357 type-qualifier specifier-qualifier-list-opt
360 Implementation note: Because of the non-linearities in array or
361 function declarations, this routine prints not just the
362 specifier-qualifier-list of such entities or types of such entities,
363 but also the 'pointer' production part of their declarators. The
364 remaining part is done by pp_declarator or pp_c_abstract_declarator. */
366 void
367 pp_c_specifier_qualifier_list (c_pretty_printer *pp, tree t)
369 const enum tree_code code = TREE_CODE (t);
371 if (TREE_CODE (t) != POINTER_TYPE)
372 pp_c_type_qualifier_list (pp, t);
373 switch (code)
375 case REFERENCE_TYPE:
376 case POINTER_TYPE:
378 /* Get the types-specifier of this type. */
379 tree pointee = strip_pointer_operator (TREE_TYPE (t));
380 pp_c_specifier_qualifier_list (pp, pointee);
381 if (TREE_CODE (pointee) == ARRAY_TYPE
382 || TREE_CODE (pointee) == FUNCTION_TYPE)
384 pp_c_whitespace (pp);
385 pp_c_left_paren (pp);
387 else if (!c_dialect_cxx ())
388 pp_c_whitespace (pp);
389 pp_ptr_operator (pp, t);
391 break;
393 case FUNCTION_TYPE:
394 case ARRAY_TYPE:
395 pp_c_specifier_qualifier_list (pp, TREE_TYPE (t));
396 break;
398 case VECTOR_TYPE:
399 case COMPLEX_TYPE:
400 pp_c_specifier_qualifier_list (pp, TREE_TYPE (t));
401 if (code == COMPLEX_TYPE)
402 pp_c_identifier (pp, flag_isoc99 ? "_Complex" : "__complex__");
403 else if (code == VECTOR_TYPE)
404 pp_c_identifier (pp, "__vector__");
405 break;
407 default:
408 pp_simple_type_specifier (pp, t);
409 break;
413 /* parameter-type-list:
414 parameter-list
415 parameter-list , ...
417 parameter-list:
418 parameter-declaration
419 parameter-list , parameter-declaration
421 parameter-declaration:
422 declaration-specifiers declarator
423 declaration-specifiers abstract-declarator(opt) */
425 void
426 pp_c_parameter_type_list (c_pretty_printer *pp, tree t)
428 bool want_parm_decl = DECL_P (t) && !(pp->flags & pp_c_flag_abstract);
429 tree parms = want_parm_decl ? DECL_ARGUMENTS (t) : TYPE_ARG_TYPES (t);
430 pp_c_left_paren (pp);
431 if (parms == void_list_node)
432 pp_c_identifier (pp, "void");
433 else
435 bool first = true;
436 for ( ; parms && parms != void_list_node; parms = TREE_CHAIN (parms))
438 if (!first)
439 pp_separate_with (pp, ',');
440 first = false;
441 pp_declaration_specifiers
442 (pp, want_parm_decl ? parms : TREE_VALUE (parms));
443 if (want_parm_decl)
444 pp_declarator (pp, parms);
445 else
446 pp_abstract_declarator (pp, TREE_VALUE (parms));
449 pp_c_right_paren (pp);
452 /* abstract-declarator:
453 pointer
454 pointer(opt) direct-abstract-declarator */
456 static void
457 pp_c_abstract_declarator (c_pretty_printer *pp, tree t)
459 if (TREE_CODE (t) == POINTER_TYPE)
461 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
462 || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
463 pp_c_right_paren (pp);
464 t = TREE_TYPE (t);
467 pp_direct_abstract_declarator (pp, t);
470 /* direct-abstract-declarator:
471 ( abstract-declarator )
472 direct-abstract-declarator(opt) [ assignment-expression(opt) ]
473 direct-abstract-declarator(opt) [ * ]
474 direct-abstract-declarator(opt) ( parameter-type-list(opt) ) */
476 void
477 pp_c_direct_abstract_declarator (c_pretty_printer *pp, tree t)
479 switch (TREE_CODE (t))
481 case POINTER_TYPE:
482 pp_abstract_declarator (pp, t);
483 break;
485 case FUNCTION_TYPE:
486 pp_c_parameter_type_list (pp, t);
487 pp_direct_abstract_declarator (pp, TREE_TYPE (t));
488 break;
490 case ARRAY_TYPE:
491 pp_c_left_bracket (pp);
492 if (TYPE_DOMAIN (t) && TYPE_MAX_VALUE (TYPE_DOMAIN (t)))
493 pp_expression (pp, TYPE_MAX_VALUE (TYPE_DOMAIN (t)));
494 pp_c_right_bracket (pp);
495 pp_direct_abstract_declarator (pp, TREE_TYPE (t));
496 break;
498 case IDENTIFIER_NODE:
499 case VOID_TYPE:
500 case BOOLEAN_TYPE:
501 case INTEGER_TYPE:
502 case REAL_TYPE:
503 case ENUMERAL_TYPE:
504 case RECORD_TYPE:
505 case UNION_TYPE:
506 case VECTOR_TYPE:
507 case COMPLEX_TYPE:
508 case TYPE_DECL:
509 break;
511 default:
512 pp_unsupported_tree (pp, t);
513 break;
517 /* type-name:
518 specifier-qualifier-list abstract-declarator(opt) */
520 void
521 pp_c_type_id (c_pretty_printer *pp, tree t)
523 pp_c_specifier_qualifier_list (pp, t);
524 pp_abstract_declarator (pp, t);
527 /* storage-class-specifier:
528 typedef
529 extern
530 static
531 auto
532 register */
534 void
535 pp_c_storage_class_specifier (c_pretty_printer *pp, tree t)
537 if (TREE_CODE (t) == TYPE_DECL)
538 pp_c_identifier (pp, "typedef");
539 else if (DECL_P (t))
541 if (DECL_REGISTER (t))
542 pp_c_identifier (pp, "register");
543 else if (TREE_STATIC (t) && TREE_CODE (t) == VAR_DECL)
544 pp_c_identifier (pp, "static");
548 /* function-specifier:
549 inline */
551 void
552 pp_c_function_specifier (c_pretty_printer *pp, tree t)
554 if (TREE_CODE (t) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (t))
555 pp_c_identifier (pp, "inline");
558 /* declaration-specifiers:
559 storage-class-specifier declaration-specifiers(opt)
560 type-specifier declaration-specifiers(opt)
561 type-qualifier declaration-specifiers(opt)
562 function-specifier declaration-specifiers(opt) */
564 void
565 pp_c_declaration_specifiers (c_pretty_printer *pp, tree t)
567 pp_storage_class_specifier (pp, t);
568 pp_function_specifier (pp, t);
569 pp_c_specifier_qualifier_list (pp, DECL_P (t) ? TREE_TYPE (t) : t);
572 /* direct-declarator
573 identifier
574 ( declarator )
575 direct-declarator [ type-qualifier-list(opt) assignment-expression(opt) ]
576 direct-declarator [ static type-qualifier-list(opt) assignment-expression(opt)]
577 direct-declarator [ type-qualifier-list static assignment-expression ]
578 direct-declarator [ type-qualifier-list * ]
579 direct-declarator ( parameter-type-list )
580 direct-declarator ( identifier-list(opt) ) */
582 void
583 pp_c_direct_declarator (c_pretty_printer *pp, tree t)
585 switch (TREE_CODE (t))
587 case VAR_DECL:
588 case PARM_DECL:
589 case TYPE_DECL:
590 case FIELD_DECL:
591 case LABEL_DECL:
592 pp_c_space_for_pointer_operator (pp, TREE_TYPE (t));
593 pp_c_tree_decl_identifier (pp, t);
594 break;
596 case ARRAY_TYPE:
597 case POINTER_TYPE:
598 pp_abstract_declarator (pp, TREE_TYPE (t));
599 break;
601 case FUNCTION_TYPE:
602 pp_parameter_list (pp, t);
603 pp_abstract_declarator (pp, TREE_TYPE (t));
604 break;
606 case FUNCTION_DECL:
607 pp_c_space_for_pointer_operator (pp, TREE_TYPE (TREE_TYPE (t)));
608 pp_c_tree_decl_identifier (pp, t);
609 if (pp_c_base (pp)->flags & pp_c_flag_abstract)
610 pp_abstract_declarator (pp, TREE_TYPE (t));
611 else
613 pp_parameter_list (pp, t);
614 pp_abstract_declarator (pp, TREE_TYPE (TREE_TYPE (t)));
616 break;
618 case INTEGER_TYPE:
619 case REAL_TYPE:
620 case ENUMERAL_TYPE:
621 case UNION_TYPE:
622 case RECORD_TYPE:
623 break;
625 default:
626 pp_unsupported_tree (pp, t);
627 break;
632 /* declarator:
633 pointer(opt) direct-declarator */
635 void
636 pp_c_declarator (c_pretty_printer *pp, tree t)
638 switch (TREE_CODE (t))
640 case INTEGER_TYPE:
641 case REAL_TYPE:
642 case ENUMERAL_TYPE:
643 case UNION_TYPE:
644 case RECORD_TYPE:
645 break;
647 case VAR_DECL:
648 case PARM_DECL:
649 case FIELD_DECL:
650 case ARRAY_TYPE:
651 case FUNCTION_TYPE:
652 case FUNCTION_DECL:
653 case TYPE_DECL:
654 pp_direct_declarator (pp, t);
655 break;
658 default:
659 pp_unsupported_tree (pp, t);
660 break;
664 /* declaration:
665 declaration-specifiers init-declarator-list(opt) ; */
667 void
668 pp_c_declaration (c_pretty_printer *pp, tree t)
670 pp_declaration_specifiers (pp, t);
671 pp_c_init_declarator (pp, t);
674 /* Pretty-print ATTRIBUTES using GNU C extension syntax. */
676 void
677 pp_c_attributes (c_pretty_printer *pp, tree attributes)
679 if (attributes == NULL_TREE)
680 return;
682 pp_c_identifier (pp, "__attribute__");
683 pp_c_left_paren (pp);
684 pp_c_left_paren (pp);
685 for (; attributes != NULL_TREE; attributes = TREE_CHAIN (attributes))
687 pp_tree_identifier (pp, TREE_PURPOSE (attributes));
688 if (TREE_VALUE (attributes))
689 pp_c_call_argument_list (pp, TREE_VALUE (attributes));
691 if (TREE_CHAIN (attributes))
692 pp_separate_with (pp, ',');
694 pp_c_right_paren (pp);
695 pp_c_right_paren (pp);
698 /* function-definition:
699 declaration-specifiers declarator compound-statement */
701 void
702 pp_c_function_definition (c_pretty_printer *pp, tree t)
704 pp_declaration_specifiers (pp, t);
705 pp_declarator (pp, t);
706 pp_needs_newline (pp) = true;
707 pp_statement (pp, DECL_SAVED_TREE (t));
708 pp_newline (pp);
709 pp_flush (pp);
713 /* Expressions. */
715 /* Print out a c-char. */
717 static void
718 pp_c_char (c_pretty_printer *pp, int c)
720 switch (c)
722 case TARGET_NEWLINE:
723 pp_string (pp, "\\n");
724 break;
725 case TARGET_TAB:
726 pp_string (pp, "\\t");
727 break;
728 case TARGET_VT:
729 pp_string (pp, "\\v");
730 break;
731 case TARGET_BS:
732 pp_string (pp, "\\b");
733 break;
734 case TARGET_CR:
735 pp_string (pp, "\\r");
736 break;
737 case TARGET_FF:
738 pp_string (pp, "\\f");
739 break;
740 case TARGET_BELL:
741 pp_string (pp, "\\a");
742 break;
743 case '\\':
744 pp_string (pp, "\\\\");
745 break;
746 case '\'':
747 pp_string (pp, "\\'");
748 break;
749 case '\"':
750 pp_string (pp, "\\\"");
751 break;
752 default:
753 if (ISPRINT (c))
754 pp_character (pp, c);
755 else
756 pp_scalar (pp, "\\%03o", (unsigned) c);
757 break;
761 /* Print out a STRING literal. */
763 void
764 pp_c_string_literal (c_pretty_printer *pp, tree s)
766 const char *p = TREE_STRING_POINTER (s);
767 int n = TREE_STRING_LENGTH (s) - 1;
768 int i;
769 pp_doublequote (pp);
770 for (i = 0; i < n; ++i)
771 pp_c_char (pp, p[i]);
772 pp_doublequote (pp);
775 /* Pretty-print an INTEGER literal. */
777 static void
778 pp_c_integer_constant (c_pretty_printer *pp, tree i)
780 tree type = TREE_TYPE (i);
782 if (TREE_INT_CST_HIGH (i) == 0)
783 pp_wide_integer (pp, TREE_INT_CST_LOW (i));
784 else
786 if (tree_int_cst_sgn (i) < 0)
788 pp_c_char (pp, '-');
789 i = build_int_2 (-TREE_INT_CST_LOW (i),
790 ~TREE_INT_CST_HIGH (i) + !TREE_INT_CST_LOW (i));
792 sprintf (pp_buffer (pp)->digit_buffer,
793 HOST_WIDE_INT_PRINT_DOUBLE_HEX,
794 TREE_INT_CST_HIGH (i), TREE_INT_CST_LOW (i));
795 pp_string (pp, pp_buffer (pp)->digit_buffer);
797 if (TYPE_UNSIGNED (type))
798 pp_character (pp, 'u');
799 if (type == long_integer_type_node || type == long_unsigned_type_node)
800 pp_character (pp, 'l');
801 else if (type == long_long_integer_type_node
802 || type == long_long_unsigned_type_node)
803 pp_string (pp, "ll");
806 /* Print out a CHARACTER literal. */
808 static void
809 pp_c_character_constant (c_pretty_printer *pp, tree c)
811 tree type = TREE_TYPE (c);
812 if (type == wchar_type_node)
813 pp_character (pp, 'L');
814 pp_quote (pp);
815 if (host_integerp (c, TYPE_UNSIGNED (type)))
816 pp_c_char (pp, tree_low_cst (c, TYPE_UNSIGNED (type)));
817 else
818 pp_scalar (pp, "\\x%x", (unsigned) TREE_INT_CST_LOW (c));
819 pp_quote (pp);
822 /* Print out a BOOLEAN literal. */
824 static void
825 pp_c_bool_constant (c_pretty_printer *pp, tree b)
827 if (b == boolean_false_node)
829 if (c_dialect_cxx ())
830 pp_c_identifier (pp, "false");
831 else if (flag_isoc99)
832 pp_c_identifier (pp, "_False");
833 else
834 pp_unsupported_tree (pp, b);
836 else if (b == boolean_true_node)
838 if (c_dialect_cxx ())
839 pp_c_identifier (pp, "true");
840 else if (flag_isoc99)
841 pp_c_identifier (pp, "_True");
842 else
843 pp_unsupported_tree (pp, b);
845 else if (TREE_CODE (b) == INTEGER_CST)
846 pp_c_integer_constant (pp, b);
847 else
848 pp_unsupported_tree (pp, b);
851 /* Attempt to print out an ENUMERATOR. Return true on success. Else return
852 false; that means the value was obtained by a cast, in which case
853 print out the type-id part of the cast-expression -- the casted value
854 is then printed by pp_c_integer_literal. */
856 static bool
857 pp_c_enumeration_constant (c_pretty_printer *pp, tree e)
859 bool value_is_named = true;
860 tree type = TREE_TYPE (e);
861 tree value;
863 /* Find the name of this constant. */
864 for (value = TYPE_VALUES (type);
865 value != NULL_TREE && !tree_int_cst_equal (TREE_VALUE (value), e);
866 value = TREE_CHAIN (value))
869 if (value != NULL_TREE)
870 pp_id_expression (pp, TREE_PURPOSE (value));
871 else
873 /* Value must have been cast. */
874 pp_c_type_cast (pp, type);
875 value_is_named = false;
878 return value_is_named;
881 /* Print out a REAL value as a decimal-floating-constant. */
883 static void
884 pp_c_floating_constant (c_pretty_printer *pp, tree r)
886 real_to_decimal (pp_buffer (pp)->digit_buffer, &TREE_REAL_CST (r),
887 sizeof (pp_buffer (pp)->digit_buffer), 0, 1);
888 pp_string (pp, pp_buffer(pp)->digit_buffer);
889 if (TREE_TYPE (r) == float_type_node)
890 pp_character (pp, 'f');
891 else if (TREE_TYPE (r) == long_double_type_node)
892 pp_character (pp, 'l');
895 /* Pretty-print a compound literal expression. GNU extensions include
896 vector constants. */
898 static void
899 pp_c_compound_literal (c_pretty_printer *pp, tree e)
901 tree type = TREE_TYPE (e);
902 pp_c_type_cast (pp, type);
904 switch (TREE_CODE (type))
906 case RECORD_TYPE:
907 case UNION_TYPE:
908 case ARRAY_TYPE:
909 case VECTOR_TYPE:
910 case COMPLEX_TYPE:
911 pp_c_brace_enclosed_initializer_list (pp, e);
912 break;
914 default:
915 pp_unsupported_tree (pp, e);
916 break;
920 /* constant:
921 integer-constant
922 floating-constant
923 enumeration-constant
924 character-constant */
926 void
927 pp_c_constant (c_pretty_printer *pp, tree e)
929 const enum tree_code code = TREE_CODE (e);
931 switch (code)
933 case INTEGER_CST:
935 tree type = TREE_TYPE (e);
936 if (type == boolean_type_node)
937 pp_c_bool_constant (pp, e);
938 else if (type == char_type_node)
939 pp_c_character_constant (pp, e);
940 else if (TREE_CODE (type) == ENUMERAL_TYPE
941 && pp_c_enumeration_constant (pp, e))
943 else
944 pp_c_integer_constant (pp, e);
946 break;
948 case REAL_CST:
949 pp_c_floating_constant (pp, e);
950 break;
952 case STRING_CST:
953 pp_c_string_literal (pp, e);
954 break;
956 default:
957 pp_unsupported_tree (pp, e);
958 break;
962 /* Pretty-print an IDENTIFIER_NODE, preceded by whitespace is necessary. */
964 void
965 pp_c_identifier (c_pretty_printer *pp, const char *id)
967 pp_c_maybe_whitespace (pp);
968 pp_identifier (pp, id);
969 pp_base (pp)->padding = pp_before;
972 /* Pretty-print a C primary-expression.
973 primary-expression:
974 identifier
975 constant
976 string-literal
977 ( expression ) */
979 void
980 pp_c_primary_expression (c_pretty_printer *pp, tree e)
982 switch (TREE_CODE (e))
984 case VAR_DECL:
985 case PARM_DECL:
986 case FIELD_DECL:
987 case CONST_DECL:
988 case FUNCTION_DECL:
989 case LABEL_DECL:
990 pp_c_tree_decl_identifier (pp, e);
991 break;
993 case IDENTIFIER_NODE:
994 pp_c_tree_identifier (pp, e);
995 break;
997 case ERROR_MARK:
998 pp_c_identifier (pp, "<erroneous-expression>");
999 break;
1001 case RESULT_DECL:
1002 pp_c_identifier (pp, "<return-value>");
1003 break;
1005 case INTEGER_CST:
1006 case REAL_CST:
1007 case STRING_CST:
1008 pp_c_constant (pp, e);
1009 break;
1011 case TARGET_EXPR:
1012 pp_c_identifier (pp, "__builtin_memcpy");
1013 pp_c_left_paren (pp);
1014 pp_ampersand (pp);
1015 pp_primary_expression (pp, TREE_OPERAND (e, 0));
1016 pp_separate_with (pp, ',');
1017 pp_ampersand (pp);
1018 pp_initializer (pp, TREE_OPERAND (e, 1));
1019 if (TREE_OPERAND (e, 2))
1021 pp_separate_with (pp, ',');
1022 pp_c_expression (pp, TREE_OPERAND (e, 2));
1024 pp_c_right_paren (pp);
1025 break;
1027 case STMT_EXPR:
1028 pp_c_left_paren (pp);
1029 pp_statement (pp, STMT_EXPR_STMT (e));
1030 pp_c_right_paren (pp);
1031 break;
1033 default:
1034 /* FIXME: Make sure we won't get into an infinie loop. */
1035 pp_c_left_paren (pp);
1036 pp_expression (pp, e);
1037 pp_c_right_paren (pp);
1038 break;
1042 /* Print out a C initializer -- also support C compound-literals.
1043 initializer:
1044 assignment-expression:
1045 { initializer-list }
1046 { initializer-list , } */
1048 static void
1049 pp_c_initializer (c_pretty_printer *pp, tree e)
1051 if (TREE_CODE (e) == CONSTRUCTOR)
1052 pp_c_brace_enclosed_initializer_list (pp, e);
1053 else
1054 pp_expression (pp, e);
1057 /* init-declarator:
1058 declarator:
1059 declarator = initializer */
1061 void
1062 pp_c_init_declarator (c_pretty_printer *pp, tree t)
1064 pp_declarator (pp, t);
1065 /* We don't want to output function definitions here. There are handled
1066 elsewhere (and the syntactic form is bogus anyway). */
1067 if (TREE_CODE (t) != FUNCTION_DECL && DECL_INITIAL (t))
1069 tree init = DECL_INITIAL (t);
1070 /* This C++ bit is handled here because it is easier to do so.
1071 In templates, the C++ parser builds a TREE_LIST for a
1072 direct-initialization; the TREE_PURPOSE is the variable to
1073 initialize and the TREE_VALUE is the initializer. */
1074 if (TREE_CODE (init) == TREE_LIST)
1076 pp_c_left_paren (pp);
1077 pp_expression (pp, TREE_VALUE (init));
1078 pp_right_paren (pp);
1080 else
1082 pp_space (pp);
1083 pp_equal (pp);
1084 pp_space (pp);
1085 pp_c_initializer (pp, init);
1090 /* initializer-list:
1091 designation(opt) initializer
1092 initializer-list , designation(opt) initializer
1094 designation:
1095 designator-list =
1097 designator-list:
1098 designator
1099 designator-list designator
1101 designator:
1102 [ constant-expression ]
1103 identifier */
1105 static void
1106 pp_c_initializer_list (c_pretty_printer *pp, tree e)
1108 tree type = TREE_TYPE (e);
1109 const enum tree_code code = TREE_CODE (type);
1111 switch (code)
1113 case RECORD_TYPE:
1114 case UNION_TYPE:
1115 case ARRAY_TYPE:
1117 tree init = TREE_OPERAND (e, 0);
1118 for (; init != NULL_TREE; init = TREE_CHAIN (init))
1120 if (code == RECORD_TYPE || code == UNION_TYPE)
1122 pp_c_dot (pp);
1123 pp_c_primary_expression (pp, TREE_PURPOSE (init));
1125 else
1127 pp_c_left_bracket (pp);
1128 if (TREE_PURPOSE (init))
1129 pp_c_constant (pp, TREE_PURPOSE (init));
1130 pp_c_right_bracket (pp);
1132 pp_c_whitespace (pp);
1133 pp_equal (pp);
1134 pp_c_whitespace (pp);
1135 pp_initializer (pp, TREE_VALUE (init));
1136 if (TREE_CHAIN (init))
1137 pp_separate_with (pp, ',');
1140 return;
1142 case VECTOR_TYPE:
1143 if (TREE_CODE (e) == VECTOR_CST)
1144 pp_c_expression_list (pp, TREE_VECTOR_CST_ELTS (e));
1145 else if (TREE_CODE (e) == CONSTRUCTOR)
1146 pp_c_expression_list (pp, CONSTRUCTOR_ELTS (e));
1147 else
1148 break;
1149 return;
1151 case COMPLEX_TYPE:
1152 if (TREE_CODE (e) == CONSTRUCTOR)
1153 pp_c_expression_list (pp, CONSTRUCTOR_ELTS (e));
1154 else if (TREE_CODE (e) == COMPLEX_CST || TREE_CODE (e) == COMPLEX_EXPR)
1156 const bool cst = TREE_CODE (e) == COMPLEX_CST;
1157 pp_expression (pp, cst ? TREE_REALPART (e) : TREE_OPERAND (e, 0));
1158 pp_separate_with (pp, ',');
1159 pp_expression (pp, cst ? TREE_IMAGPART (e) : TREE_OPERAND (e, 1));
1161 else
1162 break;
1163 return;
1165 default:
1166 break;
1169 pp_unsupported_tree (pp, type);
1172 /* Pretty-print a brace-enclosed initializer-list. */
1174 static void
1175 pp_c_brace_enclosed_initializer_list (c_pretty_printer *pp, tree l)
1177 pp_c_left_brace (pp);
1178 pp_c_initializer_list (pp, l);
1179 pp_c_right_brace (pp);
1183 /* This is a convenient function, used to bridge gap between C and C++
1184 grammars.
1186 id-expression:
1187 identifier */
1189 void
1190 pp_c_id_expression (c_pretty_printer *pp, tree t)
1192 switch (TREE_CODE (t))
1194 case VAR_DECL:
1195 case PARM_DECL:
1196 case CONST_DECL:
1197 case TYPE_DECL:
1198 case FUNCTION_DECL:
1199 case FIELD_DECL:
1200 case LABEL_DECL:
1201 pp_c_tree_decl_identifier (pp, t);
1202 break;
1204 case IDENTIFIER_NODE:
1205 pp_c_tree_identifier (pp, t);
1206 break;
1208 default:
1209 pp_unsupported_tree (pp, t);
1210 break;
1214 /* postfix-expression:
1215 primary-expression
1216 postfix-expression [ expression ]
1217 postfix-expression ( argument-expression-list(opt) )
1218 postfix-expression . identifier
1219 postfix-expression -> identifier
1220 postfix-expression ++
1221 postfix-expression --
1222 ( type-name ) { initializer-list }
1223 ( type-name ) { initializer-list , } */
1225 void
1226 pp_c_postfix_expression (c_pretty_printer *pp, tree e)
1228 enum tree_code code = TREE_CODE (e);
1229 switch (code)
1231 case POSTINCREMENT_EXPR:
1232 case POSTDECREMENT_EXPR:
1233 pp_postfix_expression (pp, TREE_OPERAND (e, 0));
1234 pp_identifier (pp, code == POSTINCREMENT_EXPR ? "++" : "--");
1235 break;
1237 case ARROW_EXPR:
1238 pp_postfix_expression (pp, TREE_OPERAND (e, 0));
1239 pp_c_arrow (pp);
1240 break;
1242 case ARRAY_REF:
1243 pp_postfix_expression (pp, TREE_OPERAND (e, 0));
1244 pp_c_left_bracket (pp);
1245 pp_expression (pp, TREE_OPERAND (e, 1));
1246 pp_c_right_bracket (pp);
1247 break;
1249 case CALL_EXPR:
1250 pp_postfix_expression (pp, TREE_OPERAND (e, 0));
1251 pp_c_call_argument_list (pp, TREE_OPERAND (e, 1));
1252 break;
1254 case UNORDERED_EXPR:
1255 pp_c_identifier (pp, flag_isoc99
1256 ? "isunordered"
1257 : "__builtin_isunordered");
1258 goto two_args_fun;
1260 case ORDERED_EXPR:
1261 pp_c_identifier (pp, flag_isoc99
1262 ? "!isunordered"
1263 : "!__builtin_isunordered");
1264 goto two_args_fun;
1266 case UNLT_EXPR:
1267 pp_c_identifier (pp, flag_isoc99
1268 ? "!isgreaterequal"
1269 : "!__builtin_isgreaterequal");
1270 goto two_args_fun;
1272 case UNLE_EXPR:
1273 pp_c_identifier (pp, flag_isoc99
1274 ? "!isgreater"
1275 : "!__builtin_isgreater");
1276 goto two_args_fun;
1278 case UNGT_EXPR:
1279 pp_c_identifier (pp, flag_isoc99
1280 ? "!islessequal"
1281 : "!__builtin_islessequal");
1282 goto two_args_fun;
1284 case UNGE_EXPR:
1285 pp_c_identifier (pp, flag_isoc99
1286 ? "!isless"
1287 : "!__builtin_isless");
1288 goto two_args_fun;
1290 case UNEQ_EXPR:
1291 pp_c_identifier (pp, flag_isoc99
1292 ? "!islessgreater"
1293 : "!__builtin_islessgreater");
1294 goto two_args_fun;
1296 case LTGT_EXPR:
1297 pp_c_identifier (pp, flag_isoc99
1298 ? "islessgreater"
1299 : "__builtin_islessgreater");
1300 goto two_args_fun;
1302 two_args_fun:
1303 pp_c_left_paren (pp);
1304 pp_expression (pp, TREE_OPERAND (e, 0));
1305 pp_separate_with (pp, ',');
1306 pp_expression (pp, TREE_OPERAND (e, 1));
1307 pp_c_right_paren (pp);
1308 break;
1310 case ABS_EXPR:
1311 pp_c_identifier (pp, "__builtin_abs");
1312 pp_c_left_paren (pp);
1313 pp_expression (pp, TREE_OPERAND (e, 0));
1314 pp_c_right_paren (pp);
1315 break;
1317 case COMPONENT_REF:
1319 tree object = TREE_OPERAND (e, 0);
1320 if (TREE_CODE (object) == INDIRECT_REF)
1322 pp_postfix_expression (pp, TREE_OPERAND (object, 0));
1323 pp_c_arrow (pp);
1325 else
1327 pp_postfix_expression (pp, object);
1328 pp_c_dot (pp);
1330 pp_expression (pp, TREE_OPERAND (e, 1));
1332 break;
1334 case COMPLEX_CST:
1335 case VECTOR_CST:
1336 case COMPLEX_EXPR:
1337 pp_c_compound_literal (pp, e);
1338 break;
1340 case COMPOUND_LITERAL_EXPR:
1341 e = DECL_INITIAL (COMPOUND_LITERAL_EXPR_DECL (e));
1342 /* Fall through. */
1343 case CONSTRUCTOR:
1344 pp_initializer (pp, e);
1345 break;
1347 case VA_ARG_EXPR:
1348 pp_c_identifier (pp, "__builtin_va_arg");
1349 pp_c_left_paren (pp);
1350 pp_assignment_expression (pp, TREE_OPERAND (e, 0));
1351 pp_separate_with (pp, ',');
1352 pp_type_id (pp, TREE_TYPE (e));
1353 pp_c_right_paren (pp);
1354 break;
1356 case ADDR_EXPR:
1357 if (TREE_CODE (TREE_OPERAND (e, 0)) == FUNCTION_DECL)
1359 pp_c_id_expression (pp, TREE_OPERAND (e, 0));
1360 break;
1362 /* else fall through. */
1364 default:
1365 pp_primary_expression (pp, e);
1366 break;
1370 /* Print out an expression-list; E is expected to be a TREE_LIST. */
1372 void
1373 pp_c_expression_list (c_pretty_printer *pp, tree e)
1375 for (; e != NULL_TREE; e = TREE_CHAIN (e))
1377 pp_expression (pp, TREE_VALUE (e));
1378 if (TREE_CHAIN (e))
1379 pp_separate_with (pp, ',');
1383 /* Print out an expression-list in parens, as in a function call. */
1385 void
1386 pp_c_call_argument_list (c_pretty_printer *pp, tree t)
1388 pp_c_left_paren (pp);
1389 if (t && TREE_CODE (t) == TREE_LIST)
1390 pp_c_expression_list (pp, t);
1391 pp_c_right_paren (pp);
1394 /* unary-expression:
1395 postfix-expression
1396 ++ cast-expression
1397 -- cast-expression
1398 unary-operator cast-expression
1399 sizeof unary-expression
1400 sizeof ( type-id )
1402 unary-operator: one of
1403 * & + - ! ~
1405 GNU extensions.
1406 unary-expression:
1407 __alignof__ unary-expression
1408 __alignof__ ( type-id )
1409 __real__ unary-expression
1410 __imag__ unary-expression */
1412 void
1413 pp_c_unary_expression (c_pretty_printer *pp, tree e)
1415 enum tree_code code = TREE_CODE (e);
1416 switch (code)
1418 case PREINCREMENT_EXPR:
1419 case PREDECREMENT_EXPR:
1420 pp_identifier (pp, code == PREINCREMENT_EXPR ? "++" : "--");
1421 pp_c_unary_expression (pp, TREE_OPERAND (e, 0));
1422 break;
1424 case ADDR_EXPR:
1425 case INDIRECT_REF:
1426 case NEGATE_EXPR:
1427 case BIT_NOT_EXPR:
1428 case TRUTH_NOT_EXPR:
1429 case CONJ_EXPR:
1430 /* String literal are used by address. */
1431 if (code == ADDR_EXPR && TREE_CODE (TREE_OPERAND (e, 0)) != STRING_CST)
1432 pp_ampersand (pp);
1433 else if (code == INDIRECT_REF)
1434 pp_c_star (pp);
1435 else if (code == NEGATE_EXPR)
1436 pp_minus (pp);
1437 else if (code == BIT_NOT_EXPR || code == CONJ_EXPR)
1438 pp_complement (pp);
1439 else if (code == TRUTH_NOT_EXPR)
1440 pp_exclamation (pp);
1441 pp_c_cast_expression (pp, TREE_OPERAND (e, 0));
1442 break;
1444 case SIZEOF_EXPR:
1445 case ALIGNOF_EXPR:
1446 pp_c_identifier (pp, code == SIZEOF_EXPR ? "sizeof" : "__alignof__");
1447 pp_c_whitespace (pp);
1448 if (TYPE_P (TREE_OPERAND (e, 0)))
1449 pp_c_type_cast (pp, TREE_OPERAND (e, 0));
1450 else
1451 pp_unary_expression (pp, TREE_OPERAND (e, 0));
1452 break;
1454 case REALPART_EXPR:
1455 case IMAGPART_EXPR:
1456 pp_c_identifier (pp, code == REALPART_EXPR ? "__real__" : "__imag__");
1457 pp_c_whitespace (pp);
1458 pp_unary_expression (pp, TREE_OPERAND (e, 0));
1459 break;
1461 default:
1462 pp_postfix_expression (pp, e);
1463 break;
1467 /* cast-expression:
1468 unary-expression
1469 ( type-name ) cast-expression */
1471 void
1472 pp_c_cast_expression (c_pretty_printer *pp, tree e)
1474 switch (TREE_CODE (e))
1476 case FLOAT_EXPR:
1477 case FIX_TRUNC_EXPR:
1478 case CONVERT_EXPR:
1479 pp_c_type_cast (pp, TREE_TYPE (e));
1480 pp_c_cast_expression (pp, TREE_OPERAND (e, 0));
1481 break;
1483 default:
1484 pp_unary_expression (pp, e);
1488 /* multiplicative-expression:
1489 cast-expression
1490 multiplicative-expression * cast-expression
1491 multiplicative-expression / cast-expression
1492 multiplicative-expression % cast-expression */
1494 static void
1495 pp_c_multiplicative_expression (c_pretty_printer *pp, tree e)
1497 enum tree_code code = TREE_CODE (e);
1498 switch (code)
1500 case MULT_EXPR:
1501 case TRUNC_DIV_EXPR:
1502 case TRUNC_MOD_EXPR:
1503 pp_multiplicative_expression (pp, TREE_OPERAND (e, 0));
1504 pp_c_whitespace (pp);
1505 if (code == MULT_EXPR)
1506 pp_c_star (pp);
1507 else if (code == TRUNC_DIV_EXPR)
1508 pp_slash (pp);
1509 else
1510 pp_modulo (pp);
1511 pp_c_whitespace (pp);
1512 pp_c_cast_expression (pp, TREE_OPERAND (e, 1));
1513 break;
1515 default:
1516 pp_c_cast_expression (pp, e);
1517 break;
1521 /* additive-expression:
1522 multiplicative-expression
1523 additive-expression + multiplicative-expression
1524 additive-expression - multiplicative-expression */
1526 static void
1527 pp_c_additive_expression (c_pretty_printer *pp, tree e)
1529 enum tree_code code = TREE_CODE (e);
1530 switch (code)
1532 case PLUS_EXPR:
1533 case MINUS_EXPR:
1534 pp_c_additive_expression (pp, TREE_OPERAND (e, 0));
1535 pp_c_whitespace (pp);
1536 if (code == PLUS_EXPR)
1537 pp_plus (pp);
1538 else
1539 pp_minus (pp);
1540 pp_c_whitespace (pp);
1541 pp_multiplicative_expression (pp, TREE_OPERAND (e, 1));
1542 break;
1544 default:
1545 pp_multiplicative_expression (pp, e);
1546 break;
1550 /* additive-expression:
1551 additive-expression
1552 shift-expression << additive-expression
1553 shift-expression >> additive-expression */
1555 static void
1556 pp_c_shift_expression (c_pretty_printer *pp, tree e)
1558 enum tree_code code = TREE_CODE (e);
1559 switch (code)
1561 case LSHIFT_EXPR:
1562 case RSHIFT_EXPR:
1563 pp_c_shift_expression (pp, TREE_OPERAND (e, 0));
1564 pp_c_whitespace (pp);
1565 pp_identifier (pp, code == LSHIFT_EXPR ? "<<" : ">>");
1566 pp_c_whitespace (pp);
1567 pp_c_additive_expression (pp, TREE_OPERAND (e, 1));
1568 break;
1570 default:
1571 pp_c_additive_expression (pp, e);
1575 /* relational-expression:
1576 shift-expression
1577 relational-expression < shift-expression
1578 relational-expression > shift-expression
1579 relational-expression <= shift-expression
1580 relational-expression >= shift-expression */
1582 static void
1583 pp_c_relational_expression (c_pretty_printer *pp, tree e)
1585 enum tree_code code = TREE_CODE (e);
1586 switch (code)
1588 case LT_EXPR:
1589 case GT_EXPR:
1590 case LE_EXPR:
1591 case GE_EXPR:
1592 pp_c_relational_expression (pp, TREE_OPERAND (e, 0));
1593 pp_c_whitespace (pp);
1594 if (code == LT_EXPR)
1595 pp_less (pp);
1596 else if (code == GT_EXPR)
1597 pp_greater (pp);
1598 else if (code == LE_EXPR)
1599 pp_identifier (pp, "<=");
1600 else if (code == GE_EXPR)
1601 pp_identifier (pp, ">=");
1602 pp_c_whitespace (pp);
1603 pp_c_shift_expression (pp, TREE_OPERAND (e, 1));
1604 break;
1606 default:
1607 pp_c_shift_expression (pp, e);
1608 break;
1612 /* equality-expression:
1613 relational-expression
1614 equality-expression == relational-expression
1615 equality-equality != relational-expression */
1617 static void
1618 pp_c_equality_expression (c_pretty_printer *pp, tree e)
1620 enum tree_code code = TREE_CODE (e);
1621 switch (code)
1623 case EQ_EXPR:
1624 case NE_EXPR:
1625 pp_c_equality_expression (pp, TREE_OPERAND (e, 0));
1626 pp_c_whitespace (pp);
1627 pp_identifier (pp, code == EQ_EXPR ? "==" : "!=");
1628 pp_c_whitespace (pp);
1629 pp_c_relational_expression (pp, TREE_OPERAND (e, 1));
1630 break;
1632 default:
1633 pp_c_relational_expression (pp, e);
1634 break;
1638 /* AND-expression:
1639 equality-expression
1640 AND-expression & equality-equality */
1642 static void
1643 pp_c_and_expression (c_pretty_printer *pp, tree e)
1645 if (TREE_CODE (e) == BIT_AND_EXPR)
1647 pp_c_and_expression (pp, TREE_OPERAND (e, 0));
1648 pp_c_whitespace (pp);
1649 pp_ampersand (pp);
1650 pp_c_whitespace (pp);
1651 pp_c_equality_expression (pp, TREE_OPERAND (e, 1));
1653 else
1654 pp_c_equality_expression (pp, e);
1657 /* exclusive-OR-expression:
1658 AND-expression
1659 exclusive-OR-expression ^ AND-expression */
1661 static void
1662 pp_c_exclusive_or_expression (c_pretty_printer *pp, tree e)
1664 if (TREE_CODE (e) == BIT_XOR_EXPR)
1666 pp_c_exclusive_or_expression (pp, TREE_OPERAND (e, 0));
1667 pp_c_maybe_whitespace (pp);
1668 pp_carret (pp);
1669 pp_c_whitespace (pp);
1670 pp_c_and_expression (pp, TREE_OPERAND (e, 1));
1672 else
1673 pp_c_and_expression (pp, e);
1676 /* inclusive-OR-expression:
1677 exclusive-OR-expression
1678 inclusive-OR-expression | exclusive-OR-expression */
1680 static void
1681 pp_c_inclusive_or_expression (c_pretty_printer *pp, tree e)
1683 if (TREE_CODE (e) == BIT_IOR_EXPR)
1685 pp_c_exclusive_or_expression (pp, TREE_OPERAND (e, 0));
1686 pp_c_whitespace (pp);
1687 pp_bar (pp);
1688 pp_c_whitespace (pp);
1689 pp_c_exclusive_or_expression (pp, TREE_OPERAND (e, 1));
1691 else
1692 pp_c_exclusive_or_expression (pp, e);
1695 /* logical-AND-expression:
1696 inclusive-OR-expression
1697 logical-AND-expression && inclusive-OR-expression */
1699 static void
1700 pp_c_logical_and_expression (c_pretty_printer *pp, tree e)
1702 if (TREE_CODE (e) == TRUTH_ANDIF_EXPR)
1704 pp_c_logical_and_expression (pp, TREE_OPERAND (e, 0));
1705 pp_c_whitespace (pp);
1706 pp_identifier (pp, "&&");
1707 pp_c_whitespace (pp);
1708 pp_c_inclusive_or_expression (pp, TREE_OPERAND (e, 1));
1710 else
1711 pp_c_inclusive_or_expression (pp, e);
1714 /* logical-OR-expression:
1715 logical-AND-expression
1716 logical-OR-expression || logical-AND-expression */
1718 void
1719 pp_c_logical_or_expression (c_pretty_printer *pp, tree e)
1721 if (TREE_CODE (e) == TRUTH_ORIF_EXPR)
1723 pp_c_logical_or_expression (pp, TREE_OPERAND (e, 0));
1724 pp_c_whitespace (pp);
1725 pp_identifier (pp, "||");
1726 pp_c_whitespace (pp);
1727 pp_c_logical_and_expression (pp, TREE_OPERAND (e, 1));
1729 else
1730 pp_c_logical_and_expression (pp, e);
1733 /* conditional-expression:
1734 logical-OR-expression
1735 logical-OR-expression ? expression : conditional-expression */
1737 static void
1738 pp_c_conditional_expression (c_pretty_printer *pp, tree e)
1740 if (TREE_CODE (e) == COND_EXPR)
1742 pp_c_logical_or_expression (pp, TREE_OPERAND (e, 0));
1743 pp_c_whitespace (pp);
1744 pp_question (pp);
1745 pp_c_whitespace (pp);
1746 pp_expression (pp, TREE_OPERAND (e, 1));
1747 pp_c_whitespace (pp);
1748 pp_colon (pp);
1749 pp_c_whitespace (pp);
1750 pp_c_conditional_expression (pp, TREE_OPERAND (e, 2));
1752 else
1753 pp_c_logical_or_expression (pp, e);
1757 /* assignment-expression:
1758 conditional-expression
1759 unary-expression assignment-operator assignment-expression
1761 assignment-expression: one of
1762 = *= /= %= += -= >>= <<= &= ^= |= */
1764 static void
1765 pp_c_assignment_expression (c_pretty_printer *pp, tree e)
1767 if (TREE_CODE (e) == MODIFY_EXPR || TREE_CODE (e) == INIT_EXPR)
1769 pp_c_unary_expression (pp, TREE_OPERAND (e, 0));
1770 pp_c_whitespace (pp);
1771 pp_equal (pp);
1772 pp_space (pp);
1773 pp_c_expression (pp, TREE_OPERAND (e, 1));
1775 else
1776 pp_c_conditional_expression (pp, e);
1779 /* expression:
1780 assignment-expression
1781 expression , assignment-expression
1783 Implementation note: instead of going through the usual recursion
1784 chain, I take the liberty of dispatching nodes to the appropriate
1785 functions. This makes some redundancy, but it worths it. That also
1786 prevents a possible infinite recursion between pp_c_primary_expression ()
1787 and pp_c_expression (). */
1789 void
1790 pp_c_expression (c_pretty_printer *pp, tree e)
1792 switch (TREE_CODE (e))
1794 case INTEGER_CST:
1795 pp_c_integer_constant (pp, e);
1796 break;
1798 case REAL_CST:
1799 pp_c_floating_constant (pp, e);
1800 break;
1802 case STRING_CST:
1803 pp_c_string_literal (pp, e);
1804 break;
1806 case IDENTIFIER_NODE:
1807 case FUNCTION_DECL:
1808 case VAR_DECL:
1809 case CONST_DECL:
1810 case PARM_DECL:
1811 case RESULT_DECL:
1812 case FIELD_DECL:
1813 case LABEL_DECL:
1814 case ERROR_MARK:
1815 case STMT_EXPR:
1816 pp_primary_expression (pp, e);
1817 break;
1819 case POSTINCREMENT_EXPR:
1820 case POSTDECREMENT_EXPR:
1821 case ARROW_EXPR:
1822 case ARRAY_REF:
1823 case CALL_EXPR:
1824 case COMPONENT_REF:
1825 case COMPLEX_CST:
1826 case COMPLEX_EXPR:
1827 case VECTOR_CST:
1828 case ORDERED_EXPR:
1829 case UNORDERED_EXPR:
1830 case LTGT_EXPR:
1831 case UNEQ_EXPR:
1832 case UNLE_EXPR:
1833 case UNLT_EXPR:
1834 case UNGE_EXPR:
1835 case UNGT_EXPR:
1836 case ABS_EXPR:
1837 case CONSTRUCTOR:
1838 case COMPOUND_LITERAL_EXPR:
1839 case VA_ARG_EXPR:
1840 pp_postfix_expression (pp, e);
1841 break;
1843 case CONJ_EXPR:
1844 case ADDR_EXPR:
1845 case INDIRECT_REF:
1846 case NEGATE_EXPR:
1847 case BIT_NOT_EXPR:
1848 case TRUTH_NOT_EXPR:
1849 case PREINCREMENT_EXPR:
1850 case PREDECREMENT_EXPR:
1851 case SIZEOF_EXPR:
1852 case ALIGNOF_EXPR:
1853 case REALPART_EXPR:
1854 case IMAGPART_EXPR:
1855 pp_c_unary_expression (pp, e);
1856 break;
1858 case FLOAT_EXPR:
1859 case FIX_TRUNC_EXPR:
1860 case CONVERT_EXPR:
1861 pp_c_cast_expression (pp, e);
1862 break;
1864 case MULT_EXPR:
1865 case TRUNC_MOD_EXPR:
1866 case TRUNC_DIV_EXPR:
1867 pp_multiplicative_expression (pp, e);
1868 break;
1870 case LSHIFT_EXPR:
1871 case RSHIFT_EXPR:
1872 pp_c_shift_expression (pp, e);
1873 break;
1875 case LT_EXPR:
1876 case GT_EXPR:
1877 case LE_EXPR:
1878 case GE_EXPR:
1879 pp_c_relational_expression (pp, e);
1880 break;
1882 case BIT_AND_EXPR:
1883 pp_c_and_expression (pp, e);
1884 break;
1886 case BIT_XOR_EXPR:
1887 pp_c_exclusive_or_expression (pp, e);
1888 break;
1890 case BIT_IOR_EXPR:
1891 pp_c_inclusive_or_expression (pp, e);
1892 break;
1894 case TRUTH_ANDIF_EXPR:
1895 pp_c_logical_and_expression (pp, e);
1896 break;
1898 case TRUTH_ORIF_EXPR:
1899 pp_c_logical_or_expression (pp, e);
1900 break;
1902 case EQ_EXPR:
1903 case NE_EXPR:
1904 pp_c_equality_expression (pp, e);
1905 break;
1907 case COND_EXPR:
1908 pp_conditional_expression (pp, e);
1909 break;
1911 case PLUS_EXPR:
1912 case MINUS_EXPR:
1913 pp_c_additive_expression (pp, e);
1914 break;
1916 case MODIFY_EXPR:
1917 case INIT_EXPR:
1918 pp_assignment_expression (pp, e);
1919 break;
1921 case COMPOUND_EXPR:
1922 pp_c_left_paren (pp);
1923 pp_expression (pp, TREE_OPERAND (e, 0));
1924 pp_separate_with (pp, ',');
1925 pp_assignment_expression (pp, TREE_OPERAND (e, 1));
1926 pp_c_right_paren (pp);
1927 break;
1929 case NOP_EXPR:
1930 case NON_LVALUE_EXPR:
1931 case SAVE_EXPR:
1932 pp_expression (pp, TREE_OPERAND (e, 0));
1933 break;
1935 case TARGET_EXPR:
1936 pp_postfix_expression (pp, TREE_OPERAND (e, 1));
1937 break;
1939 default:
1940 pp_unsupported_tree (pp, e);
1941 break;
1947 /* Statements. */
1949 /* statement:
1950 labeled-statement
1951 compound-statement
1952 expression-statement
1953 selection-statement
1954 iteration-statement
1955 jump-statement */
1957 void
1958 pp_c_statement (c_pretty_printer *pp, tree stmt)
1960 enum tree_code code;
1962 if (stmt == NULL)
1963 return;
1965 if (pp_needs_newline (pp))
1966 pp_newline_and_indent (pp, 0);
1968 code = TREE_CODE (stmt);
1969 switch (code)
1971 /* expression-statement:
1972 expression(opt) ; */
1973 case EXPR_STMT:
1974 pp_expression (pp, EXPR_STMT_EXPR (stmt));
1975 pp_c_semicolon (pp);
1976 pp_needs_newline (pp) = true;
1977 break;
1979 case SWITCH_STMT:
1980 pp_c_identifier (pp, "switch");
1981 pp_space (pp);
1982 pp_c_left_paren (pp);
1983 pp_expression (pp, SWITCH_COND (stmt));
1984 pp_c_right_paren (pp);
1985 pp_indentation (pp) += 3;
1986 pp_needs_newline (pp) = true;
1987 pp_statement (pp, SWITCH_BODY (stmt));
1988 pp_newline_and_indent (pp, -3);
1989 break;
1991 /* iteration-statement:
1992 while ( expression ) statement
1993 do statement while ( expression ) ;
1994 for ( expression(opt) ; expression(opt) ; expression(opt) ) statement
1995 for ( declaration expression(opt) ; expression(opt) ) statement */
1996 case WHILE_STMT:
1997 pp_c_identifier (pp, "while");
1998 pp_space (pp);
1999 pp_c_left_paren (pp);
2000 pp_expression (pp, WHILE_COND (stmt));
2001 pp_c_right_paren (pp);
2002 pp_newline_and_indent (pp, 3);
2003 pp_statement (pp, WHILE_BODY (stmt));
2004 pp_indentation (pp) -= 3;
2005 pp_needs_newline (pp) = true;
2006 break;
2008 case DO_STMT:
2009 pp_c_identifier (pp, "do");
2010 pp_newline_and_indent (pp, 3);
2011 pp_statement (pp, DO_BODY (stmt));
2012 pp_newline_and_indent (pp, -3);
2013 pp_c_identifier (pp, "while");
2014 pp_space (pp);
2015 pp_c_left_paren (pp);
2016 pp_expression (pp, DO_COND (stmt));
2017 pp_c_right_paren (pp);
2018 pp_c_semicolon (pp);
2019 pp_needs_newline (pp) = true;
2020 break;
2022 case FOR_STMT:
2023 pp_c_identifier (pp, "for");
2024 pp_space (pp);
2025 pp_c_left_paren (pp);
2026 if (FOR_INIT_STMT (stmt))
2027 pp_statement (pp, FOR_INIT_STMT (stmt));
2028 else
2029 pp_c_semicolon (pp);
2030 pp_needs_newline (pp) = false;
2031 pp_c_whitespace (pp);
2032 if (FOR_COND (stmt))
2033 pp_expression (pp, FOR_COND (stmt));
2034 pp_c_semicolon (pp);
2035 pp_needs_newline (pp) = false;
2036 pp_c_whitespace (pp);
2037 if (FOR_EXPR (stmt))
2038 pp_expression (pp, FOR_EXPR (stmt));
2039 pp_c_right_paren (pp);
2040 pp_newline_and_indent (pp, 3);
2041 pp_statement (pp, FOR_BODY (stmt));
2042 pp_indentation (pp) -= 3;
2043 pp_needs_newline (pp) = true;
2044 break;
2046 /* jump-statement:
2047 goto identifier;
2048 continue ;
2049 return expression(opt) ; */
2050 case BREAK_STMT:
2051 case CONTINUE_STMT:
2052 pp_identifier (pp, code == BREAK_STMT ? "break" : "continue");
2053 pp_c_semicolon (pp);
2054 pp_needs_newline (pp) = true;
2055 break;
2057 default:
2058 dump_generic_node (pp_base (pp), stmt, pp_indentation (pp), 0, true);
2059 break;
2064 /* Initialize the PRETTY-PRINTER for handling C codes. */
2066 void
2067 pp_c_pretty_printer_init (c_pretty_printer *pp)
2069 pp->offset_list = 0;
2071 pp->declaration = pp_c_declaration;
2072 pp->declaration_specifiers = pp_c_declaration_specifiers;
2073 pp->declarator = pp_c_declarator;
2074 pp->direct_declarator = pp_c_direct_declarator;
2075 pp->type_specifier_seq = pp_c_specifier_qualifier_list;
2076 pp->abstract_declarator = pp_c_abstract_declarator;
2077 pp->direct_abstract_declarator = pp_c_direct_abstract_declarator;
2078 pp->ptr_operator = pp_c_pointer;
2079 pp->parameter_list = pp_c_parameter_type_list;
2080 pp->type_id = pp_c_type_id;
2081 pp->simple_type_specifier = pp_c_type_specifier;
2082 pp->function_specifier = pp_c_function_specifier;
2083 pp->storage_class_specifier = pp_c_storage_class_specifier;
2085 pp->statement = pp_c_statement;
2087 pp->id_expression = pp_c_id_expression;
2088 pp->primary_expression = pp_c_primary_expression;
2089 pp->postfix_expression = pp_c_postfix_expression;
2090 pp->unary_expression = pp_c_unary_expression;
2091 pp->initializer = pp_c_initializer;
2092 pp->multiplicative_expression = pp_c_multiplicative_expression;
2093 pp->conditional_expression = pp_c_conditional_expression;
2094 pp->assignment_expression = pp_c_assignment_expression;
2095 pp->expression = pp_c_expression;
2099 /* Print the tree T in full, on file FILE. */
2101 void
2102 print_c_tree (FILE *file, tree t)
2104 static c_pretty_printer pp_rec;
2105 static bool initialized = 0;
2106 c_pretty_printer *pp = &pp_rec;
2108 if (!initialized)
2110 initialized = 1;
2111 pp_construct (pp_base (pp), NULL, 0);
2112 pp_c_pretty_printer_init (pp);
2113 pp_needs_newline (pp) = true;
2115 pp_base (pp)->buffer->stream = file;
2117 pp_statement (pp, t);
2119 pp_newline (pp);
2120 pp_flush (pp);
2123 /* Print the tree T in full, on stderr. */
2125 void
2126 debug_c_tree (tree t)
2128 print_c_tree (stderr, t);
2129 fputc ('\n', stderr);
2132 /* Output the DECL_NAME of T. If T has no DECL_NAME, output a string made
2133 up of T's memory address. */
2135 void
2136 pp_c_tree_decl_identifier (c_pretty_printer *pp, tree t)
2138 const char *name;
2140 if (!DECL_P (t))
2141 abort ();
2143 if (DECL_NAME (t))
2144 name = IDENTIFIER_POINTER (DECL_NAME (t));
2145 else
2147 static char xname[8];
2148 sprintf (xname, "<U%4x>", ((unsigned)((unsigned long)(t) & 0xffff)));
2149 name = xname;
2152 pp_c_identifier (pp, name);