1 /* Implementation of subroutines for the GNU C++ pretty-printer.
2 Copyright (C) 2003, 2004, 2005, 2007, 2008,
3 2009, 2010 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"
32 /* Translate if being used for diagnostics, but not for dump files or
34 #define M_(msgid) (pp_translate_identifiers (pp) ? _(msgid) : (msgid))
36 static void pp_cxx_unqualified_id (cxx_pretty_printer *, tree);
37 static void pp_cxx_nested_name_specifier (cxx_pretty_printer *, tree);
38 static void pp_cxx_qualified_id (cxx_pretty_printer *, tree);
39 static void pp_cxx_assignment_expression (cxx_pretty_printer *, tree);
40 static void pp_cxx_expression (cxx_pretty_printer *, tree);
41 static void pp_cxx_template_argument_list (cxx_pretty_printer *, tree);
42 static void pp_cxx_type_specifier_seq (cxx_pretty_printer *, tree);
43 static void pp_cxx_ptr_operator (cxx_pretty_printer *, tree);
44 static void pp_cxx_type_id (cxx_pretty_printer *, tree);
45 static void pp_cxx_direct_abstract_declarator (cxx_pretty_printer *, tree);
46 static void pp_cxx_declarator (cxx_pretty_printer *, tree);
47 static void pp_cxx_parameter_declaration_clause (cxx_pretty_printer *, tree);
48 static void pp_cxx_abstract_declarator (cxx_pretty_printer *, tree);
49 static void pp_cxx_statement (cxx_pretty_printer *, tree);
50 static void pp_cxx_template_parameter (cxx_pretty_printer *, tree);
51 static void pp_cxx_cast_expression (cxx_pretty_printer *, tree);
52 static void pp_cxx_typeid_expression (cxx_pretty_printer *, tree);
56 pp_cxx_nonconsecutive_character (cxx_pretty_printer *pp, int c)
58 const char *p = pp_last_position_in_text (pp);
60 if (p != NULL && *p == c)
61 pp_cxx_whitespace (pp);
63 pp_base (pp)->padding = pp_none;
66 #define pp_cxx_storage_class_specifier(PP, T) \
67 pp_c_storage_class_specifier (pp_c_base (PP), T)
68 #define pp_cxx_expression_list(PP, T) \
69 pp_c_expression_list (pp_c_base (PP), T)
70 #define pp_cxx_space_for_pointer_operator(PP, T) \
71 pp_c_space_for_pointer_operator (pp_c_base (PP), T)
72 #define pp_cxx_init_declarator(PP, T) \
73 pp_c_init_declarator (pp_c_base (PP), T)
74 #define pp_cxx_call_argument_list(PP, T) \
75 pp_c_call_argument_list (pp_c_base (PP), T)
78 pp_cxx_colon_colon (cxx_pretty_printer *pp)
81 pp_base (pp)->padding = pp_none;
85 pp_cxx_begin_template_argument_list (cxx_pretty_printer *pp)
87 pp_cxx_nonconsecutive_character (pp, '<');
91 pp_cxx_end_template_argument_list (cxx_pretty_printer *pp)
93 pp_cxx_nonconsecutive_character (pp, '>');
97 pp_cxx_separate_with (cxx_pretty_printer *pp, int c)
99 pp_separate_with (pp, c);
100 pp_base (pp)->padding = pp_none;
106 is_destructor_name (tree name)
108 return name == complete_dtor_identifier
109 || name == base_dtor_identifier
110 || name == deleting_dtor_identifier;
113 /* conversion-function-id:
114 operator conversion-type-id
117 type-specifier-seq conversion-declarator(opt)
119 conversion-declarator:
120 ptr-operator conversion-declarator(opt) */
123 pp_cxx_conversion_function_id (cxx_pretty_printer *pp, tree t)
125 pp_cxx_ws_string (pp, "operator");
126 pp_cxx_type_specifier_seq (pp, TREE_TYPE (t));
130 pp_cxx_template_id (cxx_pretty_printer *pp, tree t)
132 pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 0));
133 pp_cxx_begin_template_argument_list (pp);
134 pp_cxx_template_argument_list (pp, TREE_OPERAND (t, 1));
135 pp_cxx_end_template_argument_list (pp);
138 /* Prints the unqualified part of the id-expression T.
143 conversion-function-id
148 pp_cxx_unqualified_id (cxx_pretty_printer *pp, tree t)
150 enum tree_code code = TREE_CODE (t);
154 pp_cxx_ws_string (pp, M_("<return-value>"));
171 case IDENTIFIER_NODE:
173 pp_cxx_ws_string (pp, M_("<unnamed>"));
174 else if (IDENTIFIER_TYPENAME_P (t))
175 pp_cxx_conversion_function_id (pp, t);
178 if (is_destructor_name (t))
181 /* FIXME: Why is this necessary? */
183 t = constructor_name (TREE_TYPE (t));
185 pp_cxx_tree_identifier (pp, t);
189 case TEMPLATE_ID_EXPR:
190 pp_cxx_template_id (pp, t);
194 pp_cxx_unqualified_id (pp, BASELINK_FUNCTIONS (t));
201 case UNBOUND_CLASS_TEMPLATE:
202 pp_cxx_unqualified_id (pp, TYPE_NAME (t));
203 if (CLASS_TYPE_P (t) && CLASSTYPE_USE_TEMPLATE (t))
205 pp_cxx_begin_template_argument_list (pp);
206 pp_cxx_template_argument_list (pp, INNERMOST_TEMPLATE_ARGS
207 (CLASSTYPE_TI_ARGS (t)));
208 pp_cxx_end_template_argument_list (pp);
213 pp_cxx_complement (pp);
214 pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 0));
217 case TEMPLATE_TYPE_PARM:
218 case TEMPLATE_TEMPLATE_PARM:
219 if (TYPE_IDENTIFIER (t))
220 pp_cxx_unqualified_id (pp, TYPE_IDENTIFIER (t));
222 pp_cxx_canonical_template_parameter (pp, t);
225 case TEMPLATE_PARM_INDEX:
226 pp_cxx_unqualified_id (pp, TEMPLATE_PARM_DECL (t));
229 case BOUND_TEMPLATE_TEMPLATE_PARM:
230 pp_cxx_cv_qualifier_seq (pp, t);
231 pp_cxx_unqualified_id (pp, TYPE_IDENTIFIER (t));
232 pp_cxx_begin_template_argument_list (pp);
233 pp_cxx_template_argument_list (pp, TYPE_TI_ARGS (t));
234 pp_cxx_end_template_argument_list (pp);
238 pp_unsupported_tree (pp, t);
243 /* Pretty-print out the token sequence ":: template" in template codes
244 where it is needed to "inline declare" the (following) member as
245 a template. This situation arises when SCOPE of T is dependent
246 on template parameters. */
249 pp_cxx_template_keyword_if_needed (cxx_pretty_printer *pp, tree scope, tree t)
251 if (TREE_CODE (t) == TEMPLATE_ID_EXPR
252 && TYPE_P (scope) && dependent_type_p (scope))
253 pp_cxx_ws_string (pp, "template");
256 /* nested-name-specifier:
257 class-or-namespace-name :: nested-name-specifier(opt)
258 class-or-namespace-name :: template nested-name-specifier */
261 pp_cxx_nested_name_specifier (cxx_pretty_printer *pp, tree t)
263 if (!SCOPE_FILE_SCOPE_P (t) && t != pp->enclosing_scope)
265 tree scope = TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t);
266 pp_cxx_nested_name_specifier (pp, scope);
267 pp_cxx_template_keyword_if_needed (pp, scope, t);
268 pp_cxx_unqualified_id (pp, t);
269 pp_cxx_colon_colon (pp);
274 nested-name-specifier template(opt) unqualified-id */
277 pp_cxx_qualified_id (cxx_pretty_printer *pp, tree t)
279 switch (TREE_CODE (t))
281 /* A pointer-to-member is always qualified. */
283 pp_cxx_nested_name_specifier (pp, PTRMEM_CST_CLASS (t));
284 pp_cxx_unqualified_id (pp, PTRMEM_CST_MEMBER (t));
287 /* In Standard C++, functions cannot possibly be used as
288 nested-name-specifiers. However, there are situations where
289 is "makes sense" to output the surrounding function name for the
290 purpose of emphasizing on the scope kind. Just printing the
291 function name might not be sufficient as it may be overloaded; so,
292 we decorate the function with its signature too.
293 FIXME: This is probably the wrong pretty-printing for conversion
294 functions and some function templates. */
298 if (DECL_FUNCTION_MEMBER_P (t))
299 pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
300 pp_cxx_unqualified_id
301 (pp, DECL_CONSTRUCTOR_P (t) ? DECL_CONTEXT (t) : t);
302 pp_cxx_parameter_declaration_clause (pp, TREE_TYPE (t));
307 pp_cxx_nested_name_specifier (pp, TREE_OPERAND (t, 0));
308 pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 1));
313 tree scope = TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t);
314 if (scope != pp->enclosing_scope)
316 pp_cxx_nested_name_specifier (pp, scope);
317 pp_cxx_template_keyword_if_needed (pp, scope, t);
319 pp_cxx_unqualified_id (pp, t);
327 pp_cxx_constant (cxx_pretty_printer *pp, tree t)
329 switch (TREE_CODE (t))
333 const bool in_parens = PAREN_STRING_LITERAL_P (t);
335 pp_cxx_left_paren (pp);
336 pp_c_constant (pp_c_base (pp), t);
338 pp_cxx_right_paren (pp);
343 if (NULLPTR_TYPE_P (TREE_TYPE (t)))
345 pp_string (pp, "nullptr");
348 /* else fall through. */
351 pp_c_constant (pp_c_base (pp), t);
361 pp_cxx_id_expression (cxx_pretty_printer *pp, tree t)
363 if (TREE_CODE (t) == OVERLOAD)
365 if (DECL_P (t) && DECL_CONTEXT (t))
366 pp_cxx_qualified_id (pp, t);
368 pp_cxx_unqualified_id (pp, t);
371 /* primary-expression:
375 :: operator-function-id
381 __builtin_va_arg ( assignment-expression , type-id )
382 __builtin_offsetof ( type-id, offsetof-expression )
384 __has_nothrow_assign ( type-id )
385 __has_nothrow_constructor ( type-id )
386 __has_nothrow_copy ( type-id )
387 __has_trivial_assign ( type-id )
388 __has_trivial_constructor ( type-id )
389 __has_trivial_copy ( type-id )
390 __has_trivial_destructor ( type-id )
391 __has_virtual_destructor ( type-id )
392 __is_abstract ( type-id )
393 __is_base_of ( type-id , type-id )
394 __is_class ( type-id )
395 __is_convertible_to ( type-id , type-id )
396 __is_empty ( type-id )
397 __is_enum ( type-id )
399 __is_polymorphic ( type-id )
400 __is_union ( type-id ) */
403 pp_cxx_primary_expression (cxx_pretty_printer *pp, tree t)
405 switch (TREE_CODE (t))
411 pp_cxx_constant (pp, t);
415 t = BASELINK_FUNCTIONS (t);
423 pp_cxx_id_expression (pp, t);
427 case TEMPLATE_TYPE_PARM:
428 case TEMPLATE_TEMPLATE_PARM:
429 case TEMPLATE_PARM_INDEX:
430 pp_cxx_unqualified_id (pp, t);
434 pp_cxx_left_paren (pp);
435 pp_cxx_statement (pp, STMT_EXPR_STMT (t));
436 pp_cxx_right_paren (pp);
440 pp_cxx_trait_expression (pp, t);
444 pp_cxx_va_arg_expression (pp, t);
448 pp_cxx_offsetof_expression (pp, t);
452 pp_c_primary_expression (pp_c_base (pp), t);
457 /* postfix-expression:
459 postfix-expression [ expression ]
460 postfix-expression ( expression-list(opt) )
461 simple-type-specifier ( expression-list(opt) )
462 typename ::(opt) nested-name-specifier identifier ( expression-list(opt) )
463 typename ::(opt) nested-name-specifier template(opt)
464 template-id ( expression-list(opt) )
465 postfix-expression . template(opt) ::(opt) id-expression
466 postfix-expression -> template(opt) ::(opt) id-expression
467 postfix-expression . pseudo-destructor-name
468 postfix-expression -> pseudo-destructor-name
469 postfix-expression ++
470 postfix-expression --
471 dynamic_cast < type-id > ( expression )
472 static_cast < type-id > ( expression )
473 reinterpret_cast < type-id > ( expression )
474 const_cast < type-id > ( expression )
475 typeid ( expression )
476 typeid ( type-id ) */
479 pp_cxx_postfix_expression (cxx_pretty_printer *pp, tree t)
481 enum tree_code code = TREE_CODE (t);
488 tree fun = (code == AGGR_INIT_EXPR ? AGGR_INIT_EXPR_FN (t)
490 tree saved_scope = pp->enclosing_scope;
491 bool skipfirst = false;
494 if (TREE_CODE (fun) == ADDR_EXPR)
495 fun = TREE_OPERAND (fun, 0);
497 /* In templates, where there is no way to tell whether a given
498 call uses an actual member function. So the parser builds
499 FUN as a COMPONENT_REF or a plain IDENTIFIER_NODE until
500 instantiation time. */
501 if (TREE_CODE (fun) != FUNCTION_DECL)
503 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun))
505 tree object = (code == AGGR_INIT_EXPR
506 ? (AGGR_INIT_VIA_CTOR_P (t)
507 ? AGGR_INIT_EXPR_SLOT (t)
508 : AGGR_INIT_EXPR_ARG (t, 0))
509 : CALL_EXPR_ARG (t, 0));
511 while (TREE_CODE (object) == NOP_EXPR)
512 object = TREE_OPERAND (object, 0);
514 if (TREE_CODE (object) == ADDR_EXPR)
515 object = TREE_OPERAND (object, 0);
517 if (TREE_CODE (TREE_TYPE (object)) != POINTER_TYPE)
519 pp_cxx_postfix_expression (pp, object);
524 pp_cxx_postfix_expression (pp, object);
528 pp->enclosing_scope = strip_pointer_operator (TREE_TYPE (object));
531 pp_cxx_postfix_expression (pp, fun);
532 pp->enclosing_scope = saved_scope;
533 pp_cxx_left_paren (pp);
534 if (code == AGGR_INIT_EXPR)
536 aggr_init_expr_arg_iterator iter;
537 FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
543 pp_cxx_expression (pp, arg);
544 if (more_aggr_init_expr_args_p (&iter))
545 pp_cxx_separate_with (pp, ',');
551 call_expr_arg_iterator iter;
552 FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
558 pp_cxx_expression (pp, arg);
559 if (more_call_expr_args_p (&iter))
560 pp_cxx_separate_with (pp, ',');
564 pp_cxx_right_paren (pp);
566 if (code == AGGR_INIT_EXPR && AGGR_INIT_VIA_CTOR_P (t))
568 pp_cxx_separate_with (pp, ',');
569 pp_cxx_postfix_expression (pp, AGGR_INIT_EXPR_SLOT (t));
582 pp_cxx_primary_expression (pp, t);
585 case DYNAMIC_CAST_EXPR:
586 case STATIC_CAST_EXPR:
587 case REINTERPRET_CAST_EXPR:
588 case CONST_CAST_EXPR:
589 if (code == DYNAMIC_CAST_EXPR)
590 pp_cxx_ws_string (pp, "dynamic_cast");
591 else if (code == STATIC_CAST_EXPR)
592 pp_cxx_ws_string (pp, "static_cast");
593 else if (code == REINTERPRET_CAST_EXPR)
594 pp_cxx_ws_string (pp, "reinterpret_cast");
596 pp_cxx_ws_string (pp, "const_cast");
597 pp_cxx_begin_template_argument_list (pp);
598 pp_cxx_type_id (pp, TREE_TYPE (t));
599 pp_cxx_end_template_argument_list (pp);
601 pp_cxx_expression (pp, TREE_OPERAND (t, 0));
605 case EMPTY_CLASS_EXPR:
606 pp_cxx_type_id (pp, TREE_TYPE (t));
612 pp_cxx_typeid_expression (pp, t);
615 case PSEUDO_DTOR_EXPR:
616 pp_cxx_postfix_expression (pp, TREE_OPERAND (t, 0));
618 pp_cxx_qualified_id (pp, TREE_OPERAND (t, 1));
619 pp_cxx_colon_colon (pp);
621 pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 2));
625 pp_cxx_postfix_expression (pp, TREE_OPERAND (t, 0));
630 pp_c_postfix_expression (pp_c_base (pp), t);
636 ::(opt) new new-placement(opt) new-type-id new-initializer(opt)
637 ::(opt) new new-placement(opt) ( type-id ) new-initializer(opt)
643 type-specifier-seq new-declarator(opt)
646 ptr-operator new-declarator(opt)
647 direct-new-declarator
649 direct-new-declarator
651 direct-new-declarator [ constant-expression ]
654 ( expression-list(opt) ) */
657 pp_cxx_new_expression (cxx_pretty_printer *pp, tree t)
659 enum tree_code code = TREE_CODE (t);
660 tree type = TREE_OPERAND (t, 1);
661 tree init = TREE_OPERAND (t, 2);
666 if (NEW_EXPR_USE_GLOBAL (t))
667 pp_cxx_colon_colon (pp);
668 pp_cxx_ws_string (pp, "new");
669 if (TREE_OPERAND (t, 0))
671 pp_cxx_call_argument_list (pp, TREE_OPERAND (t, 0));
674 if (TREE_CODE (type) == ARRAY_REF)
675 type = build_cplus_array_type
676 (TREE_OPERAND (type, 0),
677 build_index_type (fold_build2_loc (input_location,
678 MINUS_EXPR, integer_type_node,
679 TREE_OPERAND (type, 1),
681 pp_cxx_type_id (pp, type);
685 if (TREE_CODE (init) == TREE_LIST)
686 pp_c_expression_list (pp_c_base (pp), init);
687 else if (init == void_zero_node)
688 ; /* OK, empty initializer list. */
690 pp_cxx_expression (pp, init);
696 pp_unsupported_tree (pp, t);
700 /* delete-expression:
701 ::(opt) delete cast-expression
702 ::(opt) delete [ ] cast-expression */
705 pp_cxx_delete_expression (cxx_pretty_printer *pp, tree t)
707 enum tree_code code = TREE_CODE (t);
711 case VEC_DELETE_EXPR:
712 if (DELETE_EXPR_USE_GLOBAL (t))
713 pp_cxx_colon_colon (pp);
714 pp_cxx_ws_string (pp, "delete");
716 if (code == VEC_DELETE_EXPR
717 || DELETE_EXPR_USE_VEC (t))
719 pp_left_bracket (pp);
720 pp_right_bracket (pp);
723 pp_c_cast_expression (pp_c_base (pp), TREE_OPERAND (t, 0));
727 pp_unsupported_tree (pp, t);
735 unary-operator cast-expression
736 sizeof unary-expression
738 sizeof ... ( identifier )
742 unary-operator: one of
746 __alignof__ unary-expression
747 __alignof__ ( type-id ) */
750 pp_cxx_unary_expression (cxx_pretty_printer *pp, tree t)
752 enum tree_code code = TREE_CODE (t);
757 pp_cxx_new_expression (pp, t);
761 case VEC_DELETE_EXPR:
762 pp_cxx_delete_expression (pp, t);
766 if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
768 pp_cxx_ws_string (pp, "sizeof");
769 pp_cxx_ws_string (pp, "...");
770 pp_cxx_whitespace (pp);
771 pp_cxx_left_paren (pp);
772 if (TYPE_P (TREE_OPERAND (t, 0)))
773 pp_cxx_type_id (pp, TREE_OPERAND (t, 0));
775 pp_unary_expression (pp, TREE_OPERAND (t, 0));
776 pp_cxx_right_paren (pp);
782 pp_cxx_ws_string (pp, code == SIZEOF_EXPR ? "sizeof" : "__alignof__");
783 pp_cxx_whitespace (pp);
784 if (TYPE_P (TREE_OPERAND (t, 0)))
786 pp_cxx_left_paren (pp);
787 pp_cxx_type_id (pp, TREE_OPERAND (t, 0));
788 pp_cxx_right_paren (pp);
791 pp_unary_expression (pp, TREE_OPERAND (t, 0));
795 pp_cxx_ws_string (pp, "@encode");
796 pp_cxx_whitespace (pp);
797 pp_cxx_left_paren (pp);
798 pp_cxx_type_id (pp, TREE_OPERAND (t, 0));
799 pp_cxx_right_paren (pp);
803 pp_cxx_ws_string (pp, "noexcept");
804 pp_cxx_whitespace (pp);
805 pp_cxx_left_paren (pp);
806 pp_cxx_expression (pp, TREE_OPERAND (t, 0));
807 pp_cxx_right_paren (pp);
810 case UNARY_PLUS_EXPR:
812 pp_cxx_cast_expression (pp, TREE_OPERAND (t, 0));
816 pp_c_unary_expression (pp_c_base (pp), t);
823 ( type-id ) cast-expression */
826 pp_cxx_cast_expression (cxx_pretty_printer *pp, tree t)
828 switch (TREE_CODE (t))
831 pp_cxx_type_id (pp, TREE_TYPE (t));
832 pp_cxx_call_argument_list (pp, TREE_OPERAND (t, 0));
836 pp_c_cast_expression (pp_c_base (pp), t);
843 pm-expression .* cast-expression
844 pm-expression ->* cast-expression */
847 pp_cxx_pm_expression (cxx_pretty_printer *pp, tree t)
849 switch (TREE_CODE (t))
851 /* Handle unfortunate OFFSET_REF overloading here. */
853 if (TYPE_P (TREE_OPERAND (t, 0)))
855 pp_cxx_qualified_id (pp, t);
858 /* Else fall through. */
861 pp_cxx_pm_expression (pp, TREE_OPERAND (t, 0));
862 if (TREE_CODE (t) == MEMBER_REF)
867 pp_cxx_cast_expression (pp, TREE_OPERAND (t, 1));
872 pp_cxx_cast_expression (pp, t);
877 /* multiplicative-expression:
879 multiplicative-expression * pm-expression
880 multiplicative-expression / pm-expression
881 multiplicative-expression % pm-expression */
884 pp_cxx_multiplicative_expression (cxx_pretty_printer *pp, tree e)
886 enum tree_code code = TREE_CODE (e);
892 pp_cxx_multiplicative_expression (pp, TREE_OPERAND (e, 0));
894 if (code == MULT_EXPR)
896 else if (code == TRUNC_DIV_EXPR)
901 pp_cxx_pm_expression (pp, TREE_OPERAND (e, 1));
905 pp_cxx_pm_expression (pp, e);
910 /* conditional-expression:
911 logical-or-expression
912 logical-or-expression ? expression : assignment-expression */
915 pp_cxx_conditional_expression (cxx_pretty_printer *pp, tree e)
917 if (TREE_CODE (e) == COND_EXPR)
919 pp_c_logical_or_expression (pp_c_base (pp), TREE_OPERAND (e, 0));
923 pp_cxx_expression (pp, TREE_OPERAND (e, 1));
925 pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 2));
928 pp_c_logical_or_expression (pp_c_base (pp), e);
931 /* Pretty-print a compound assignment operator token as indicated by T. */
934 pp_cxx_assignment_operator (cxx_pretty_printer *pp, tree t)
938 switch (TREE_CODE (t))
961 op = tree_code_name[TREE_CODE (t)];
965 pp_cxx_ws_string (pp, op);
969 /* assignment-expression:
970 conditional-expression
971 logical-or-expression assignment-operator assignment-expression
975 throw assignment-expression(opt)
977 assignment-operator: one of
978 = *= /= %= += -= >>= <<= &= ^= |= */
981 pp_cxx_assignment_expression (cxx_pretty_printer *pp, tree e)
983 switch (TREE_CODE (e))
987 pp_c_logical_or_expression (pp_c_base (pp), TREE_OPERAND (e, 0));
991 pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 1));
995 pp_cxx_ws_string (pp, "throw");
996 if (TREE_OPERAND (e, 0))
997 pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 0));
1001 pp_c_logical_or_expression (pp_c_base (pp), TREE_OPERAND (e, 0));
1002 pp_cxx_assignment_operator (pp, TREE_OPERAND (e, 1));
1003 pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 2));
1007 pp_cxx_conditional_expression (pp, e);
1013 pp_cxx_expression (cxx_pretty_printer *pp, tree t)
1015 switch (TREE_CODE (t))
1021 pp_cxx_constant (pp, t);
1025 pp_cxx_unqualified_id (pp, t);
1033 pp_cxx_qualified_id (pp, t);
1037 t = OVL_CURRENT (t);
1045 case TEMPLATE_TYPE_PARM:
1046 case TEMPLATE_PARM_INDEX:
1047 case TEMPLATE_TEMPLATE_PARM:
1049 pp_cxx_primary_expression (pp, t);
1053 case DYNAMIC_CAST_EXPR:
1054 case STATIC_CAST_EXPR:
1055 case REINTERPRET_CAST_EXPR:
1056 case CONST_CAST_EXPR:
1060 case EMPTY_CLASS_EXPR:
1062 case PSEUDO_DTOR_EXPR:
1063 case AGGR_INIT_EXPR:
1065 pp_cxx_postfix_expression (pp, t);
1070 pp_cxx_new_expression (pp, t);
1074 case VEC_DELETE_EXPR:
1075 pp_cxx_delete_expression (pp, t);
1081 pp_cxx_unary_expression (pp, t);
1085 pp_cxx_cast_expression (pp, t);
1091 pp_cxx_pm_expression (pp, t);
1095 case TRUNC_DIV_EXPR:
1096 case TRUNC_MOD_EXPR:
1097 pp_cxx_multiplicative_expression (pp, t);
1101 pp_cxx_conditional_expression (pp, t);
1108 pp_cxx_assignment_expression (pp, t);
1111 case NON_DEPENDENT_EXPR:
1112 case MUST_NOT_THROW_EXPR:
1113 pp_cxx_expression (pp, TREE_OPERAND (t, 0));
1116 case EXPR_PACK_EXPANSION:
1117 pp_cxx_expression (pp, PACK_EXPANSION_PATTERN (t));
1118 pp_cxx_ws_string (pp, "...");
1121 case TEMPLATE_ID_EXPR:
1122 pp_cxx_template_id (pp, t);
1125 case NONTYPE_ARGUMENT_PACK:
1127 tree args = ARGUMENT_PACK_ARGS (t);
1128 int i, len = TREE_VEC_LENGTH (args);
1129 for (i = 0; i < len; ++i)
1132 pp_cxx_separate_with (pp, ',');
1133 pp_cxx_expression (pp, TREE_VEC_ELT (args, i));
1139 pp_c_expression (pp_c_base (pp), t);
1147 /* function-specifier:
1153 pp_cxx_function_specifier (cxx_pretty_printer *pp, tree t)
1155 switch (TREE_CODE (t))
1158 if (DECL_VIRTUAL_P (t))
1159 pp_cxx_ws_string (pp, "virtual");
1160 else if (DECL_CONSTRUCTOR_P (t) && DECL_NONCONVERTING_P (t))
1161 pp_cxx_ws_string (pp, "explicit");
1163 pp_c_function_specifier (pp_c_base (pp), t);
1170 /* decl-specifier-seq:
1171 decl-specifier-seq(opt) decl-specifier
1174 storage-class-specifier
1181 pp_cxx_decl_specifier_seq (cxx_pretty_printer *pp, tree t)
1183 switch (TREE_CODE (t))
1189 pp_cxx_storage_class_specifier (pp, t);
1190 pp_cxx_decl_specifier_seq (pp, TREE_TYPE (t));
1194 pp_cxx_ws_string (pp, "typedef");
1195 pp_cxx_decl_specifier_seq (pp, TREE_TYPE (t));
1199 /* Constructors don't have return types. And conversion functions
1200 do not have a type-specifier in their return types. */
1201 if (DECL_CONSTRUCTOR_P (t) || DECL_CONV_FN_P (t))
1202 pp_cxx_function_specifier (pp, t);
1203 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
1204 pp_cxx_decl_specifier_seq (pp, TREE_TYPE (TREE_TYPE (t)));
1207 pp_c_declaration_specifiers (pp_c_base (pp), t);
1212 /* simple-type-specifier:
1213 ::(opt) nested-name-specifier(opt) type-name
1214 ::(opt) nested-name-specifier(opt) template(opt) template-id
1228 pp_cxx_simple_type_specifier (cxx_pretty_printer *pp, tree t)
1230 switch (TREE_CODE (t))
1235 pp_cxx_qualified_id (pp, t);
1238 case TEMPLATE_TYPE_PARM:
1239 case TEMPLATE_TEMPLATE_PARM:
1240 case TEMPLATE_PARM_INDEX:
1241 pp_cxx_unqualified_id (pp, t);
1245 pp_cxx_ws_string (pp, "typename");
1246 pp_cxx_nested_name_specifier (pp, TYPE_CONTEXT (t));
1247 pp_cxx_unqualified_id (pp, TYPE_NAME (t));
1251 pp_c_type_specifier (pp_c_base (pp), t);
1256 /* type-specifier-seq:
1257 type-specifier type-specifier-seq(opt)
1260 simple-type-specifier
1263 elaborated-type-specifier
1267 pp_cxx_type_specifier_seq (cxx_pretty_printer *pp, tree t)
1269 switch (TREE_CODE (t))
1272 case TEMPLATE_TYPE_PARM:
1273 case TEMPLATE_TEMPLATE_PARM:
1275 case BOUND_TEMPLATE_TEMPLATE_PARM:
1276 pp_cxx_cv_qualifier_seq (pp, t);
1277 pp_cxx_simple_type_specifier (pp, t);
1281 pp_cxx_type_specifier_seq (pp, TREE_TYPE (t));
1282 pp_cxx_space_for_pointer_operator (pp, TREE_TYPE (t));
1283 pp_cxx_nested_name_specifier (pp, TYPE_METHOD_BASETYPE (t));
1287 pp_cxx_ws_string (pp, "decltype");
1288 pp_cxx_left_paren (pp);
1289 pp_cxx_expression (pp, DECLTYPE_TYPE_EXPR (t));
1290 pp_cxx_right_paren (pp);
1294 if (TYPE_PTRMEMFUNC_P (t))
1296 tree pfm = TYPE_PTRMEMFUNC_FN_TYPE (t);
1297 pp_cxx_decl_specifier_seq (pp, TREE_TYPE (TREE_TYPE (pfm)));
1298 pp_cxx_whitespace (pp);
1299 pp_cxx_ptr_operator (pp, t);
1302 /* else fall through */
1305 if (!(TREE_CODE (t) == FUNCTION_DECL && DECL_CONSTRUCTOR_P (t)))
1306 pp_c_specifier_qualifier_list (pp_c_base (pp), t);
1311 * cv-qualifier-seq(opt)
1313 ::(opt) nested-name-specifier * cv-qualifier-seq(opt) */
1316 pp_cxx_ptr_operator (cxx_pretty_printer *pp, tree t)
1318 if (!TYPE_P (t) && TREE_CODE (t) != TYPE_DECL)
1320 switch (TREE_CODE (t))
1322 case REFERENCE_TYPE:
1324 if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE
1325 || TYPE_PTR_TO_MEMBER_P (TREE_TYPE (t)))
1326 pp_cxx_ptr_operator (pp, TREE_TYPE (t));
1327 if (TREE_CODE (t) == POINTER_TYPE)
1330 pp_cxx_cv_qualifier_seq (pp, t);
1337 if (TYPE_PTRMEMFUNC_P (t))
1339 pp_cxx_left_paren (pp);
1340 pp_cxx_nested_name_specifier (pp, TYPE_PTRMEMFUNC_OBJECT_TYPE (t));
1345 if (TYPE_PTR_TO_MEMBER_P (t))
1347 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
1348 pp_cxx_left_paren (pp);
1349 pp_cxx_nested_name_specifier (pp, TYPE_PTRMEM_CLASS_TYPE (t));
1351 pp_cxx_cv_qualifier_seq (pp, t);
1354 /* else fall through. */
1357 pp_unsupported_tree (pp, t);
1363 pp_cxx_implicit_parameter_type (tree mf)
1365 return TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (mf))));
1369 parameter-declaration:
1370 decl-specifier-seq declarator
1371 decl-specifier-seq declarator = assignment-expression
1372 decl-specifier-seq abstract-declarator(opt)
1373 decl-specifier-seq abstract-declarator(opt) assignment-expression */
1376 pp_cxx_parameter_declaration (cxx_pretty_printer *pp, tree t)
1378 pp_cxx_decl_specifier_seq (pp, t);
1380 pp_cxx_abstract_declarator (pp, t);
1382 pp_cxx_declarator (pp, t);
1385 /* parameter-declaration-clause:
1386 parameter-declaration-list(opt) ...(opt)
1387 parameter-declaration-list , ...
1389 parameter-declaration-list:
1390 parameter-declaration
1391 parameter-declaration-list , parameter-declaration */
1394 pp_cxx_parameter_declaration_clause (cxx_pretty_printer *pp, tree t)
1396 tree args = TYPE_P (t) ? NULL : FUNCTION_FIRST_USER_PARM (t);
1398 TYPE_P (t) ? TYPE_ARG_TYPES (t) : FUNCTION_FIRST_USER_PARMTYPE (t);
1399 const bool abstract = args == NULL
1400 || pp_c_base (pp)->flags & pp_c_flag_abstract;
1403 /* Skip artificial parameter for nonstatic member functions. */
1404 if (TREE_CODE (t) == METHOD_TYPE)
1405 types = TREE_CHAIN (types);
1407 pp_cxx_left_paren (pp);
1408 for (; args; args = TREE_CHAIN (args), types = TREE_CHAIN (types))
1411 pp_cxx_separate_with (pp, ',');
1413 pp_cxx_parameter_declaration (pp, abstract ? TREE_VALUE (types) : args);
1414 if (!abstract && pp_c_base (pp)->flags & pp_cxx_flag_default_argument)
1416 pp_cxx_whitespace (pp);
1418 pp_cxx_whitespace (pp);
1419 pp_cxx_assignment_expression (pp, TREE_PURPOSE (types));
1422 pp_cxx_right_paren (pp);
1425 /* exception-specification:
1426 throw ( type-id-list(opt) )
1430 type-id-list , type-id */
1433 pp_cxx_exception_specification (cxx_pretty_printer *pp, tree t)
1435 tree ex_spec = TYPE_RAISES_EXCEPTIONS (t);
1436 bool need_comma = false;
1438 if (ex_spec == NULL)
1440 if (TREE_PURPOSE (ex_spec))
1442 pp_cxx_ws_string (pp, "noexcept");
1443 pp_cxx_whitespace (pp);
1444 pp_cxx_left_paren (pp);
1445 pp_cxx_expression (pp, TREE_PURPOSE (ex_spec));
1446 pp_cxx_right_paren (pp);
1449 pp_cxx_ws_string (pp, "throw");
1450 pp_cxx_left_paren (pp);
1451 for (; ex_spec && TREE_VALUE (ex_spec); ex_spec = TREE_CHAIN (ex_spec))
1453 tree type = TREE_VALUE (ex_spec);
1454 tree argpack = NULL_TREE;
1457 if (ARGUMENT_PACK_P (type))
1459 argpack = ARGUMENT_PACK_ARGS (type);
1460 len = TREE_VEC_LENGTH (argpack);
1463 for (i = 0; i < len; ++i)
1466 type = TREE_VEC_ELT (argpack, i);
1469 pp_cxx_separate_with (pp, ',');
1473 pp_cxx_type_id (pp, type);
1476 pp_cxx_right_paren (pp);
1479 /* direct-declarator:
1481 direct-declarator ( parameter-declaration-clause ) cv-qualifier-seq(opt)
1482 exception-specification(opt)
1483 direct-declaration [ constant-expression(opt) ]
1487 pp_cxx_direct_declarator (cxx_pretty_printer *pp, tree t)
1489 switch (TREE_CODE (t))
1497 pp_cxx_space_for_pointer_operator (pp, TREE_TYPE (t));
1499 if ((TREE_CODE (t) == PARM_DECL && FUNCTION_PARAMETER_PACK_P (t))
1500 || template_parameter_pack_p (t))
1501 /* A function parameter pack or non-type template
1503 pp_cxx_ws_string (pp, "...");
1505 pp_cxx_id_expression (pp, DECL_NAME (t));
1507 pp_cxx_abstract_declarator (pp, TREE_TYPE (t));
1511 pp_cxx_space_for_pointer_operator (pp, TREE_TYPE (TREE_TYPE (t)));
1512 pp_cxx_id_expression (pp, t);
1513 pp_cxx_parameter_declaration_clause (pp, t);
1515 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
1517 pp_base (pp)->padding = pp_before;
1518 pp_cxx_cv_qualifier_seq (pp, pp_cxx_implicit_parameter_type (t));
1521 pp_cxx_exception_specification (pp, TREE_TYPE (t));
1526 case TEMPLATE_TYPE_PARM:
1527 case TEMPLATE_PARM_INDEX:
1528 case TEMPLATE_TEMPLATE_PARM:
1532 pp_c_direct_declarator (pp_c_base (pp), t);
1539 ptr-operator declarator */
1542 pp_cxx_declarator (cxx_pretty_printer *pp, tree t)
1544 pp_cxx_direct_declarator (pp, t);
1547 /* ctor-initializer:
1548 : mem-initializer-list
1550 mem-initializer-list:
1552 mem-initializer , mem-initializer-list
1555 mem-initializer-id ( expression-list(opt) )
1558 ::(opt) nested-name-specifier(opt) class-name
1562 pp_cxx_ctor_initializer (cxx_pretty_printer *pp, tree t)
1564 t = TREE_OPERAND (t, 0);
1565 pp_cxx_whitespace (pp);
1567 pp_cxx_whitespace (pp);
1568 for (; t; t = TREE_CHAIN (t))
1570 tree purpose = TREE_PURPOSE (t);
1571 bool is_pack = PACK_EXPANSION_P (purpose);
1574 pp_cxx_primary_expression (pp, PACK_EXPANSION_PATTERN (purpose));
1576 pp_cxx_primary_expression (pp, purpose);
1577 pp_cxx_call_argument_list (pp, TREE_VALUE (t));
1579 pp_cxx_ws_string (pp, "...");
1581 pp_cxx_separate_with (pp, ',');
1585 /* function-definition:
1586 decl-specifier-seq(opt) declarator ctor-initializer(opt) function-body
1587 decl-specifier-seq(opt) declarator function-try-block */
1590 pp_cxx_function_definition (cxx_pretty_printer *pp, tree t)
1592 tree saved_scope = pp->enclosing_scope;
1593 pp_cxx_decl_specifier_seq (pp, t);
1594 pp_cxx_declarator (pp, t);
1595 pp_needs_newline (pp) = true;
1596 pp->enclosing_scope = DECL_CONTEXT (t);
1597 if (DECL_SAVED_TREE (t))
1598 pp_cxx_statement (pp, DECL_SAVED_TREE (t));
1601 pp_cxx_semicolon (pp);
1602 pp_needs_newline (pp) = true;
1605 pp->enclosing_scope = saved_scope;
1608 /* abstract-declarator:
1609 ptr-operator abstract-declarator(opt)
1610 direct-abstract-declarator */
1613 pp_cxx_abstract_declarator (cxx_pretty_printer *pp, tree t)
1615 if (TYPE_PTRMEM_P (t) || TYPE_PTRMEMFUNC_P (t))
1616 pp_cxx_right_paren (pp);
1617 else if (POINTER_TYPE_P (t))
1619 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
1620 || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
1621 pp_cxx_right_paren (pp);
1624 pp_cxx_direct_abstract_declarator (pp, t);
1627 /* direct-abstract-declarator:
1628 direct-abstract-declarator(opt) ( parameter-declaration-clause )
1629 cv-qualifier-seq(opt) exception-specification(opt)
1630 direct-abstract-declarator(opt) [ constant-expression(opt) ]
1631 ( abstract-declarator ) */
1634 pp_cxx_direct_abstract_declarator (cxx_pretty_printer *pp, tree t)
1636 switch (TREE_CODE (t))
1638 case REFERENCE_TYPE:
1639 pp_cxx_abstract_declarator (pp, t);
1643 if (TYPE_PTRMEMFUNC_P (t))
1644 pp_cxx_direct_abstract_declarator (pp, TYPE_PTRMEMFUNC_FN_TYPE (t));
1649 pp_cxx_parameter_declaration_clause (pp, t);
1650 pp_cxx_direct_abstract_declarator (pp, TREE_TYPE (t));
1651 if (TREE_CODE (t) == METHOD_TYPE)
1653 pp_base (pp)->padding = pp_before;
1654 pp_cxx_cv_qualifier_seq
1655 (pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
1657 pp_cxx_exception_specification (pp, t);
1661 case TEMPLATE_TYPE_PARM:
1662 case TEMPLATE_TEMPLATE_PARM:
1663 case BOUND_TEMPLATE_TEMPLATE_PARM:
1664 case UNBOUND_CLASS_TEMPLATE:
1668 pp_c_direct_abstract_declarator (pp_c_base (pp), t);
1674 type-specifier-seq abstract-declarator(opt) */
1677 pp_cxx_type_id (cxx_pretty_printer *pp, tree t)
1679 pp_flags saved_flags = pp_c_base (pp)->flags;
1680 pp_c_base (pp)->flags |= pp_c_flag_abstract;
1682 switch (TREE_CODE (t))
1689 case BOUND_TEMPLATE_TEMPLATE_PARM:
1690 case UNBOUND_CLASS_TEMPLATE:
1691 case TEMPLATE_TEMPLATE_PARM:
1692 case TEMPLATE_TYPE_PARM:
1693 case TEMPLATE_PARM_INDEX:
1697 case TEMPLATE_ID_EXPR:
1698 pp_cxx_type_specifier_seq (pp, t);
1701 case TYPE_PACK_EXPANSION:
1702 pp_cxx_type_id (pp, PACK_EXPANSION_PATTERN (t));
1703 pp_cxx_ws_string (pp, "...");
1707 pp_c_type_id (pp_c_base (pp), t);
1711 pp_c_base (pp)->flags = saved_flags;
1714 /* template-argument-list:
1715 template-argument ...(opt)
1716 template-argument-list, template-argument ...(opt)
1719 assignment-expression
1724 pp_cxx_template_argument_list (cxx_pretty_printer *pp, tree t)
1727 bool need_comma = false;
1731 for (i = 0; i < TREE_VEC_LENGTH (t); ++i)
1733 tree arg = TREE_VEC_ELT (t, i);
1734 tree argpack = NULL_TREE;
1737 if (ARGUMENT_PACK_P (arg))
1739 argpack = ARGUMENT_PACK_ARGS (arg);
1740 len = TREE_VEC_LENGTH (argpack);
1743 for (idx = 0; idx < len; idx++)
1746 arg = TREE_VEC_ELT (argpack, idx);
1749 pp_cxx_separate_with (pp, ',');
1753 if (TYPE_P (arg) || (TREE_CODE (arg) == TEMPLATE_DECL
1754 && TYPE_P (DECL_TEMPLATE_RESULT (arg))))
1755 pp_cxx_type_id (pp, arg);
1757 pp_cxx_expression (pp, arg);
1764 pp_cxx_exception_declaration (cxx_pretty_printer *pp, tree t)
1766 t = DECL_EXPR_DECL (t);
1767 pp_cxx_type_specifier_seq (pp, t);
1769 pp_cxx_abstract_declarator (pp, t);
1771 pp_cxx_declarator (pp, t);
1777 pp_cxx_statement (cxx_pretty_printer *pp, tree t)
1779 switch (TREE_CODE (t))
1781 case CTOR_INITIALIZER:
1782 pp_cxx_ctor_initializer (pp, t);
1786 pp_cxx_ws_string (pp, "using");
1787 pp_cxx_ws_string (pp, "namespace");
1788 if (DECL_CONTEXT (t))
1789 pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
1790 pp_cxx_qualified_id (pp, USING_STMT_NAMESPACE (t));
1794 pp_cxx_ws_string (pp, "using");
1795 pp_cxx_nested_name_specifier (pp, USING_DECL_SCOPE (t));
1796 pp_cxx_unqualified_id (pp, DECL_NAME (t));
1803 try compound-statement handler-seq */
1805 pp_maybe_newline_and_indent (pp, 0);
1806 pp_cxx_ws_string (pp, "try");
1807 pp_newline_and_indent (pp, 3);
1808 pp_cxx_statement (pp, TRY_STMTS (t));
1809 pp_newline_and_indent (pp, -3);
1813 pp_cxx_statement (pp, TRY_HANDLERS (t));
1818 handler handler-seq(opt)
1821 catch ( exception-declaration ) compound-statement
1823 exception-declaration:
1824 type-specifier-seq declarator
1825 type-specifier-seq abstract-declarator
1828 pp_cxx_ws_string (pp, "catch");
1829 pp_cxx_left_paren (pp);
1830 pp_cxx_exception_declaration (pp, HANDLER_PARMS (t));
1831 pp_cxx_right_paren (pp);
1832 pp_indentation (pp) += 3;
1833 pp_needs_newline (pp) = true;
1834 pp_cxx_statement (pp, HANDLER_BODY (t));
1835 pp_indentation (pp) -= 3;
1836 pp_needs_newline (pp) = true;
1839 /* selection-statement:
1840 if ( expression ) statement
1841 if ( expression ) statement else statement */
1843 pp_cxx_ws_string (pp, "if");
1844 pp_cxx_whitespace (pp);
1845 pp_cxx_left_paren (pp);
1846 pp_cxx_expression (pp, IF_COND (t));
1847 pp_cxx_right_paren (pp);
1848 pp_newline_and_indent (pp, 2);
1849 pp_cxx_statement (pp, THEN_CLAUSE (t));
1850 pp_newline_and_indent (pp, -2);
1851 if (ELSE_CLAUSE (t))
1853 tree else_clause = ELSE_CLAUSE (t);
1854 pp_cxx_ws_string (pp, "else");
1855 if (TREE_CODE (else_clause) == IF_STMT)
1856 pp_cxx_whitespace (pp);
1858 pp_newline_and_indent (pp, 2);
1859 pp_cxx_statement (pp, else_clause);
1860 if (TREE_CODE (else_clause) != IF_STMT)
1861 pp_newline_and_indent (pp, -2);
1866 pp_cxx_ws_string (pp, "switch");
1868 pp_cxx_left_paren (pp);
1869 pp_cxx_expression (pp, SWITCH_STMT_COND (t));
1870 pp_cxx_right_paren (pp);
1871 pp_indentation (pp) += 3;
1872 pp_needs_newline (pp) = true;
1873 pp_cxx_statement (pp, SWITCH_STMT_BODY (t));
1874 pp_newline_and_indent (pp, -3);
1877 /* iteration-statement:
1878 while ( expression ) statement
1879 do statement while ( expression ) ;
1880 for ( expression(opt) ; expression(opt) ; expression(opt) ) statement
1881 for ( declaration expression(opt) ; expression(opt) ) statement */
1883 pp_cxx_ws_string (pp, "while");
1885 pp_cxx_left_paren (pp);
1886 pp_cxx_expression (pp, WHILE_COND (t));
1887 pp_cxx_right_paren (pp);
1888 pp_newline_and_indent (pp, 3);
1889 pp_cxx_statement (pp, WHILE_BODY (t));
1890 pp_indentation (pp) -= 3;
1891 pp_needs_newline (pp) = true;
1895 pp_cxx_ws_string (pp, "do");
1896 pp_newline_and_indent (pp, 3);
1897 pp_cxx_statement (pp, DO_BODY (t));
1898 pp_newline_and_indent (pp, -3);
1899 pp_cxx_ws_string (pp, "while");
1901 pp_cxx_left_paren (pp);
1902 pp_cxx_expression (pp, DO_COND (t));
1903 pp_cxx_right_paren (pp);
1904 pp_cxx_semicolon (pp);
1905 pp_needs_newline (pp) = true;
1909 pp_cxx_ws_string (pp, "for");
1911 pp_cxx_left_paren (pp);
1912 if (FOR_INIT_STMT (t))
1913 pp_cxx_statement (pp, FOR_INIT_STMT (t));
1915 pp_cxx_semicolon (pp);
1916 pp_needs_newline (pp) = false;
1917 pp_cxx_whitespace (pp);
1919 pp_cxx_expression (pp, FOR_COND (t));
1920 pp_cxx_semicolon (pp);
1921 pp_needs_newline (pp) = false;
1922 pp_cxx_whitespace (pp);
1924 pp_cxx_expression (pp, FOR_EXPR (t));
1925 pp_cxx_right_paren (pp);
1926 pp_newline_and_indent (pp, 3);
1927 pp_cxx_statement (pp, FOR_BODY (t));
1928 pp_indentation (pp) -= 3;
1929 pp_needs_newline (pp) = true;
1932 case RANGE_FOR_STMT:
1933 pp_cxx_ws_string (pp, "for");
1935 pp_cxx_left_paren (pp);
1936 pp_cxx_statement (pp, RANGE_FOR_DECL (t));
1938 pp_needs_newline (pp) = false;
1941 pp_cxx_statement (pp, RANGE_FOR_EXPR (t));
1942 pp_cxx_right_paren (pp);
1943 pp_newline_and_indent (pp, 3);
1944 pp_cxx_statement (pp, FOR_BODY (t));
1945 pp_indentation (pp) -= 3;
1946 pp_needs_newline (pp) = true;
1952 return expression(opt) ; */
1955 pp_string (pp, TREE_CODE (t) == BREAK_STMT ? "break" : "continue");
1956 pp_cxx_semicolon (pp);
1957 pp_needs_newline (pp) = true;
1960 /* expression-statement:
1961 expression(opt) ; */
1963 pp_cxx_expression (pp, EXPR_STMT_EXPR (t));
1964 pp_cxx_semicolon (pp);
1965 pp_needs_newline (pp) = true;
1969 pp_cxx_ws_string (pp, "try");
1970 pp_newline_and_indent (pp, 2);
1971 pp_cxx_statement (pp, CLEANUP_BODY (t));
1972 pp_newline_and_indent (pp, -2);
1973 pp_cxx_ws_string (pp, CLEANUP_EH_ONLY (t) ? "catch" : "finally");
1974 pp_newline_and_indent (pp, 2);
1975 pp_cxx_statement (pp, CLEANUP_EXPR (t));
1976 pp_newline_and_indent (pp, -2);
1980 pp_cxx_declaration (pp, t);
1984 pp_c_statement (pp_c_base (pp), t);
1989 /* original-namespace-definition:
1990 namespace identifier { namespace-body }
1992 As an edge case, we also handle unnamed namespace definition here. */
1995 pp_cxx_original_namespace_definition (cxx_pretty_printer *pp, tree t)
1997 pp_cxx_ws_string (pp, "namespace");
1998 if (DECL_CONTEXT (t))
1999 pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
2001 pp_cxx_unqualified_id (pp, t);
2002 pp_cxx_whitespace (pp);
2003 pp_cxx_left_brace (pp);
2004 /* We do not print the namespace-body. */
2005 pp_cxx_whitespace (pp);
2006 pp_cxx_right_brace (pp);
2012 namespace-alias-definition:
2013 namespace identifier = qualified-namespace-specifier ;
2015 qualified-namespace-specifier:
2016 ::(opt) nested-name-specifier(opt) namespace-name */
2019 pp_cxx_namespace_alias_definition (cxx_pretty_printer *pp, tree t)
2021 pp_cxx_ws_string (pp, "namespace");
2022 if (DECL_CONTEXT (t))
2023 pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
2024 pp_cxx_unqualified_id (pp, t);
2025 pp_cxx_whitespace (pp);
2027 pp_cxx_whitespace (pp);
2028 if (DECL_CONTEXT (DECL_NAMESPACE_ALIAS (t)))
2029 pp_cxx_nested_name_specifier (pp,
2030 DECL_CONTEXT (DECL_NAMESPACE_ALIAS (t)));
2031 pp_cxx_qualified_id (pp, DECL_NAMESPACE_ALIAS (t));
2032 pp_cxx_semicolon (pp);
2035 /* simple-declaration:
2036 decl-specifier-seq(opt) init-declarator-list(opt) */
2039 pp_cxx_simple_declaration (cxx_pretty_printer *pp, tree t)
2041 pp_cxx_decl_specifier_seq (pp, t);
2042 pp_cxx_init_declarator (pp, t);
2043 pp_cxx_semicolon (pp);
2044 pp_needs_newline (pp) = true;
2048 template-parameter-list:
2050 template-parameter-list , template-parameter */
2053 pp_cxx_template_parameter_list (cxx_pretty_printer *pp, tree t)
2055 const int n = TREE_VEC_LENGTH (t);
2057 for (i = 0; i < n; ++i)
2060 pp_cxx_separate_with (pp, ',');
2061 pp_cxx_template_parameter (pp, TREE_VEC_ELT (t, i));
2065 /* template-parameter:
2067 parameter-declaration
2070 class ...(opt) identifier(opt)
2071 class identifier(opt) = type-id
2072 typename identifier(opt)
2073 typename ...(opt) identifier(opt) = type-id
2074 template < template-parameter-list > class ...(opt) identifier(opt)
2075 template < template-parameter-list > class identifier(opt) = template-name */
2078 pp_cxx_template_parameter (cxx_pretty_printer *pp, tree t)
2080 tree parameter = TREE_VALUE (t);
2081 switch (TREE_CODE (parameter))
2084 pp_cxx_ws_string (pp, "class");
2085 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
2086 pp_cxx_ws_string (pp, "...");
2087 if (DECL_NAME (parameter))
2088 pp_cxx_tree_identifier (pp, DECL_NAME (parameter));
2089 /* FIXME: Check if we should print also default argument. */
2093 pp_cxx_parameter_declaration (pp, parameter);
2100 pp_unsupported_tree (pp, t);
2105 /* Pretty-print a template parameter in the canonical form
2106 "template-parameter-<level>-<position in parameter list>". */
2109 pp_cxx_canonical_template_parameter (cxx_pretty_printer *pp, tree parm)
2111 const enum tree_code code = TREE_CODE (parm);
2113 /* Brings type template parameters to the canonical forms. */
2114 if (code == TEMPLATE_TYPE_PARM || code == TEMPLATE_TEMPLATE_PARM
2115 || code == BOUND_TEMPLATE_TEMPLATE_PARM)
2116 parm = TEMPLATE_TYPE_PARM_INDEX (parm);
2118 pp_cxx_begin_template_argument_list (pp);
2119 pp_cxx_ws_string (pp, M_("template-parameter-"));
2120 pp_wide_integer (pp, TEMPLATE_PARM_LEVEL (parm));
2122 pp_wide_integer (pp, TEMPLATE_PARM_IDX (parm) + 1);
2123 pp_cxx_end_template_argument_list (pp);
2127 template-declaration:
2128 export(opt) template < template-parameter-list > declaration */
2131 pp_cxx_template_declaration (cxx_pretty_printer *pp, tree t)
2133 tree tmpl = most_general_template (t);
2137 pp_maybe_newline_and_indent (pp, 0);
2138 for (level = DECL_TEMPLATE_PARMS (tmpl); level; level = TREE_CHAIN (level))
2140 pp_cxx_ws_string (pp, "template");
2141 pp_cxx_begin_template_argument_list (pp);
2142 pp_cxx_template_parameter_list (pp, TREE_VALUE (level));
2143 pp_cxx_end_template_argument_list (pp);
2144 pp_newline_and_indent (pp, 3);
2147 if (TREE_CODE (t) == FUNCTION_DECL && DECL_SAVED_TREE (t))
2148 pp_cxx_function_definition (pp, t);
2150 pp_cxx_simple_declaration (pp, t);
2154 pp_cxx_explicit_specialization (cxx_pretty_printer *pp, tree t)
2156 pp_unsupported_tree (pp, t);
2160 pp_cxx_explicit_instantiation (cxx_pretty_printer *pp, tree t)
2162 pp_unsupported_tree (pp, t);
2169 template-declaration
2170 explicit-instantiation
2171 explicit-specialization
2172 linkage-specification
2173 namespace-definition
2178 namespace-alias-definition
2181 static_assert-declaration */
2183 pp_cxx_declaration (cxx_pretty_printer *pp, tree t)
2185 if (TREE_CODE (t) == STATIC_ASSERT)
2187 pp_cxx_ws_string (pp, "static_assert");
2188 pp_cxx_left_paren (pp);
2189 pp_cxx_expression (pp, STATIC_ASSERT_CONDITION (t));
2190 pp_cxx_separate_with (pp, ',');
2191 pp_cxx_expression (pp, STATIC_ASSERT_MESSAGE (t));
2192 pp_cxx_right_paren (pp);
2194 else if (!DECL_LANG_SPECIFIC (t))
2195 pp_cxx_simple_declaration (pp, t);
2196 else if (DECL_USE_TEMPLATE (t))
2197 switch (DECL_USE_TEMPLATE (t))
2200 pp_cxx_template_declaration (pp, t);
2204 pp_cxx_explicit_specialization (pp, t);
2208 pp_cxx_explicit_instantiation (pp, t);
2214 else switch (TREE_CODE (t))
2218 pp_cxx_simple_declaration (pp, t);
2222 if (DECL_SAVED_TREE (t))
2223 pp_cxx_function_definition (pp, t);
2225 pp_cxx_simple_declaration (pp, t);
2228 case NAMESPACE_DECL:
2229 if (DECL_NAMESPACE_ALIAS (t))
2230 pp_cxx_namespace_alias_definition (pp, t);
2232 pp_cxx_original_namespace_definition (pp, t);
2236 pp_unsupported_tree (pp, t);
2242 pp_cxx_typeid_expression (cxx_pretty_printer *pp, tree t)
2244 t = TREE_OPERAND (t, 0);
2245 pp_cxx_ws_string (pp, "typeid");
2246 pp_cxx_left_paren (pp);
2248 pp_cxx_type_id (pp, t);
2250 pp_cxx_expression (pp, t);
2251 pp_cxx_right_paren (pp);
2255 pp_cxx_va_arg_expression (cxx_pretty_printer *pp, tree t)
2257 pp_cxx_ws_string (pp, "va_arg");
2258 pp_cxx_left_paren (pp);
2259 pp_cxx_assignment_expression (pp, TREE_OPERAND (t, 0));
2260 pp_cxx_separate_with (pp, ',');
2261 pp_cxx_type_id (pp, TREE_TYPE (t));
2262 pp_cxx_right_paren (pp);
2266 pp_cxx_offsetof_expression_1 (cxx_pretty_printer *pp, tree t)
2268 switch (TREE_CODE (t))
2271 if (TREE_CODE (TREE_OPERAND (t, 0)) == STATIC_CAST_EXPR
2272 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (t, 0))))
2274 pp_cxx_type_id (pp, TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0))));
2275 pp_cxx_separate_with (pp, ',');
2280 if (!pp_cxx_offsetof_expression_1 (pp, TREE_OPERAND (t, 0)))
2282 if (TREE_CODE (TREE_OPERAND (t, 0)) != ARROW_EXPR)
2284 pp_cxx_expression (pp, TREE_OPERAND (t, 1));
2287 if (!pp_cxx_offsetof_expression_1 (pp, TREE_OPERAND (t, 0)))
2289 pp_left_bracket (pp);
2290 pp_cxx_expression (pp, TREE_OPERAND (t, 1));
2291 pp_right_bracket (pp);
2299 pp_cxx_offsetof_expression (cxx_pretty_printer *pp, tree t)
2301 pp_cxx_ws_string (pp, "offsetof");
2302 pp_cxx_left_paren (pp);
2303 if (!pp_cxx_offsetof_expression_1 (pp, TREE_OPERAND (t, 0)))
2304 pp_cxx_expression (pp, TREE_OPERAND (t, 0));
2305 pp_cxx_right_paren (pp);
2309 pp_cxx_trait_expression (cxx_pretty_printer *pp, tree t)
2311 cp_trait_kind kind = TRAIT_EXPR_KIND (t);
2315 case CPTK_HAS_NOTHROW_ASSIGN:
2316 pp_cxx_ws_string (pp, "__has_nothrow_assign");
2318 case CPTK_HAS_TRIVIAL_ASSIGN:
2319 pp_cxx_ws_string (pp, "__has_trivial_assign");
2321 case CPTK_HAS_NOTHROW_CONSTRUCTOR:
2322 pp_cxx_ws_string (pp, "__has_nothrow_constructor");
2324 case CPTK_HAS_TRIVIAL_CONSTRUCTOR:
2325 pp_cxx_ws_string (pp, "__has_trivial_constructor");
2327 case CPTK_HAS_NOTHROW_COPY:
2328 pp_cxx_ws_string (pp, "__has_nothrow_copy");
2330 case CPTK_HAS_TRIVIAL_COPY:
2331 pp_cxx_ws_string (pp, "__has_trivial_copy");
2333 case CPTK_HAS_TRIVIAL_DESTRUCTOR:
2334 pp_cxx_ws_string (pp, "__has_trivial_destructor");
2336 case CPTK_HAS_VIRTUAL_DESTRUCTOR:
2337 pp_cxx_ws_string (pp, "__has_virtual_destructor");
2339 case CPTK_IS_ABSTRACT:
2340 pp_cxx_ws_string (pp, "__is_abstract");
2342 case CPTK_IS_BASE_OF:
2343 pp_cxx_ws_string (pp, "__is_base_of");
2346 pp_cxx_ws_string (pp, "__is_class");
2348 case CPTK_IS_CONVERTIBLE_TO:
2349 pp_cxx_ws_string (pp, "__is_convertible_to");
2352 pp_cxx_ws_string (pp, "__is_empty");
2355 pp_cxx_ws_string (pp, "__is_enum");
2358 pp_cxx_ws_string (pp, "__is_pod");
2360 case CPTK_IS_POLYMORPHIC:
2361 pp_cxx_ws_string (pp, "__is_polymorphic");
2363 case CPTK_IS_STD_LAYOUT:
2364 pp_cxx_ws_string (pp, "__is_std_layout");
2366 case CPTK_IS_TRIVIAL:
2367 pp_cxx_ws_string (pp, "__is_trivial");
2370 pp_cxx_ws_string (pp, "__is_union");
2372 case CPTK_IS_LITERAL_TYPE:
2373 pp_cxx_ws_string (pp, "__is_literal_type");
2380 pp_cxx_left_paren (pp);
2381 pp_cxx_type_id (pp, TRAIT_EXPR_TYPE1 (t));
2383 if (kind == CPTK_IS_BASE_OF || kind == CPTK_IS_CONVERTIBLE_TO)
2385 pp_cxx_separate_with (pp, ',');
2386 pp_cxx_type_id (pp, TRAIT_EXPR_TYPE2 (t));
2389 pp_cxx_right_paren (pp);
2392 typedef c_pretty_print_fn pp_fun;
2394 /* Initialization of a C++ pretty-printer object. */
2397 pp_cxx_pretty_printer_init (cxx_pretty_printer *pp)
2399 pp_c_pretty_printer_init (pp_c_base (pp));
2400 pp_set_line_maximum_length (pp, 0);
2402 pp->c_base.declaration = (pp_fun) pp_cxx_declaration;
2403 pp->c_base.declaration_specifiers = (pp_fun) pp_cxx_decl_specifier_seq;
2404 pp->c_base.function_specifier = (pp_fun) pp_cxx_function_specifier;
2405 pp->c_base.type_specifier_seq = (pp_fun) pp_cxx_type_specifier_seq;
2406 pp->c_base.declarator = (pp_fun) pp_cxx_declarator;
2407 pp->c_base.direct_declarator = (pp_fun) pp_cxx_direct_declarator;
2408 pp->c_base.parameter_list = (pp_fun) pp_cxx_parameter_declaration_clause;
2409 pp->c_base.type_id = (pp_fun) pp_cxx_type_id;
2410 pp->c_base.abstract_declarator = (pp_fun) pp_cxx_abstract_declarator;
2411 pp->c_base.direct_abstract_declarator =
2412 (pp_fun) pp_cxx_direct_abstract_declarator;
2413 pp->c_base.simple_type_specifier = (pp_fun)pp_cxx_simple_type_specifier;
2415 /* pp->c_base.statement = (pp_fun) pp_cxx_statement; */
2417 pp->c_base.constant = (pp_fun) pp_cxx_constant;
2418 pp->c_base.id_expression = (pp_fun) pp_cxx_id_expression;
2419 pp->c_base.primary_expression = (pp_fun) pp_cxx_primary_expression;
2420 pp->c_base.postfix_expression = (pp_fun) pp_cxx_postfix_expression;
2421 pp->c_base.unary_expression = (pp_fun) pp_cxx_unary_expression;
2422 pp->c_base.multiplicative_expression = (pp_fun) pp_cxx_multiplicative_expression;
2423 pp->c_base.conditional_expression = (pp_fun) pp_cxx_conditional_expression;
2424 pp->c_base.assignment_expression = (pp_fun) pp_cxx_assignment_expression;
2425 pp->c_base.expression = (pp_fun) pp_cxx_expression;
2426 pp->enclosing_scope = global_namespace;