1 /* Implementation of subroutines for the GNU C++ pretty-printer.
2 Copyright (C) 2003, 2004, 2005, 2007, 2008,
3 2009 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"
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));
206 pp_cxx_complement (pp);
207 pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 0));
210 case TEMPLATE_TYPE_PARM:
211 case TEMPLATE_TEMPLATE_PARM:
212 if (TYPE_IDENTIFIER (t))
213 pp_cxx_unqualified_id (pp, TYPE_IDENTIFIER (t));
215 pp_cxx_canonical_template_parameter (pp, t);
218 case TEMPLATE_PARM_INDEX:
219 pp_cxx_unqualified_id (pp, TEMPLATE_PARM_DECL (t));
222 case BOUND_TEMPLATE_TEMPLATE_PARM:
223 pp_cxx_cv_qualifier_seq (pp, t);
224 pp_cxx_unqualified_id (pp, TYPE_IDENTIFIER (t));
225 pp_cxx_begin_template_argument_list (pp);
226 pp_cxx_template_argument_list (pp, TYPE_TI_ARGS (t));
227 pp_cxx_end_template_argument_list (pp);
231 pp_unsupported_tree (pp, t);
236 /* Pretty-print out the token sequence ":: template" in template codes
237 where it is needed to "inline declare" the (following) member as
238 a template. This situation arises when SCOPE of T is dependent
239 on template parameters. */
242 pp_cxx_template_keyword_if_needed (cxx_pretty_printer *pp, tree scope, tree t)
244 if (TREE_CODE (t) == TEMPLATE_ID_EXPR
245 && TYPE_P (scope) && dependent_type_p (scope))
246 pp_cxx_ws_string (pp, "template");
249 /* nested-name-specifier:
250 class-or-namespace-name :: nested-name-specifier(opt)
251 class-or-namespace-name :: template nested-name-specifier */
254 pp_cxx_nested_name_specifier (cxx_pretty_printer *pp, tree t)
256 if (t != NULL && t != pp->enclosing_scope)
258 tree scope = TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t);
259 pp_cxx_nested_name_specifier (pp, scope);
260 pp_cxx_template_keyword_if_needed (pp, scope, t);
261 pp_cxx_unqualified_id (pp, t);
262 pp_cxx_colon_colon (pp);
267 nested-name-specifier template(opt) unqualified-id */
270 pp_cxx_qualified_id (cxx_pretty_printer *pp, tree t)
272 switch (TREE_CODE (t))
274 /* A pointer-to-member is always qualified. */
276 pp_cxx_nested_name_specifier (pp, PTRMEM_CST_CLASS (t));
277 pp_cxx_unqualified_id (pp, PTRMEM_CST_MEMBER (t));
280 /* In Standard C++, functions cannot possibly be used as
281 nested-name-specifiers. However, there are situations where
282 is "makes sense" to output the surrounding function name for the
283 purpose of emphasizing on the scope kind. Just printing the
284 function name might not be sufficient as it may be overloaded; so,
285 we decorate the function with its signature too.
286 FIXME: This is probably the wrong pretty-printing for conversion
287 functions and some function templates. */
291 if (DECL_FUNCTION_MEMBER_P (t))
292 pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
293 pp_cxx_unqualified_id
294 (pp, DECL_CONSTRUCTOR_P (t) ? DECL_CONTEXT (t) : t);
295 pp_cxx_parameter_declaration_clause (pp, TREE_TYPE (t));
300 pp_cxx_nested_name_specifier (pp, TREE_OPERAND (t, 0));
301 pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 1));
306 tree scope = TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t);
307 if (scope != pp->enclosing_scope)
309 pp_cxx_nested_name_specifier (pp, scope);
310 pp_cxx_template_keyword_if_needed (pp, scope, t);
312 pp_cxx_unqualified_id (pp, t);
320 pp_cxx_constant (cxx_pretty_printer *pp, tree t)
322 switch (TREE_CODE (t))
326 const bool in_parens = PAREN_STRING_LITERAL_P (t);
328 pp_cxx_left_paren (pp);
329 pp_c_constant (pp_c_base (pp), t);
331 pp_cxx_right_paren (pp);
336 pp_c_constant (pp_c_base (pp), t);
346 pp_cxx_id_expression (cxx_pretty_printer *pp, tree t)
348 if (TREE_CODE (t) == OVERLOAD)
350 if (DECL_P (t) && DECL_CONTEXT (t))
351 pp_cxx_qualified_id (pp, t);
353 pp_cxx_unqualified_id (pp, t);
356 /* primary-expression:
360 :: operator-function-id
366 __builtin_va_arg ( assignment-expression , type-id )
367 __builtin_offsetof ( type-id, offsetof-expression )
369 __has_nothrow_assign ( type-id )
370 __has_nothrow_constructor ( type-id )
371 __has_nothrow_copy ( type-id )
372 __has_trivial_assign ( type-id )
373 __has_trivial_constructor ( type-id )
374 __has_trivial_copy ( type-id )
375 __has_trivial_destructor ( type-id )
376 __has_virtual_destructor ( type-id )
377 __is_abstract ( type-id )
378 __is_base_of ( type-id , type-id )
379 __is_class ( type-id )
380 __is_convertible_to ( type-id , type-id )
381 __is_empty ( type-id )
382 __is_enum ( type-id )
384 __is_polymorphic ( type-id )
385 __is_union ( type-id ) */
388 pp_cxx_primary_expression (cxx_pretty_printer *pp, tree t)
390 switch (TREE_CODE (t))
396 pp_cxx_constant (pp, t);
400 t = BASELINK_FUNCTIONS (t);
408 pp_cxx_id_expression (pp, t);
412 case TEMPLATE_TYPE_PARM:
413 case TEMPLATE_TEMPLATE_PARM:
414 case TEMPLATE_PARM_INDEX:
415 pp_cxx_unqualified_id (pp, t);
419 pp_cxx_left_paren (pp);
420 pp_cxx_statement (pp, STMT_EXPR_STMT (t));
421 pp_cxx_right_paren (pp);
425 pp_cxx_trait_expression (pp, t);
429 pp_cxx_va_arg_expression (pp, t);
433 pp_cxx_offsetof_expression (pp, t);
437 pp_c_primary_expression (pp_c_base (pp), t);
442 /* postfix-expression:
444 postfix-expression [ expression ]
445 postfix-expression ( expression-list(opt) )
446 simple-type-specifier ( expression-list(opt) )
447 typename ::(opt) nested-name-specifier identifier ( expression-list(opt) )
448 typename ::(opt) nested-name-specifier template(opt)
449 template-id ( expression-list(opt) )
450 postfix-expression . template(opt) ::(opt) id-expression
451 postfix-expression -> template(opt) ::(opt) id-expression
452 postfix-expression . pseudo-destructor-name
453 postfix-expression -> pseudo-destructor-name
454 postfix-expression ++
455 postfix-expression --
456 dynamic_cast < type-id > ( expression )
457 static_cast < type-id > ( expression )
458 reinterpret_cast < type-id > ( expression )
459 const_cast < type-id > ( expression )
460 typeid ( expression )
461 typeid ( type-id ) */
464 pp_cxx_postfix_expression (cxx_pretty_printer *pp, tree t)
466 enum tree_code code = TREE_CODE (t);
473 tree fun = (code == AGGR_INIT_EXPR ? AGGR_INIT_EXPR_FN (t)
475 tree saved_scope = pp->enclosing_scope;
476 bool skipfirst = false;
479 if (TREE_CODE (fun) == ADDR_EXPR)
480 fun = TREE_OPERAND (fun, 0);
482 /* In templates, where there is no way to tell whether a given
483 call uses an actual member function. So the parser builds
484 FUN as a COMPONENT_REF or a plain IDENTIFIER_NODE until
485 instantiation time. */
486 if (TREE_CODE (fun) != FUNCTION_DECL)
488 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun))
490 tree object = (code == AGGR_INIT_EXPR
491 ? (AGGR_INIT_VIA_CTOR_P (t)
492 ? AGGR_INIT_EXPR_SLOT (t)
493 : AGGR_INIT_EXPR_ARG (t, 0))
494 : CALL_EXPR_ARG (t, 0));
496 while (TREE_CODE (object) == NOP_EXPR)
497 object = TREE_OPERAND (object, 0);
499 if (TREE_CODE (object) == ADDR_EXPR)
500 object = TREE_OPERAND (object, 0);
502 if (TREE_CODE (TREE_TYPE (object)) != POINTER_TYPE)
504 pp_cxx_postfix_expression (pp, object);
509 pp_cxx_postfix_expression (pp, object);
513 pp->enclosing_scope = strip_pointer_operator (TREE_TYPE (object));
516 pp_cxx_postfix_expression (pp, fun);
517 pp->enclosing_scope = saved_scope;
518 pp_cxx_left_paren (pp);
519 if (code == AGGR_INIT_EXPR)
521 aggr_init_expr_arg_iterator iter;
522 FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
528 pp_cxx_expression (pp, arg);
529 if (more_aggr_init_expr_args_p (&iter))
530 pp_cxx_separate_with (pp, ',');
536 call_expr_arg_iterator iter;
537 FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
543 pp_cxx_expression (pp, arg);
544 if (more_call_expr_args_p (&iter))
545 pp_cxx_separate_with (pp, ',');
549 pp_cxx_right_paren (pp);
551 if (code == AGGR_INIT_EXPR && AGGR_INIT_VIA_CTOR_P (t))
553 pp_cxx_separate_with (pp, ',');
554 pp_cxx_postfix_expression (pp, AGGR_INIT_EXPR_SLOT (t));
567 pp_cxx_primary_expression (pp, t);
570 case DYNAMIC_CAST_EXPR:
571 case STATIC_CAST_EXPR:
572 case REINTERPRET_CAST_EXPR:
573 case CONST_CAST_EXPR:
574 if (code == DYNAMIC_CAST_EXPR)
575 pp_cxx_ws_string (pp, "dynamic_cast");
576 else if (code == STATIC_CAST_EXPR)
577 pp_cxx_ws_string (pp, "static_cast");
578 else if (code == REINTERPRET_CAST_EXPR)
579 pp_cxx_ws_string (pp, "reinterpret_cast");
581 pp_cxx_ws_string (pp, "const_cast");
582 pp_cxx_begin_template_argument_list (pp);
583 pp_cxx_type_id (pp, TREE_TYPE (t));
584 pp_cxx_end_template_argument_list (pp);
586 pp_cxx_expression (pp, TREE_OPERAND (t, 0));
590 case EMPTY_CLASS_EXPR:
591 pp_cxx_type_id (pp, TREE_TYPE (t));
597 pp_cxx_typeid_expression (pp, t);
600 case PSEUDO_DTOR_EXPR:
601 pp_cxx_postfix_expression (pp, TREE_OPERAND (t, 0));
603 pp_cxx_qualified_id (pp, TREE_OPERAND (t, 1));
604 pp_cxx_colon_colon (pp);
606 pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 2));
610 pp_cxx_postfix_expression (pp, TREE_OPERAND (t, 0));
615 pp_c_postfix_expression (pp_c_base (pp), t);
621 ::(opt) new new-placement(opt) new-type-id new-initializer(opt)
622 ::(opt) new new-placement(opt) ( type-id ) new-initializer(opt)
628 type-specifier-seq new-declarator(opt)
631 ptr-operator new-declarator(opt)
632 direct-new-declarator
634 direct-new-declarator
636 direct-new-declarator [ constant-expression ]
639 ( expression-list(opt) ) */
642 pp_cxx_new_expression (cxx_pretty_printer *pp, tree t)
644 enum tree_code code = TREE_CODE (t);
645 tree type = TREE_OPERAND (t, 1);
646 tree init = TREE_OPERAND (t, 2);
651 if (NEW_EXPR_USE_GLOBAL (t))
652 pp_cxx_colon_colon (pp);
653 pp_cxx_ws_string (pp, "new");
654 if (TREE_OPERAND (t, 0))
656 pp_cxx_call_argument_list (pp, TREE_OPERAND (t, 0));
659 if (TREE_CODE (type) == ARRAY_REF)
660 type = build_cplus_array_type
661 (TREE_OPERAND (type, 0),
662 build_index_type (fold_build2 (MINUS_EXPR, integer_type_node,
663 TREE_OPERAND (type, 1),
665 pp_cxx_type_id (pp, type);
669 if (TREE_CODE (init) == TREE_LIST)
670 pp_c_expression_list (pp_c_base (pp), init);
671 else if (init == void_zero_node)
672 ; /* OK, empty initializer list. */
674 pp_cxx_expression (pp, init);
680 pp_unsupported_tree (pp, t);
684 /* delete-expression:
685 ::(opt) delete cast-expression
686 ::(opt) delete [ ] cast-expression */
689 pp_cxx_delete_expression (cxx_pretty_printer *pp, tree t)
691 enum tree_code code = TREE_CODE (t);
695 case VEC_DELETE_EXPR:
696 if (DELETE_EXPR_USE_GLOBAL (t))
697 pp_cxx_colon_colon (pp);
698 pp_cxx_ws_string (pp, "delete");
700 if (code == VEC_DELETE_EXPR
701 || DELETE_EXPR_USE_VEC (t))
703 pp_left_bracket (pp);
704 pp_right_bracket (pp);
707 pp_c_cast_expression (pp_c_base (pp), TREE_OPERAND (t, 0));
711 pp_unsupported_tree (pp, t);
719 unary-operator cast-expression
720 sizeof unary-expression
722 sizeof ... ( identifier )
726 unary-operator: one of
730 __alignof__ unary-expression
731 __alignof__ ( type-id ) */
734 pp_cxx_unary_expression (cxx_pretty_printer *pp, tree t)
736 enum tree_code code = TREE_CODE (t);
741 pp_cxx_new_expression (pp, t);
745 case VEC_DELETE_EXPR:
746 pp_cxx_delete_expression (pp, t);
750 if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
752 pp_cxx_ws_string (pp, "sizeof");
753 pp_cxx_ws_string (pp, "...");
754 pp_cxx_whitespace (pp);
755 pp_cxx_left_paren (pp);
756 if (TYPE_P (TREE_OPERAND (t, 0)))
757 pp_cxx_type_id (pp, TREE_OPERAND (t, 0));
759 pp_unary_expression (pp, TREE_OPERAND (t, 0));
760 pp_cxx_right_paren (pp);
766 pp_cxx_ws_string (pp, code == SIZEOF_EXPR ? "sizeof" : "__alignof__");
767 pp_cxx_whitespace (pp);
768 if (TYPE_P (TREE_OPERAND (t, 0)))
770 pp_cxx_left_paren (pp);
771 pp_cxx_type_id (pp, TREE_OPERAND (t, 0));
772 pp_cxx_right_paren (pp);
775 pp_unary_expression (pp, TREE_OPERAND (t, 0));
778 case UNARY_PLUS_EXPR:
780 pp_cxx_cast_expression (pp, TREE_OPERAND (t, 0));
784 pp_c_unary_expression (pp_c_base (pp), t);
791 ( type-id ) cast-expression */
794 pp_cxx_cast_expression (cxx_pretty_printer *pp, tree t)
796 switch (TREE_CODE (t))
799 pp_cxx_type_id (pp, TREE_TYPE (t));
800 pp_cxx_call_argument_list (pp, TREE_OPERAND (t, 0));
804 pp_c_cast_expression (pp_c_base (pp), t);
811 pm-expression .* cast-expression
812 pm-expression ->* cast-expression */
815 pp_cxx_pm_expression (cxx_pretty_printer *pp, tree t)
817 switch (TREE_CODE (t))
819 /* Handle unfortunate OFFSET_REF overloading here. */
821 if (TYPE_P (TREE_OPERAND (t, 0)))
823 pp_cxx_qualified_id (pp, t);
826 /* Else fall through. */
829 pp_cxx_pm_expression (pp, TREE_OPERAND (t, 0));
830 if (TREE_CODE (t) == MEMBER_REF)
835 pp_cxx_cast_expression (pp, TREE_OPERAND (t, 1));
840 pp_cxx_cast_expression (pp, t);
845 /* multiplicative-expression:
847 multiplicative-expression * pm-expression
848 multiplicative-expression / pm-expression
849 multiplicative-expression % pm-expression */
852 pp_cxx_multiplicative_expression (cxx_pretty_printer *pp, tree e)
854 enum tree_code code = TREE_CODE (e);
860 pp_cxx_multiplicative_expression (pp, TREE_OPERAND (e, 0));
862 if (code == MULT_EXPR)
864 else if (code == TRUNC_DIV_EXPR)
869 pp_cxx_pm_expression (pp, TREE_OPERAND (e, 1));
873 pp_cxx_pm_expression (pp, e);
878 /* conditional-expression:
879 logical-or-expression
880 logical-or-expression ? expression : assignment-expression */
883 pp_cxx_conditional_expression (cxx_pretty_printer *pp, tree e)
885 if (TREE_CODE (e) == COND_EXPR)
887 pp_c_logical_or_expression (pp_c_base (pp), TREE_OPERAND (e, 0));
891 pp_cxx_expression (pp, TREE_OPERAND (e, 1));
893 pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 2));
896 pp_c_logical_or_expression (pp_c_base (pp), e);
899 /* Pretty-print a compound assignment operator token as indicated by T. */
902 pp_cxx_assignment_operator (cxx_pretty_printer *pp, tree t)
906 switch (TREE_CODE (t))
929 op = tree_code_name[TREE_CODE (t)];
933 pp_cxx_ws_string (pp, op);
937 /* assignment-expression:
938 conditional-expression
939 logical-or-expression assignment-operator assignment-expression
943 throw assignment-expression(opt)
945 assignment-operator: one of
946 = *= /= %= += -= >>= <<= &= ^= |= */
949 pp_cxx_assignment_expression (cxx_pretty_printer *pp, tree e)
951 switch (TREE_CODE (e))
955 pp_c_logical_or_expression (pp_c_base (pp), TREE_OPERAND (e, 0));
959 pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 1));
963 pp_cxx_ws_string (pp, "throw");
964 if (TREE_OPERAND (e, 0))
965 pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 0));
969 pp_c_logical_or_expression (pp_c_base (pp), TREE_OPERAND (e, 0));
970 pp_cxx_assignment_operator (pp, TREE_OPERAND (e, 1));
971 pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 2));
975 pp_cxx_conditional_expression (pp, e);
981 pp_cxx_expression (cxx_pretty_printer *pp, tree t)
983 switch (TREE_CODE (t))
989 pp_cxx_constant (pp, t);
993 pp_cxx_unqualified_id (pp, t);
1001 pp_cxx_qualified_id (pp, t);
1005 t = OVL_CURRENT (t);
1013 case TEMPLATE_TYPE_PARM:
1014 case TEMPLATE_PARM_INDEX:
1015 case TEMPLATE_TEMPLATE_PARM:
1017 pp_cxx_primary_expression (pp, t);
1021 case DYNAMIC_CAST_EXPR:
1022 case STATIC_CAST_EXPR:
1023 case REINTERPRET_CAST_EXPR:
1024 case CONST_CAST_EXPR:
1028 case EMPTY_CLASS_EXPR:
1030 case PSEUDO_DTOR_EXPR:
1031 case AGGR_INIT_EXPR:
1033 pp_cxx_postfix_expression (pp, t);
1038 pp_cxx_new_expression (pp, t);
1042 case VEC_DELETE_EXPR:
1043 pp_cxx_delete_expression (pp, t);
1048 pp_cxx_unary_expression (pp, t);
1052 pp_cxx_cast_expression (pp, t);
1058 pp_cxx_pm_expression (pp, t);
1062 case TRUNC_DIV_EXPR:
1063 case TRUNC_MOD_EXPR:
1064 pp_cxx_multiplicative_expression (pp, t);
1068 pp_cxx_conditional_expression (pp, t);
1075 pp_cxx_assignment_expression (pp, t);
1078 case NON_DEPENDENT_EXPR:
1079 case MUST_NOT_THROW_EXPR:
1080 pp_cxx_expression (pp, TREE_OPERAND (t, 0));
1083 case EXPR_PACK_EXPANSION:
1084 pp_cxx_expression (pp, PACK_EXPANSION_PATTERN (t));
1085 pp_cxx_ws_string (pp, "...");
1088 case NONTYPE_ARGUMENT_PACK:
1090 tree args = ARGUMENT_PACK_ARGS (t);
1091 int i, len = TREE_VEC_LENGTH (args);
1092 for (i = 0; i < len; ++i)
1095 pp_cxx_separate_with (pp, ',');
1096 pp_cxx_expression (pp, TREE_VEC_ELT (args, i));
1102 pp_c_expression (pp_c_base (pp), t);
1110 /* function-specifier:
1116 pp_cxx_function_specifier (cxx_pretty_printer *pp, tree t)
1118 switch (TREE_CODE (t))
1121 if (DECL_VIRTUAL_P (t))
1122 pp_cxx_ws_string (pp, "virtual");
1123 else if (DECL_CONSTRUCTOR_P (t) && DECL_NONCONVERTING_P (t))
1124 pp_cxx_ws_string (pp, "explicit");
1126 pp_c_function_specifier (pp_c_base (pp), t);
1133 /* decl-specifier-seq:
1134 decl-specifier-seq(opt) decl-specifier
1137 storage-class-specifier
1144 pp_cxx_decl_specifier_seq (cxx_pretty_printer *pp, tree t)
1146 switch (TREE_CODE (t))
1152 pp_cxx_storage_class_specifier (pp, t);
1153 pp_cxx_decl_specifier_seq (pp, TREE_TYPE (t));
1157 pp_cxx_ws_string (pp, "typedef");
1158 pp_cxx_decl_specifier_seq (pp, TREE_TYPE (t));
1162 if (TYPE_PTRMEMFUNC_P (t))
1164 tree pfm = TYPE_PTRMEMFUNC_FN_TYPE (t);
1165 pp_cxx_decl_specifier_seq (pp, TREE_TYPE (TREE_TYPE (pfm)));
1166 pp_cxx_whitespace (pp);
1167 pp_cxx_ptr_operator (pp, t);
1172 /* Constructors don't have return types. And conversion functions
1173 do not have a type-specifier in their return types. */
1174 if (DECL_CONSTRUCTOR_P (t) || DECL_CONV_FN_P (t))
1175 pp_cxx_function_specifier (pp, t);
1176 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
1177 pp_cxx_decl_specifier_seq (pp, TREE_TYPE (TREE_TYPE (t)));
1180 pp_c_declaration_specifiers (pp_c_base (pp), t);
1185 /* simple-type-specifier:
1186 ::(opt) nested-name-specifier(opt) type-name
1187 ::(opt) nested-name-specifier(opt) template(opt) template-id
1201 pp_cxx_simple_type_specifier (cxx_pretty_printer *pp, tree t)
1203 switch (TREE_CODE (t))
1208 pp_cxx_qualified_id (pp, t);
1211 case TEMPLATE_TYPE_PARM:
1212 case TEMPLATE_TEMPLATE_PARM:
1213 case TEMPLATE_PARM_INDEX:
1214 pp_cxx_unqualified_id (pp, t);
1218 pp_cxx_ws_string (pp, "typename");
1219 pp_cxx_nested_name_specifier (pp, TYPE_CONTEXT (t));
1220 pp_cxx_unqualified_id (pp, TYPE_NAME (t));
1224 pp_c_type_specifier (pp_c_base (pp), t);
1229 /* type-specifier-seq:
1230 type-specifier type-specifier-seq(opt)
1233 simple-type-specifier
1236 elaborated-type-specifier
1240 pp_cxx_type_specifier_seq (cxx_pretty_printer *pp, tree t)
1242 switch (TREE_CODE (t))
1245 case TEMPLATE_TYPE_PARM:
1246 case TEMPLATE_TEMPLATE_PARM:
1248 case BOUND_TEMPLATE_TEMPLATE_PARM:
1249 pp_cxx_cv_qualifier_seq (pp, t);
1250 pp_cxx_simple_type_specifier (pp, t);
1254 pp_cxx_type_specifier_seq (pp, TREE_TYPE (t));
1255 pp_cxx_space_for_pointer_operator (pp, TREE_TYPE (t));
1256 pp_cxx_nested_name_specifier (pp, TYPE_METHOD_BASETYPE (t));
1260 pp_cxx_ws_string (pp, "decltype");
1261 pp_cxx_left_paren (pp);
1262 pp_cxx_expression (pp, DECLTYPE_TYPE_EXPR (t));
1263 pp_cxx_right_paren (pp);
1267 if (!(TREE_CODE (t) == FUNCTION_DECL && DECL_CONSTRUCTOR_P (t)))
1268 pp_c_specifier_qualifier_list (pp_c_base (pp), t);
1273 * cv-qualifier-seq(opt)
1275 ::(opt) nested-name-specifier * cv-qualifier-seq(opt) */
1278 pp_cxx_ptr_operator (cxx_pretty_printer *pp, tree t)
1280 if (!TYPE_P (t) && TREE_CODE (t) != TYPE_DECL)
1282 switch (TREE_CODE (t))
1284 case REFERENCE_TYPE:
1286 if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE
1287 || TYPE_PTR_TO_MEMBER_P (TREE_TYPE (t)))
1288 pp_cxx_ptr_operator (pp, TREE_TYPE (t));
1289 if (TREE_CODE (t) == POINTER_TYPE)
1292 pp_cxx_cv_qualifier_seq (pp, t);
1299 if (TYPE_PTRMEMFUNC_P (t))
1301 pp_cxx_left_paren (pp);
1302 pp_cxx_nested_name_specifier (pp, TYPE_PTRMEMFUNC_OBJECT_TYPE (t));
1307 if (TYPE_PTR_TO_MEMBER_P (t))
1309 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
1310 pp_cxx_left_paren (pp);
1311 pp_cxx_nested_name_specifier (pp, TYPE_PTRMEM_CLASS_TYPE (t));
1313 pp_cxx_cv_qualifier_seq (pp, t);
1316 /* else fall through. */
1319 pp_unsupported_tree (pp, t);
1325 pp_cxx_implicit_parameter_type (tree mf)
1327 return TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (mf))));
1331 parameter-declaration:
1332 decl-specifier-seq declarator
1333 decl-specifier-seq declarator = assignment-expression
1334 decl-specifier-seq abstract-declarator(opt)
1335 decl-specifier-seq abstract-declarator(opt) assignment-expression */
1338 pp_cxx_parameter_declaration (cxx_pretty_printer *pp, tree t)
1340 pp_cxx_decl_specifier_seq (pp, t);
1342 pp_cxx_abstract_declarator (pp, t);
1344 pp_cxx_declarator (pp, t);
1347 /* parameter-declaration-clause:
1348 parameter-declaration-list(opt) ...(opt)
1349 parameter-declaration-list , ...
1351 parameter-declaration-list:
1352 parameter-declaration
1353 parameter-declaration-list , parameter-declaration */
1356 pp_cxx_parameter_declaration_clause (cxx_pretty_printer *pp, tree t)
1358 tree args = TYPE_P (t) ? NULL : FUNCTION_FIRST_USER_PARM (t);
1360 TYPE_P (t) ? TYPE_ARG_TYPES (t) : FUNCTION_FIRST_USER_PARMTYPE (t);
1361 const bool abstract = args == NULL
1362 || pp_c_base (pp)->flags & pp_c_flag_abstract;
1365 /* Skip artificial parameter for nonstatic member functions. */
1366 if (TREE_CODE (t) == METHOD_TYPE)
1367 types = TREE_CHAIN (types);
1369 pp_cxx_left_paren (pp);
1370 for (; args; args = TREE_CHAIN (args), types = TREE_CHAIN (types))
1373 pp_cxx_separate_with (pp, ',');
1375 pp_cxx_parameter_declaration (pp, abstract ? TREE_VALUE (types) : args);
1376 if (!abstract && pp_c_base (pp)->flags & pp_cxx_flag_default_argument)
1378 pp_cxx_whitespace (pp);
1380 pp_cxx_whitespace (pp);
1381 pp_cxx_assignment_expression (pp, TREE_PURPOSE (types));
1384 pp_cxx_right_paren (pp);
1387 /* exception-specification:
1388 throw ( type-id-list(opt) )
1392 type-id-list , type-id */
1395 pp_cxx_exception_specification (cxx_pretty_printer *pp, tree t)
1397 tree ex_spec = TYPE_RAISES_EXCEPTIONS (t);
1398 bool need_comma = false;
1400 if (!TYPE_NOTHROW_P (t) && ex_spec == NULL)
1402 pp_cxx_ws_string (pp, "throw");
1403 pp_cxx_left_paren (pp);
1404 for (; ex_spec && TREE_VALUE (ex_spec); ex_spec = TREE_CHAIN (ex_spec))
1406 tree type = TREE_VALUE (ex_spec);
1407 tree argpack = NULL_TREE;
1410 if (ARGUMENT_PACK_P (type))
1412 argpack = ARGUMENT_PACK_ARGS (type);
1413 len = TREE_VEC_LENGTH (argpack);
1416 for (i = 0; i < len; ++i)
1419 type = TREE_VEC_ELT (argpack, i);
1422 pp_cxx_separate_with (pp, ',');
1426 pp_cxx_type_id (pp, type);
1429 pp_cxx_right_paren (pp);
1432 /* direct-declarator:
1434 direct-declarator ( parameter-declaration-clause ) cv-qualifier-seq(opt)
1435 exception-specification(opt)
1436 direct-declaration [ constant-expression(opt) ]
1440 pp_cxx_direct_declarator (cxx_pretty_printer *pp, tree t)
1442 switch (TREE_CODE (t))
1450 pp_cxx_space_for_pointer_operator (pp, TREE_TYPE (t));
1452 if ((TREE_CODE (t) == PARM_DECL && FUNCTION_PARAMETER_PACK_P (t))
1453 || template_parameter_pack_p (t))
1454 /* A function parameter pack or non-type template
1456 pp_cxx_ws_string (pp, "...");
1458 pp_cxx_id_expression (pp, DECL_NAME (t));
1460 pp_cxx_abstract_declarator (pp, TREE_TYPE (t));
1464 pp_cxx_space_for_pointer_operator (pp, TREE_TYPE (TREE_TYPE (t)));
1465 pp_cxx_id_expression (pp, t);
1466 pp_cxx_parameter_declaration_clause (pp, t);
1468 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
1470 pp_base (pp)->padding = pp_before;
1471 pp_cxx_cv_qualifier_seq (pp, pp_cxx_implicit_parameter_type (t));
1474 pp_cxx_exception_specification (pp, TREE_TYPE (t));
1479 case TEMPLATE_TYPE_PARM:
1480 case TEMPLATE_PARM_INDEX:
1481 case TEMPLATE_TEMPLATE_PARM:
1485 pp_c_direct_declarator (pp_c_base (pp), t);
1492 ptr-operator declarator */
1495 pp_cxx_declarator (cxx_pretty_printer *pp, tree t)
1497 pp_cxx_direct_declarator (pp, t);
1500 /* ctor-initializer:
1501 : mem-initializer-list
1503 mem-initializer-list:
1505 mem-initializer , mem-initializer-list
1508 mem-initializer-id ( expression-list(opt) )
1511 ::(opt) nested-name-specifier(opt) class-name
1515 pp_cxx_ctor_initializer (cxx_pretty_printer *pp, tree t)
1517 t = TREE_OPERAND (t, 0);
1518 pp_cxx_whitespace (pp);
1520 pp_cxx_whitespace (pp);
1521 for (; t; t = TREE_CHAIN (t))
1523 tree purpose = TREE_PURPOSE (t);
1524 bool is_pack = PACK_EXPANSION_P (purpose);
1527 pp_cxx_primary_expression (pp, PACK_EXPANSION_PATTERN (purpose));
1529 pp_cxx_primary_expression (pp, purpose);
1530 pp_cxx_call_argument_list (pp, TREE_VALUE (t));
1532 pp_cxx_ws_string (pp, "...");
1534 pp_cxx_separate_with (pp, ',');
1538 /* function-definition:
1539 decl-specifier-seq(opt) declarator ctor-initializer(opt) function-body
1540 decl-specifier-seq(opt) declarator function-try-block */
1543 pp_cxx_function_definition (cxx_pretty_printer *pp, tree t)
1545 tree saved_scope = pp->enclosing_scope;
1546 pp_cxx_decl_specifier_seq (pp, t);
1547 pp_cxx_declarator (pp, t);
1548 pp_needs_newline (pp) = true;
1549 pp->enclosing_scope = DECL_CONTEXT (t);
1550 if (DECL_SAVED_TREE (t))
1551 pp_cxx_statement (pp, DECL_SAVED_TREE (t));
1554 pp_cxx_semicolon (pp);
1555 pp_needs_newline (pp) = true;
1558 pp->enclosing_scope = saved_scope;
1561 /* abstract-declarator:
1562 ptr-operator abstract-declarator(opt)
1563 direct-abstract-declarator */
1566 pp_cxx_abstract_declarator (cxx_pretty_printer *pp, tree t)
1568 if (TYPE_PTRMEM_P (t) || TYPE_PTRMEMFUNC_P (t))
1569 pp_cxx_right_paren (pp);
1570 else if (POINTER_TYPE_P (t))
1572 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
1573 || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
1574 pp_cxx_right_paren (pp);
1577 pp_cxx_direct_abstract_declarator (pp, t);
1580 /* direct-abstract-declarator:
1581 direct-abstract-declarator(opt) ( parameter-declaration-clause )
1582 cv-qualifier-seq(opt) exception-specification(opt)
1583 direct-abstract-declarator(opt) [ constant-expression(opt) ]
1584 ( abstract-declarator ) */
1587 pp_cxx_direct_abstract_declarator (cxx_pretty_printer *pp, tree t)
1589 switch (TREE_CODE (t))
1591 case REFERENCE_TYPE:
1592 pp_cxx_abstract_declarator (pp, t);
1596 if (TYPE_PTRMEMFUNC_P (t))
1597 pp_cxx_direct_abstract_declarator (pp, TYPE_PTRMEMFUNC_FN_TYPE (t));
1602 pp_cxx_parameter_declaration_clause (pp, t);
1603 pp_cxx_direct_abstract_declarator (pp, TREE_TYPE (t));
1604 if (TREE_CODE (t) == METHOD_TYPE)
1606 pp_base (pp)->padding = pp_before;
1607 pp_cxx_cv_qualifier_seq
1608 (pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
1610 pp_cxx_exception_specification (pp, t);
1614 case TEMPLATE_TYPE_PARM:
1615 case TEMPLATE_TEMPLATE_PARM:
1616 case BOUND_TEMPLATE_TEMPLATE_PARM:
1617 case UNBOUND_CLASS_TEMPLATE:
1621 pp_c_direct_abstract_declarator (pp_c_base (pp), t);
1627 type-specifier-seq abstract-declarator(opt) */
1630 pp_cxx_type_id (cxx_pretty_printer *pp, tree t)
1632 pp_flags saved_flags = pp_c_base (pp)->flags;
1633 pp_c_base (pp)->flags |= pp_c_flag_abstract;
1635 switch (TREE_CODE (t))
1642 case BOUND_TEMPLATE_TEMPLATE_PARM:
1643 case UNBOUND_CLASS_TEMPLATE:
1644 case TEMPLATE_TEMPLATE_PARM:
1645 case TEMPLATE_TYPE_PARM:
1646 case TEMPLATE_PARM_INDEX:
1650 case TEMPLATE_ID_EXPR:
1651 pp_cxx_type_specifier_seq (pp, t);
1654 case TYPE_PACK_EXPANSION:
1655 pp_cxx_type_id (pp, PACK_EXPANSION_PATTERN (t));
1656 pp_cxx_ws_string (pp, "...");
1660 pp_c_type_id (pp_c_base (pp), t);
1664 pp_c_base (pp)->flags = saved_flags;
1667 /* template-argument-list:
1668 template-argument ...(opt)
1669 template-argument-list, template-argument ...(opt)
1672 assignment-expression
1677 pp_cxx_template_argument_list (cxx_pretty_printer *pp, tree t)
1680 bool need_comma = false;
1684 for (i = 0; i < TREE_VEC_LENGTH (t); ++i)
1686 tree arg = TREE_VEC_ELT (t, i);
1687 tree argpack = NULL_TREE;
1690 if (ARGUMENT_PACK_P (arg))
1692 argpack = ARGUMENT_PACK_ARGS (arg);
1693 len = TREE_VEC_LENGTH (argpack);
1696 for (idx = 0; idx < len; idx++)
1699 arg = TREE_VEC_ELT (argpack, idx);
1702 pp_cxx_separate_with (pp, ',');
1706 if (TYPE_P (arg) || (TREE_CODE (arg) == TEMPLATE_DECL
1707 && TYPE_P (DECL_TEMPLATE_RESULT (arg))))
1708 pp_cxx_type_id (pp, arg);
1710 pp_cxx_expression (pp, arg);
1717 pp_cxx_exception_declaration (cxx_pretty_printer *pp, tree t)
1719 t = DECL_EXPR_DECL (t);
1720 pp_cxx_type_specifier_seq (pp, t);
1722 pp_cxx_abstract_declarator (pp, t);
1724 pp_cxx_declarator (pp, t);
1730 pp_cxx_statement (cxx_pretty_printer *pp, tree t)
1732 switch (TREE_CODE (t))
1734 case CTOR_INITIALIZER:
1735 pp_cxx_ctor_initializer (pp, t);
1739 pp_cxx_ws_string (pp, "using");
1740 pp_cxx_ws_string (pp, "namespace");
1741 if (DECL_CONTEXT (t))
1742 pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
1743 pp_cxx_qualified_id (pp, USING_STMT_NAMESPACE (t));
1747 pp_cxx_ws_string (pp, "using");
1748 pp_cxx_nested_name_specifier (pp, USING_DECL_SCOPE (t));
1749 pp_cxx_unqualified_id (pp, DECL_NAME (t));
1756 try compound-statement handler-seq */
1758 pp_maybe_newline_and_indent (pp, 0);
1759 pp_cxx_ws_string (pp, "try");
1760 pp_newline_and_indent (pp, 3);
1761 pp_cxx_statement (pp, TRY_STMTS (t));
1762 pp_newline_and_indent (pp, -3);
1766 pp_cxx_statement (pp, TRY_HANDLERS (t));
1771 handler handler-seq(opt)
1774 catch ( exception-declaration ) compound-statement
1776 exception-declaration:
1777 type-specifier-seq declarator
1778 type-specifier-seq abstract-declarator
1781 pp_cxx_ws_string (pp, "catch");
1782 pp_cxx_left_paren (pp);
1783 pp_cxx_exception_declaration (pp, HANDLER_PARMS (t));
1784 pp_cxx_right_paren (pp);
1785 pp_indentation (pp) += 3;
1786 pp_needs_newline (pp) = true;
1787 pp_cxx_statement (pp, HANDLER_BODY (t));
1788 pp_indentation (pp) -= 3;
1789 pp_needs_newline (pp) = true;
1792 /* selection-statement:
1793 if ( expression ) statement
1794 if ( expression ) statement else statement */
1796 pp_cxx_ws_string (pp, "if");
1797 pp_cxx_whitespace (pp);
1798 pp_cxx_left_paren (pp);
1799 pp_cxx_expression (pp, IF_COND (t));
1800 pp_cxx_right_paren (pp);
1801 pp_newline_and_indent (pp, 2);
1802 pp_cxx_statement (pp, THEN_CLAUSE (t));
1803 pp_newline_and_indent (pp, -2);
1804 if (ELSE_CLAUSE (t))
1806 tree else_clause = ELSE_CLAUSE (t);
1807 pp_cxx_ws_string (pp, "else");
1808 if (TREE_CODE (else_clause) == IF_STMT)
1809 pp_cxx_whitespace (pp);
1811 pp_newline_and_indent (pp, 2);
1812 pp_cxx_statement (pp, else_clause);
1813 if (TREE_CODE (else_clause) != IF_STMT)
1814 pp_newline_and_indent (pp, -2);
1819 pp_cxx_ws_string (pp, "switch");
1821 pp_cxx_left_paren (pp);
1822 pp_cxx_expression (pp, SWITCH_STMT_COND (t));
1823 pp_cxx_right_paren (pp);
1824 pp_indentation (pp) += 3;
1825 pp_needs_newline (pp) = true;
1826 pp_cxx_statement (pp, SWITCH_STMT_BODY (t));
1827 pp_newline_and_indent (pp, -3);
1830 /* iteration-statement:
1831 while ( expression ) statement
1832 do statement while ( expression ) ;
1833 for ( expression(opt) ; expression(opt) ; expression(opt) ) statement
1834 for ( declaration expression(opt) ; expression(opt) ) statement */
1836 pp_cxx_ws_string (pp, "while");
1838 pp_cxx_left_paren (pp);
1839 pp_cxx_expression (pp, WHILE_COND (t));
1840 pp_cxx_right_paren (pp);
1841 pp_newline_and_indent (pp, 3);
1842 pp_cxx_statement (pp, WHILE_BODY (t));
1843 pp_indentation (pp) -= 3;
1844 pp_needs_newline (pp) = true;
1848 pp_cxx_ws_string (pp, "do");
1849 pp_newline_and_indent (pp, 3);
1850 pp_cxx_statement (pp, DO_BODY (t));
1851 pp_newline_and_indent (pp, -3);
1852 pp_cxx_ws_string (pp, "while");
1854 pp_cxx_left_paren (pp);
1855 pp_cxx_expression (pp, DO_COND (t));
1856 pp_cxx_right_paren (pp);
1857 pp_cxx_semicolon (pp);
1858 pp_needs_newline (pp) = true;
1862 pp_cxx_ws_string (pp, "for");
1864 pp_cxx_left_paren (pp);
1865 if (FOR_INIT_STMT (t))
1866 pp_cxx_statement (pp, FOR_INIT_STMT (t));
1868 pp_cxx_semicolon (pp);
1869 pp_needs_newline (pp) = false;
1870 pp_cxx_whitespace (pp);
1872 pp_cxx_expression (pp, FOR_COND (t));
1873 pp_cxx_semicolon (pp);
1874 pp_needs_newline (pp) = false;
1875 pp_cxx_whitespace (pp);
1877 pp_cxx_expression (pp, FOR_EXPR (t));
1878 pp_cxx_right_paren (pp);
1879 pp_newline_and_indent (pp, 3);
1880 pp_cxx_statement (pp, FOR_BODY (t));
1881 pp_indentation (pp) -= 3;
1882 pp_needs_newline (pp) = true;
1888 return expression(opt) ; */
1891 pp_string (pp, TREE_CODE (t) == BREAK_STMT ? "break" : "continue");
1892 pp_cxx_semicolon (pp);
1893 pp_needs_newline (pp) = true;
1896 /* expression-statement:
1897 expression(opt) ; */
1899 pp_cxx_expression (pp, EXPR_STMT_EXPR (t));
1900 pp_cxx_semicolon (pp);
1901 pp_needs_newline (pp) = true;
1905 pp_cxx_ws_string (pp, "try");
1906 pp_newline_and_indent (pp, 2);
1907 pp_cxx_statement (pp, CLEANUP_BODY (t));
1908 pp_newline_and_indent (pp, -2);
1909 pp_cxx_ws_string (pp, CLEANUP_EH_ONLY (t) ? "catch" : "finally");
1910 pp_newline_and_indent (pp, 2);
1911 pp_cxx_statement (pp, CLEANUP_EXPR (t));
1912 pp_newline_and_indent (pp, -2);
1916 pp_cxx_declaration (pp, t);
1920 pp_c_statement (pp_c_base (pp), t);
1925 /* original-namespace-definition:
1926 namespace identifier { namespace-body }
1928 As an edge case, we also handle unnamed namespace definition here. */
1931 pp_cxx_original_namespace_definition (cxx_pretty_printer *pp, tree t)
1933 pp_cxx_ws_string (pp, "namespace");
1934 if (DECL_CONTEXT (t))
1935 pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
1937 pp_cxx_unqualified_id (pp, t);
1938 pp_cxx_whitespace (pp);
1939 pp_cxx_left_brace (pp);
1940 /* We do not print the namespace-body. */
1941 pp_cxx_whitespace (pp);
1942 pp_cxx_right_brace (pp);
1948 namespace-alias-definition:
1949 namespace identifier = qualified-namespace-specifier ;
1951 qualified-namespace-specifier:
1952 ::(opt) nested-name-specifier(opt) namespace-name */
1955 pp_cxx_namespace_alias_definition (cxx_pretty_printer *pp, tree t)
1957 pp_cxx_ws_string (pp, "namespace");
1958 if (DECL_CONTEXT (t))
1959 pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
1960 pp_cxx_unqualified_id (pp, t);
1961 pp_cxx_whitespace (pp);
1963 pp_cxx_whitespace (pp);
1964 if (DECL_CONTEXT (DECL_NAMESPACE_ALIAS (t)))
1965 pp_cxx_nested_name_specifier (pp,
1966 DECL_CONTEXT (DECL_NAMESPACE_ALIAS (t)));
1967 pp_cxx_qualified_id (pp, DECL_NAMESPACE_ALIAS (t));
1968 pp_cxx_semicolon (pp);
1971 /* simple-declaration:
1972 decl-specifier-seq(opt) init-declarator-list(opt) */
1975 pp_cxx_simple_declaration (cxx_pretty_printer *pp, tree t)
1977 pp_cxx_decl_specifier_seq (pp, t);
1978 pp_cxx_init_declarator (pp, t);
1979 pp_cxx_semicolon (pp);
1980 pp_needs_newline (pp) = true;
1984 template-parameter-list:
1986 template-parameter-list , template-parameter */
1989 pp_cxx_template_parameter_list (cxx_pretty_printer *pp, tree t)
1991 const int n = TREE_VEC_LENGTH (t);
1993 for (i = 0; i < n; ++i)
1996 pp_cxx_separate_with (pp, ',');
1997 pp_cxx_template_parameter (pp, TREE_VEC_ELT (t, i));
2001 /* template-parameter:
2003 parameter-declaration
2006 class ...(opt) identifier(opt)
2007 class identifier(opt) = type-id
2008 typename identifier(opt)
2009 typename ...(opt) identifier(opt) = type-id
2010 template < template-parameter-list > class ...(opt) identifier(opt)
2011 template < template-parameter-list > class identifier(opt) = template-name */
2014 pp_cxx_template_parameter (cxx_pretty_printer *pp, tree t)
2016 tree parameter = TREE_VALUE (t);
2017 switch (TREE_CODE (parameter))
2020 pp_cxx_ws_string (pp, "class");
2021 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
2022 pp_cxx_ws_string (pp, "...");
2023 if (DECL_NAME (parameter))
2024 pp_cxx_tree_identifier (pp, DECL_NAME (parameter));
2025 /* FIXME: Check if we should print also default argument. */
2029 pp_cxx_parameter_declaration (pp, parameter);
2036 pp_unsupported_tree (pp, t);
2041 /* Pretty-print a template parameter in the canonical form
2042 "template-parameter-<level>-<position in parameter list>". */
2045 pp_cxx_canonical_template_parameter (cxx_pretty_printer *pp, tree parm)
2047 const enum tree_code code = TREE_CODE (parm);
2049 /* Brings type template parameters to the canonical forms. */
2050 if (code == TEMPLATE_TYPE_PARM || code == TEMPLATE_TEMPLATE_PARM
2051 || code == BOUND_TEMPLATE_TEMPLATE_PARM)
2052 parm = TEMPLATE_TYPE_PARM_INDEX (parm);
2054 pp_cxx_begin_template_argument_list (pp);
2055 pp_cxx_ws_string (pp, M_("template-parameter-"));
2056 pp_wide_integer (pp, TEMPLATE_PARM_LEVEL (parm));
2058 pp_wide_integer (pp, TEMPLATE_PARM_IDX (parm) + 1);
2059 pp_cxx_end_template_argument_list (pp);
2063 template-declaration:
2064 export(opt) template < template-parameter-list > declaration */
2067 pp_cxx_template_declaration (cxx_pretty_printer *pp, tree t)
2069 tree tmpl = most_general_template (t);
2073 pp_maybe_newline_and_indent (pp, 0);
2074 for (level = DECL_TEMPLATE_PARMS (tmpl); level; level = TREE_CHAIN (level))
2076 pp_cxx_ws_string (pp, "template");
2077 pp_cxx_begin_template_argument_list (pp);
2078 pp_cxx_template_parameter_list (pp, TREE_VALUE (level));
2079 pp_cxx_end_template_argument_list (pp);
2080 pp_newline_and_indent (pp, 3);
2083 if (TREE_CODE (t) == FUNCTION_DECL && DECL_SAVED_TREE (t))
2084 pp_cxx_function_definition (pp, t);
2086 pp_cxx_simple_declaration (pp, t);
2090 pp_cxx_explicit_specialization (cxx_pretty_printer *pp, tree t)
2092 pp_unsupported_tree (pp, t);
2096 pp_cxx_explicit_instantiation (cxx_pretty_printer *pp, tree t)
2098 pp_unsupported_tree (pp, t);
2105 template-declaration
2106 explicit-instantiation
2107 explicit-specialization
2108 linkage-specification
2109 namespace-definition
2114 namespace-alias-definition
2117 static_assert-declaration */
2119 pp_cxx_declaration (cxx_pretty_printer *pp, tree t)
2121 if (TREE_CODE (t) == STATIC_ASSERT)
2123 pp_cxx_ws_string (pp, "static_assert");
2124 pp_cxx_left_paren (pp);
2125 pp_cxx_expression (pp, STATIC_ASSERT_CONDITION (t));
2126 pp_cxx_separate_with (pp, ',');
2127 pp_cxx_expression (pp, STATIC_ASSERT_MESSAGE (t));
2128 pp_cxx_right_paren (pp);
2130 else if (!DECL_LANG_SPECIFIC (t))
2131 pp_cxx_simple_declaration (pp, t);
2132 else if (DECL_USE_TEMPLATE (t))
2133 switch (DECL_USE_TEMPLATE (t))
2136 pp_cxx_template_declaration (pp, t);
2140 pp_cxx_explicit_specialization (pp, t);
2144 pp_cxx_explicit_instantiation (pp, t);
2150 else switch (TREE_CODE (t))
2154 pp_cxx_simple_declaration (pp, t);
2158 if (DECL_SAVED_TREE (t))
2159 pp_cxx_function_definition (pp, t);
2161 pp_cxx_simple_declaration (pp, t);
2164 case NAMESPACE_DECL:
2165 if (DECL_NAMESPACE_ALIAS (t))
2166 pp_cxx_namespace_alias_definition (pp, t);
2168 pp_cxx_original_namespace_definition (pp, t);
2172 pp_unsupported_tree (pp, t);
2178 pp_cxx_typeid_expression (cxx_pretty_printer *pp, tree t)
2180 t = TREE_OPERAND (t, 0);
2181 pp_cxx_ws_string (pp, "typeid");
2182 pp_cxx_left_paren (pp);
2184 pp_cxx_type_id (pp, t);
2186 pp_cxx_expression (pp, t);
2187 pp_cxx_right_paren (pp);
2191 pp_cxx_va_arg_expression (cxx_pretty_printer *pp, tree t)
2193 pp_cxx_ws_string (pp, "va_arg");
2194 pp_cxx_left_paren (pp);
2195 pp_cxx_assignment_expression (pp, TREE_OPERAND (t, 0));
2196 pp_cxx_separate_with (pp, ',');
2197 pp_cxx_type_id (pp, TREE_TYPE (t));
2198 pp_cxx_right_paren (pp);
2202 pp_cxx_offsetof_expression_1 (cxx_pretty_printer *pp, tree t)
2204 switch (TREE_CODE (t))
2207 if (TREE_CODE (TREE_OPERAND (t, 0)) == STATIC_CAST_EXPR
2208 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (t, 0))))
2210 pp_cxx_type_id (pp, TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0))));
2211 pp_cxx_separate_with (pp, ',');
2216 if (!pp_cxx_offsetof_expression_1 (pp, TREE_OPERAND (t, 0)))
2218 if (TREE_CODE (TREE_OPERAND (t, 0)) != ARROW_EXPR)
2220 pp_cxx_expression (pp, TREE_OPERAND (t, 1));
2223 if (!pp_cxx_offsetof_expression_1 (pp, TREE_OPERAND (t, 0)))
2225 pp_left_bracket (pp);
2226 pp_cxx_expression (pp, TREE_OPERAND (t, 1));
2227 pp_right_bracket (pp);
2235 pp_cxx_offsetof_expression (cxx_pretty_printer *pp, tree t)
2237 pp_cxx_ws_string (pp, "offsetof");
2238 pp_cxx_left_paren (pp);
2239 if (!pp_cxx_offsetof_expression_1 (pp, TREE_OPERAND (t, 0)))
2240 pp_cxx_expression (pp, TREE_OPERAND (t, 0));
2241 pp_cxx_right_paren (pp);
2245 pp_cxx_trait_expression (cxx_pretty_printer *pp, tree t)
2247 cp_trait_kind kind = TRAIT_EXPR_KIND (t);
2251 case CPTK_HAS_NOTHROW_ASSIGN:
2252 pp_cxx_ws_string (pp, "__has_nothrow_assign");
2254 case CPTK_HAS_TRIVIAL_ASSIGN:
2255 pp_cxx_ws_string (pp, "__has_trivial_assign");
2257 case CPTK_HAS_NOTHROW_CONSTRUCTOR:
2258 pp_cxx_ws_string (pp, "__has_nothrow_constructor");
2260 case CPTK_HAS_TRIVIAL_CONSTRUCTOR:
2261 pp_cxx_ws_string (pp, "__has_trivial_constructor");
2263 case CPTK_HAS_NOTHROW_COPY:
2264 pp_cxx_ws_string (pp, "__has_nothrow_copy");
2266 case CPTK_HAS_TRIVIAL_COPY:
2267 pp_cxx_ws_string (pp, "__has_trivial_copy");
2269 case CPTK_HAS_TRIVIAL_DESTRUCTOR:
2270 pp_cxx_ws_string (pp, "__has_trivial_destructor");
2272 case CPTK_HAS_VIRTUAL_DESTRUCTOR:
2273 pp_cxx_ws_string (pp, "__has_virtual_destructor");
2275 case CPTK_IS_ABSTRACT:
2276 pp_cxx_ws_string (pp, "__is_abstract");
2278 case CPTK_IS_BASE_OF:
2279 pp_cxx_ws_string (pp, "__is_base_of");
2282 pp_cxx_ws_string (pp, "__is_class");
2284 case CPTK_IS_CONVERTIBLE_TO:
2285 pp_cxx_ws_string (pp, "__is_convertible_to");
2288 pp_cxx_ws_string (pp, "__is_empty");
2291 pp_cxx_ws_string (pp, "__is_enum");
2294 pp_cxx_ws_string (pp, "__is_pod");
2296 case CPTK_IS_POLYMORPHIC:
2297 pp_cxx_ws_string (pp, "__is_polymorphic");
2300 pp_cxx_ws_string (pp, "__is_union");
2307 pp_cxx_left_paren (pp);
2308 pp_cxx_type_id (pp, TRAIT_EXPR_TYPE1 (t));
2310 if (kind == CPTK_IS_BASE_OF || kind == CPTK_IS_CONVERTIBLE_TO)
2312 pp_cxx_separate_with (pp, ',');
2313 pp_cxx_type_id (pp, TRAIT_EXPR_TYPE2 (t));
2316 pp_cxx_right_paren (pp);
2319 typedef c_pretty_print_fn pp_fun;
2321 /* Initialization of a C++ pretty-printer object. */
2324 pp_cxx_pretty_printer_init (cxx_pretty_printer *pp)
2326 pp_c_pretty_printer_init (pp_c_base (pp));
2327 pp_set_line_maximum_length (pp, 0);
2329 pp->c_base.declaration = (pp_fun) pp_cxx_declaration;
2330 pp->c_base.declaration_specifiers = (pp_fun) pp_cxx_decl_specifier_seq;
2331 pp->c_base.function_specifier = (pp_fun) pp_cxx_function_specifier;
2332 pp->c_base.type_specifier_seq = (pp_fun) pp_cxx_type_specifier_seq;
2333 pp->c_base.declarator = (pp_fun) pp_cxx_declarator;
2334 pp->c_base.direct_declarator = (pp_fun) pp_cxx_direct_declarator;
2335 pp->c_base.parameter_list = (pp_fun) pp_cxx_parameter_declaration_clause;
2336 pp->c_base.type_id = (pp_fun) pp_cxx_type_id;
2337 pp->c_base.abstract_declarator = (pp_fun) pp_cxx_abstract_declarator;
2338 pp->c_base.direct_abstract_declarator =
2339 (pp_fun) pp_cxx_direct_abstract_declarator;
2340 pp->c_base.simple_type_specifier = (pp_fun)pp_cxx_simple_type_specifier;
2342 /* pp->c_base.statement = (pp_fun) pp_cxx_statement; */
2344 pp->c_base.constant = (pp_fun) pp_cxx_constant;
2345 pp->c_base.id_expression = (pp_fun) pp_cxx_id_expression;
2346 pp->c_base.primary_expression = (pp_fun) pp_cxx_primary_expression;
2347 pp->c_base.postfix_expression = (pp_fun) pp_cxx_postfix_expression;
2348 pp->c_base.unary_expression = (pp_fun) pp_cxx_unary_expression;
2349 pp->c_base.multiplicative_expression = (pp_fun) pp_cxx_multiplicative_expression;
2350 pp->c_base.conditional_expression = (pp_fun) pp_cxx_conditional_expression;
2351 pp->c_base.assignment_expression = (pp_fun) pp_cxx_assignment_expression;
2352 pp->c_base.expression = (pp_fun) pp_cxx_expression;
2353 pp->enclosing_scope = global_namespace;