1 /* Implementation of subroutines for the GNU C++ pretty-printer.
2 Copyright (C) 2003, 2004, 2005, 2007, 2008,
3 2009, 2010, 2011 Free Software Foundation, Inc.
4 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
28 #include "cxx-pretty-print.h"
29 #include "tree-pretty-print.h"
31 /* Translate if being used for diagnostics, but not for dump files or
33 #define M_(msgid) (pp_translate_identifiers (pp) ? _(msgid) : (msgid))
35 static void pp_cxx_unqualified_id (cxx_pretty_printer *, tree);
36 static void pp_cxx_nested_name_specifier (cxx_pretty_printer *, tree);
37 static void pp_cxx_qualified_id (cxx_pretty_printer *, tree);
38 static void pp_cxx_assignment_expression (cxx_pretty_printer *, tree);
39 static void pp_cxx_expression (cxx_pretty_printer *, tree);
40 static void pp_cxx_template_argument_list (cxx_pretty_printer *, tree);
41 static void pp_cxx_type_specifier_seq (cxx_pretty_printer *, tree);
42 static void pp_cxx_ptr_operator (cxx_pretty_printer *, tree);
43 static void pp_cxx_type_id (cxx_pretty_printer *, tree);
44 static void pp_cxx_direct_abstract_declarator (cxx_pretty_printer *, tree);
45 static void pp_cxx_declarator (cxx_pretty_printer *, tree);
46 static void pp_cxx_parameter_declaration_clause (cxx_pretty_printer *, tree);
47 static void pp_cxx_abstract_declarator (cxx_pretty_printer *, tree);
48 static void pp_cxx_statement (cxx_pretty_printer *, tree);
49 static void pp_cxx_template_parameter (cxx_pretty_printer *, tree);
50 static void pp_cxx_cast_expression (cxx_pretty_printer *, tree);
51 static void pp_cxx_typeid_expression (cxx_pretty_printer *, tree);
55 pp_cxx_nonconsecutive_character (cxx_pretty_printer *pp, int c)
57 const char *p = pp_last_position_in_text (pp);
59 if (p != NULL && *p == c)
60 pp_cxx_whitespace (pp);
62 pp_base (pp)->padding = pp_none;
65 #define pp_cxx_storage_class_specifier(PP, T) \
66 pp_c_storage_class_specifier (pp_c_base (PP), T)
67 #define pp_cxx_expression_list(PP, T) \
68 pp_c_expression_list (pp_c_base (PP), T)
69 #define pp_cxx_space_for_pointer_operator(PP, T) \
70 pp_c_space_for_pointer_operator (pp_c_base (PP), T)
71 #define pp_cxx_init_declarator(PP, T) \
72 pp_c_init_declarator (pp_c_base (PP), T)
73 #define pp_cxx_call_argument_list(PP, T) \
74 pp_c_call_argument_list (pp_c_base (PP), T)
77 pp_cxx_colon_colon (cxx_pretty_printer *pp)
80 pp_base (pp)->padding = pp_none;
84 pp_cxx_begin_template_argument_list (cxx_pretty_printer *pp)
86 pp_cxx_nonconsecutive_character (pp, '<');
90 pp_cxx_end_template_argument_list (cxx_pretty_printer *pp)
92 pp_cxx_nonconsecutive_character (pp, '>');
96 pp_cxx_separate_with (cxx_pretty_printer *pp, int c)
98 pp_separate_with (pp, c);
99 pp_base (pp)->padding = pp_none;
105 is_destructor_name (tree name)
107 return name == complete_dtor_identifier
108 || name == base_dtor_identifier
109 || name == deleting_dtor_identifier;
112 /* conversion-function-id:
113 operator conversion-type-id
116 type-specifier-seq conversion-declarator(opt)
118 conversion-declarator:
119 ptr-operator conversion-declarator(opt) */
122 pp_cxx_conversion_function_id (cxx_pretty_printer *pp, tree t)
124 pp_cxx_ws_string (pp, "operator");
125 pp_cxx_type_specifier_seq (pp, TREE_TYPE (t));
129 pp_cxx_template_id (cxx_pretty_printer *pp, tree t)
131 pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 0));
132 pp_cxx_begin_template_argument_list (pp);
133 pp_cxx_template_argument_list (pp, TREE_OPERAND (t, 1));
134 pp_cxx_end_template_argument_list (pp);
137 /* Prints the unqualified part of the id-expression T.
142 conversion-function-id
147 pp_cxx_unqualified_id (cxx_pretty_printer *pp, tree t)
149 enum tree_code code = TREE_CODE (t);
153 pp_cxx_ws_string (pp, M_("<return-value>"));
170 case IDENTIFIER_NODE:
172 pp_cxx_ws_string (pp, M_("<unnamed>"));
173 else if (IDENTIFIER_TYPENAME_P (t))
174 pp_cxx_conversion_function_id (pp, t);
177 if (is_destructor_name (t))
180 /* FIXME: Why is this necessary? */
182 t = constructor_name (TREE_TYPE (t));
184 pp_cxx_tree_identifier (pp, t);
188 case TEMPLATE_ID_EXPR:
189 pp_cxx_template_id (pp, t);
193 pp_cxx_unqualified_id (pp, BASELINK_FUNCTIONS (t));
200 case UNBOUND_CLASS_TEMPLATE:
201 pp_cxx_unqualified_id (pp, TYPE_NAME (t));
202 if (CLASS_TYPE_P (t) && CLASSTYPE_USE_TEMPLATE (t))
204 pp_cxx_begin_template_argument_list (pp);
205 pp_cxx_template_argument_list (pp, INNERMOST_TEMPLATE_ARGS
206 (CLASSTYPE_TI_ARGS (t)));
207 pp_cxx_end_template_argument_list (pp);
212 pp_cxx_complement (pp);
213 pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 0));
216 case TEMPLATE_TYPE_PARM:
217 case TEMPLATE_TEMPLATE_PARM:
218 if (TYPE_IDENTIFIER (t))
219 pp_cxx_unqualified_id (pp, TYPE_IDENTIFIER (t));
221 pp_cxx_canonical_template_parameter (pp, t);
224 case TEMPLATE_PARM_INDEX:
225 pp_cxx_unqualified_id (pp, TEMPLATE_PARM_DECL (t));
228 case BOUND_TEMPLATE_TEMPLATE_PARM:
229 pp_cxx_cv_qualifier_seq (pp, t);
230 pp_cxx_unqualified_id (pp, TYPE_IDENTIFIER (t));
231 pp_cxx_begin_template_argument_list (pp);
232 pp_cxx_template_argument_list (pp, TYPE_TI_ARGS (t));
233 pp_cxx_end_template_argument_list (pp);
237 pp_unsupported_tree (pp, t);
242 /* Pretty-print out the token sequence ":: template" in template codes
243 where it is needed to "inline declare" the (following) member as
244 a template. This situation arises when SCOPE of T is dependent
245 on template parameters. */
248 pp_cxx_template_keyword_if_needed (cxx_pretty_printer *pp, tree scope, tree t)
250 if (TREE_CODE (t) == TEMPLATE_ID_EXPR
251 && TYPE_P (scope) && dependent_type_p (scope))
252 pp_cxx_ws_string (pp, "template");
255 /* nested-name-specifier:
256 class-or-namespace-name :: nested-name-specifier(opt)
257 class-or-namespace-name :: template nested-name-specifier */
260 pp_cxx_nested_name_specifier (cxx_pretty_printer *pp, tree t)
262 if (!SCOPE_FILE_SCOPE_P (t) && t != pp->enclosing_scope)
264 tree scope = TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t);
265 pp_cxx_nested_name_specifier (pp, scope);
266 pp_cxx_template_keyword_if_needed (pp, scope, t);
267 pp_cxx_unqualified_id (pp, t);
268 pp_cxx_colon_colon (pp);
273 nested-name-specifier template(opt) unqualified-id */
276 pp_cxx_qualified_id (cxx_pretty_printer *pp, tree t)
278 switch (TREE_CODE (t))
280 /* A pointer-to-member is always qualified. */
282 pp_cxx_nested_name_specifier (pp, PTRMEM_CST_CLASS (t));
283 pp_cxx_unqualified_id (pp, PTRMEM_CST_MEMBER (t));
286 /* In Standard C++, functions cannot possibly be used as
287 nested-name-specifiers. However, there are situations where
288 is "makes sense" to output the surrounding function name for the
289 purpose of emphasizing on the scope kind. Just printing the
290 function name might not be sufficient as it may be overloaded; so,
291 we decorate the function with its signature too.
292 FIXME: This is probably the wrong pretty-printing for conversion
293 functions and some function templates. */
297 if (DECL_FUNCTION_MEMBER_P (t))
298 pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
299 pp_cxx_unqualified_id
300 (pp, DECL_CONSTRUCTOR_P (t) ? DECL_CONTEXT (t) : t);
301 pp_cxx_parameter_declaration_clause (pp, TREE_TYPE (t));
306 pp_cxx_nested_name_specifier (pp, TREE_OPERAND (t, 0));
307 pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 1));
312 tree scope = TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t);
313 if (scope != pp->enclosing_scope)
315 pp_cxx_nested_name_specifier (pp, scope);
316 pp_cxx_template_keyword_if_needed (pp, scope, t);
318 pp_cxx_unqualified_id (pp, t);
326 pp_cxx_constant (cxx_pretty_printer *pp, tree t)
328 switch (TREE_CODE (t))
332 const bool in_parens = PAREN_STRING_LITERAL_P (t);
334 pp_cxx_left_paren (pp);
335 pp_c_constant (pp_c_base (pp), t);
337 pp_cxx_right_paren (pp);
342 if (NULLPTR_TYPE_P (TREE_TYPE (t)))
344 pp_string (pp, "nullptr");
347 /* else fall through. */
350 pp_c_constant (pp_c_base (pp), t);
360 pp_cxx_id_expression (cxx_pretty_printer *pp, tree t)
362 if (TREE_CODE (t) == OVERLOAD)
364 if (DECL_P (t) && DECL_CONTEXT (t))
365 pp_cxx_qualified_id (pp, t);
367 pp_cxx_unqualified_id (pp, t);
370 /* primary-expression:
374 :: operator-function-id
380 __builtin_va_arg ( assignment-expression , type-id )
381 __builtin_offsetof ( type-id, offsetof-expression )
383 __has_nothrow_assign ( type-id )
384 __has_nothrow_constructor ( type-id )
385 __has_nothrow_copy ( type-id )
386 __has_trivial_assign ( type-id )
387 __has_trivial_constructor ( type-id )
388 __has_trivial_copy ( type-id )
389 __has_trivial_destructor ( type-id )
390 __has_virtual_destructor ( type-id )
391 __is_abstract ( type-id )
392 __is_base_of ( type-id , type-id )
393 __is_class ( type-id )
394 __is_convertible_to ( type-id , type-id )
395 __is_empty ( type-id )
396 __is_enum ( type-id )
397 __is_literal_type ( type-id )
399 __is_polymorphic ( type-id )
400 __is_std_layout ( type-id )
401 __is_trivial ( type-id )
402 __is_union ( type-id ) */
405 pp_cxx_primary_expression (cxx_pretty_printer *pp, tree t)
407 switch (TREE_CODE (t))
413 pp_cxx_constant (pp, t);
417 t = BASELINK_FUNCTIONS (t);
425 pp_cxx_id_expression (pp, t);
429 case TEMPLATE_TYPE_PARM:
430 case TEMPLATE_TEMPLATE_PARM:
431 case TEMPLATE_PARM_INDEX:
432 pp_cxx_unqualified_id (pp, t);
436 pp_cxx_left_paren (pp);
437 pp_cxx_statement (pp, STMT_EXPR_STMT (t));
438 pp_cxx_right_paren (pp);
442 pp_cxx_trait_expression (pp, t);
446 pp_cxx_va_arg_expression (pp, t);
450 pp_cxx_offsetof_expression (pp, t);
454 pp_c_primary_expression (pp_c_base (pp), t);
459 /* postfix-expression:
461 postfix-expression [ expression ]
462 postfix-expression ( expression-list(opt) )
463 simple-type-specifier ( expression-list(opt) )
464 typename ::(opt) nested-name-specifier identifier ( expression-list(opt) )
465 typename ::(opt) nested-name-specifier template(opt)
466 template-id ( expression-list(opt) )
467 postfix-expression . template(opt) ::(opt) id-expression
468 postfix-expression -> template(opt) ::(opt) id-expression
469 postfix-expression . pseudo-destructor-name
470 postfix-expression -> pseudo-destructor-name
471 postfix-expression ++
472 postfix-expression --
473 dynamic_cast < type-id > ( expression )
474 static_cast < type-id > ( expression )
475 reinterpret_cast < type-id > ( expression )
476 const_cast < type-id > ( expression )
477 typeid ( expression )
478 typeid ( type-id ) */
481 pp_cxx_postfix_expression (cxx_pretty_printer *pp, tree t)
483 enum tree_code code = TREE_CODE (t);
490 tree fun = (code == AGGR_INIT_EXPR ? AGGR_INIT_EXPR_FN (t)
492 tree saved_scope = pp->enclosing_scope;
493 bool skipfirst = false;
496 if (TREE_CODE (fun) == ADDR_EXPR)
497 fun = TREE_OPERAND (fun, 0);
499 /* In templates, where there is no way to tell whether a given
500 call uses an actual member function. So the parser builds
501 FUN as a COMPONENT_REF or a plain IDENTIFIER_NODE until
502 instantiation time. */
503 if (TREE_CODE (fun) != FUNCTION_DECL)
505 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun))
507 tree object = (code == AGGR_INIT_EXPR
508 ? (AGGR_INIT_VIA_CTOR_P (t)
509 ? AGGR_INIT_EXPR_SLOT (t)
510 : AGGR_INIT_EXPR_ARG (t, 0))
511 : CALL_EXPR_ARG (t, 0));
513 while (TREE_CODE (object) == NOP_EXPR)
514 object = TREE_OPERAND (object, 0);
516 if (TREE_CODE (object) == ADDR_EXPR)
517 object = TREE_OPERAND (object, 0);
519 if (TREE_CODE (TREE_TYPE (object)) != POINTER_TYPE)
521 pp_cxx_postfix_expression (pp, object);
526 pp_cxx_postfix_expression (pp, object);
530 pp->enclosing_scope = strip_pointer_operator (TREE_TYPE (object));
533 pp_cxx_postfix_expression (pp, fun);
534 pp->enclosing_scope = saved_scope;
535 pp_cxx_left_paren (pp);
536 if (code == AGGR_INIT_EXPR)
538 aggr_init_expr_arg_iterator iter;
539 FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
545 pp_cxx_expression (pp, arg);
546 if (more_aggr_init_expr_args_p (&iter))
547 pp_cxx_separate_with (pp, ',');
553 call_expr_arg_iterator iter;
554 FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
560 pp_cxx_expression (pp, arg);
561 if (more_call_expr_args_p (&iter))
562 pp_cxx_separate_with (pp, ',');
566 pp_cxx_right_paren (pp);
568 if (code == AGGR_INIT_EXPR && AGGR_INIT_VIA_CTOR_P (t))
570 pp_cxx_separate_with (pp, ',');
571 pp_cxx_postfix_expression (pp, AGGR_INIT_EXPR_SLOT (t));
584 pp_cxx_primary_expression (pp, t);
587 case DYNAMIC_CAST_EXPR:
588 case STATIC_CAST_EXPR:
589 case REINTERPRET_CAST_EXPR:
590 case CONST_CAST_EXPR:
591 if (code == DYNAMIC_CAST_EXPR)
592 pp_cxx_ws_string (pp, "dynamic_cast");
593 else if (code == STATIC_CAST_EXPR)
594 pp_cxx_ws_string (pp, "static_cast");
595 else if (code == REINTERPRET_CAST_EXPR)
596 pp_cxx_ws_string (pp, "reinterpret_cast");
598 pp_cxx_ws_string (pp, "const_cast");
599 pp_cxx_begin_template_argument_list (pp);
600 pp_cxx_type_id (pp, TREE_TYPE (t));
601 pp_cxx_end_template_argument_list (pp);
603 pp_cxx_expression (pp, TREE_OPERAND (t, 0));
607 case EMPTY_CLASS_EXPR:
608 pp_cxx_type_id (pp, TREE_TYPE (t));
614 pp_cxx_typeid_expression (pp, t);
617 case PSEUDO_DTOR_EXPR:
618 pp_cxx_postfix_expression (pp, TREE_OPERAND (t, 0));
620 pp_cxx_qualified_id (pp, TREE_OPERAND (t, 1));
621 pp_cxx_colon_colon (pp);
623 pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 2));
627 pp_cxx_postfix_expression (pp, TREE_OPERAND (t, 0));
632 pp_c_postfix_expression (pp_c_base (pp), t);
638 ::(opt) new new-placement(opt) new-type-id new-initializer(opt)
639 ::(opt) new new-placement(opt) ( type-id ) new-initializer(opt)
645 type-specifier-seq new-declarator(opt)
648 ptr-operator new-declarator(opt)
649 direct-new-declarator
651 direct-new-declarator
653 direct-new-declarator [ constant-expression ]
656 ( expression-list(opt) ) */
659 pp_cxx_new_expression (cxx_pretty_printer *pp, tree t)
661 enum tree_code code = TREE_CODE (t);
662 tree type = TREE_OPERAND (t, 1);
663 tree init = TREE_OPERAND (t, 2);
668 if (NEW_EXPR_USE_GLOBAL (t))
669 pp_cxx_colon_colon (pp);
670 pp_cxx_ws_string (pp, "new");
671 if (TREE_OPERAND (t, 0))
673 pp_cxx_call_argument_list (pp, TREE_OPERAND (t, 0));
676 if (TREE_CODE (type) == ARRAY_REF)
677 type = build_cplus_array_type
678 (TREE_OPERAND (type, 0),
679 build_index_type (fold_build2_loc (input_location,
680 MINUS_EXPR, integer_type_node,
681 TREE_OPERAND (type, 1),
683 pp_cxx_type_id (pp, type);
687 if (TREE_CODE (init) == TREE_LIST)
688 pp_c_expression_list (pp_c_base (pp), init);
689 else if (init == void_zero_node)
690 ; /* OK, empty initializer list. */
692 pp_cxx_expression (pp, init);
698 pp_unsupported_tree (pp, t);
702 /* delete-expression:
703 ::(opt) delete cast-expression
704 ::(opt) delete [ ] cast-expression */
707 pp_cxx_delete_expression (cxx_pretty_printer *pp, tree t)
709 enum tree_code code = TREE_CODE (t);
713 case VEC_DELETE_EXPR:
714 if (DELETE_EXPR_USE_GLOBAL (t))
715 pp_cxx_colon_colon (pp);
716 pp_cxx_ws_string (pp, "delete");
718 if (code == VEC_DELETE_EXPR
719 || DELETE_EXPR_USE_VEC (t))
721 pp_left_bracket (pp);
722 pp_right_bracket (pp);
725 pp_c_cast_expression (pp_c_base (pp), TREE_OPERAND (t, 0));
729 pp_unsupported_tree (pp, t);
737 unary-operator cast-expression
738 sizeof unary-expression
740 sizeof ... ( identifier )
744 unary-operator: one of
748 __alignof__ unary-expression
749 __alignof__ ( type-id ) */
752 pp_cxx_unary_expression (cxx_pretty_printer *pp, tree t)
754 enum tree_code code = TREE_CODE (t);
759 pp_cxx_new_expression (pp, t);
763 case VEC_DELETE_EXPR:
764 pp_cxx_delete_expression (pp, t);
768 if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
770 pp_cxx_ws_string (pp, "sizeof");
771 pp_cxx_ws_string (pp, "...");
772 pp_cxx_whitespace (pp);
773 pp_cxx_left_paren (pp);
774 if (TYPE_P (TREE_OPERAND (t, 0)))
775 pp_cxx_type_id (pp, TREE_OPERAND (t, 0));
777 pp_unary_expression (pp, TREE_OPERAND (t, 0));
778 pp_cxx_right_paren (pp);
784 pp_cxx_ws_string (pp, code == SIZEOF_EXPR ? "sizeof" : "__alignof__");
785 pp_cxx_whitespace (pp);
786 if (TYPE_P (TREE_OPERAND (t, 0)))
788 pp_cxx_left_paren (pp);
789 pp_cxx_type_id (pp, TREE_OPERAND (t, 0));
790 pp_cxx_right_paren (pp);
793 pp_unary_expression (pp, TREE_OPERAND (t, 0));
797 pp_cxx_ws_string (pp, "@encode");
798 pp_cxx_whitespace (pp);
799 pp_cxx_left_paren (pp);
800 pp_cxx_type_id (pp, TREE_OPERAND (t, 0));
801 pp_cxx_right_paren (pp);
805 pp_cxx_ws_string (pp, "noexcept");
806 pp_cxx_whitespace (pp);
807 pp_cxx_left_paren (pp);
808 pp_cxx_expression (pp, TREE_OPERAND (t, 0));
809 pp_cxx_right_paren (pp);
812 case UNARY_PLUS_EXPR:
814 pp_cxx_cast_expression (pp, TREE_OPERAND (t, 0));
818 pp_c_unary_expression (pp_c_base (pp), t);
825 ( type-id ) cast-expression */
828 pp_cxx_cast_expression (cxx_pretty_printer *pp, tree t)
830 switch (TREE_CODE (t))
833 pp_cxx_type_id (pp, TREE_TYPE (t));
834 pp_cxx_call_argument_list (pp, TREE_OPERAND (t, 0));
838 pp_c_cast_expression (pp_c_base (pp), t);
845 pm-expression .* cast-expression
846 pm-expression ->* cast-expression */
849 pp_cxx_pm_expression (cxx_pretty_printer *pp, tree t)
851 switch (TREE_CODE (t))
853 /* Handle unfortunate OFFSET_REF overloading here. */
855 if (TYPE_P (TREE_OPERAND (t, 0)))
857 pp_cxx_qualified_id (pp, t);
860 /* Else fall through. */
863 pp_cxx_pm_expression (pp, TREE_OPERAND (t, 0));
864 if (TREE_CODE (t) == MEMBER_REF)
869 pp_cxx_cast_expression (pp, TREE_OPERAND (t, 1));
874 pp_cxx_cast_expression (pp, t);
879 /* multiplicative-expression:
881 multiplicative-expression * pm-expression
882 multiplicative-expression / pm-expression
883 multiplicative-expression % pm-expression */
886 pp_cxx_multiplicative_expression (cxx_pretty_printer *pp, tree e)
888 enum tree_code code = TREE_CODE (e);
894 pp_cxx_multiplicative_expression (pp, TREE_OPERAND (e, 0));
896 if (code == MULT_EXPR)
898 else if (code == TRUNC_DIV_EXPR)
903 pp_cxx_pm_expression (pp, TREE_OPERAND (e, 1));
907 pp_cxx_pm_expression (pp, e);
912 /* conditional-expression:
913 logical-or-expression
914 logical-or-expression ? expression : assignment-expression */
917 pp_cxx_conditional_expression (cxx_pretty_printer *pp, tree e)
919 if (TREE_CODE (e) == COND_EXPR)
921 pp_c_logical_or_expression (pp_c_base (pp), TREE_OPERAND (e, 0));
925 pp_cxx_expression (pp, TREE_OPERAND (e, 1));
927 pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 2));
930 pp_c_logical_or_expression (pp_c_base (pp), e);
933 /* Pretty-print a compound assignment operator token as indicated by T. */
936 pp_cxx_assignment_operator (cxx_pretty_printer *pp, tree t)
940 switch (TREE_CODE (t))
963 op = tree_code_name[TREE_CODE (t)];
967 pp_cxx_ws_string (pp, op);
971 /* assignment-expression:
972 conditional-expression
973 logical-or-expression assignment-operator assignment-expression
977 throw assignment-expression(opt)
979 assignment-operator: one of
980 = *= /= %= += -= >>= <<= &= ^= |= */
983 pp_cxx_assignment_expression (cxx_pretty_printer *pp, tree e)
985 switch (TREE_CODE (e))
989 pp_c_logical_or_expression (pp_c_base (pp), TREE_OPERAND (e, 0));
993 pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 1));
997 pp_cxx_ws_string (pp, "throw");
998 if (TREE_OPERAND (e, 0))
999 pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 0));
1003 pp_c_logical_or_expression (pp_c_base (pp), TREE_OPERAND (e, 0));
1004 pp_cxx_assignment_operator (pp, TREE_OPERAND (e, 1));
1005 pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 2));
1009 pp_cxx_conditional_expression (pp, e);
1015 pp_cxx_expression (cxx_pretty_printer *pp, tree t)
1017 switch (TREE_CODE (t))
1023 pp_cxx_constant (pp, t);
1027 pp_cxx_unqualified_id (pp, t);
1035 pp_cxx_qualified_id (pp, t);
1039 t = OVL_CURRENT (t);
1047 case TEMPLATE_TYPE_PARM:
1048 case TEMPLATE_PARM_INDEX:
1049 case TEMPLATE_TEMPLATE_PARM:
1051 pp_cxx_primary_expression (pp, t);
1055 case DYNAMIC_CAST_EXPR:
1056 case STATIC_CAST_EXPR:
1057 case REINTERPRET_CAST_EXPR:
1058 case CONST_CAST_EXPR:
1062 case EMPTY_CLASS_EXPR:
1064 case PSEUDO_DTOR_EXPR:
1065 case AGGR_INIT_EXPR:
1067 pp_cxx_postfix_expression (pp, t);
1072 pp_cxx_new_expression (pp, t);
1076 case VEC_DELETE_EXPR:
1077 pp_cxx_delete_expression (pp, t);
1083 pp_cxx_unary_expression (pp, t);
1087 pp_cxx_cast_expression (pp, t);
1093 pp_cxx_pm_expression (pp, t);
1097 case TRUNC_DIV_EXPR:
1098 case TRUNC_MOD_EXPR:
1099 pp_cxx_multiplicative_expression (pp, t);
1103 pp_cxx_conditional_expression (pp, t);
1110 pp_cxx_assignment_expression (pp, t);
1113 case NON_DEPENDENT_EXPR:
1114 case MUST_NOT_THROW_EXPR:
1115 pp_cxx_expression (pp, TREE_OPERAND (t, 0));
1118 case EXPR_PACK_EXPANSION:
1119 pp_cxx_expression (pp, PACK_EXPANSION_PATTERN (t));
1120 pp_cxx_ws_string (pp, "...");
1123 case TEMPLATE_ID_EXPR:
1124 pp_cxx_template_id (pp, t);
1127 case NONTYPE_ARGUMENT_PACK:
1129 tree args = ARGUMENT_PACK_ARGS (t);
1130 int i, len = TREE_VEC_LENGTH (args);
1131 for (i = 0; i < len; ++i)
1134 pp_cxx_separate_with (pp, ',');
1135 pp_cxx_expression (pp, TREE_VEC_ELT (args, i));
1141 pp_c_expression (pp_c_base (pp), t);
1149 /* function-specifier:
1155 pp_cxx_function_specifier (cxx_pretty_printer *pp, tree t)
1157 switch (TREE_CODE (t))
1160 if (DECL_VIRTUAL_P (t))
1161 pp_cxx_ws_string (pp, "virtual");
1162 else if (DECL_CONSTRUCTOR_P (t) && DECL_NONCONVERTING_P (t))
1163 pp_cxx_ws_string (pp, "explicit");
1165 pp_c_function_specifier (pp_c_base (pp), t);
1172 /* decl-specifier-seq:
1173 decl-specifier-seq(opt) decl-specifier
1176 storage-class-specifier
1183 pp_cxx_decl_specifier_seq (cxx_pretty_printer *pp, tree t)
1185 switch (TREE_CODE (t))
1191 pp_cxx_storage_class_specifier (pp, t);
1192 pp_cxx_decl_specifier_seq (pp, TREE_TYPE (t));
1196 pp_cxx_ws_string (pp, "typedef");
1197 pp_cxx_decl_specifier_seq (pp, TREE_TYPE (t));
1201 /* Constructors don't have return types. And conversion functions
1202 do not have a type-specifier in their return types. */
1203 if (DECL_CONSTRUCTOR_P (t) || DECL_CONV_FN_P (t))
1204 pp_cxx_function_specifier (pp, t);
1205 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
1206 pp_cxx_decl_specifier_seq (pp, TREE_TYPE (TREE_TYPE (t)));
1209 pp_c_declaration_specifiers (pp_c_base (pp), t);
1214 /* simple-type-specifier:
1215 ::(opt) nested-name-specifier(opt) type-name
1216 ::(opt) nested-name-specifier(opt) template(opt) template-id
1230 pp_cxx_simple_type_specifier (cxx_pretty_printer *pp, tree t)
1232 switch (TREE_CODE (t))
1237 pp_cxx_qualified_id (pp, t);
1240 case TEMPLATE_TYPE_PARM:
1241 case TEMPLATE_TEMPLATE_PARM:
1242 case TEMPLATE_PARM_INDEX:
1243 pp_cxx_unqualified_id (pp, t);
1247 pp_cxx_ws_string (pp, "typename");
1248 pp_cxx_nested_name_specifier (pp, TYPE_CONTEXT (t));
1249 pp_cxx_unqualified_id (pp, TYPE_NAME (t));
1253 pp_c_type_specifier (pp_c_base (pp), t);
1258 /* type-specifier-seq:
1259 type-specifier type-specifier-seq(opt)
1262 simple-type-specifier
1265 elaborated-type-specifier
1269 pp_cxx_type_specifier_seq (cxx_pretty_printer *pp, tree t)
1271 switch (TREE_CODE (t))
1274 case TEMPLATE_TYPE_PARM:
1275 case TEMPLATE_TEMPLATE_PARM:
1277 case BOUND_TEMPLATE_TEMPLATE_PARM:
1278 pp_cxx_cv_qualifier_seq (pp, t);
1279 pp_cxx_simple_type_specifier (pp, t);
1283 pp_cxx_type_specifier_seq (pp, TREE_TYPE (t));
1284 pp_cxx_space_for_pointer_operator (pp, TREE_TYPE (t));
1285 pp_cxx_nested_name_specifier (pp, TYPE_METHOD_BASETYPE (t));
1289 pp_cxx_ws_string (pp, "decltype");
1290 pp_cxx_left_paren (pp);
1291 pp_cxx_expression (pp, DECLTYPE_TYPE_EXPR (t));
1292 pp_cxx_right_paren (pp);
1296 if (TYPE_PTRMEMFUNC_P (t))
1298 tree pfm = TYPE_PTRMEMFUNC_FN_TYPE (t);
1299 pp_cxx_decl_specifier_seq (pp, TREE_TYPE (TREE_TYPE (pfm)));
1300 pp_cxx_whitespace (pp);
1301 pp_cxx_ptr_operator (pp, t);
1304 /* else fall through */
1307 if (!(TREE_CODE (t) == FUNCTION_DECL && DECL_CONSTRUCTOR_P (t)))
1308 pp_c_specifier_qualifier_list (pp_c_base (pp), t);
1313 * cv-qualifier-seq(opt)
1315 ::(opt) nested-name-specifier * cv-qualifier-seq(opt) */
1318 pp_cxx_ptr_operator (cxx_pretty_printer *pp, tree t)
1320 if (!TYPE_P (t) && TREE_CODE (t) != TYPE_DECL)
1322 switch (TREE_CODE (t))
1324 case REFERENCE_TYPE:
1326 if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE
1327 || TYPE_PTR_TO_MEMBER_P (TREE_TYPE (t)))
1328 pp_cxx_ptr_operator (pp, TREE_TYPE (t));
1329 pp_c_attributes_display (pp_c_base (pp),
1330 TYPE_ATTRIBUTES (TREE_TYPE (t)));
1331 if (TREE_CODE (t) == POINTER_TYPE)
1334 pp_cxx_cv_qualifier_seq (pp, t);
1341 if (TYPE_PTRMEMFUNC_P (t))
1343 pp_cxx_left_paren (pp);
1344 pp_cxx_nested_name_specifier (pp, TYPE_PTRMEMFUNC_OBJECT_TYPE (t));
1349 if (TYPE_PTR_TO_MEMBER_P (t))
1351 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
1352 pp_cxx_left_paren (pp);
1353 pp_cxx_nested_name_specifier (pp, TYPE_PTRMEM_CLASS_TYPE (t));
1355 pp_cxx_cv_qualifier_seq (pp, t);
1358 /* else fall through. */
1361 pp_unsupported_tree (pp, t);
1367 pp_cxx_implicit_parameter_type (tree mf)
1369 return class_of_this_parm (TREE_TYPE (mf));
1373 parameter-declaration:
1374 decl-specifier-seq declarator
1375 decl-specifier-seq declarator = assignment-expression
1376 decl-specifier-seq abstract-declarator(opt)
1377 decl-specifier-seq abstract-declarator(opt) assignment-expression */
1380 pp_cxx_parameter_declaration (cxx_pretty_printer *pp, tree t)
1382 pp_cxx_decl_specifier_seq (pp, t);
1384 pp_cxx_abstract_declarator (pp, t);
1386 pp_cxx_declarator (pp, t);
1389 /* parameter-declaration-clause:
1390 parameter-declaration-list(opt) ...(opt)
1391 parameter-declaration-list , ...
1393 parameter-declaration-list:
1394 parameter-declaration
1395 parameter-declaration-list , parameter-declaration */
1398 pp_cxx_parameter_declaration_clause (cxx_pretty_printer *pp, tree t)
1400 tree args = TYPE_P (t) ? NULL : FUNCTION_FIRST_USER_PARM (t);
1402 TYPE_P (t) ? TYPE_ARG_TYPES (t) : FUNCTION_FIRST_USER_PARMTYPE (t);
1403 const bool abstract = args == NULL
1404 || pp_c_base (pp)->flags & pp_c_flag_abstract;
1407 /* Skip artificial parameter for nonstatic member functions. */
1408 if (TREE_CODE (t) == METHOD_TYPE)
1409 types = TREE_CHAIN (types);
1411 pp_cxx_left_paren (pp);
1412 for (; args; args = TREE_CHAIN (args), types = TREE_CHAIN (types))
1415 pp_cxx_separate_with (pp, ',');
1417 pp_cxx_parameter_declaration (pp, abstract ? TREE_VALUE (types) : args);
1418 if (!abstract && pp_c_base (pp)->flags & pp_cxx_flag_default_argument)
1420 pp_cxx_whitespace (pp);
1422 pp_cxx_whitespace (pp);
1423 pp_cxx_assignment_expression (pp, TREE_PURPOSE (types));
1426 pp_cxx_right_paren (pp);
1429 /* exception-specification:
1430 throw ( type-id-list(opt) )
1434 type-id-list , type-id */
1437 pp_cxx_exception_specification (cxx_pretty_printer *pp, tree t)
1439 tree ex_spec = TYPE_RAISES_EXCEPTIONS (t);
1440 bool need_comma = false;
1442 if (ex_spec == NULL)
1444 if (TREE_PURPOSE (ex_spec))
1446 pp_cxx_ws_string (pp, "noexcept");
1447 pp_cxx_whitespace (pp);
1448 pp_cxx_left_paren (pp);
1449 if (DEFERRED_NOEXCEPT_SPEC_P (ex_spec))
1450 pp_cxx_ws_string (pp, "<uninstantiated>");
1452 pp_cxx_expression (pp, TREE_PURPOSE (ex_spec));
1453 pp_cxx_right_paren (pp);
1456 pp_cxx_ws_string (pp, "throw");
1457 pp_cxx_left_paren (pp);
1458 for (; ex_spec && TREE_VALUE (ex_spec); ex_spec = TREE_CHAIN (ex_spec))
1460 tree type = TREE_VALUE (ex_spec);
1461 tree argpack = NULL_TREE;
1464 if (ARGUMENT_PACK_P (type))
1466 argpack = ARGUMENT_PACK_ARGS (type);
1467 len = TREE_VEC_LENGTH (argpack);
1470 for (i = 0; i < len; ++i)
1473 type = TREE_VEC_ELT (argpack, i);
1476 pp_cxx_separate_with (pp, ',');
1480 pp_cxx_type_id (pp, type);
1483 pp_cxx_right_paren (pp);
1486 /* direct-declarator:
1488 direct-declarator ( parameter-declaration-clause ) cv-qualifier-seq(opt)
1489 exception-specification(opt)
1490 direct-declaration [ constant-expression(opt) ]
1494 pp_cxx_direct_declarator (cxx_pretty_printer *pp, tree t)
1496 switch (TREE_CODE (t))
1504 pp_cxx_space_for_pointer_operator (pp, TREE_TYPE (t));
1506 if ((TREE_CODE (t) == PARM_DECL && FUNCTION_PARAMETER_PACK_P (t))
1507 || template_parameter_pack_p (t))
1508 /* A function parameter pack or non-type template
1510 pp_cxx_ws_string (pp, "...");
1512 pp_cxx_id_expression (pp, DECL_NAME (t));
1514 pp_cxx_abstract_declarator (pp, TREE_TYPE (t));
1518 pp_cxx_space_for_pointer_operator (pp, TREE_TYPE (TREE_TYPE (t)));
1519 pp_cxx_id_expression (pp, t);
1520 pp_cxx_parameter_declaration_clause (pp, t);
1522 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
1524 pp_base (pp)->padding = pp_before;
1525 pp_cxx_cv_qualifier_seq (pp, pp_cxx_implicit_parameter_type (t));
1528 pp_cxx_exception_specification (pp, TREE_TYPE (t));
1533 case TEMPLATE_TYPE_PARM:
1534 case TEMPLATE_PARM_INDEX:
1535 case TEMPLATE_TEMPLATE_PARM:
1539 pp_c_direct_declarator (pp_c_base (pp), t);
1546 ptr-operator declarator */
1549 pp_cxx_declarator (cxx_pretty_printer *pp, tree t)
1551 pp_cxx_direct_declarator (pp, t);
1554 /* ctor-initializer:
1555 : mem-initializer-list
1557 mem-initializer-list:
1559 mem-initializer , mem-initializer-list
1562 mem-initializer-id ( expression-list(opt) )
1565 ::(opt) nested-name-specifier(opt) class-name
1569 pp_cxx_ctor_initializer (cxx_pretty_printer *pp, tree t)
1571 t = TREE_OPERAND (t, 0);
1572 pp_cxx_whitespace (pp);
1574 pp_cxx_whitespace (pp);
1575 for (; t; t = TREE_CHAIN (t))
1577 tree purpose = TREE_PURPOSE (t);
1578 bool is_pack = PACK_EXPANSION_P (purpose);
1581 pp_cxx_primary_expression (pp, PACK_EXPANSION_PATTERN (purpose));
1583 pp_cxx_primary_expression (pp, purpose);
1584 pp_cxx_call_argument_list (pp, TREE_VALUE (t));
1586 pp_cxx_ws_string (pp, "...");
1588 pp_cxx_separate_with (pp, ',');
1592 /* function-definition:
1593 decl-specifier-seq(opt) declarator ctor-initializer(opt) function-body
1594 decl-specifier-seq(opt) declarator function-try-block */
1597 pp_cxx_function_definition (cxx_pretty_printer *pp, tree t)
1599 tree saved_scope = pp->enclosing_scope;
1600 pp_cxx_decl_specifier_seq (pp, t);
1601 pp_cxx_declarator (pp, t);
1602 pp_needs_newline (pp) = true;
1603 pp->enclosing_scope = DECL_CONTEXT (t);
1604 if (DECL_SAVED_TREE (t))
1605 pp_cxx_statement (pp, DECL_SAVED_TREE (t));
1608 pp_cxx_semicolon (pp);
1609 pp_needs_newline (pp) = true;
1612 pp->enclosing_scope = saved_scope;
1615 /* abstract-declarator:
1616 ptr-operator abstract-declarator(opt)
1617 direct-abstract-declarator */
1620 pp_cxx_abstract_declarator (cxx_pretty_printer *pp, tree t)
1622 if (TYPE_PTRMEM_P (t) || TYPE_PTRMEMFUNC_P (t))
1623 pp_cxx_right_paren (pp);
1624 else if (POINTER_TYPE_P (t))
1626 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
1627 || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
1628 pp_cxx_right_paren (pp);
1631 pp_cxx_direct_abstract_declarator (pp, t);
1634 /* direct-abstract-declarator:
1635 direct-abstract-declarator(opt) ( parameter-declaration-clause )
1636 cv-qualifier-seq(opt) exception-specification(opt)
1637 direct-abstract-declarator(opt) [ constant-expression(opt) ]
1638 ( abstract-declarator ) */
1641 pp_cxx_direct_abstract_declarator (cxx_pretty_printer *pp, tree t)
1643 switch (TREE_CODE (t))
1645 case REFERENCE_TYPE:
1646 pp_cxx_abstract_declarator (pp, t);
1650 if (TYPE_PTRMEMFUNC_P (t))
1651 pp_cxx_direct_abstract_declarator (pp, TYPE_PTRMEMFUNC_FN_TYPE (t));
1656 pp_cxx_parameter_declaration_clause (pp, t);
1657 pp_cxx_direct_abstract_declarator (pp, TREE_TYPE (t));
1658 if (TREE_CODE (t) == METHOD_TYPE)
1660 pp_base (pp)->padding = pp_before;
1661 pp_cxx_cv_qualifier_seq (pp, class_of_this_parm (t));
1663 pp_cxx_exception_specification (pp, t);
1667 case TEMPLATE_TYPE_PARM:
1668 case TEMPLATE_TEMPLATE_PARM:
1669 case BOUND_TEMPLATE_TEMPLATE_PARM:
1670 case UNBOUND_CLASS_TEMPLATE:
1674 pp_c_direct_abstract_declarator (pp_c_base (pp), t);
1680 type-specifier-seq abstract-declarator(opt) */
1683 pp_cxx_type_id (cxx_pretty_printer *pp, tree t)
1685 pp_flags saved_flags = pp_c_base (pp)->flags;
1686 pp_c_base (pp)->flags |= pp_c_flag_abstract;
1688 switch (TREE_CODE (t))
1695 case BOUND_TEMPLATE_TEMPLATE_PARM:
1696 case UNBOUND_CLASS_TEMPLATE:
1697 case TEMPLATE_TEMPLATE_PARM:
1698 case TEMPLATE_TYPE_PARM:
1699 case TEMPLATE_PARM_INDEX:
1702 case UNDERLYING_TYPE:
1704 case TEMPLATE_ID_EXPR:
1705 pp_cxx_type_specifier_seq (pp, t);
1708 case TYPE_PACK_EXPANSION:
1709 pp_cxx_type_id (pp, PACK_EXPANSION_PATTERN (t));
1710 pp_cxx_ws_string (pp, "...");
1714 pp_c_type_id (pp_c_base (pp), t);
1718 pp_c_base (pp)->flags = saved_flags;
1721 /* template-argument-list:
1722 template-argument ...(opt)
1723 template-argument-list, template-argument ...(opt)
1726 assignment-expression
1731 pp_cxx_template_argument_list (cxx_pretty_printer *pp, tree t)
1734 bool need_comma = false;
1738 for (i = 0; i < TREE_VEC_LENGTH (t); ++i)
1740 tree arg = TREE_VEC_ELT (t, i);
1741 tree argpack = NULL_TREE;
1744 if (ARGUMENT_PACK_P (arg))
1746 argpack = ARGUMENT_PACK_ARGS (arg);
1747 len = TREE_VEC_LENGTH (argpack);
1750 for (idx = 0; idx < len; idx++)
1753 arg = TREE_VEC_ELT (argpack, idx);
1756 pp_cxx_separate_with (pp, ',');
1760 if (TYPE_P (arg) || (TREE_CODE (arg) == TEMPLATE_DECL
1761 && TYPE_P (DECL_TEMPLATE_RESULT (arg))))
1762 pp_cxx_type_id (pp, arg);
1764 pp_cxx_expression (pp, arg);
1771 pp_cxx_exception_declaration (cxx_pretty_printer *pp, tree t)
1773 t = DECL_EXPR_DECL (t);
1774 pp_cxx_type_specifier_seq (pp, t);
1776 pp_cxx_abstract_declarator (pp, t);
1778 pp_cxx_declarator (pp, t);
1784 pp_cxx_statement (cxx_pretty_printer *pp, tree t)
1786 switch (TREE_CODE (t))
1788 case CTOR_INITIALIZER:
1789 pp_cxx_ctor_initializer (pp, t);
1793 pp_cxx_ws_string (pp, "using");
1794 pp_cxx_ws_string (pp, "namespace");
1795 if (DECL_CONTEXT (t))
1796 pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
1797 pp_cxx_qualified_id (pp, USING_STMT_NAMESPACE (t));
1801 pp_cxx_ws_string (pp, "using");
1802 pp_cxx_nested_name_specifier (pp, USING_DECL_SCOPE (t));
1803 pp_cxx_unqualified_id (pp, DECL_NAME (t));
1810 try compound-statement handler-seq */
1812 pp_maybe_newline_and_indent (pp, 0);
1813 pp_cxx_ws_string (pp, "try");
1814 pp_newline_and_indent (pp, 3);
1815 pp_cxx_statement (pp, TRY_STMTS (t));
1816 pp_newline_and_indent (pp, -3);
1820 pp_cxx_statement (pp, TRY_HANDLERS (t));
1825 handler handler-seq(opt)
1828 catch ( exception-declaration ) compound-statement
1830 exception-declaration:
1831 type-specifier-seq declarator
1832 type-specifier-seq abstract-declarator
1835 pp_cxx_ws_string (pp, "catch");
1836 pp_cxx_left_paren (pp);
1837 pp_cxx_exception_declaration (pp, HANDLER_PARMS (t));
1838 pp_cxx_right_paren (pp);
1839 pp_indentation (pp) += 3;
1840 pp_needs_newline (pp) = true;
1841 pp_cxx_statement (pp, HANDLER_BODY (t));
1842 pp_indentation (pp) -= 3;
1843 pp_needs_newline (pp) = true;
1846 /* selection-statement:
1847 if ( expression ) statement
1848 if ( expression ) statement else statement */
1850 pp_cxx_ws_string (pp, "if");
1851 pp_cxx_whitespace (pp);
1852 pp_cxx_left_paren (pp);
1853 pp_cxx_expression (pp, IF_COND (t));
1854 pp_cxx_right_paren (pp);
1855 pp_newline_and_indent (pp, 2);
1856 pp_cxx_statement (pp, THEN_CLAUSE (t));
1857 pp_newline_and_indent (pp, -2);
1858 if (ELSE_CLAUSE (t))
1860 tree else_clause = ELSE_CLAUSE (t);
1861 pp_cxx_ws_string (pp, "else");
1862 if (TREE_CODE (else_clause) == IF_STMT)
1863 pp_cxx_whitespace (pp);
1865 pp_newline_and_indent (pp, 2);
1866 pp_cxx_statement (pp, else_clause);
1867 if (TREE_CODE (else_clause) != IF_STMT)
1868 pp_newline_and_indent (pp, -2);
1873 pp_cxx_ws_string (pp, "switch");
1875 pp_cxx_left_paren (pp);
1876 pp_cxx_expression (pp, SWITCH_STMT_COND (t));
1877 pp_cxx_right_paren (pp);
1878 pp_indentation (pp) += 3;
1879 pp_needs_newline (pp) = true;
1880 pp_cxx_statement (pp, SWITCH_STMT_BODY (t));
1881 pp_newline_and_indent (pp, -3);
1884 /* iteration-statement:
1885 while ( expression ) statement
1886 do statement while ( expression ) ;
1887 for ( expression(opt) ; expression(opt) ; expression(opt) ) statement
1888 for ( declaration expression(opt) ; expression(opt) ) statement */
1890 pp_cxx_ws_string (pp, "while");
1892 pp_cxx_left_paren (pp);
1893 pp_cxx_expression (pp, WHILE_COND (t));
1894 pp_cxx_right_paren (pp);
1895 pp_newline_and_indent (pp, 3);
1896 pp_cxx_statement (pp, WHILE_BODY (t));
1897 pp_indentation (pp) -= 3;
1898 pp_needs_newline (pp) = true;
1902 pp_cxx_ws_string (pp, "do");
1903 pp_newline_and_indent (pp, 3);
1904 pp_cxx_statement (pp, DO_BODY (t));
1905 pp_newline_and_indent (pp, -3);
1906 pp_cxx_ws_string (pp, "while");
1908 pp_cxx_left_paren (pp);
1909 pp_cxx_expression (pp, DO_COND (t));
1910 pp_cxx_right_paren (pp);
1911 pp_cxx_semicolon (pp);
1912 pp_needs_newline (pp) = true;
1916 pp_cxx_ws_string (pp, "for");
1918 pp_cxx_left_paren (pp);
1919 if (FOR_INIT_STMT (t))
1920 pp_cxx_statement (pp, FOR_INIT_STMT (t));
1922 pp_cxx_semicolon (pp);
1923 pp_needs_newline (pp) = false;
1924 pp_cxx_whitespace (pp);
1926 pp_cxx_expression (pp, FOR_COND (t));
1927 pp_cxx_semicolon (pp);
1928 pp_needs_newline (pp) = false;
1929 pp_cxx_whitespace (pp);
1931 pp_cxx_expression (pp, FOR_EXPR (t));
1932 pp_cxx_right_paren (pp);
1933 pp_newline_and_indent (pp, 3);
1934 pp_cxx_statement (pp, FOR_BODY (t));
1935 pp_indentation (pp) -= 3;
1936 pp_needs_newline (pp) = true;
1939 case RANGE_FOR_STMT:
1940 pp_cxx_ws_string (pp, "for");
1942 pp_cxx_left_paren (pp);
1943 pp_cxx_statement (pp, RANGE_FOR_DECL (t));
1945 pp_needs_newline (pp) = false;
1948 pp_cxx_statement (pp, RANGE_FOR_EXPR (t));
1949 pp_cxx_right_paren (pp);
1950 pp_newline_and_indent (pp, 3);
1951 pp_cxx_statement (pp, FOR_BODY (t));
1952 pp_indentation (pp) -= 3;
1953 pp_needs_newline (pp) = true;
1959 return expression(opt) ; */
1962 pp_string (pp, TREE_CODE (t) == BREAK_STMT ? "break" : "continue");
1963 pp_cxx_semicolon (pp);
1964 pp_needs_newline (pp) = true;
1967 /* expression-statement:
1968 expression(opt) ; */
1970 pp_cxx_expression (pp, EXPR_STMT_EXPR (t));
1971 pp_cxx_semicolon (pp);
1972 pp_needs_newline (pp) = true;
1976 pp_cxx_ws_string (pp, "try");
1977 pp_newline_and_indent (pp, 2);
1978 pp_cxx_statement (pp, CLEANUP_BODY (t));
1979 pp_newline_and_indent (pp, -2);
1980 pp_cxx_ws_string (pp, CLEANUP_EH_ONLY (t) ? "catch" : "finally");
1981 pp_newline_and_indent (pp, 2);
1982 pp_cxx_statement (pp, CLEANUP_EXPR (t));
1983 pp_newline_and_indent (pp, -2);
1987 pp_cxx_declaration (pp, t);
1991 pp_c_statement (pp_c_base (pp), t);
1996 /* original-namespace-definition:
1997 namespace identifier { namespace-body }
1999 As an edge case, we also handle unnamed namespace definition here. */
2002 pp_cxx_original_namespace_definition (cxx_pretty_printer *pp, tree t)
2004 pp_cxx_ws_string (pp, "namespace");
2005 if (DECL_CONTEXT (t))
2006 pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
2008 pp_cxx_unqualified_id (pp, t);
2009 pp_cxx_whitespace (pp);
2010 pp_cxx_left_brace (pp);
2011 /* We do not print the namespace-body. */
2012 pp_cxx_whitespace (pp);
2013 pp_cxx_right_brace (pp);
2019 namespace-alias-definition:
2020 namespace identifier = qualified-namespace-specifier ;
2022 qualified-namespace-specifier:
2023 ::(opt) nested-name-specifier(opt) namespace-name */
2026 pp_cxx_namespace_alias_definition (cxx_pretty_printer *pp, tree t)
2028 pp_cxx_ws_string (pp, "namespace");
2029 if (DECL_CONTEXT (t))
2030 pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
2031 pp_cxx_unqualified_id (pp, t);
2032 pp_cxx_whitespace (pp);
2034 pp_cxx_whitespace (pp);
2035 if (DECL_CONTEXT (DECL_NAMESPACE_ALIAS (t)))
2036 pp_cxx_nested_name_specifier (pp,
2037 DECL_CONTEXT (DECL_NAMESPACE_ALIAS (t)));
2038 pp_cxx_qualified_id (pp, DECL_NAMESPACE_ALIAS (t));
2039 pp_cxx_semicolon (pp);
2042 /* simple-declaration:
2043 decl-specifier-seq(opt) init-declarator-list(opt) */
2046 pp_cxx_simple_declaration (cxx_pretty_printer *pp, tree t)
2048 pp_cxx_decl_specifier_seq (pp, t);
2049 pp_cxx_init_declarator (pp, t);
2050 pp_cxx_semicolon (pp);
2051 pp_needs_newline (pp) = true;
2055 template-parameter-list:
2057 template-parameter-list , template-parameter */
2060 pp_cxx_template_parameter_list (cxx_pretty_printer *pp, tree t)
2062 const int n = TREE_VEC_LENGTH (t);
2064 for (i = 0; i < n; ++i)
2067 pp_cxx_separate_with (pp, ',');
2068 pp_cxx_template_parameter (pp, TREE_VEC_ELT (t, i));
2072 /* template-parameter:
2074 parameter-declaration
2077 class ...(opt) identifier(opt)
2078 class identifier(opt) = type-id
2079 typename identifier(opt)
2080 typename ...(opt) identifier(opt) = type-id
2081 template < template-parameter-list > class ...(opt) identifier(opt)
2082 template < template-parameter-list > class identifier(opt) = template-name */
2085 pp_cxx_template_parameter (cxx_pretty_printer *pp, tree t)
2087 tree parameter = TREE_VALUE (t);
2088 switch (TREE_CODE (parameter))
2091 pp_cxx_ws_string (pp, "class");
2092 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
2093 pp_cxx_ws_string (pp, "...");
2094 if (DECL_NAME (parameter))
2095 pp_cxx_tree_identifier (pp, DECL_NAME (parameter));
2096 /* FIXME: Check if we should print also default argument. */
2100 pp_cxx_parameter_declaration (pp, parameter);
2107 pp_unsupported_tree (pp, t);
2112 /* Pretty-print a template parameter in the canonical form
2113 "template-parameter-<level>-<position in parameter list>". */
2116 pp_cxx_canonical_template_parameter (cxx_pretty_printer *pp, tree parm)
2118 const enum tree_code code = TREE_CODE (parm);
2120 /* Brings type template parameters to the canonical forms. */
2121 if (code == TEMPLATE_TYPE_PARM || code == TEMPLATE_TEMPLATE_PARM
2122 || code == BOUND_TEMPLATE_TEMPLATE_PARM)
2123 parm = TEMPLATE_TYPE_PARM_INDEX (parm);
2125 pp_cxx_begin_template_argument_list (pp);
2126 pp_cxx_ws_string (pp, M_("template-parameter-"));
2127 pp_wide_integer (pp, TEMPLATE_PARM_LEVEL (parm));
2129 pp_wide_integer (pp, TEMPLATE_PARM_IDX (parm) + 1);
2130 pp_cxx_end_template_argument_list (pp);
2134 template-declaration:
2135 export(opt) template < template-parameter-list > declaration */
2138 pp_cxx_template_declaration (cxx_pretty_printer *pp, tree t)
2140 tree tmpl = most_general_template (t);
2143 pp_maybe_newline_and_indent (pp, 0);
2144 for (level = DECL_TEMPLATE_PARMS (tmpl); level; level = TREE_CHAIN (level))
2146 pp_cxx_ws_string (pp, "template");
2147 pp_cxx_begin_template_argument_list (pp);
2148 pp_cxx_template_parameter_list (pp, TREE_VALUE (level));
2149 pp_cxx_end_template_argument_list (pp);
2150 pp_newline_and_indent (pp, 3);
2152 if (TREE_CODE (t) == FUNCTION_DECL && DECL_SAVED_TREE (t))
2153 pp_cxx_function_definition (pp, t);
2155 pp_cxx_simple_declaration (pp, t);
2159 pp_cxx_explicit_specialization (cxx_pretty_printer *pp, tree t)
2161 pp_unsupported_tree (pp, t);
2165 pp_cxx_explicit_instantiation (cxx_pretty_printer *pp, tree t)
2167 pp_unsupported_tree (pp, t);
2174 template-declaration
2175 explicit-instantiation
2176 explicit-specialization
2177 linkage-specification
2178 namespace-definition
2183 namespace-alias-definition
2186 static_assert-declaration */
2188 pp_cxx_declaration (cxx_pretty_printer *pp, tree t)
2190 if (TREE_CODE (t) == STATIC_ASSERT)
2192 pp_cxx_ws_string (pp, "static_assert");
2193 pp_cxx_left_paren (pp);
2194 pp_cxx_expression (pp, STATIC_ASSERT_CONDITION (t));
2195 pp_cxx_separate_with (pp, ',');
2196 pp_cxx_expression (pp, STATIC_ASSERT_MESSAGE (t));
2197 pp_cxx_right_paren (pp);
2199 else if (!DECL_LANG_SPECIFIC (t))
2200 pp_cxx_simple_declaration (pp, t);
2201 else if (DECL_USE_TEMPLATE (t))
2202 switch (DECL_USE_TEMPLATE (t))
2205 pp_cxx_template_declaration (pp, t);
2209 pp_cxx_explicit_specialization (pp, t);
2213 pp_cxx_explicit_instantiation (pp, t);
2219 else switch (TREE_CODE (t))
2223 pp_cxx_simple_declaration (pp, t);
2227 if (DECL_SAVED_TREE (t))
2228 pp_cxx_function_definition (pp, t);
2230 pp_cxx_simple_declaration (pp, t);
2233 case NAMESPACE_DECL:
2234 if (DECL_NAMESPACE_ALIAS (t))
2235 pp_cxx_namespace_alias_definition (pp, t);
2237 pp_cxx_original_namespace_definition (pp, t);
2241 pp_unsupported_tree (pp, t);
2247 pp_cxx_typeid_expression (cxx_pretty_printer *pp, tree t)
2249 t = TREE_OPERAND (t, 0);
2250 pp_cxx_ws_string (pp, "typeid");
2251 pp_cxx_left_paren (pp);
2253 pp_cxx_type_id (pp, t);
2255 pp_cxx_expression (pp, t);
2256 pp_cxx_right_paren (pp);
2260 pp_cxx_va_arg_expression (cxx_pretty_printer *pp, tree t)
2262 pp_cxx_ws_string (pp, "va_arg");
2263 pp_cxx_left_paren (pp);
2264 pp_cxx_assignment_expression (pp, TREE_OPERAND (t, 0));
2265 pp_cxx_separate_with (pp, ',');
2266 pp_cxx_type_id (pp, TREE_TYPE (t));
2267 pp_cxx_right_paren (pp);
2271 pp_cxx_offsetof_expression_1 (cxx_pretty_printer *pp, tree t)
2273 switch (TREE_CODE (t))
2276 if (TREE_CODE (TREE_OPERAND (t, 0)) == STATIC_CAST_EXPR
2277 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (t, 0))))
2279 pp_cxx_type_id (pp, TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0))));
2280 pp_cxx_separate_with (pp, ',');
2285 if (!pp_cxx_offsetof_expression_1 (pp, TREE_OPERAND (t, 0)))
2287 if (TREE_CODE (TREE_OPERAND (t, 0)) != ARROW_EXPR)
2289 pp_cxx_expression (pp, TREE_OPERAND (t, 1));
2292 if (!pp_cxx_offsetof_expression_1 (pp, TREE_OPERAND (t, 0)))
2294 pp_left_bracket (pp);
2295 pp_cxx_expression (pp, TREE_OPERAND (t, 1));
2296 pp_right_bracket (pp);
2304 pp_cxx_offsetof_expression (cxx_pretty_printer *pp, tree t)
2306 pp_cxx_ws_string (pp, "offsetof");
2307 pp_cxx_left_paren (pp);
2308 if (!pp_cxx_offsetof_expression_1 (pp, TREE_OPERAND (t, 0)))
2309 pp_cxx_expression (pp, TREE_OPERAND (t, 0));
2310 pp_cxx_right_paren (pp);
2314 pp_cxx_trait_expression (cxx_pretty_printer *pp, tree t)
2316 cp_trait_kind kind = TRAIT_EXPR_KIND (t);
2320 case CPTK_HAS_NOTHROW_ASSIGN:
2321 pp_cxx_ws_string (pp, "__has_nothrow_assign");
2323 case CPTK_HAS_TRIVIAL_ASSIGN:
2324 pp_cxx_ws_string (pp, "__has_trivial_assign");
2326 case CPTK_HAS_NOTHROW_CONSTRUCTOR:
2327 pp_cxx_ws_string (pp, "__has_nothrow_constructor");
2329 case CPTK_HAS_TRIVIAL_CONSTRUCTOR:
2330 pp_cxx_ws_string (pp, "__has_trivial_constructor");
2332 case CPTK_HAS_NOTHROW_COPY:
2333 pp_cxx_ws_string (pp, "__has_nothrow_copy");
2335 case CPTK_HAS_TRIVIAL_COPY:
2336 pp_cxx_ws_string (pp, "__has_trivial_copy");
2338 case CPTK_HAS_TRIVIAL_DESTRUCTOR:
2339 pp_cxx_ws_string (pp, "__has_trivial_destructor");
2341 case CPTK_HAS_VIRTUAL_DESTRUCTOR:
2342 pp_cxx_ws_string (pp, "__has_virtual_destructor");
2344 case CPTK_IS_ABSTRACT:
2345 pp_cxx_ws_string (pp, "__is_abstract");
2347 case CPTK_IS_BASE_OF:
2348 pp_cxx_ws_string (pp, "__is_base_of");
2351 pp_cxx_ws_string (pp, "__is_class");
2353 case CPTK_IS_CONVERTIBLE_TO:
2354 pp_cxx_ws_string (pp, "__is_convertible_to");
2357 pp_cxx_ws_string (pp, "__is_empty");
2360 pp_cxx_ws_string (pp, "__is_enum");
2363 pp_cxx_ws_string (pp, "__is_pod");
2365 case CPTK_IS_POLYMORPHIC:
2366 pp_cxx_ws_string (pp, "__is_polymorphic");
2368 case CPTK_IS_STD_LAYOUT:
2369 pp_cxx_ws_string (pp, "__is_std_layout");
2371 case CPTK_IS_TRIVIAL:
2372 pp_cxx_ws_string (pp, "__is_trivial");
2375 pp_cxx_ws_string (pp, "__is_union");
2377 case CPTK_IS_LITERAL_TYPE:
2378 pp_cxx_ws_string (pp, "__is_literal_type");
2385 pp_cxx_left_paren (pp);
2386 pp_cxx_type_id (pp, TRAIT_EXPR_TYPE1 (t));
2388 if (kind == CPTK_IS_BASE_OF || kind == CPTK_IS_CONVERTIBLE_TO)
2390 pp_cxx_separate_with (pp, ',');
2391 pp_cxx_type_id (pp, TRAIT_EXPR_TYPE2 (t));
2394 pp_cxx_right_paren (pp);
2397 typedef c_pretty_print_fn pp_fun;
2399 /* Initialization of a C++ pretty-printer object. */
2402 pp_cxx_pretty_printer_init (cxx_pretty_printer *pp)
2404 pp_c_pretty_printer_init (pp_c_base (pp));
2405 pp_set_line_maximum_length (pp, 0);
2407 pp->c_base.declaration = (pp_fun) pp_cxx_declaration;
2408 pp->c_base.declaration_specifiers = (pp_fun) pp_cxx_decl_specifier_seq;
2409 pp->c_base.function_specifier = (pp_fun) pp_cxx_function_specifier;
2410 pp->c_base.type_specifier_seq = (pp_fun) pp_cxx_type_specifier_seq;
2411 pp->c_base.declarator = (pp_fun) pp_cxx_declarator;
2412 pp->c_base.direct_declarator = (pp_fun) pp_cxx_direct_declarator;
2413 pp->c_base.parameter_list = (pp_fun) pp_cxx_parameter_declaration_clause;
2414 pp->c_base.type_id = (pp_fun) pp_cxx_type_id;
2415 pp->c_base.abstract_declarator = (pp_fun) pp_cxx_abstract_declarator;
2416 pp->c_base.direct_abstract_declarator =
2417 (pp_fun) pp_cxx_direct_abstract_declarator;
2418 pp->c_base.simple_type_specifier = (pp_fun)pp_cxx_simple_type_specifier;
2420 /* pp->c_base.statement = (pp_fun) pp_cxx_statement; */
2422 pp->c_base.constant = (pp_fun) pp_cxx_constant;
2423 pp->c_base.id_expression = (pp_fun) pp_cxx_id_expression;
2424 pp->c_base.primary_expression = (pp_fun) pp_cxx_primary_expression;
2425 pp->c_base.postfix_expression = (pp_fun) pp_cxx_postfix_expression;
2426 pp->c_base.unary_expression = (pp_fun) pp_cxx_unary_expression;
2427 pp->c_base.multiplicative_expression = (pp_fun) pp_cxx_multiplicative_expression;
2428 pp->c_base.conditional_expression = (pp_fun) pp_cxx_conditional_expression;
2429 pp->c_base.assignment_expression = (pp_fun) pp_cxx_assignment_expression;
2430 pp->c_base.expression = (pp_fun) pp_cxx_expression;
2431 pp->enclosing_scope = global_namespace;