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"
31 /* Translate if being used for diagnostics, but not for dump files or
33 #define M_(msgid) (pp_translate_identifiers (pp) ? _(msgid) : (msgid))
35 static void pp_cxx_unqualified_id (cxx_pretty_printer *, tree);
36 static void pp_cxx_nested_name_specifier (cxx_pretty_printer *, tree);
37 static void pp_cxx_qualified_id (cxx_pretty_printer *, tree);
38 static void pp_cxx_assignment_expression (cxx_pretty_printer *, tree);
39 static void pp_cxx_expression (cxx_pretty_printer *, tree);
40 static void pp_cxx_template_argument_list (cxx_pretty_printer *, tree);
41 static void pp_cxx_type_specifier_seq (cxx_pretty_printer *, tree);
42 static void pp_cxx_ptr_operator (cxx_pretty_printer *, tree);
43 static void pp_cxx_type_id (cxx_pretty_printer *, tree);
44 static void pp_cxx_direct_abstract_declarator (cxx_pretty_printer *, tree);
45 static void pp_cxx_declarator (cxx_pretty_printer *, tree);
46 static void pp_cxx_parameter_declaration_clause (cxx_pretty_printer *, tree);
47 static void pp_cxx_abstract_declarator (cxx_pretty_printer *, tree);
48 static void pp_cxx_statement (cxx_pretty_printer *, tree);
49 static void pp_cxx_template_parameter (cxx_pretty_printer *, tree);
50 static void pp_cxx_cast_expression (cxx_pretty_printer *, tree);
51 static void pp_cxx_typeid_expression (cxx_pretty_printer *, tree);
55 pp_cxx_nonconsecutive_character (cxx_pretty_printer *pp, int c)
57 const char *p = pp_last_position_in_text (pp);
59 if (p != NULL && *p == c)
60 pp_cxx_whitespace (pp);
62 pp_base (pp)->padding = pp_none;
65 #define pp_cxx_storage_class_specifier(PP, T) \
66 pp_c_storage_class_specifier (pp_c_base (PP), T)
67 #define pp_cxx_expression_list(PP, T) \
68 pp_c_expression_list (pp_c_base (PP), T)
69 #define pp_cxx_space_for_pointer_operator(PP, T) \
70 pp_c_space_for_pointer_operator (pp_c_base (PP), T)
71 #define pp_cxx_init_declarator(PP, T) \
72 pp_c_init_declarator (pp_c_base (PP), T)
73 #define pp_cxx_call_argument_list(PP, T) \
74 pp_c_call_argument_list (pp_c_base (PP), T)
77 pp_cxx_colon_colon (cxx_pretty_printer *pp)
80 pp_base (pp)->padding = pp_none;
84 pp_cxx_begin_template_argument_list (cxx_pretty_printer *pp)
86 pp_cxx_nonconsecutive_character (pp, '<');
90 pp_cxx_end_template_argument_list (cxx_pretty_printer *pp)
92 pp_cxx_nonconsecutive_character (pp, '>');
96 pp_cxx_separate_with (cxx_pretty_printer *pp, int c)
98 pp_separate_with (pp, c);
99 pp_base (pp)->padding = pp_none;
105 is_destructor_name (tree name)
107 return name == complete_dtor_identifier
108 || name == base_dtor_identifier
109 || name == deleting_dtor_identifier;
112 /* conversion-function-id:
113 operator conversion-type-id
116 type-specifier-seq conversion-declarator(opt)
118 conversion-declarator:
119 ptr-operator conversion-declarator(opt) */
122 pp_cxx_conversion_function_id (cxx_pretty_printer *pp, tree t)
124 pp_cxx_ws_string (pp, "operator");
125 pp_cxx_type_specifier_seq (pp, TREE_TYPE (t));
129 pp_cxx_template_id (cxx_pretty_printer *pp, tree t)
131 pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 0));
132 pp_cxx_begin_template_argument_list (pp);
133 pp_cxx_template_argument_list (pp, TREE_OPERAND (t, 1));
134 pp_cxx_end_template_argument_list (pp);
137 /* Prints the unqualified part of the id-expression T.
142 conversion-function-id
147 pp_cxx_unqualified_id (cxx_pretty_printer *pp, tree t)
149 enum tree_code code = TREE_CODE (t);
153 pp_cxx_ws_string (pp, M_("<return-value>"));
170 case IDENTIFIER_NODE:
172 pp_cxx_ws_string (pp, M_("<unnamed>"));
173 else if (IDENTIFIER_TYPENAME_P (t))
174 pp_cxx_conversion_function_id (pp, t);
177 if (is_destructor_name (t))
180 /* FIXME: Why is this necessary? */
182 t = constructor_name (TREE_TYPE (t));
184 pp_cxx_tree_identifier (pp, t);
188 case TEMPLATE_ID_EXPR:
189 pp_cxx_template_id (pp, t);
193 pp_cxx_unqualified_id (pp, BASELINK_FUNCTIONS (t));
200 case UNBOUND_CLASS_TEMPLATE:
201 pp_cxx_unqualified_id (pp, TYPE_NAME (t));
202 if (CLASS_TYPE_P (t) && CLASSTYPE_USE_TEMPLATE (t))
204 pp_cxx_begin_template_argument_list (pp);
205 pp_cxx_template_argument_list (pp, INNERMOST_TEMPLATE_ARGS
206 (CLASSTYPE_TI_ARGS (t)));
207 pp_cxx_end_template_argument_list (pp);
212 pp_cxx_complement (pp);
213 pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 0));
216 case TEMPLATE_TYPE_PARM:
217 case TEMPLATE_TEMPLATE_PARM:
218 if (TYPE_IDENTIFIER (t))
219 pp_cxx_unqualified_id (pp, TYPE_IDENTIFIER (t));
221 pp_cxx_canonical_template_parameter (pp, t);
224 case TEMPLATE_PARM_INDEX:
225 pp_cxx_unqualified_id (pp, TEMPLATE_PARM_DECL (t));
228 case BOUND_TEMPLATE_TEMPLATE_PARM:
229 pp_cxx_cv_qualifier_seq (pp, t);
230 pp_cxx_unqualified_id (pp, TYPE_IDENTIFIER (t));
231 pp_cxx_begin_template_argument_list (pp);
232 pp_cxx_template_argument_list (pp, TYPE_TI_ARGS (t));
233 pp_cxx_end_template_argument_list (pp);
237 pp_unsupported_tree (pp, t);
242 /* Pretty-print out the token sequence ":: template" in template codes
243 where it is needed to "inline declare" the (following) member as
244 a template. This situation arises when SCOPE of T is dependent
245 on template parameters. */
248 pp_cxx_template_keyword_if_needed (cxx_pretty_printer *pp, tree scope, tree t)
250 if (TREE_CODE (t) == TEMPLATE_ID_EXPR
251 && TYPE_P (scope) && dependent_type_p (scope))
252 pp_cxx_ws_string (pp, "template");
255 /* nested-name-specifier:
256 class-or-namespace-name :: nested-name-specifier(opt)
257 class-or-namespace-name :: template nested-name-specifier */
260 pp_cxx_nested_name_specifier (cxx_pretty_printer *pp, tree t)
262 if (t != NULL && t != pp->enclosing_scope)
264 tree scope = TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t);
265 pp_cxx_nested_name_specifier (pp, scope);
266 pp_cxx_template_keyword_if_needed (pp, scope, t);
267 pp_cxx_unqualified_id (pp, t);
268 pp_cxx_colon_colon (pp);
273 nested-name-specifier template(opt) unqualified-id */
276 pp_cxx_qualified_id (cxx_pretty_printer *pp, tree t)
278 switch (TREE_CODE (t))
280 /* A pointer-to-member is always qualified. */
282 pp_cxx_nested_name_specifier (pp, PTRMEM_CST_CLASS (t));
283 pp_cxx_unqualified_id (pp, PTRMEM_CST_MEMBER (t));
286 /* In Standard C++, functions cannot possibly be used as
287 nested-name-specifiers. However, there are situations where
288 is "makes sense" to output the surrounding function name for the
289 purpose of emphasizing on the scope kind. Just printing the
290 function name might not be sufficient as it may be overloaded; so,
291 we decorate the function with its signature too.
292 FIXME: This is probably the wrong pretty-printing for conversion
293 functions and some function templates. */
297 if (DECL_FUNCTION_MEMBER_P (t))
298 pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
299 pp_cxx_unqualified_id
300 (pp, DECL_CONSTRUCTOR_P (t) ? DECL_CONTEXT (t) : t);
301 pp_cxx_parameter_declaration_clause (pp, TREE_TYPE (t));
306 pp_cxx_nested_name_specifier (pp, TREE_OPERAND (t, 0));
307 pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 1));
312 tree scope = TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t);
313 if (scope != pp->enclosing_scope)
315 pp_cxx_nested_name_specifier (pp, scope);
316 pp_cxx_template_keyword_if_needed (pp, scope, t);
318 pp_cxx_unqualified_id (pp, t);
326 pp_cxx_constant (cxx_pretty_printer *pp, tree t)
328 switch (TREE_CODE (t))
332 const bool in_parens = PAREN_STRING_LITERAL_P (t);
334 pp_cxx_left_paren (pp);
335 pp_c_constant (pp_c_base (pp), t);
337 pp_cxx_right_paren (pp);
342 if (NULLPTR_TYPE_P (TREE_TYPE (t)))
344 pp_string (pp, "nullptr");
347 /* else fall through. */
350 pp_c_constant (pp_c_base (pp), t);
360 pp_cxx_id_expression (cxx_pretty_printer *pp, tree t)
362 if (TREE_CODE (t) == OVERLOAD)
364 if (DECL_P (t) && DECL_CONTEXT (t))
365 pp_cxx_qualified_id (pp, t);
367 pp_cxx_unqualified_id (pp, t);
370 /* primary-expression:
374 :: operator-function-id
380 __builtin_va_arg ( assignment-expression , type-id )
381 __builtin_offsetof ( type-id, offsetof-expression )
383 __has_nothrow_assign ( type-id )
384 __has_nothrow_constructor ( type-id )
385 __has_nothrow_copy ( type-id )
386 __has_trivial_assign ( type-id )
387 __has_trivial_constructor ( type-id )
388 __has_trivial_copy ( type-id )
389 __has_trivial_destructor ( type-id )
390 __has_virtual_destructor ( type-id )
391 __is_abstract ( type-id )
392 __is_base_of ( type-id , type-id )
393 __is_class ( type-id )
394 __is_convertible_to ( type-id , type-id )
395 __is_empty ( type-id )
396 __is_enum ( type-id )
398 __is_polymorphic ( type-id )
399 __is_union ( type-id ) */
402 pp_cxx_primary_expression (cxx_pretty_printer *pp, tree t)
404 switch (TREE_CODE (t))
410 pp_cxx_constant (pp, t);
414 t = BASELINK_FUNCTIONS (t);
422 pp_cxx_id_expression (pp, t);
426 case TEMPLATE_TYPE_PARM:
427 case TEMPLATE_TEMPLATE_PARM:
428 case TEMPLATE_PARM_INDEX:
429 pp_cxx_unqualified_id (pp, t);
433 pp_cxx_left_paren (pp);
434 pp_cxx_statement (pp, STMT_EXPR_STMT (t));
435 pp_cxx_right_paren (pp);
439 pp_cxx_trait_expression (pp, t);
443 pp_cxx_va_arg_expression (pp, t);
447 pp_cxx_offsetof_expression (pp, t);
451 pp_c_primary_expression (pp_c_base (pp), t);
456 /* postfix-expression:
458 postfix-expression [ expression ]
459 postfix-expression ( expression-list(opt) )
460 simple-type-specifier ( expression-list(opt) )
461 typename ::(opt) nested-name-specifier identifier ( expression-list(opt) )
462 typename ::(opt) nested-name-specifier template(opt)
463 template-id ( expression-list(opt) )
464 postfix-expression . template(opt) ::(opt) id-expression
465 postfix-expression -> template(opt) ::(opt) id-expression
466 postfix-expression . pseudo-destructor-name
467 postfix-expression -> pseudo-destructor-name
468 postfix-expression ++
469 postfix-expression --
470 dynamic_cast < type-id > ( expression )
471 static_cast < type-id > ( expression )
472 reinterpret_cast < type-id > ( expression )
473 const_cast < type-id > ( expression )
474 typeid ( expression )
475 typeid ( type-id ) */
478 pp_cxx_postfix_expression (cxx_pretty_printer *pp, tree t)
480 enum tree_code code = TREE_CODE (t);
487 tree fun = (code == AGGR_INIT_EXPR ? AGGR_INIT_EXPR_FN (t)
489 tree saved_scope = pp->enclosing_scope;
490 bool skipfirst = false;
493 if (TREE_CODE (fun) == ADDR_EXPR)
494 fun = TREE_OPERAND (fun, 0);
496 /* In templates, where there is no way to tell whether a given
497 call uses an actual member function. So the parser builds
498 FUN as a COMPONENT_REF or a plain IDENTIFIER_NODE until
499 instantiation time. */
500 if (TREE_CODE (fun) != FUNCTION_DECL)
502 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun))
504 tree object = (code == AGGR_INIT_EXPR
505 ? (AGGR_INIT_VIA_CTOR_P (t)
506 ? AGGR_INIT_EXPR_SLOT (t)
507 : AGGR_INIT_EXPR_ARG (t, 0))
508 : CALL_EXPR_ARG (t, 0));
510 while (TREE_CODE (object) == NOP_EXPR)
511 object = TREE_OPERAND (object, 0);
513 if (TREE_CODE (object) == ADDR_EXPR)
514 object = TREE_OPERAND (object, 0);
516 if (TREE_CODE (TREE_TYPE (object)) != POINTER_TYPE)
518 pp_cxx_postfix_expression (pp, object);
523 pp_cxx_postfix_expression (pp, object);
527 pp->enclosing_scope = strip_pointer_operator (TREE_TYPE (object));
530 pp_cxx_postfix_expression (pp, fun);
531 pp->enclosing_scope = saved_scope;
532 pp_cxx_left_paren (pp);
533 if (code == AGGR_INIT_EXPR)
535 aggr_init_expr_arg_iterator iter;
536 FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
542 pp_cxx_expression (pp, arg);
543 if (more_aggr_init_expr_args_p (&iter))
544 pp_cxx_separate_with (pp, ',');
550 call_expr_arg_iterator iter;
551 FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
557 pp_cxx_expression (pp, arg);
558 if (more_call_expr_args_p (&iter))
559 pp_cxx_separate_with (pp, ',');
563 pp_cxx_right_paren (pp);
565 if (code == AGGR_INIT_EXPR && AGGR_INIT_VIA_CTOR_P (t))
567 pp_cxx_separate_with (pp, ',');
568 pp_cxx_postfix_expression (pp, AGGR_INIT_EXPR_SLOT (t));
581 pp_cxx_primary_expression (pp, t);
584 case DYNAMIC_CAST_EXPR:
585 case STATIC_CAST_EXPR:
586 case REINTERPRET_CAST_EXPR:
587 case CONST_CAST_EXPR:
588 if (code == DYNAMIC_CAST_EXPR)
589 pp_cxx_ws_string (pp, "dynamic_cast");
590 else if (code == STATIC_CAST_EXPR)
591 pp_cxx_ws_string (pp, "static_cast");
592 else if (code == REINTERPRET_CAST_EXPR)
593 pp_cxx_ws_string (pp, "reinterpret_cast");
595 pp_cxx_ws_string (pp, "const_cast");
596 pp_cxx_begin_template_argument_list (pp);
597 pp_cxx_type_id (pp, TREE_TYPE (t));
598 pp_cxx_end_template_argument_list (pp);
600 pp_cxx_expression (pp, TREE_OPERAND (t, 0));
604 case EMPTY_CLASS_EXPR:
605 pp_cxx_type_id (pp, TREE_TYPE (t));
611 pp_cxx_typeid_expression (pp, t);
614 case PSEUDO_DTOR_EXPR:
615 pp_cxx_postfix_expression (pp, TREE_OPERAND (t, 0));
617 pp_cxx_qualified_id (pp, TREE_OPERAND (t, 1));
618 pp_cxx_colon_colon (pp);
620 pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 2));
624 pp_cxx_postfix_expression (pp, TREE_OPERAND (t, 0));
629 pp_c_postfix_expression (pp_c_base (pp), t);
635 ::(opt) new new-placement(opt) new-type-id new-initializer(opt)
636 ::(opt) new new-placement(opt) ( type-id ) new-initializer(opt)
642 type-specifier-seq new-declarator(opt)
645 ptr-operator new-declarator(opt)
646 direct-new-declarator
648 direct-new-declarator
650 direct-new-declarator [ constant-expression ]
653 ( expression-list(opt) ) */
656 pp_cxx_new_expression (cxx_pretty_printer *pp, tree t)
658 enum tree_code code = TREE_CODE (t);
659 tree type = TREE_OPERAND (t, 1);
660 tree init = TREE_OPERAND (t, 2);
665 if (NEW_EXPR_USE_GLOBAL (t))
666 pp_cxx_colon_colon (pp);
667 pp_cxx_ws_string (pp, "new");
668 if (TREE_OPERAND (t, 0))
670 pp_cxx_call_argument_list (pp, TREE_OPERAND (t, 0));
673 if (TREE_CODE (type) == ARRAY_REF)
674 type = build_cplus_array_type
675 (TREE_OPERAND (type, 0),
676 build_index_type (fold_build2_loc (input_location,
677 MINUS_EXPR, integer_type_node,
678 TREE_OPERAND (type, 1),
680 pp_cxx_type_id (pp, type);
684 if (TREE_CODE (init) == TREE_LIST)
685 pp_c_expression_list (pp_c_base (pp), init);
686 else if (init == void_zero_node)
687 ; /* OK, empty initializer list. */
689 pp_cxx_expression (pp, init);
695 pp_unsupported_tree (pp, t);
699 /* delete-expression:
700 ::(opt) delete cast-expression
701 ::(opt) delete [ ] cast-expression */
704 pp_cxx_delete_expression (cxx_pretty_printer *pp, tree t)
706 enum tree_code code = TREE_CODE (t);
710 case VEC_DELETE_EXPR:
711 if (DELETE_EXPR_USE_GLOBAL (t))
712 pp_cxx_colon_colon (pp);
713 pp_cxx_ws_string (pp, "delete");
715 if (code == VEC_DELETE_EXPR
716 || DELETE_EXPR_USE_VEC (t))
718 pp_left_bracket (pp);
719 pp_right_bracket (pp);
722 pp_c_cast_expression (pp_c_base (pp), TREE_OPERAND (t, 0));
726 pp_unsupported_tree (pp, t);
734 unary-operator cast-expression
735 sizeof unary-expression
737 sizeof ... ( identifier )
741 unary-operator: one of
745 __alignof__ unary-expression
746 __alignof__ ( type-id ) */
749 pp_cxx_unary_expression (cxx_pretty_printer *pp, tree t)
751 enum tree_code code = TREE_CODE (t);
756 pp_cxx_new_expression (pp, t);
760 case VEC_DELETE_EXPR:
761 pp_cxx_delete_expression (pp, t);
765 if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
767 pp_cxx_ws_string (pp, "sizeof");
768 pp_cxx_ws_string (pp, "...");
769 pp_cxx_whitespace (pp);
770 pp_cxx_left_paren (pp);
771 if (TYPE_P (TREE_OPERAND (t, 0)))
772 pp_cxx_type_id (pp, TREE_OPERAND (t, 0));
774 pp_unary_expression (pp, TREE_OPERAND (t, 0));
775 pp_cxx_right_paren (pp);
781 pp_cxx_ws_string (pp, code == SIZEOF_EXPR ? "sizeof" : "__alignof__");
782 pp_cxx_whitespace (pp);
783 if (TYPE_P (TREE_OPERAND (t, 0)))
785 pp_cxx_left_paren (pp);
786 pp_cxx_type_id (pp, TREE_OPERAND (t, 0));
787 pp_cxx_right_paren (pp);
790 pp_unary_expression (pp, TREE_OPERAND (t, 0));
793 case UNARY_PLUS_EXPR:
795 pp_cxx_cast_expression (pp, TREE_OPERAND (t, 0));
799 pp_c_unary_expression (pp_c_base (pp), t);
806 ( type-id ) cast-expression */
809 pp_cxx_cast_expression (cxx_pretty_printer *pp, tree t)
811 switch (TREE_CODE (t))
814 pp_cxx_type_id (pp, TREE_TYPE (t));
815 pp_cxx_call_argument_list (pp, TREE_OPERAND (t, 0));
819 pp_c_cast_expression (pp_c_base (pp), t);
826 pm-expression .* cast-expression
827 pm-expression ->* cast-expression */
830 pp_cxx_pm_expression (cxx_pretty_printer *pp, tree t)
832 switch (TREE_CODE (t))
834 /* Handle unfortunate OFFSET_REF overloading here. */
836 if (TYPE_P (TREE_OPERAND (t, 0)))
838 pp_cxx_qualified_id (pp, t);
841 /* Else fall through. */
844 pp_cxx_pm_expression (pp, TREE_OPERAND (t, 0));
845 if (TREE_CODE (t) == MEMBER_REF)
850 pp_cxx_cast_expression (pp, TREE_OPERAND (t, 1));
855 pp_cxx_cast_expression (pp, t);
860 /* multiplicative-expression:
862 multiplicative-expression * pm-expression
863 multiplicative-expression / pm-expression
864 multiplicative-expression % pm-expression */
867 pp_cxx_multiplicative_expression (cxx_pretty_printer *pp, tree e)
869 enum tree_code code = TREE_CODE (e);
875 pp_cxx_multiplicative_expression (pp, TREE_OPERAND (e, 0));
877 if (code == MULT_EXPR)
879 else if (code == TRUNC_DIV_EXPR)
884 pp_cxx_pm_expression (pp, TREE_OPERAND (e, 1));
888 pp_cxx_pm_expression (pp, e);
893 /* conditional-expression:
894 logical-or-expression
895 logical-or-expression ? expression : assignment-expression */
898 pp_cxx_conditional_expression (cxx_pretty_printer *pp, tree e)
900 if (TREE_CODE (e) == COND_EXPR)
902 pp_c_logical_or_expression (pp_c_base (pp), TREE_OPERAND (e, 0));
906 pp_cxx_expression (pp, TREE_OPERAND (e, 1));
908 pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 2));
911 pp_c_logical_or_expression (pp_c_base (pp), e);
914 /* Pretty-print a compound assignment operator token as indicated by T. */
917 pp_cxx_assignment_operator (cxx_pretty_printer *pp, tree t)
921 switch (TREE_CODE (t))
944 op = tree_code_name[TREE_CODE (t)];
948 pp_cxx_ws_string (pp, op);
952 /* assignment-expression:
953 conditional-expression
954 logical-or-expression assignment-operator assignment-expression
958 throw assignment-expression(opt)
960 assignment-operator: one of
961 = *= /= %= += -= >>= <<= &= ^= |= */
964 pp_cxx_assignment_expression (cxx_pretty_printer *pp, tree e)
966 switch (TREE_CODE (e))
970 pp_c_logical_or_expression (pp_c_base (pp), TREE_OPERAND (e, 0));
974 pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 1));
978 pp_cxx_ws_string (pp, "throw");
979 if (TREE_OPERAND (e, 0))
980 pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 0));
984 pp_c_logical_or_expression (pp_c_base (pp), TREE_OPERAND (e, 0));
985 pp_cxx_assignment_operator (pp, TREE_OPERAND (e, 1));
986 pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 2));
990 pp_cxx_conditional_expression (pp, e);
996 pp_cxx_expression (cxx_pretty_printer *pp, tree t)
998 switch (TREE_CODE (t))
1004 pp_cxx_constant (pp, t);
1008 pp_cxx_unqualified_id (pp, t);
1016 pp_cxx_qualified_id (pp, t);
1020 t = OVL_CURRENT (t);
1028 case TEMPLATE_TYPE_PARM:
1029 case TEMPLATE_PARM_INDEX:
1030 case TEMPLATE_TEMPLATE_PARM:
1032 pp_cxx_primary_expression (pp, t);
1036 case DYNAMIC_CAST_EXPR:
1037 case STATIC_CAST_EXPR:
1038 case REINTERPRET_CAST_EXPR:
1039 case CONST_CAST_EXPR:
1043 case EMPTY_CLASS_EXPR:
1045 case PSEUDO_DTOR_EXPR:
1046 case AGGR_INIT_EXPR:
1048 pp_cxx_postfix_expression (pp, t);
1053 pp_cxx_new_expression (pp, t);
1057 case VEC_DELETE_EXPR:
1058 pp_cxx_delete_expression (pp, t);
1063 pp_cxx_unary_expression (pp, t);
1067 pp_cxx_cast_expression (pp, t);
1073 pp_cxx_pm_expression (pp, t);
1077 case TRUNC_DIV_EXPR:
1078 case TRUNC_MOD_EXPR:
1079 pp_cxx_multiplicative_expression (pp, t);
1083 pp_cxx_conditional_expression (pp, t);
1090 pp_cxx_assignment_expression (pp, t);
1093 case NON_DEPENDENT_EXPR:
1094 case MUST_NOT_THROW_EXPR:
1095 pp_cxx_expression (pp, TREE_OPERAND (t, 0));
1098 case EXPR_PACK_EXPANSION:
1099 pp_cxx_expression (pp, PACK_EXPANSION_PATTERN (t));
1100 pp_cxx_ws_string (pp, "...");
1103 case TEMPLATE_ID_EXPR:
1104 pp_cxx_template_id (pp, t);
1107 case NONTYPE_ARGUMENT_PACK:
1109 tree args = ARGUMENT_PACK_ARGS (t);
1110 int i, len = TREE_VEC_LENGTH (args);
1111 for (i = 0; i < len; ++i)
1114 pp_cxx_separate_with (pp, ',');
1115 pp_cxx_expression (pp, TREE_VEC_ELT (args, i));
1121 pp_c_expression (pp_c_base (pp), t);
1129 /* function-specifier:
1135 pp_cxx_function_specifier (cxx_pretty_printer *pp, tree t)
1137 switch (TREE_CODE (t))
1140 if (DECL_VIRTUAL_P (t))
1141 pp_cxx_ws_string (pp, "virtual");
1142 else if (DECL_CONSTRUCTOR_P (t) && DECL_NONCONVERTING_P (t))
1143 pp_cxx_ws_string (pp, "explicit");
1145 pp_c_function_specifier (pp_c_base (pp), t);
1152 /* decl-specifier-seq:
1153 decl-specifier-seq(opt) decl-specifier
1156 storage-class-specifier
1163 pp_cxx_decl_specifier_seq (cxx_pretty_printer *pp, tree t)
1165 switch (TREE_CODE (t))
1171 pp_cxx_storage_class_specifier (pp, t);
1172 pp_cxx_decl_specifier_seq (pp, TREE_TYPE (t));
1176 pp_cxx_ws_string (pp, "typedef");
1177 pp_cxx_decl_specifier_seq (pp, TREE_TYPE (t));
1181 /* Constructors don't have return types. And conversion functions
1182 do not have a type-specifier in their return types. */
1183 if (DECL_CONSTRUCTOR_P (t) || DECL_CONV_FN_P (t))
1184 pp_cxx_function_specifier (pp, t);
1185 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
1186 pp_cxx_decl_specifier_seq (pp, TREE_TYPE (TREE_TYPE (t)));
1189 pp_c_declaration_specifiers (pp_c_base (pp), t);
1194 /* simple-type-specifier:
1195 ::(opt) nested-name-specifier(opt) type-name
1196 ::(opt) nested-name-specifier(opt) template(opt) template-id
1210 pp_cxx_simple_type_specifier (cxx_pretty_printer *pp, tree t)
1212 switch (TREE_CODE (t))
1217 pp_cxx_qualified_id (pp, t);
1220 case TEMPLATE_TYPE_PARM:
1221 case TEMPLATE_TEMPLATE_PARM:
1222 case TEMPLATE_PARM_INDEX:
1223 pp_cxx_unqualified_id (pp, t);
1227 pp_cxx_ws_string (pp, "typename");
1228 pp_cxx_nested_name_specifier (pp, TYPE_CONTEXT (t));
1229 pp_cxx_unqualified_id (pp, TYPE_NAME (t));
1233 pp_c_type_specifier (pp_c_base (pp), t);
1238 /* type-specifier-seq:
1239 type-specifier type-specifier-seq(opt)
1242 simple-type-specifier
1245 elaborated-type-specifier
1249 pp_cxx_type_specifier_seq (cxx_pretty_printer *pp, tree t)
1251 switch (TREE_CODE (t))
1254 case TEMPLATE_TYPE_PARM:
1255 case TEMPLATE_TEMPLATE_PARM:
1257 case BOUND_TEMPLATE_TEMPLATE_PARM:
1258 pp_cxx_cv_qualifier_seq (pp, t);
1259 pp_cxx_simple_type_specifier (pp, t);
1263 pp_cxx_type_specifier_seq (pp, TREE_TYPE (t));
1264 pp_cxx_space_for_pointer_operator (pp, TREE_TYPE (t));
1265 pp_cxx_nested_name_specifier (pp, TYPE_METHOD_BASETYPE (t));
1269 pp_cxx_ws_string (pp, "decltype");
1270 pp_cxx_left_paren (pp);
1271 pp_cxx_expression (pp, DECLTYPE_TYPE_EXPR (t));
1272 pp_cxx_right_paren (pp);
1276 if (TYPE_PTRMEMFUNC_P (t))
1278 tree pfm = TYPE_PTRMEMFUNC_FN_TYPE (t);
1279 pp_cxx_decl_specifier_seq (pp, TREE_TYPE (TREE_TYPE (pfm)));
1280 pp_cxx_whitespace (pp);
1281 pp_cxx_ptr_operator (pp, t);
1284 /* else fall through */
1287 if (!(TREE_CODE (t) == FUNCTION_DECL && DECL_CONSTRUCTOR_P (t)))
1288 pp_c_specifier_qualifier_list (pp_c_base (pp), t);
1293 * cv-qualifier-seq(opt)
1295 ::(opt) nested-name-specifier * cv-qualifier-seq(opt) */
1298 pp_cxx_ptr_operator (cxx_pretty_printer *pp, tree t)
1300 if (!TYPE_P (t) && TREE_CODE (t) != TYPE_DECL)
1302 switch (TREE_CODE (t))
1304 case REFERENCE_TYPE:
1306 if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE
1307 || TYPE_PTR_TO_MEMBER_P (TREE_TYPE (t)))
1308 pp_cxx_ptr_operator (pp, TREE_TYPE (t));
1309 if (TREE_CODE (t) == POINTER_TYPE)
1312 pp_cxx_cv_qualifier_seq (pp, t);
1319 if (TYPE_PTRMEMFUNC_P (t))
1321 pp_cxx_left_paren (pp);
1322 pp_cxx_nested_name_specifier (pp, TYPE_PTRMEMFUNC_OBJECT_TYPE (t));
1327 if (TYPE_PTR_TO_MEMBER_P (t))
1329 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
1330 pp_cxx_left_paren (pp);
1331 pp_cxx_nested_name_specifier (pp, TYPE_PTRMEM_CLASS_TYPE (t));
1333 pp_cxx_cv_qualifier_seq (pp, t);
1336 /* else fall through. */
1339 pp_unsupported_tree (pp, t);
1345 pp_cxx_implicit_parameter_type (tree mf)
1347 return TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (mf))));
1351 parameter-declaration:
1352 decl-specifier-seq declarator
1353 decl-specifier-seq declarator = assignment-expression
1354 decl-specifier-seq abstract-declarator(opt)
1355 decl-specifier-seq abstract-declarator(opt) assignment-expression */
1358 pp_cxx_parameter_declaration (cxx_pretty_printer *pp, tree t)
1360 pp_cxx_decl_specifier_seq (pp, t);
1362 pp_cxx_abstract_declarator (pp, t);
1364 pp_cxx_declarator (pp, t);
1367 /* parameter-declaration-clause:
1368 parameter-declaration-list(opt) ...(opt)
1369 parameter-declaration-list , ...
1371 parameter-declaration-list:
1372 parameter-declaration
1373 parameter-declaration-list , parameter-declaration */
1376 pp_cxx_parameter_declaration_clause (cxx_pretty_printer *pp, tree t)
1378 tree args = TYPE_P (t) ? NULL : FUNCTION_FIRST_USER_PARM (t);
1380 TYPE_P (t) ? TYPE_ARG_TYPES (t) : FUNCTION_FIRST_USER_PARMTYPE (t);
1381 const bool abstract = args == NULL
1382 || pp_c_base (pp)->flags & pp_c_flag_abstract;
1385 /* Skip artificial parameter for nonstatic member functions. */
1386 if (TREE_CODE (t) == METHOD_TYPE)
1387 types = TREE_CHAIN (types);
1389 pp_cxx_left_paren (pp);
1390 for (; args; args = TREE_CHAIN (args), types = TREE_CHAIN (types))
1393 pp_cxx_separate_with (pp, ',');
1395 pp_cxx_parameter_declaration (pp, abstract ? TREE_VALUE (types) : args);
1396 if (!abstract && pp_c_base (pp)->flags & pp_cxx_flag_default_argument)
1398 pp_cxx_whitespace (pp);
1400 pp_cxx_whitespace (pp);
1401 pp_cxx_assignment_expression (pp, TREE_PURPOSE (types));
1404 pp_cxx_right_paren (pp);
1407 /* exception-specification:
1408 throw ( type-id-list(opt) )
1412 type-id-list , type-id */
1415 pp_cxx_exception_specification (cxx_pretty_printer *pp, tree t)
1417 tree ex_spec = TYPE_RAISES_EXCEPTIONS (t);
1418 bool need_comma = false;
1420 if (!TYPE_NOTHROW_P (t) && ex_spec == NULL)
1422 pp_cxx_ws_string (pp, "throw");
1423 pp_cxx_left_paren (pp);
1424 for (; ex_spec && TREE_VALUE (ex_spec); ex_spec = TREE_CHAIN (ex_spec))
1426 tree type = TREE_VALUE (ex_spec);
1427 tree argpack = NULL_TREE;
1430 if (ARGUMENT_PACK_P (type))
1432 argpack = ARGUMENT_PACK_ARGS (type);
1433 len = TREE_VEC_LENGTH (argpack);
1436 for (i = 0; i < len; ++i)
1439 type = TREE_VEC_ELT (argpack, i);
1442 pp_cxx_separate_with (pp, ',');
1446 pp_cxx_type_id (pp, type);
1449 pp_cxx_right_paren (pp);
1452 /* direct-declarator:
1454 direct-declarator ( parameter-declaration-clause ) cv-qualifier-seq(opt)
1455 exception-specification(opt)
1456 direct-declaration [ constant-expression(opt) ]
1460 pp_cxx_direct_declarator (cxx_pretty_printer *pp, tree t)
1462 switch (TREE_CODE (t))
1470 pp_cxx_space_for_pointer_operator (pp, TREE_TYPE (t));
1472 if ((TREE_CODE (t) == PARM_DECL && FUNCTION_PARAMETER_PACK_P (t))
1473 || template_parameter_pack_p (t))
1474 /* A function parameter pack or non-type template
1476 pp_cxx_ws_string (pp, "...");
1478 pp_cxx_id_expression (pp, DECL_NAME (t));
1480 pp_cxx_abstract_declarator (pp, TREE_TYPE (t));
1484 pp_cxx_space_for_pointer_operator (pp, TREE_TYPE (TREE_TYPE (t)));
1485 pp_cxx_id_expression (pp, t);
1486 pp_cxx_parameter_declaration_clause (pp, t);
1488 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
1490 pp_base (pp)->padding = pp_before;
1491 pp_cxx_cv_qualifier_seq (pp, pp_cxx_implicit_parameter_type (t));
1494 pp_cxx_exception_specification (pp, TREE_TYPE (t));
1499 case TEMPLATE_TYPE_PARM:
1500 case TEMPLATE_PARM_INDEX:
1501 case TEMPLATE_TEMPLATE_PARM:
1505 pp_c_direct_declarator (pp_c_base (pp), t);
1512 ptr-operator declarator */
1515 pp_cxx_declarator (cxx_pretty_printer *pp, tree t)
1517 pp_cxx_direct_declarator (pp, t);
1520 /* ctor-initializer:
1521 : mem-initializer-list
1523 mem-initializer-list:
1525 mem-initializer , mem-initializer-list
1528 mem-initializer-id ( expression-list(opt) )
1531 ::(opt) nested-name-specifier(opt) class-name
1535 pp_cxx_ctor_initializer (cxx_pretty_printer *pp, tree t)
1537 t = TREE_OPERAND (t, 0);
1538 pp_cxx_whitespace (pp);
1540 pp_cxx_whitespace (pp);
1541 for (; t; t = TREE_CHAIN (t))
1543 tree purpose = TREE_PURPOSE (t);
1544 bool is_pack = PACK_EXPANSION_P (purpose);
1547 pp_cxx_primary_expression (pp, PACK_EXPANSION_PATTERN (purpose));
1549 pp_cxx_primary_expression (pp, purpose);
1550 pp_cxx_call_argument_list (pp, TREE_VALUE (t));
1552 pp_cxx_ws_string (pp, "...");
1554 pp_cxx_separate_with (pp, ',');
1558 /* function-definition:
1559 decl-specifier-seq(opt) declarator ctor-initializer(opt) function-body
1560 decl-specifier-seq(opt) declarator function-try-block */
1563 pp_cxx_function_definition (cxx_pretty_printer *pp, tree t)
1565 tree saved_scope = pp->enclosing_scope;
1566 pp_cxx_decl_specifier_seq (pp, t);
1567 pp_cxx_declarator (pp, t);
1568 pp_needs_newline (pp) = true;
1569 pp->enclosing_scope = DECL_CONTEXT (t);
1570 if (DECL_SAVED_TREE (t))
1571 pp_cxx_statement (pp, DECL_SAVED_TREE (t));
1574 pp_cxx_semicolon (pp);
1575 pp_needs_newline (pp) = true;
1578 pp->enclosing_scope = saved_scope;
1581 /* abstract-declarator:
1582 ptr-operator abstract-declarator(opt)
1583 direct-abstract-declarator */
1586 pp_cxx_abstract_declarator (cxx_pretty_printer *pp, tree t)
1588 if (TYPE_PTRMEM_P (t) || TYPE_PTRMEMFUNC_P (t))
1589 pp_cxx_right_paren (pp);
1590 else if (POINTER_TYPE_P (t))
1592 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
1593 || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
1594 pp_cxx_right_paren (pp);
1597 pp_cxx_direct_abstract_declarator (pp, t);
1600 /* direct-abstract-declarator:
1601 direct-abstract-declarator(opt) ( parameter-declaration-clause )
1602 cv-qualifier-seq(opt) exception-specification(opt)
1603 direct-abstract-declarator(opt) [ constant-expression(opt) ]
1604 ( abstract-declarator ) */
1607 pp_cxx_direct_abstract_declarator (cxx_pretty_printer *pp, tree t)
1609 switch (TREE_CODE (t))
1611 case REFERENCE_TYPE:
1612 pp_cxx_abstract_declarator (pp, t);
1616 if (TYPE_PTRMEMFUNC_P (t))
1617 pp_cxx_direct_abstract_declarator (pp, TYPE_PTRMEMFUNC_FN_TYPE (t));
1622 pp_cxx_parameter_declaration_clause (pp, t);
1623 pp_cxx_direct_abstract_declarator (pp, TREE_TYPE (t));
1624 if (TREE_CODE (t) == METHOD_TYPE)
1626 pp_base (pp)->padding = pp_before;
1627 pp_cxx_cv_qualifier_seq
1628 (pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
1630 pp_cxx_exception_specification (pp, t);
1634 case TEMPLATE_TYPE_PARM:
1635 case TEMPLATE_TEMPLATE_PARM:
1636 case BOUND_TEMPLATE_TEMPLATE_PARM:
1637 case UNBOUND_CLASS_TEMPLATE:
1641 pp_c_direct_abstract_declarator (pp_c_base (pp), t);
1647 type-specifier-seq abstract-declarator(opt) */
1650 pp_cxx_type_id (cxx_pretty_printer *pp, tree t)
1652 pp_flags saved_flags = pp_c_base (pp)->flags;
1653 pp_c_base (pp)->flags |= pp_c_flag_abstract;
1655 switch (TREE_CODE (t))
1662 case BOUND_TEMPLATE_TEMPLATE_PARM:
1663 case UNBOUND_CLASS_TEMPLATE:
1664 case TEMPLATE_TEMPLATE_PARM:
1665 case TEMPLATE_TYPE_PARM:
1666 case TEMPLATE_PARM_INDEX:
1670 case TEMPLATE_ID_EXPR:
1671 pp_cxx_type_specifier_seq (pp, t);
1674 case TYPE_PACK_EXPANSION:
1675 pp_cxx_type_id (pp, PACK_EXPANSION_PATTERN (t));
1676 pp_cxx_ws_string (pp, "...");
1680 pp_c_type_id (pp_c_base (pp), t);
1684 pp_c_base (pp)->flags = saved_flags;
1687 /* template-argument-list:
1688 template-argument ...(opt)
1689 template-argument-list, template-argument ...(opt)
1692 assignment-expression
1697 pp_cxx_template_argument_list (cxx_pretty_printer *pp, tree t)
1700 bool need_comma = false;
1704 for (i = 0; i < TREE_VEC_LENGTH (t); ++i)
1706 tree arg = TREE_VEC_ELT (t, i);
1707 tree argpack = NULL_TREE;
1710 if (ARGUMENT_PACK_P (arg))
1712 argpack = ARGUMENT_PACK_ARGS (arg);
1713 len = TREE_VEC_LENGTH (argpack);
1716 for (idx = 0; idx < len; idx++)
1719 arg = TREE_VEC_ELT (argpack, idx);
1722 pp_cxx_separate_with (pp, ',');
1726 if (TYPE_P (arg) || (TREE_CODE (arg) == TEMPLATE_DECL
1727 && TYPE_P (DECL_TEMPLATE_RESULT (arg))))
1728 pp_cxx_type_id (pp, arg);
1730 pp_cxx_expression (pp, arg);
1737 pp_cxx_exception_declaration (cxx_pretty_printer *pp, tree t)
1739 t = DECL_EXPR_DECL (t);
1740 pp_cxx_type_specifier_seq (pp, t);
1742 pp_cxx_abstract_declarator (pp, t);
1744 pp_cxx_declarator (pp, t);
1750 pp_cxx_statement (cxx_pretty_printer *pp, tree t)
1752 switch (TREE_CODE (t))
1754 case CTOR_INITIALIZER:
1755 pp_cxx_ctor_initializer (pp, t);
1759 pp_cxx_ws_string (pp, "using");
1760 pp_cxx_ws_string (pp, "namespace");
1761 if (DECL_CONTEXT (t))
1762 pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
1763 pp_cxx_qualified_id (pp, USING_STMT_NAMESPACE (t));
1767 pp_cxx_ws_string (pp, "using");
1768 pp_cxx_nested_name_specifier (pp, USING_DECL_SCOPE (t));
1769 pp_cxx_unqualified_id (pp, DECL_NAME (t));
1776 try compound-statement handler-seq */
1778 pp_maybe_newline_and_indent (pp, 0);
1779 pp_cxx_ws_string (pp, "try");
1780 pp_newline_and_indent (pp, 3);
1781 pp_cxx_statement (pp, TRY_STMTS (t));
1782 pp_newline_and_indent (pp, -3);
1786 pp_cxx_statement (pp, TRY_HANDLERS (t));
1791 handler handler-seq(opt)
1794 catch ( exception-declaration ) compound-statement
1796 exception-declaration:
1797 type-specifier-seq declarator
1798 type-specifier-seq abstract-declarator
1801 pp_cxx_ws_string (pp, "catch");
1802 pp_cxx_left_paren (pp);
1803 pp_cxx_exception_declaration (pp, HANDLER_PARMS (t));
1804 pp_cxx_right_paren (pp);
1805 pp_indentation (pp) += 3;
1806 pp_needs_newline (pp) = true;
1807 pp_cxx_statement (pp, HANDLER_BODY (t));
1808 pp_indentation (pp) -= 3;
1809 pp_needs_newline (pp) = true;
1812 /* selection-statement:
1813 if ( expression ) statement
1814 if ( expression ) statement else statement */
1816 pp_cxx_ws_string (pp, "if");
1817 pp_cxx_whitespace (pp);
1818 pp_cxx_left_paren (pp);
1819 pp_cxx_expression (pp, IF_COND (t));
1820 pp_cxx_right_paren (pp);
1821 pp_newline_and_indent (pp, 2);
1822 pp_cxx_statement (pp, THEN_CLAUSE (t));
1823 pp_newline_and_indent (pp, -2);
1824 if (ELSE_CLAUSE (t))
1826 tree else_clause = ELSE_CLAUSE (t);
1827 pp_cxx_ws_string (pp, "else");
1828 if (TREE_CODE (else_clause) == IF_STMT)
1829 pp_cxx_whitespace (pp);
1831 pp_newline_and_indent (pp, 2);
1832 pp_cxx_statement (pp, else_clause);
1833 if (TREE_CODE (else_clause) != IF_STMT)
1834 pp_newline_and_indent (pp, -2);
1839 pp_cxx_ws_string (pp, "switch");
1841 pp_cxx_left_paren (pp);
1842 pp_cxx_expression (pp, SWITCH_STMT_COND (t));
1843 pp_cxx_right_paren (pp);
1844 pp_indentation (pp) += 3;
1845 pp_needs_newline (pp) = true;
1846 pp_cxx_statement (pp, SWITCH_STMT_BODY (t));
1847 pp_newline_and_indent (pp, -3);
1850 /* iteration-statement:
1851 while ( expression ) statement
1852 do statement while ( expression ) ;
1853 for ( expression(opt) ; expression(opt) ; expression(opt) ) statement
1854 for ( declaration expression(opt) ; expression(opt) ) statement */
1856 pp_cxx_ws_string (pp, "while");
1858 pp_cxx_left_paren (pp);
1859 pp_cxx_expression (pp, WHILE_COND (t));
1860 pp_cxx_right_paren (pp);
1861 pp_newline_and_indent (pp, 3);
1862 pp_cxx_statement (pp, WHILE_BODY (t));
1863 pp_indentation (pp) -= 3;
1864 pp_needs_newline (pp) = true;
1868 pp_cxx_ws_string (pp, "do");
1869 pp_newline_and_indent (pp, 3);
1870 pp_cxx_statement (pp, DO_BODY (t));
1871 pp_newline_and_indent (pp, -3);
1872 pp_cxx_ws_string (pp, "while");
1874 pp_cxx_left_paren (pp);
1875 pp_cxx_expression (pp, DO_COND (t));
1876 pp_cxx_right_paren (pp);
1877 pp_cxx_semicolon (pp);
1878 pp_needs_newline (pp) = true;
1882 pp_cxx_ws_string (pp, "for");
1884 pp_cxx_left_paren (pp);
1885 if (FOR_INIT_STMT (t))
1886 pp_cxx_statement (pp, FOR_INIT_STMT (t));
1888 pp_cxx_semicolon (pp);
1889 pp_needs_newline (pp) = false;
1890 pp_cxx_whitespace (pp);
1892 pp_cxx_expression (pp, FOR_COND (t));
1893 pp_cxx_semicolon (pp);
1894 pp_needs_newline (pp) = false;
1895 pp_cxx_whitespace (pp);
1897 pp_cxx_expression (pp, FOR_EXPR (t));
1898 pp_cxx_right_paren (pp);
1899 pp_newline_and_indent (pp, 3);
1900 pp_cxx_statement (pp, FOR_BODY (t));
1901 pp_indentation (pp) -= 3;
1902 pp_needs_newline (pp) = true;
1908 return expression(opt) ; */
1911 pp_string (pp, TREE_CODE (t) == BREAK_STMT ? "break" : "continue");
1912 pp_cxx_semicolon (pp);
1913 pp_needs_newline (pp) = true;
1916 /* expression-statement:
1917 expression(opt) ; */
1919 pp_cxx_expression (pp, EXPR_STMT_EXPR (t));
1920 pp_cxx_semicolon (pp);
1921 pp_needs_newline (pp) = true;
1925 pp_cxx_ws_string (pp, "try");
1926 pp_newline_and_indent (pp, 2);
1927 pp_cxx_statement (pp, CLEANUP_BODY (t));
1928 pp_newline_and_indent (pp, -2);
1929 pp_cxx_ws_string (pp, CLEANUP_EH_ONLY (t) ? "catch" : "finally");
1930 pp_newline_and_indent (pp, 2);
1931 pp_cxx_statement (pp, CLEANUP_EXPR (t));
1932 pp_newline_and_indent (pp, -2);
1936 pp_cxx_declaration (pp, t);
1940 pp_c_statement (pp_c_base (pp), t);
1945 /* original-namespace-definition:
1946 namespace identifier { namespace-body }
1948 As an edge case, we also handle unnamed namespace definition here. */
1951 pp_cxx_original_namespace_definition (cxx_pretty_printer *pp, tree t)
1953 pp_cxx_ws_string (pp, "namespace");
1954 if (DECL_CONTEXT (t))
1955 pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
1957 pp_cxx_unqualified_id (pp, t);
1958 pp_cxx_whitespace (pp);
1959 pp_cxx_left_brace (pp);
1960 /* We do not print the namespace-body. */
1961 pp_cxx_whitespace (pp);
1962 pp_cxx_right_brace (pp);
1968 namespace-alias-definition:
1969 namespace identifier = qualified-namespace-specifier ;
1971 qualified-namespace-specifier:
1972 ::(opt) nested-name-specifier(opt) namespace-name */
1975 pp_cxx_namespace_alias_definition (cxx_pretty_printer *pp, tree t)
1977 pp_cxx_ws_string (pp, "namespace");
1978 if (DECL_CONTEXT (t))
1979 pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t));
1980 pp_cxx_unqualified_id (pp, t);
1981 pp_cxx_whitespace (pp);
1983 pp_cxx_whitespace (pp);
1984 if (DECL_CONTEXT (DECL_NAMESPACE_ALIAS (t)))
1985 pp_cxx_nested_name_specifier (pp,
1986 DECL_CONTEXT (DECL_NAMESPACE_ALIAS (t)));
1987 pp_cxx_qualified_id (pp, DECL_NAMESPACE_ALIAS (t));
1988 pp_cxx_semicolon (pp);
1991 /* simple-declaration:
1992 decl-specifier-seq(opt) init-declarator-list(opt) */
1995 pp_cxx_simple_declaration (cxx_pretty_printer *pp, tree t)
1997 pp_cxx_decl_specifier_seq (pp, t);
1998 pp_cxx_init_declarator (pp, t);
1999 pp_cxx_semicolon (pp);
2000 pp_needs_newline (pp) = true;
2004 template-parameter-list:
2006 template-parameter-list , template-parameter */
2009 pp_cxx_template_parameter_list (cxx_pretty_printer *pp, tree t)
2011 const int n = TREE_VEC_LENGTH (t);
2013 for (i = 0; i < n; ++i)
2016 pp_cxx_separate_with (pp, ',');
2017 pp_cxx_template_parameter (pp, TREE_VEC_ELT (t, i));
2021 /* template-parameter:
2023 parameter-declaration
2026 class ...(opt) identifier(opt)
2027 class identifier(opt) = type-id
2028 typename identifier(opt)
2029 typename ...(opt) identifier(opt) = type-id
2030 template < template-parameter-list > class ...(opt) identifier(opt)
2031 template < template-parameter-list > class identifier(opt) = template-name */
2034 pp_cxx_template_parameter (cxx_pretty_printer *pp, tree t)
2036 tree parameter = TREE_VALUE (t);
2037 switch (TREE_CODE (parameter))
2040 pp_cxx_ws_string (pp, "class");
2041 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
2042 pp_cxx_ws_string (pp, "...");
2043 if (DECL_NAME (parameter))
2044 pp_cxx_tree_identifier (pp, DECL_NAME (parameter));
2045 /* FIXME: Check if we should print also default argument. */
2049 pp_cxx_parameter_declaration (pp, parameter);
2056 pp_unsupported_tree (pp, t);
2061 /* Pretty-print a template parameter in the canonical form
2062 "template-parameter-<level>-<position in parameter list>". */
2065 pp_cxx_canonical_template_parameter (cxx_pretty_printer *pp, tree parm)
2067 const enum tree_code code = TREE_CODE (parm);
2069 /* Brings type template parameters to the canonical forms. */
2070 if (code == TEMPLATE_TYPE_PARM || code == TEMPLATE_TEMPLATE_PARM
2071 || code == BOUND_TEMPLATE_TEMPLATE_PARM)
2072 parm = TEMPLATE_TYPE_PARM_INDEX (parm);
2074 pp_cxx_begin_template_argument_list (pp);
2075 pp_cxx_ws_string (pp, M_("template-parameter-"));
2076 pp_wide_integer (pp, TEMPLATE_PARM_LEVEL (parm));
2078 pp_wide_integer (pp, TEMPLATE_PARM_IDX (parm) + 1);
2079 pp_cxx_end_template_argument_list (pp);
2083 template-declaration:
2084 export(opt) template < template-parameter-list > declaration */
2087 pp_cxx_template_declaration (cxx_pretty_printer *pp, tree t)
2089 tree tmpl = most_general_template (t);
2093 pp_maybe_newline_and_indent (pp, 0);
2094 for (level = DECL_TEMPLATE_PARMS (tmpl); level; level = TREE_CHAIN (level))
2096 pp_cxx_ws_string (pp, "template");
2097 pp_cxx_begin_template_argument_list (pp);
2098 pp_cxx_template_parameter_list (pp, TREE_VALUE (level));
2099 pp_cxx_end_template_argument_list (pp);
2100 pp_newline_and_indent (pp, 3);
2103 if (TREE_CODE (t) == FUNCTION_DECL && DECL_SAVED_TREE (t))
2104 pp_cxx_function_definition (pp, t);
2106 pp_cxx_simple_declaration (pp, t);
2110 pp_cxx_explicit_specialization (cxx_pretty_printer *pp, tree t)
2112 pp_unsupported_tree (pp, t);
2116 pp_cxx_explicit_instantiation (cxx_pretty_printer *pp, tree t)
2118 pp_unsupported_tree (pp, t);
2125 template-declaration
2126 explicit-instantiation
2127 explicit-specialization
2128 linkage-specification
2129 namespace-definition
2134 namespace-alias-definition
2137 static_assert-declaration */
2139 pp_cxx_declaration (cxx_pretty_printer *pp, tree t)
2141 if (TREE_CODE (t) == STATIC_ASSERT)
2143 pp_cxx_ws_string (pp, "static_assert");
2144 pp_cxx_left_paren (pp);
2145 pp_cxx_expression (pp, STATIC_ASSERT_CONDITION (t));
2146 pp_cxx_separate_with (pp, ',');
2147 pp_cxx_expression (pp, STATIC_ASSERT_MESSAGE (t));
2148 pp_cxx_right_paren (pp);
2150 else if (!DECL_LANG_SPECIFIC (t))
2151 pp_cxx_simple_declaration (pp, t);
2152 else if (DECL_USE_TEMPLATE (t))
2153 switch (DECL_USE_TEMPLATE (t))
2156 pp_cxx_template_declaration (pp, t);
2160 pp_cxx_explicit_specialization (pp, t);
2164 pp_cxx_explicit_instantiation (pp, t);
2170 else switch (TREE_CODE (t))
2174 pp_cxx_simple_declaration (pp, t);
2178 if (DECL_SAVED_TREE (t))
2179 pp_cxx_function_definition (pp, t);
2181 pp_cxx_simple_declaration (pp, t);
2184 case NAMESPACE_DECL:
2185 if (DECL_NAMESPACE_ALIAS (t))
2186 pp_cxx_namespace_alias_definition (pp, t);
2188 pp_cxx_original_namespace_definition (pp, t);
2192 pp_unsupported_tree (pp, t);
2198 pp_cxx_typeid_expression (cxx_pretty_printer *pp, tree t)
2200 t = TREE_OPERAND (t, 0);
2201 pp_cxx_ws_string (pp, "typeid");
2202 pp_cxx_left_paren (pp);
2204 pp_cxx_type_id (pp, t);
2206 pp_cxx_expression (pp, t);
2207 pp_cxx_right_paren (pp);
2211 pp_cxx_va_arg_expression (cxx_pretty_printer *pp, tree t)
2213 pp_cxx_ws_string (pp, "va_arg");
2214 pp_cxx_left_paren (pp);
2215 pp_cxx_assignment_expression (pp, TREE_OPERAND (t, 0));
2216 pp_cxx_separate_with (pp, ',');
2217 pp_cxx_type_id (pp, TREE_TYPE (t));
2218 pp_cxx_right_paren (pp);
2222 pp_cxx_offsetof_expression_1 (cxx_pretty_printer *pp, tree t)
2224 switch (TREE_CODE (t))
2227 if (TREE_CODE (TREE_OPERAND (t, 0)) == STATIC_CAST_EXPR
2228 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (t, 0))))
2230 pp_cxx_type_id (pp, TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0))));
2231 pp_cxx_separate_with (pp, ',');
2236 if (!pp_cxx_offsetof_expression_1 (pp, TREE_OPERAND (t, 0)))
2238 if (TREE_CODE (TREE_OPERAND (t, 0)) != ARROW_EXPR)
2240 pp_cxx_expression (pp, TREE_OPERAND (t, 1));
2243 if (!pp_cxx_offsetof_expression_1 (pp, TREE_OPERAND (t, 0)))
2245 pp_left_bracket (pp);
2246 pp_cxx_expression (pp, TREE_OPERAND (t, 1));
2247 pp_right_bracket (pp);
2255 pp_cxx_offsetof_expression (cxx_pretty_printer *pp, tree t)
2257 pp_cxx_ws_string (pp, "offsetof");
2258 pp_cxx_left_paren (pp);
2259 if (!pp_cxx_offsetof_expression_1 (pp, TREE_OPERAND (t, 0)))
2260 pp_cxx_expression (pp, TREE_OPERAND (t, 0));
2261 pp_cxx_right_paren (pp);
2265 pp_cxx_trait_expression (cxx_pretty_printer *pp, tree t)
2267 cp_trait_kind kind = TRAIT_EXPR_KIND (t);
2271 case CPTK_HAS_NOTHROW_ASSIGN:
2272 pp_cxx_ws_string (pp, "__has_nothrow_assign");
2274 case CPTK_HAS_TRIVIAL_ASSIGN:
2275 pp_cxx_ws_string (pp, "__has_trivial_assign");
2277 case CPTK_HAS_NOTHROW_CONSTRUCTOR:
2278 pp_cxx_ws_string (pp, "__has_nothrow_constructor");
2280 case CPTK_HAS_TRIVIAL_CONSTRUCTOR:
2281 pp_cxx_ws_string (pp, "__has_trivial_constructor");
2283 case CPTK_HAS_NOTHROW_COPY:
2284 pp_cxx_ws_string (pp, "__has_nothrow_copy");
2286 case CPTK_HAS_TRIVIAL_COPY:
2287 pp_cxx_ws_string (pp, "__has_trivial_copy");
2289 case CPTK_HAS_TRIVIAL_DESTRUCTOR:
2290 pp_cxx_ws_string (pp, "__has_trivial_destructor");
2292 case CPTK_HAS_VIRTUAL_DESTRUCTOR:
2293 pp_cxx_ws_string (pp, "__has_virtual_destructor");
2295 case CPTK_IS_ABSTRACT:
2296 pp_cxx_ws_string (pp, "__is_abstract");
2298 case CPTK_IS_BASE_OF:
2299 pp_cxx_ws_string (pp, "__is_base_of");
2302 pp_cxx_ws_string (pp, "__is_class");
2304 case CPTK_IS_CONVERTIBLE_TO:
2305 pp_cxx_ws_string (pp, "__is_convertible_to");
2308 pp_cxx_ws_string (pp, "__is_empty");
2311 pp_cxx_ws_string (pp, "__is_enum");
2314 pp_cxx_ws_string (pp, "__is_pod");
2316 case CPTK_IS_POLYMORPHIC:
2317 pp_cxx_ws_string (pp, "__is_polymorphic");
2319 case CPTK_IS_STD_LAYOUT:
2320 pp_cxx_ws_string (pp, "__is_std_layout");
2322 case CPTK_IS_TRIVIAL:
2323 pp_cxx_ws_string (pp, "__is_trivial");
2326 pp_cxx_ws_string (pp, "__is_union");
2333 pp_cxx_left_paren (pp);
2334 pp_cxx_type_id (pp, TRAIT_EXPR_TYPE1 (t));
2336 if (kind == CPTK_IS_BASE_OF || kind == CPTK_IS_CONVERTIBLE_TO)
2338 pp_cxx_separate_with (pp, ',');
2339 pp_cxx_type_id (pp, TRAIT_EXPR_TYPE2 (t));
2342 pp_cxx_right_paren (pp);
2345 typedef c_pretty_print_fn pp_fun;
2347 /* Initialization of a C++ pretty-printer object. */
2350 pp_cxx_pretty_printer_init (cxx_pretty_printer *pp)
2352 pp_c_pretty_printer_init (pp_c_base (pp));
2353 pp_set_line_maximum_length (pp, 0);
2355 pp->c_base.declaration = (pp_fun) pp_cxx_declaration;
2356 pp->c_base.declaration_specifiers = (pp_fun) pp_cxx_decl_specifier_seq;
2357 pp->c_base.function_specifier = (pp_fun) pp_cxx_function_specifier;
2358 pp->c_base.type_specifier_seq = (pp_fun) pp_cxx_type_specifier_seq;
2359 pp->c_base.declarator = (pp_fun) pp_cxx_declarator;
2360 pp->c_base.direct_declarator = (pp_fun) pp_cxx_direct_declarator;
2361 pp->c_base.parameter_list = (pp_fun) pp_cxx_parameter_declaration_clause;
2362 pp->c_base.type_id = (pp_fun) pp_cxx_type_id;
2363 pp->c_base.abstract_declarator = (pp_fun) pp_cxx_abstract_declarator;
2364 pp->c_base.direct_abstract_declarator =
2365 (pp_fun) pp_cxx_direct_abstract_declarator;
2366 pp->c_base.simple_type_specifier = (pp_fun)pp_cxx_simple_type_specifier;
2368 /* pp->c_base.statement = (pp_fun) pp_cxx_statement; */
2370 pp->c_base.constant = (pp_fun) pp_cxx_constant;
2371 pp->c_base.id_expression = (pp_fun) pp_cxx_id_expression;
2372 pp->c_base.primary_expression = (pp_fun) pp_cxx_primary_expression;
2373 pp->c_base.postfix_expression = (pp_fun) pp_cxx_postfix_expression;
2374 pp->c_base.unary_expression = (pp_fun) pp_cxx_unary_expression;
2375 pp->c_base.multiplicative_expression = (pp_fun) pp_cxx_multiplicative_expression;
2376 pp->c_base.conditional_expression = (pp_fun) pp_cxx_conditional_expression;
2377 pp->c_base.assignment_expression = (pp_fun) pp_cxx_assignment_expression;
2378 pp->c_base.expression = (pp_fun) pp_cxx_expression;
2379 pp->enclosing_scope = global_namespace;