diff options
Diffstat (limited to 'gcc-4.9/gcc/cp/cxx-pretty-print.c')
| -rw-r--r-- | gcc-4.9/gcc/cp/cxx-pretty-print.c | 2433 |
1 files changed, 2433 insertions, 0 deletions
diff --git a/gcc-4.9/gcc/cp/cxx-pretty-print.c b/gcc-4.9/gcc/cp/cxx-pretty-print.c new file mode 100644 index 000000000..c39fb7d71 --- /dev/null +++ b/gcc-4.9/gcc/cp/cxx-pretty-print.c @@ -0,0 +1,2433 @@ +/* Implementation of subroutines for the GNU C++ pretty-printer. + Copyright (C) 2003-2014 Free Software Foundation, Inc. + Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net> + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 3, or (at your option) any later +version. + +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING3. If not see +<http://www.gnu.org/licenses/>. */ + +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "tm.h" +#include "intl.h" +#include "cp-tree.h" +#include "cxx-pretty-print.h" +#include "tree-pretty-print.h" + +static void pp_cxx_unqualified_id (cxx_pretty_printer *, tree); +static void pp_cxx_nested_name_specifier (cxx_pretty_printer *, tree); +static void pp_cxx_qualified_id (cxx_pretty_printer *, tree); +static void pp_cxx_template_argument_list (cxx_pretty_printer *, tree); +static void pp_cxx_type_specifier_seq (cxx_pretty_printer *, tree); +static void pp_cxx_ptr_operator (cxx_pretty_printer *, tree); +static void pp_cxx_parameter_declaration_clause (cxx_pretty_printer *, tree); +static void pp_cxx_template_parameter (cxx_pretty_printer *, tree); +static void pp_cxx_cast_expression (cxx_pretty_printer *, tree); +static void pp_cxx_typeid_expression (cxx_pretty_printer *, tree); + + +static inline void +pp_cxx_nonconsecutive_character (cxx_pretty_printer *pp, int c) +{ + const char *p = pp_last_position_in_text (pp); + + if (p != NULL && *p == c) + pp_cxx_whitespace (pp); + pp_character (pp, c); + pp->padding = pp_none; +} + +#define pp_cxx_expression_list(PP, T) \ + pp_c_expression_list (PP, T) +#define pp_cxx_space_for_pointer_operator(PP, T) \ + pp_c_space_for_pointer_operator (PP, T) +#define pp_cxx_init_declarator(PP, T) \ + pp_c_init_declarator (PP, T) +#define pp_cxx_call_argument_list(PP, T) \ + pp_c_call_argument_list (PP, T) + +void +pp_cxx_colon_colon (cxx_pretty_printer *pp) +{ + pp_colon_colon (pp); + pp->padding = pp_none; +} + +void +pp_cxx_begin_template_argument_list (cxx_pretty_printer *pp) +{ + pp_cxx_nonconsecutive_character (pp, '<'); +} + +void +pp_cxx_end_template_argument_list (cxx_pretty_printer *pp) +{ + pp_cxx_nonconsecutive_character (pp, '>'); +} + +void +pp_cxx_separate_with (cxx_pretty_printer *pp, int c) +{ + pp_separate_with (pp, c); + pp->padding = pp_none; +} + +/* Expressions. */ + +static inline bool +is_destructor_name (tree name) +{ + return name == complete_dtor_identifier + || name == base_dtor_identifier + || name == deleting_dtor_identifier; +} + +/* conversion-function-id: + operator conversion-type-id + + conversion-type-id: + type-specifier-seq conversion-declarator(opt) + + conversion-declarator: + ptr-operator conversion-declarator(opt) */ + +static inline void +pp_cxx_conversion_function_id (cxx_pretty_printer *pp, tree t) +{ + pp_cxx_ws_string (pp, "operator"); + pp_cxx_type_specifier_seq (pp, TREE_TYPE (t)); +} + +static inline void +pp_cxx_template_id (cxx_pretty_printer *pp, tree t) +{ + pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 0)); + pp_cxx_begin_template_argument_list (pp); + pp_cxx_template_argument_list (pp, TREE_OPERAND (t, 1)); + pp_cxx_end_template_argument_list (pp); +} + +/* Prints the unqualified part of the id-expression T. + + unqualified-id: + identifier + operator-function-id + conversion-function-id + ~ class-name + template-id */ + +static void +pp_cxx_unqualified_id (cxx_pretty_printer *pp, tree t) +{ + enum tree_code code = TREE_CODE (t); + switch (code) + { + case RESULT_DECL: + pp->translate_string ("<return-value>"); + break; + + case OVERLOAD: + t = OVL_CURRENT (t); + case VAR_DECL: + case PARM_DECL: + case CONST_DECL: + case TYPE_DECL: + case FUNCTION_DECL: + case NAMESPACE_DECL: + case FIELD_DECL: + case LABEL_DECL: + case USING_DECL: + case TEMPLATE_DECL: + t = DECL_NAME (t); + + case IDENTIFIER_NODE: + if (t == NULL) + pp->translate_string ("<unnamed>"); + else if (IDENTIFIER_TYPENAME_P (t)) + pp_cxx_conversion_function_id (pp, t); + else + { + if (is_destructor_name (t)) + { + pp_complement (pp); + /* FIXME: Why is this necessary? */ + if (TREE_TYPE (t)) + t = constructor_name (TREE_TYPE (t)); + } + pp_cxx_tree_identifier (pp, t); + } + break; + + case TEMPLATE_ID_EXPR: + pp_cxx_template_id (pp, t); + break; + + case BASELINK: + pp_cxx_unqualified_id (pp, BASELINK_FUNCTIONS (t)); + break; + + case RECORD_TYPE: + case UNION_TYPE: + case ENUMERAL_TYPE: + case TYPENAME_TYPE: + case UNBOUND_CLASS_TEMPLATE: + pp_cxx_unqualified_id (pp, TYPE_NAME (t)); + if (CLASS_TYPE_P (t) && CLASSTYPE_USE_TEMPLATE (t)) + { + pp_cxx_begin_template_argument_list (pp); + pp_cxx_template_argument_list (pp, INNERMOST_TEMPLATE_ARGS + (CLASSTYPE_TI_ARGS (t))); + pp_cxx_end_template_argument_list (pp); + } + break; + + case BIT_NOT_EXPR: + pp_cxx_complement (pp); + pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 0)); + break; + + case TEMPLATE_TYPE_PARM: + case TEMPLATE_TEMPLATE_PARM: + if (TYPE_IDENTIFIER (t)) + pp_cxx_unqualified_id (pp, TYPE_IDENTIFIER (t)); + else + pp_cxx_canonical_template_parameter (pp, t); + break; + + case TEMPLATE_PARM_INDEX: + pp_cxx_unqualified_id (pp, TEMPLATE_PARM_DECL (t)); + break; + + case BOUND_TEMPLATE_TEMPLATE_PARM: + pp_cxx_cv_qualifier_seq (pp, t); + pp_cxx_unqualified_id (pp, TYPE_IDENTIFIER (t)); + pp_cxx_begin_template_argument_list (pp); + pp_cxx_template_argument_list (pp, TYPE_TI_ARGS (t)); + pp_cxx_end_template_argument_list (pp); + break; + + default: + pp_unsupported_tree (pp, t); + break; + } +} + +/* Pretty-print out the token sequence ":: template" in template codes + where it is needed to "inline declare" the (following) member as + a template. This situation arises when SCOPE of T is dependent + on template parameters. */ + +static inline void +pp_cxx_template_keyword_if_needed (cxx_pretty_printer *pp, tree scope, tree t) +{ + if (TREE_CODE (t) == TEMPLATE_ID_EXPR + && TYPE_P (scope) && dependent_type_p (scope)) + pp_cxx_ws_string (pp, "template"); +} + +/* nested-name-specifier: + class-or-namespace-name :: nested-name-specifier(opt) + class-or-namespace-name :: template nested-name-specifier */ + +static void +pp_cxx_nested_name_specifier (cxx_pretty_printer *pp, tree t) +{ + if (!SCOPE_FILE_SCOPE_P (t) && t != pp->enclosing_scope) + { + tree scope = get_containing_scope (t); + pp_cxx_nested_name_specifier (pp, scope); + pp_cxx_template_keyword_if_needed (pp, scope, t); + pp_cxx_unqualified_id (pp, t); + pp_cxx_colon_colon (pp); + } +} + +/* qualified-id: + nested-name-specifier template(opt) unqualified-id */ + +static void +pp_cxx_qualified_id (cxx_pretty_printer *pp, tree t) +{ + switch (TREE_CODE (t)) + { + /* A pointer-to-member is always qualified. */ + case PTRMEM_CST: + pp_cxx_nested_name_specifier (pp, PTRMEM_CST_CLASS (t)); + pp_cxx_unqualified_id (pp, PTRMEM_CST_MEMBER (t)); + break; + + /* In Standard C++, functions cannot possibly be used as + nested-name-specifiers. However, there are situations where + is "makes sense" to output the surrounding function name for the + purpose of emphasizing on the scope kind. Just printing the + function name might not be sufficient as it may be overloaded; so, + we decorate the function with its signature too. + FIXME: This is probably the wrong pretty-printing for conversion + functions and some function templates. */ + case OVERLOAD: + t = OVL_CURRENT (t); + case FUNCTION_DECL: + if (DECL_FUNCTION_MEMBER_P (t)) + pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t)); + pp_cxx_unqualified_id + (pp, DECL_CONSTRUCTOR_P (t) ? DECL_CONTEXT (t) : t); + pp_cxx_parameter_declaration_clause (pp, TREE_TYPE (t)); + break; + + case OFFSET_REF: + case SCOPE_REF: + pp_cxx_nested_name_specifier (pp, TREE_OPERAND (t, 0)); + pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 1)); + break; + + default: + { + tree scope = get_containing_scope (t); + if (scope != pp->enclosing_scope) + { + pp_cxx_nested_name_specifier (pp, scope); + pp_cxx_template_keyword_if_needed (pp, scope, t); + } + pp_cxx_unqualified_id (pp, t); + } + break; + } +} + + +void +cxx_pretty_printer::constant (tree t) +{ + switch (TREE_CODE (t)) + { + case STRING_CST: + { + const bool in_parens = PAREN_STRING_LITERAL_P (t); + if (in_parens) + pp_cxx_left_paren (this); + c_pretty_printer::constant (t); + if (in_parens) + pp_cxx_right_paren (this); + } + break; + + case INTEGER_CST: + if (NULLPTR_TYPE_P (TREE_TYPE (t))) + { + pp_string (this, "nullptr"); + break; + } + /* else fall through. */ + + default: + c_pretty_printer::constant (t); + break; + } +} + +/* id-expression: + unqualified-id + qualified-id */ + +void +cxx_pretty_printer::id_expression (tree t) +{ + if (TREE_CODE (t) == OVERLOAD) + t = OVL_CURRENT (t); + if (DECL_P (t) && DECL_CONTEXT (t)) + pp_cxx_qualified_id (this, t); + else + pp_cxx_unqualified_id (this, t); +} + +/* user-defined literal: + literal ud-suffix */ + +void +pp_cxx_userdef_literal (cxx_pretty_printer *pp, tree t) +{ + pp->constant (USERDEF_LITERAL_VALUE (t)); + pp->id_expression (USERDEF_LITERAL_SUFFIX_ID (t)); +} + + +/* primary-expression: + literal + this + :: identifier + :: operator-function-id + :: qualifier-id + ( expression ) + id-expression + + GNU Extensions: + __builtin_va_arg ( assignment-expression , type-id ) + __builtin_offsetof ( type-id, offsetof-expression ) + + __has_nothrow_assign ( type-id ) + __has_nothrow_constructor ( type-id ) + __has_nothrow_copy ( type-id ) + __has_trivial_assign ( type-id ) + __has_trivial_constructor ( type-id ) + __has_trivial_copy ( type-id ) + __has_trivial_destructor ( type-id ) + __has_virtual_destructor ( type-id ) + __is_abstract ( type-id ) + __is_base_of ( type-id , type-id ) + __is_class ( type-id ) + __is_convertible_to ( type-id , type-id ) + __is_empty ( type-id ) + __is_enum ( type-id ) + __is_literal_type ( type-id ) + __is_pod ( type-id ) + __is_polymorphic ( type-id ) + __is_std_layout ( type-id ) + __is_trivial ( type-id ) + __is_union ( type-id ) */ + +void +cxx_pretty_printer::primary_expression (tree t) +{ + switch (TREE_CODE (t)) + { + case INTEGER_CST: + case REAL_CST: + case COMPLEX_CST: + case STRING_CST: + constant (t); + break; + + case USERDEF_LITERAL: + pp_cxx_userdef_literal (this, t); + break; + + case BASELINK: + t = BASELINK_FUNCTIONS (t); + case VAR_DECL: + case PARM_DECL: + case FIELD_DECL: + case FUNCTION_DECL: + case OVERLOAD: + case CONST_DECL: + case TEMPLATE_DECL: + id_expression (t); + break; + + case RESULT_DECL: + case TEMPLATE_TYPE_PARM: + case TEMPLATE_TEMPLATE_PARM: + case TEMPLATE_PARM_INDEX: + pp_cxx_unqualified_id (this, t); + break; + + case STMT_EXPR: + pp_cxx_left_paren (this); + statement (STMT_EXPR_STMT (t)); + pp_cxx_right_paren (this); + break; + + case TRAIT_EXPR: + pp_cxx_trait_expression (this, t); + break; + + case VA_ARG_EXPR: + pp_cxx_va_arg_expression (this, t); + break; + + case OFFSETOF_EXPR: + pp_cxx_offsetof_expression (this, t); + break; + + default: + c_pretty_printer::primary_expression (t); + break; + } +} + +/* postfix-expression: + primary-expression + postfix-expression [ expression ] + postfix-expression ( expression-list(opt) ) + simple-type-specifier ( expression-list(opt) ) + typename ::(opt) nested-name-specifier identifier ( expression-list(opt) ) + typename ::(opt) nested-name-specifier template(opt) + template-id ( expression-list(opt) ) + postfix-expression . template(opt) ::(opt) id-expression + postfix-expression -> template(opt) ::(opt) id-expression + postfix-expression . pseudo-destructor-name + postfix-expression -> pseudo-destructor-name + postfix-expression ++ + postfix-expression -- + dynamic_cast < type-id > ( expression ) + static_cast < type-id > ( expression ) + reinterpret_cast < type-id > ( expression ) + const_cast < type-id > ( expression ) + typeid ( expression ) + typeid ( type-id ) */ + +void +cxx_pretty_printer::postfix_expression (tree t) +{ + enum tree_code code = TREE_CODE (t); + + switch (code) + { + case AGGR_INIT_EXPR: + case CALL_EXPR: + { + tree fun = (code == AGGR_INIT_EXPR ? AGGR_INIT_EXPR_FN (t) + : CALL_EXPR_FN (t)); + tree saved_scope = enclosing_scope; + bool skipfirst = false; + tree arg; + + if (TREE_CODE (fun) == ADDR_EXPR) + fun = TREE_OPERAND (fun, 0); + + /* In templates, where there is no way to tell whether a given + call uses an actual member function. So the parser builds + FUN as a COMPONENT_REF or a plain IDENTIFIER_NODE until + instantiation time. */ + if (TREE_CODE (fun) != FUNCTION_DECL) + ; + else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun)) + { + tree object = (code == AGGR_INIT_EXPR + ? (AGGR_INIT_VIA_CTOR_P (t) + ? AGGR_INIT_EXPR_SLOT (t) + : AGGR_INIT_EXPR_ARG (t, 0)) + : CALL_EXPR_ARG (t, 0)); + + while (TREE_CODE (object) == NOP_EXPR) + object = TREE_OPERAND (object, 0); + + if (TREE_CODE (object) == ADDR_EXPR) + object = TREE_OPERAND (object, 0); + + if (!TYPE_PTR_P (TREE_TYPE (object))) + { + postfix_expression (object); + pp_cxx_dot (this); + } + else + { + postfix_expression (object); + pp_cxx_arrow (this); + } + skipfirst = true; + enclosing_scope = strip_pointer_operator (TREE_TYPE (object)); + } + + postfix_expression (fun); + enclosing_scope = saved_scope; + pp_cxx_left_paren (this); + if (code == AGGR_INIT_EXPR) + { + aggr_init_expr_arg_iterator iter; + FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t) + { + if (skipfirst) + skipfirst = false; + else + { + expression (arg); + if (more_aggr_init_expr_args_p (&iter)) + pp_cxx_separate_with (this, ','); + } + } + } + else + { + call_expr_arg_iterator iter; + FOR_EACH_CALL_EXPR_ARG (arg, iter, t) + { + if (skipfirst) + skipfirst = false; + else + { + expression (arg); + if (more_call_expr_args_p (&iter)) + pp_cxx_separate_with (this, ','); + } + } + } + pp_cxx_right_paren (this); + } + if (code == AGGR_INIT_EXPR && AGGR_INIT_VIA_CTOR_P (t)) + { + pp_cxx_separate_with (this, ','); + postfix_expression (AGGR_INIT_EXPR_SLOT (t)); + } + break; + + case BASELINK: + case VAR_DECL: + case PARM_DECL: + case FIELD_DECL: + case FUNCTION_DECL: + case OVERLOAD: + case CONST_DECL: + case TEMPLATE_DECL: + case RESULT_DECL: + primary_expression (t); + break; + + case DYNAMIC_CAST_EXPR: + case STATIC_CAST_EXPR: + case REINTERPRET_CAST_EXPR: + case CONST_CAST_EXPR: + if (code == DYNAMIC_CAST_EXPR) + pp_cxx_ws_string (this, "dynamic_cast"); + else if (code == STATIC_CAST_EXPR) + pp_cxx_ws_string (this, "static_cast"); + else if (code == REINTERPRET_CAST_EXPR) + pp_cxx_ws_string (this, "reinterpret_cast"); + else + pp_cxx_ws_string (this, "const_cast"); + pp_cxx_begin_template_argument_list (this); + type_id (TREE_TYPE (t)); + pp_cxx_end_template_argument_list (this); + pp_left_paren (this); + expression (TREE_OPERAND (t, 0)); + pp_right_paren (this); + break; + + case EMPTY_CLASS_EXPR: + type_id (TREE_TYPE (t)); + pp_left_paren (this); + pp_right_paren (this); + break; + + case TYPEID_EXPR: + pp_cxx_typeid_expression (this, t); + break; + + case PSEUDO_DTOR_EXPR: + postfix_expression (TREE_OPERAND (t, 0)); + pp_cxx_dot (this); + if (TREE_OPERAND (t, 1)) + { + pp_cxx_qualified_id (this, TREE_OPERAND (t, 1)); + pp_cxx_colon_colon (this); + } + pp_complement (this); + pp_cxx_unqualified_id (this, TREE_OPERAND (t, 2)); + break; + + case ARROW_EXPR: + postfix_expression (TREE_OPERAND (t, 0)); + pp_cxx_arrow (this); + break; + + default: + c_pretty_printer::postfix_expression (t); + break; + } +} + +/* new-expression: + ::(opt) new new-placement(opt) new-type-id new-initializer(opt) + ::(opt) new new-placement(opt) ( type-id ) new-initializer(opt) + + new-placement: + ( expression-list ) + + new-type-id: + type-specifier-seq new-declarator(opt) + + new-declarator: + ptr-operator new-declarator(opt) + direct-new-declarator + + direct-new-declarator + [ expression ] + direct-new-declarator [ constant-expression ] + + new-initializer: + ( expression-list(opt) ) */ + +static void +pp_cxx_new_expression (cxx_pretty_printer *pp, tree t) +{ + enum tree_code code = TREE_CODE (t); + tree type = TREE_OPERAND (t, 1); + tree init = TREE_OPERAND (t, 2); + switch (code) + { + case NEW_EXPR: + case VEC_NEW_EXPR: + if (NEW_EXPR_USE_GLOBAL (t)) + pp_cxx_colon_colon (pp); + pp_cxx_ws_string (pp, "new"); + if (TREE_OPERAND (t, 0)) + { + pp_cxx_call_argument_list (pp, TREE_OPERAND (t, 0)); + pp_space (pp); + } + if (TREE_CODE (type) == ARRAY_REF) + type = build_cplus_array_type + (TREE_OPERAND (type, 0), + build_index_type (fold_build2_loc (input_location, + MINUS_EXPR, integer_type_node, + TREE_OPERAND (type, 1), + integer_one_node))); + pp->type_id (type); + if (init) + { + pp_left_paren (pp); + if (TREE_CODE (init) == TREE_LIST) + pp_c_expression_list (pp, init); + else if (init == void_zero_node) + ; /* OK, empty initializer list. */ + else + pp->expression (init); + pp_right_paren (pp); + } + break; + + default: + pp_unsupported_tree (pp, t); + } +} + +/* delete-expression: + ::(opt) delete cast-expression + ::(opt) delete [ ] cast-expression */ + +static void +pp_cxx_delete_expression (cxx_pretty_printer *pp, tree t) +{ + enum tree_code code = TREE_CODE (t); + switch (code) + { + case DELETE_EXPR: + case VEC_DELETE_EXPR: + if (DELETE_EXPR_USE_GLOBAL (t)) + pp_cxx_colon_colon (pp); + pp_cxx_ws_string (pp, "delete"); + pp_space (pp); + if (code == VEC_DELETE_EXPR + || DELETE_EXPR_USE_VEC (t)) + { + pp_left_bracket (pp); + pp_right_bracket (pp); + pp_space (pp); + } + pp_c_cast_expression (pp, TREE_OPERAND (t, 0)); + break; + + default: + pp_unsupported_tree (pp, t); + } +} + +/* unary-expression: + postfix-expression + ++ cast-expression + -- cast-expression + unary-operator cast-expression + sizeof unary-expression + sizeof ( type-id ) + sizeof ... ( identifier ) + new-expression + delete-expression + + unary-operator: one of + * & + - ! + + GNU extensions: + __alignof__ unary-expression + __alignof__ ( type-id ) */ + +void +cxx_pretty_printer::unary_expression (tree t) +{ + enum tree_code code = TREE_CODE (t); + switch (code) + { + case NEW_EXPR: + case VEC_NEW_EXPR: + pp_cxx_new_expression (this, t); + break; + + case DELETE_EXPR: + case VEC_DELETE_EXPR: + pp_cxx_delete_expression (this, t); + break; + + case SIZEOF_EXPR: + if (PACK_EXPANSION_P (TREE_OPERAND (t, 0))) + { + pp_cxx_ws_string (this, "sizeof"); + pp_cxx_ws_string (this, "..."); + pp_cxx_whitespace (this); + pp_cxx_left_paren (this); + if (TYPE_P (TREE_OPERAND (t, 0))) + type_id (TREE_OPERAND (t, 0)); + else + unary_expression (TREE_OPERAND (t, 0)); + pp_cxx_right_paren (this); + break; + } + /* Fall through */ + + case ALIGNOF_EXPR: + pp_cxx_ws_string (this, code == SIZEOF_EXPR ? "sizeof" : "__alignof__"); + pp_cxx_whitespace (this); + if (TREE_CODE (t) == SIZEOF_EXPR && SIZEOF_EXPR_TYPE_P (t)) + { + pp_cxx_left_paren (this); + type_id (TREE_TYPE (TREE_OPERAND (t, 0))); + pp_cxx_right_paren (this); + } + else if (TYPE_P (TREE_OPERAND (t, 0))) + { + pp_cxx_left_paren (this); + type_id (TREE_OPERAND (t, 0)); + pp_cxx_right_paren (this); + } + else + unary_expression (TREE_OPERAND (t, 0)); + break; + + case AT_ENCODE_EXPR: + pp_cxx_ws_string (this, "@encode"); + pp_cxx_whitespace (this); + pp_cxx_left_paren (this); + type_id (TREE_OPERAND (t, 0)); + pp_cxx_right_paren (this); + break; + + case NOEXCEPT_EXPR: + pp_cxx_ws_string (this, "noexcept"); + pp_cxx_whitespace (this); + pp_cxx_left_paren (this); + expression (TREE_OPERAND (t, 0)); + pp_cxx_right_paren (this); + break; + + case UNARY_PLUS_EXPR: + pp_plus (this); + pp_cxx_cast_expression (this, TREE_OPERAND (t, 0)); + break; + + default: + c_pretty_printer::unary_expression (t); + break; + } +} + +/* cast-expression: + unary-expression + ( type-id ) cast-expression */ + +static void +pp_cxx_cast_expression (cxx_pretty_printer *pp, tree t) +{ + switch (TREE_CODE (t)) + { + case CAST_EXPR: + case IMPLICIT_CONV_EXPR: + pp->type_id (TREE_TYPE (t)); + pp_cxx_call_argument_list (pp, TREE_OPERAND (t, 0)); + break; + + default: + pp_c_cast_expression (pp, t); + break; + } +} + +/* pm-expression: + cast-expression + pm-expression .* cast-expression + pm-expression ->* cast-expression */ + +static void +pp_cxx_pm_expression (cxx_pretty_printer *pp, tree t) +{ + switch (TREE_CODE (t)) + { + /* Handle unfortunate OFFSET_REF overloading here. */ + case OFFSET_REF: + if (TYPE_P (TREE_OPERAND (t, 0))) + { + pp_cxx_qualified_id (pp, t); + break; + } + /* Else fall through. */ + case MEMBER_REF: + case DOTSTAR_EXPR: + pp_cxx_pm_expression (pp, TREE_OPERAND (t, 0)); + if (TREE_CODE (t) == MEMBER_REF) + pp_cxx_arrow (pp); + else + pp_cxx_dot (pp); + pp_star(pp); + pp_cxx_cast_expression (pp, TREE_OPERAND (t, 1)); + break; + + + default: + pp_cxx_cast_expression (pp, t); + break; + } +} + +/* multiplicative-expression: + pm-expression + multiplicative-expression * pm-expression + multiplicative-expression / pm-expression + multiplicative-expression % pm-expression */ + +void +cxx_pretty_printer::multiplicative_expression (tree e) +{ + enum tree_code code = TREE_CODE (e); + switch (code) + { + case MULT_EXPR: + case TRUNC_DIV_EXPR: + case TRUNC_MOD_EXPR: + multiplicative_expression (TREE_OPERAND (e, 0)); + pp_space (this); + if (code == MULT_EXPR) + pp_star (this); + else if (code == TRUNC_DIV_EXPR) + pp_slash (this); + else + pp_modulo (this); + pp_space (this); + pp_cxx_pm_expression (this, TREE_OPERAND (e, 1)); + break; + + default: + pp_cxx_pm_expression (this, e); + break; + } +} + +/* conditional-expression: + logical-or-expression + logical-or-expression ? expression : assignment-expression */ + +void +cxx_pretty_printer::conditional_expression (tree e) +{ + if (TREE_CODE (e) == COND_EXPR) + { + pp_c_logical_or_expression (this, TREE_OPERAND (e, 0)); + pp_space (this); + pp_question (this); + pp_space (this); + expression (TREE_OPERAND (e, 1)); + pp_space (this); + assignment_expression (TREE_OPERAND (e, 2)); + } + else + pp_c_logical_or_expression (this, e); +} + +/* Pretty-print a compound assignment operator token as indicated by T. */ + +static void +pp_cxx_assignment_operator (cxx_pretty_printer *pp, tree t) +{ + const char *op; + + switch (TREE_CODE (t)) + { + case NOP_EXPR: + op = "="; + break; + + case PLUS_EXPR: + op = "+="; + break; + + case MINUS_EXPR: + op = "-="; + break; + + case TRUNC_DIV_EXPR: + op = "/="; + break; + + case TRUNC_MOD_EXPR: + op = "%="; + break; + + default: + op = get_tree_code_name (TREE_CODE (t)); + break; + } + + pp_cxx_ws_string (pp, op); +} + + +/* assignment-expression: + conditional-expression + logical-or-expression assignment-operator assignment-expression + throw-expression + + throw-expression: + throw assignment-expression(opt) + + assignment-operator: one of + = *= /= %= += -= >>= <<= &= ^= |= */ + +void +cxx_pretty_printer::assignment_expression (tree e) +{ + switch (TREE_CODE (e)) + { + case MODIFY_EXPR: + case INIT_EXPR: + pp_c_logical_or_expression (this, TREE_OPERAND (e, 0)); + pp_space (this); + pp_equal (this); + pp_space (this); + assignment_expression (TREE_OPERAND (e, 1)); + break; + + case THROW_EXPR: + pp_cxx_ws_string (this, "throw"); + if (TREE_OPERAND (e, 0)) + assignment_expression (TREE_OPERAND (e, 0)); + break; + + case MODOP_EXPR: + pp_c_logical_or_expression (this, TREE_OPERAND (e, 0)); + pp_cxx_assignment_operator (this, TREE_OPERAND (e, 1)); + assignment_expression (TREE_OPERAND (e, 2)); + break; + + default: + conditional_expression (e); + break; + } +} + +void +cxx_pretty_printer::expression (tree t) +{ + switch (TREE_CODE (t)) + { + case STRING_CST: + case INTEGER_CST: + case REAL_CST: + case COMPLEX_CST: + constant (t); + break; + + case USERDEF_LITERAL: + pp_cxx_userdef_literal (this, t); + break; + + case RESULT_DECL: + pp_cxx_unqualified_id (this, t); + break; + +#if 0 + case OFFSET_REF: +#endif + case SCOPE_REF: + case PTRMEM_CST: + pp_cxx_qualified_id (this, t); + break; + + case OVERLOAD: + t = OVL_CURRENT (t); + case VAR_DECL: + case PARM_DECL: + case FIELD_DECL: + case CONST_DECL: + case FUNCTION_DECL: + case BASELINK: + case TEMPLATE_DECL: + case TEMPLATE_TYPE_PARM: + case TEMPLATE_PARM_INDEX: + case TEMPLATE_TEMPLATE_PARM: + case STMT_EXPR: + primary_expression (t); + break; + + case CALL_EXPR: + case DYNAMIC_CAST_EXPR: + case STATIC_CAST_EXPR: + case REINTERPRET_CAST_EXPR: + case CONST_CAST_EXPR: +#if 0 + case MEMBER_REF: +#endif + case EMPTY_CLASS_EXPR: + case TYPEID_EXPR: + case PSEUDO_DTOR_EXPR: + case AGGR_INIT_EXPR: + case ARROW_EXPR: + postfix_expression (t); + break; + + case NEW_EXPR: + case VEC_NEW_EXPR: + pp_cxx_new_expression (this, t); + break; + + case DELETE_EXPR: + case VEC_DELETE_EXPR: + pp_cxx_delete_expression (this, t); + break; + + case SIZEOF_EXPR: + case ALIGNOF_EXPR: + case NOEXCEPT_EXPR: + unary_expression (t); + break; + + case CAST_EXPR: + case IMPLICIT_CONV_EXPR: + pp_cxx_cast_expression (this, t); + break; + + case OFFSET_REF: + case MEMBER_REF: + case DOTSTAR_EXPR: + pp_cxx_pm_expression (this, t); + break; + + case MULT_EXPR: + case TRUNC_DIV_EXPR: + case TRUNC_MOD_EXPR: + multiplicative_expression (t); + break; + + case COND_EXPR: + conditional_expression (t); + break; + + case MODIFY_EXPR: + case INIT_EXPR: + case THROW_EXPR: + case MODOP_EXPR: + assignment_expression (t); + break; + + case NON_DEPENDENT_EXPR: + case MUST_NOT_THROW_EXPR: + expression (TREE_OPERAND (t, 0)); + break; + + case EXPR_PACK_EXPANSION: + expression (PACK_EXPANSION_PATTERN (t)); + pp_cxx_ws_string (this, "..."); + break; + + case TEMPLATE_ID_EXPR: + pp_cxx_template_id (this, t); + break; + + case NONTYPE_ARGUMENT_PACK: + { + tree args = ARGUMENT_PACK_ARGS (t); + int i, len = TREE_VEC_LENGTH (args); + for (i = 0; i < len; ++i) + { + if (i > 0) + pp_cxx_separate_with (this, ','); + expression (TREE_VEC_ELT (args, i)); + } + } + break; + + case LAMBDA_EXPR: + pp_cxx_ws_string (this, "<lambda>"); + break; + + case PAREN_EXPR: + pp_cxx_left_paren (this); + expression (TREE_OPERAND (t, 0)); + pp_cxx_right_paren (this); + break; + + default: + c_pretty_printer::expression (t); + break; + } +} + + +/* Declarations. */ + +/* function-specifier: + inline + virtual + explicit */ + +void +cxx_pretty_printer::function_specifier (tree t) +{ + switch (TREE_CODE (t)) + { + case FUNCTION_DECL: + if (DECL_VIRTUAL_P (t)) + pp_cxx_ws_string (this, "virtual"); + else if (DECL_CONSTRUCTOR_P (t) && DECL_NONCONVERTING_P (t)) + pp_cxx_ws_string (this, "explicit"); + else + c_pretty_printer::function_specifier (t); + + default: + break; + } +} + +/* decl-specifier-seq: + decl-specifier-seq(opt) decl-specifier + + decl-specifier: + storage-class-specifier + type-specifier + function-specifier + friend + typedef */ + +void +cxx_pretty_printer::declaration_specifiers (tree t) +{ + switch (TREE_CODE (t)) + { + case VAR_DECL: + case PARM_DECL: + case CONST_DECL: + case FIELD_DECL: + storage_class_specifier (t); + declaration_specifiers (TREE_TYPE (t)); + break; + + case TYPE_DECL: + pp_cxx_ws_string (this, "typedef"); + declaration_specifiers (TREE_TYPE (t)); + break; + + case FUNCTION_DECL: + /* Constructors don't have return types. And conversion functions + do not have a type-specifier in their return types. */ + if (DECL_CONSTRUCTOR_P (t) || DECL_CONV_FN_P (t)) + function_specifier (t); + else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t)) + declaration_specifiers (TREE_TYPE (TREE_TYPE (t))); + else + default: + c_pretty_printer::declaration_specifiers (t); + break; + } +} + +/* simple-type-specifier: + ::(opt) nested-name-specifier(opt) type-name + ::(opt) nested-name-specifier(opt) template(opt) template-id + char + wchar_t + bool + short + int + long + signed + unsigned + float + double + void */ + +void +cxx_pretty_printer::simple_type_specifier (tree t) +{ + switch (TREE_CODE (t)) + { + case RECORD_TYPE: + case UNION_TYPE: + case ENUMERAL_TYPE: + pp_cxx_qualified_id (this, t); + break; + + case TEMPLATE_TYPE_PARM: + case TEMPLATE_TEMPLATE_PARM: + case TEMPLATE_PARM_INDEX: + case BOUND_TEMPLATE_TEMPLATE_PARM: + pp_cxx_unqualified_id (this, t); + break; + + case TYPENAME_TYPE: + pp_cxx_ws_string (this, "typename"); + pp_cxx_nested_name_specifier (this, TYPE_CONTEXT (t)); + pp_cxx_unqualified_id (this, TYPE_NAME (t)); + break; + + default: + c_pretty_printer::simple_type_specifier (t); + break; + } +} + +/* type-specifier-seq: + type-specifier type-specifier-seq(opt) + + type-specifier: + simple-type-specifier + class-specifier + enum-specifier + elaborated-type-specifier + cv-qualifier */ + +static void +pp_cxx_type_specifier_seq (cxx_pretty_printer *pp, tree t) +{ + switch (TREE_CODE (t)) + { + case TEMPLATE_DECL: + case TEMPLATE_TYPE_PARM: + case TEMPLATE_TEMPLATE_PARM: + case TYPE_DECL: + case BOUND_TEMPLATE_TEMPLATE_PARM: + pp_cxx_cv_qualifier_seq (pp, t); + pp->simple_type_specifier (t); + break; + + case METHOD_TYPE: + pp_cxx_type_specifier_seq (pp, TREE_TYPE (t)); + pp_cxx_space_for_pointer_operator (pp, TREE_TYPE (t)); + pp_cxx_nested_name_specifier (pp, TYPE_METHOD_BASETYPE (t)); + break; + + case DECLTYPE_TYPE: + pp_cxx_ws_string (pp, "decltype"); + pp_cxx_left_paren (pp); + pp->expression (DECLTYPE_TYPE_EXPR (t)); + pp_cxx_right_paren (pp); + break; + + case RECORD_TYPE: + if (TYPE_PTRMEMFUNC_P (t)) + { + tree pfm = TYPE_PTRMEMFUNC_FN_TYPE (t); + pp->declaration_specifiers (TREE_TYPE (TREE_TYPE (pfm))); + pp_cxx_whitespace (pp); + pp_cxx_ptr_operator (pp, t); + break; + } + /* else fall through */ + + default: + if (!(TREE_CODE (t) == FUNCTION_DECL && DECL_CONSTRUCTOR_P (t))) + pp_c_specifier_qualifier_list (pp, t); + } +} + +/* ptr-operator: + * cv-qualifier-seq(opt) + & + ::(opt) nested-name-specifier * cv-qualifier-seq(opt) */ + +static void +pp_cxx_ptr_operator (cxx_pretty_printer *pp, tree t) +{ + if (!TYPE_P (t) && TREE_CODE (t) != TYPE_DECL) + t = TREE_TYPE (t); + switch (TREE_CODE (t)) + { + case REFERENCE_TYPE: + case POINTER_TYPE: + if (TYPE_PTR_OR_PTRMEM_P (TREE_TYPE (t))) + pp_cxx_ptr_operator (pp, TREE_TYPE (t)); + pp_c_attributes_display (pp, TYPE_ATTRIBUTES (TREE_TYPE (t))); + if (TYPE_PTR_P (t)) + { + pp_star (pp); + pp_cxx_cv_qualifier_seq (pp, t); + } + else + pp_ampersand (pp); + break; + + case RECORD_TYPE: + if (TYPE_PTRMEMFUNC_P (t)) + { + pp_cxx_left_paren (pp); + pp_cxx_nested_name_specifier (pp, TYPE_PTRMEMFUNC_OBJECT_TYPE (t)); + pp_star (pp); + break; + } + case OFFSET_TYPE: + if (TYPE_PTRMEM_P (t)) + { + if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE) + pp_cxx_left_paren (pp); + pp_cxx_nested_name_specifier (pp, TYPE_PTRMEM_CLASS_TYPE (t)); + pp_star (pp); + pp_cxx_cv_qualifier_seq (pp, t); + break; + } + /* else fall through. */ + + default: + pp_unsupported_tree (pp, t); + break; + } +} + +static inline tree +pp_cxx_implicit_parameter_type (tree mf) +{ + return class_of_this_parm (TREE_TYPE (mf)); +} + +/* + parameter-declaration: + decl-specifier-seq declarator + decl-specifier-seq declarator = assignment-expression + decl-specifier-seq abstract-declarator(opt) + decl-specifier-seq abstract-declarator(opt) assignment-expression */ + +static inline void +pp_cxx_parameter_declaration (cxx_pretty_printer *pp, tree t) +{ + pp->declaration_specifiers (t); + if (TYPE_P (t)) + pp->abstract_declarator (t); + else + pp->declarator (t); +} + +/* parameter-declaration-clause: + parameter-declaration-list(opt) ...(opt) + parameter-declaration-list , ... + + parameter-declaration-list: + parameter-declaration + parameter-declaration-list , parameter-declaration */ + +static void +pp_cxx_parameter_declaration_clause (cxx_pretty_printer *pp, tree t) +{ + tree args = TYPE_P (t) ? NULL : FUNCTION_FIRST_USER_PARM (t); + tree types = + TYPE_P (t) ? TYPE_ARG_TYPES (t) : FUNCTION_FIRST_USER_PARMTYPE (t); + const bool abstract = args == NULL || pp->flags & pp_c_flag_abstract; + bool first = true; + + /* Skip artificial parameter for nonstatic member functions. */ + if (TREE_CODE (t) == METHOD_TYPE) + types = TREE_CHAIN (types); + + pp_cxx_left_paren (pp); + for (; args; args = TREE_CHAIN (args), types = TREE_CHAIN (types)) + { + if (!first) + pp_cxx_separate_with (pp, ','); + first = false; + pp_cxx_parameter_declaration (pp, abstract ? TREE_VALUE (types) : args); + if (!abstract && pp->flags & pp_cxx_flag_default_argument) + { + pp_cxx_whitespace (pp); + pp_equal (pp); + pp_cxx_whitespace (pp); + pp->assignment_expression (TREE_PURPOSE (types)); + } + } + pp_cxx_right_paren (pp); +} + +/* exception-specification: + throw ( type-id-list(opt) ) + + type-id-list + type-id + type-id-list , type-id */ + +static void +pp_cxx_exception_specification (cxx_pretty_printer *pp, tree t) +{ + tree ex_spec = TYPE_RAISES_EXCEPTIONS (t); + bool need_comma = false; + + if (ex_spec == NULL) + return; + if (TREE_PURPOSE (ex_spec)) + { + pp_cxx_ws_string (pp, "noexcept"); + pp_cxx_whitespace (pp); + pp_cxx_left_paren (pp); + if (DEFERRED_NOEXCEPT_SPEC_P (ex_spec)) + pp_cxx_ws_string (pp, "<uninstantiated>"); + else + pp->expression (TREE_PURPOSE (ex_spec)); + pp_cxx_right_paren (pp); + return; + } + pp_cxx_ws_string (pp, "throw"); + pp_cxx_left_paren (pp); + for (; ex_spec && TREE_VALUE (ex_spec); ex_spec = TREE_CHAIN (ex_spec)) + { + tree type = TREE_VALUE (ex_spec); + tree argpack = NULL_TREE; + int i, len = 1; + + if (ARGUMENT_PACK_P (type)) + { + argpack = ARGUMENT_PACK_ARGS (type); + len = TREE_VEC_LENGTH (argpack); + } + + for (i = 0; i < len; ++i) + { + if (argpack) + type = TREE_VEC_ELT (argpack, i); + + if (need_comma) + pp_cxx_separate_with (pp, ','); + else + need_comma = true; + + pp->type_id (type); + } + } + pp_cxx_right_paren (pp); +} + +/* direct-declarator: + declarator-id + direct-declarator ( parameter-declaration-clause ) cv-qualifier-seq(opt) + exception-specification(opt) + direct-declaration [ constant-expression(opt) ] + ( declarator ) */ + +void +cxx_pretty_printer::direct_declarator (tree t) +{ + switch (TREE_CODE (t)) + { + case VAR_DECL: + case PARM_DECL: + case CONST_DECL: + case FIELD_DECL: + if (DECL_NAME (t)) + { + pp_cxx_space_for_pointer_operator (this, TREE_TYPE (t)); + + if ((TREE_CODE (t) == PARM_DECL && DECL_PACK_P (t)) + || template_parameter_pack_p (t)) + /* A function parameter pack or non-type template + parameter pack. */ + pp_cxx_ws_string (this, "..."); + + id_expression (DECL_NAME (t)); + } + abstract_declarator (TREE_TYPE (t)); + break; + + case FUNCTION_DECL: + pp_cxx_space_for_pointer_operator (this, TREE_TYPE (TREE_TYPE (t))); + expression (t); + pp_cxx_parameter_declaration_clause (this, t); + + if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t)) + { + padding = pp_before; + pp_cxx_cv_qualifier_seq (this, pp_cxx_implicit_parameter_type (t)); + } + + pp_cxx_exception_specification (this, TREE_TYPE (t)); + break; + + case TYPENAME_TYPE: + case TEMPLATE_DECL: + case TEMPLATE_TYPE_PARM: + case TEMPLATE_PARM_INDEX: + case TEMPLATE_TEMPLATE_PARM: + break; + + default: + c_pretty_printer::direct_declarator (t); + break; + } +} + +/* declarator: + direct-declarator + ptr-operator declarator */ + +void +cxx_pretty_printer::declarator (tree t) +{ + direct_declarator (t); +} + +/* ctor-initializer: + : mem-initializer-list + + mem-initializer-list: + mem-initializer + mem-initializer , mem-initializer-list + + mem-initializer: + mem-initializer-id ( expression-list(opt) ) + + mem-initializer-id: + ::(opt) nested-name-specifier(opt) class-name + identifier */ + +static void +pp_cxx_ctor_initializer (cxx_pretty_printer *pp, tree t) +{ + t = TREE_OPERAND (t, 0); + pp_cxx_whitespace (pp); + pp_colon (pp); + pp_cxx_whitespace (pp); + for (; t; t = TREE_CHAIN (t)) + { + tree purpose = TREE_PURPOSE (t); + bool is_pack = PACK_EXPANSION_P (purpose); + + if (is_pack) + pp->primary_expression (PACK_EXPANSION_PATTERN (purpose)); + else + pp->primary_expression (purpose); + pp_cxx_call_argument_list (pp, TREE_VALUE (t)); + if (is_pack) + pp_cxx_ws_string (pp, "..."); + if (TREE_CHAIN (t)) + pp_cxx_separate_with (pp, ','); + } +} + +/* function-definition: + decl-specifier-seq(opt) declarator ctor-initializer(opt) function-body + decl-specifier-seq(opt) declarator function-try-block */ + +static void +pp_cxx_function_definition (cxx_pretty_printer *pp, tree t) +{ + tree saved_scope = pp->enclosing_scope; + pp->declaration_specifiers (t); + pp->declarator (t); + pp_needs_newline (pp) = true; + pp->enclosing_scope = DECL_CONTEXT (t); + if (DECL_SAVED_TREE (t)) + pp->statement (DECL_SAVED_TREE (t)); + else + pp_cxx_semicolon (pp); + pp_newline_and_flush (pp); + pp->enclosing_scope = saved_scope; +} + +/* abstract-declarator: + ptr-operator abstract-declarator(opt) + direct-abstract-declarator */ + +void +cxx_pretty_printer::abstract_declarator (tree t) +{ + if (TYPE_PTRMEM_P (t)) + pp_cxx_right_paren (this); + else if (POINTER_TYPE_P (t)) + { + if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE + || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE) + pp_cxx_right_paren (this); + t = TREE_TYPE (t); + } + direct_abstract_declarator (t); +} + +/* direct-abstract-declarator: + direct-abstract-declarator(opt) ( parameter-declaration-clause ) + cv-qualifier-seq(opt) exception-specification(opt) + direct-abstract-declarator(opt) [ constant-expression(opt) ] + ( abstract-declarator ) */ + +void +cxx_pretty_printer::direct_abstract_declarator (tree t) +{ + switch (TREE_CODE (t)) + { + case REFERENCE_TYPE: + abstract_declarator (t); + break; + + case RECORD_TYPE: + if (TYPE_PTRMEMFUNC_P (t)) + direct_abstract_declarator (TYPE_PTRMEMFUNC_FN_TYPE (t)); + break; + + case METHOD_TYPE: + case FUNCTION_TYPE: + pp_cxx_parameter_declaration_clause (this, t); + direct_abstract_declarator (TREE_TYPE (t)); + if (TREE_CODE (t) == METHOD_TYPE) + { + padding = pp_before; + pp_cxx_cv_qualifier_seq (this, class_of_this_parm (t)); + } + pp_cxx_exception_specification (this, t); + break; + + case TYPENAME_TYPE: + case TEMPLATE_TYPE_PARM: + case TEMPLATE_TEMPLATE_PARM: + case BOUND_TEMPLATE_TEMPLATE_PARM: + case UNBOUND_CLASS_TEMPLATE: + break; + + default: + c_pretty_printer::direct_abstract_declarator (t); + break; + } +} + +/* type-id: + type-specifier-seq abstract-declarator(opt) */ + +void +cxx_pretty_printer::type_id (tree t) +{ + pp_flags saved_flags = flags; + flags |= pp_c_flag_abstract; + + switch (TREE_CODE (t)) + { + case TYPE_DECL: + case UNION_TYPE: + case RECORD_TYPE: + case ENUMERAL_TYPE: + case TYPENAME_TYPE: + case BOUND_TEMPLATE_TEMPLATE_PARM: + case UNBOUND_CLASS_TEMPLATE: + case TEMPLATE_TEMPLATE_PARM: + case TEMPLATE_TYPE_PARM: + case TEMPLATE_PARM_INDEX: + case TEMPLATE_DECL: + case TYPEOF_TYPE: + case UNDERLYING_TYPE: + case DECLTYPE_TYPE: + case TEMPLATE_ID_EXPR: + pp_cxx_type_specifier_seq (this, t); + break; + + case TYPE_PACK_EXPANSION: + type_id (PACK_EXPANSION_PATTERN (t)); + pp_cxx_ws_string (this, "..."); + break; + + default: + c_pretty_printer::type_id (t); + break; + } + + flags = saved_flags; +} + +/* template-argument-list: + template-argument ...(opt) + template-argument-list, template-argument ...(opt) + + template-argument: + assignment-expression + type-id + template-name */ + +static void +pp_cxx_template_argument_list (cxx_pretty_printer *pp, tree t) +{ + int i; + bool need_comma = false; + + if (t == NULL) + return; + for (i = 0; i < TREE_VEC_LENGTH (t); ++i) + { + tree arg = TREE_VEC_ELT (t, i); + tree argpack = NULL_TREE; + int idx, len = 1; + + if (ARGUMENT_PACK_P (arg)) + { + argpack = ARGUMENT_PACK_ARGS (arg); + len = TREE_VEC_LENGTH (argpack); + } + + for (idx = 0; idx < len; idx++) + { + if (argpack) + arg = TREE_VEC_ELT (argpack, idx); + + if (need_comma) + pp_cxx_separate_with (pp, ','); + else + need_comma = true; + + if (TYPE_P (arg) || (TREE_CODE (arg) == TEMPLATE_DECL + && TYPE_P (DECL_TEMPLATE_RESULT (arg)))) + pp->type_id (arg); + else + pp->expression (arg); + } + } +} + + +static void +pp_cxx_exception_declaration (cxx_pretty_printer *pp, tree t) +{ + t = DECL_EXPR_DECL (t); + pp_cxx_type_specifier_seq (pp, t); + if (TYPE_P (t)) + pp->abstract_declarator (t); + else + pp->declarator (t); +} + +/* Statements. */ + +void +cxx_pretty_printer::statement (tree t) +{ + switch (TREE_CODE (t)) + { + case CTOR_INITIALIZER: + pp_cxx_ctor_initializer (this, t); + break; + + case USING_STMT: + pp_cxx_ws_string (this, "using"); + pp_cxx_ws_string (this, "namespace"); + if (DECL_CONTEXT (t)) + pp_cxx_nested_name_specifier (this, DECL_CONTEXT (t)); + pp_cxx_qualified_id (this, USING_STMT_NAMESPACE (t)); + break; + + case USING_DECL: + pp_cxx_ws_string (this, "using"); + pp_cxx_nested_name_specifier (this, USING_DECL_SCOPE (t)); + pp_cxx_unqualified_id (this, DECL_NAME (t)); + break; + + case EH_SPEC_BLOCK: + break; + + /* try-block: + try compound-statement handler-seq */ + case TRY_BLOCK: + pp_maybe_newline_and_indent (this, 0); + pp_cxx_ws_string (this, "try"); + pp_newline_and_indent (this, 3); + statement (TRY_STMTS (t)); + pp_newline_and_indent (this, -3); + if (CLEANUP_P (t)) + ; + else + statement (TRY_HANDLERS (t)); + break; + + /* + handler-seq: + handler handler-seq(opt) + + handler: + catch ( exception-declaration ) compound-statement + + exception-declaration: + type-specifier-seq declarator + type-specifier-seq abstract-declarator + ... */ + case HANDLER: + pp_cxx_ws_string (this, "catch"); + pp_cxx_left_paren (this); + pp_cxx_exception_declaration (this, HANDLER_PARMS (t)); + pp_cxx_right_paren (this); + pp_indentation (this) += 3; + pp_needs_newline (this) = true; + statement (HANDLER_BODY (t)); + pp_indentation (this) -= 3; + pp_needs_newline (this) = true; + break; + + /* selection-statement: + if ( expression ) statement + if ( expression ) statement else statement */ + case IF_STMT: + pp_cxx_ws_string (this, "if"); + pp_cxx_whitespace (this); + pp_cxx_left_paren (this); + expression (IF_COND (t)); + pp_cxx_right_paren (this); + pp_newline_and_indent (this, 2); + statement (THEN_CLAUSE (t)); + pp_newline_and_indent (this, -2); + if (ELSE_CLAUSE (t)) + { + tree else_clause = ELSE_CLAUSE (t); + pp_cxx_ws_string (this, "else"); + if (TREE_CODE (else_clause) == IF_STMT) + pp_cxx_whitespace (this); + else + pp_newline_and_indent (this, 2); + statement (else_clause); + if (TREE_CODE (else_clause) != IF_STMT) + pp_newline_and_indent (this, -2); + } + break; + + case SWITCH_STMT: + pp_cxx_ws_string (this, "switch"); + pp_space (this); + pp_cxx_left_paren (this); + expression (SWITCH_STMT_COND (t)); + pp_cxx_right_paren (this); + pp_indentation (this) += 3; + pp_needs_newline (this) = true; + statement (SWITCH_STMT_BODY (t)); + pp_newline_and_indent (this, -3); + break; + + /* iteration-statement: + while ( expression ) statement + do statement while ( expression ) ; + for ( expression(opt) ; expression(opt) ; expression(opt) ) statement + for ( declaration expression(opt) ; expression(opt) ) statement */ + case WHILE_STMT: + pp_cxx_ws_string (this, "while"); + pp_space (this); + pp_cxx_left_paren (this); + expression (WHILE_COND (t)); + pp_cxx_right_paren (this); + pp_newline_and_indent (this, 3); + statement (WHILE_BODY (t)); + pp_indentation (this) -= 3; + pp_needs_newline (this) = true; + break; + + case DO_STMT: + pp_cxx_ws_string (this, "do"); + pp_newline_and_indent (this, 3); + statement (DO_BODY (t)); + pp_newline_and_indent (this, -3); + pp_cxx_ws_string (this, "while"); + pp_space (this); + pp_cxx_left_paren (this); + expression (DO_COND (t)); + pp_cxx_right_paren (this); + pp_cxx_semicolon (this); + pp_needs_newline (this) = true; + break; + + case FOR_STMT: + pp_cxx_ws_string (this, "for"); + pp_space (this); + pp_cxx_left_paren (this); + if (FOR_INIT_STMT (t)) + statement (FOR_INIT_STMT (t)); + else + pp_cxx_semicolon (this); + pp_needs_newline (this) = false; + pp_cxx_whitespace (this); + if (FOR_COND (t)) + expression (FOR_COND (t)); + pp_cxx_semicolon (this); + pp_needs_newline (this) = false; + pp_cxx_whitespace (this); + if (FOR_EXPR (t)) + expression (FOR_EXPR (t)); + pp_cxx_right_paren (this); + pp_newline_and_indent (this, 3); + statement (FOR_BODY (t)); + pp_indentation (this) -= 3; + pp_needs_newline (this) = true; + break; + + case RANGE_FOR_STMT: + pp_cxx_ws_string (this, "for"); + pp_space (this); + pp_cxx_left_paren (this); + statement (RANGE_FOR_DECL (t)); + pp_space (this); + pp_needs_newline (this) = false; + pp_colon (this); + pp_space (this); + statement (RANGE_FOR_EXPR (t)); + pp_cxx_right_paren (this); + pp_newline_and_indent (this, 3); + statement (FOR_BODY (t)); + pp_indentation (this) -= 3; + pp_needs_newline (this) = true; + break; + + /* jump-statement: + goto identifier; + continue ; + return expression(opt) ; */ + case BREAK_STMT: + case CONTINUE_STMT: + pp_string (this, TREE_CODE (t) == BREAK_STMT ? "break" : "continue"); + pp_cxx_semicolon (this); + pp_needs_newline (this) = true; + break; + + /* expression-statement: + expression(opt) ; */ + case EXPR_STMT: + expression (EXPR_STMT_EXPR (t)); + pp_cxx_semicolon (this); + pp_needs_newline (this) = true; + break; + + case CLEANUP_STMT: + pp_cxx_ws_string (this, "try"); + pp_newline_and_indent (this, 2); + statement (CLEANUP_BODY (t)); + pp_newline_and_indent (this, -2); + pp_cxx_ws_string (this, CLEANUP_EH_ONLY (t) ? "catch" : "finally"); + pp_newline_and_indent (this, 2); + statement (CLEANUP_EXPR (t)); + pp_newline_and_indent (this, -2); + break; + + case STATIC_ASSERT: + declaration (t); + break; + + default: + c_pretty_printer::statement (t); + break; + } +} + +/* original-namespace-definition: + namespace identifier { namespace-body } + + As an edge case, we also handle unnamed namespace definition here. */ + +static void +pp_cxx_original_namespace_definition (cxx_pretty_printer *pp, tree t) +{ + pp_cxx_ws_string (pp, "namespace"); + if (DECL_CONTEXT (t)) + pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t)); + if (DECL_NAME (t)) + pp_cxx_unqualified_id (pp, t); + pp_cxx_whitespace (pp); + pp_cxx_left_brace (pp); + /* We do not print the namespace-body. */ + pp_cxx_whitespace (pp); + pp_cxx_right_brace (pp); +} + +/* namespace-alias: + identifier + + namespace-alias-definition: + namespace identifier = qualified-namespace-specifier ; + + qualified-namespace-specifier: + ::(opt) nested-name-specifier(opt) namespace-name */ + +static void +pp_cxx_namespace_alias_definition (cxx_pretty_printer *pp, tree t) +{ + pp_cxx_ws_string (pp, "namespace"); + if (DECL_CONTEXT (t)) + pp_cxx_nested_name_specifier (pp, DECL_CONTEXT (t)); + pp_cxx_unqualified_id (pp, t); + pp_cxx_whitespace (pp); + pp_equal (pp); + pp_cxx_whitespace (pp); + if (DECL_CONTEXT (DECL_NAMESPACE_ALIAS (t))) + pp_cxx_nested_name_specifier (pp, + DECL_CONTEXT (DECL_NAMESPACE_ALIAS (t))); + pp_cxx_qualified_id (pp, DECL_NAMESPACE_ALIAS (t)); + pp_cxx_semicolon (pp); +} + +/* simple-declaration: + decl-specifier-seq(opt) init-declarator-list(opt) */ + +static void +pp_cxx_simple_declaration (cxx_pretty_printer *pp, tree t) +{ + pp->declaration_specifiers (t); + pp_cxx_init_declarator (pp, t); + pp_cxx_semicolon (pp); + pp_needs_newline (pp) = true; +} + +/* + template-parameter-list: + template-parameter + template-parameter-list , template-parameter */ + +static inline void +pp_cxx_template_parameter_list (cxx_pretty_printer *pp, tree t) +{ + const int n = TREE_VEC_LENGTH (t); + int i; + for (i = 0; i < n; ++i) + { + if (i) + pp_cxx_separate_with (pp, ','); + pp_cxx_template_parameter (pp, TREE_VEC_ELT (t, i)); + } +} + +/* template-parameter: + type-parameter + parameter-declaration + + type-parameter: + class ...(opt) identifier(opt) + class identifier(opt) = type-id + typename identifier(opt) + typename ...(opt) identifier(opt) = type-id + template < template-parameter-list > class ...(opt) identifier(opt) + template < template-parameter-list > class identifier(opt) = template-name */ + +static void +pp_cxx_template_parameter (cxx_pretty_printer *pp, tree t) +{ + tree parameter = TREE_VALUE (t); + switch (TREE_CODE (parameter)) + { + case TYPE_DECL: + pp_cxx_ws_string (pp, "class"); + if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t))) + pp_cxx_ws_string (pp, "..."); + if (DECL_NAME (parameter)) + pp_cxx_tree_identifier (pp, DECL_NAME (parameter)); + /* FIXME: Check if we should print also default argument. */ + break; + + case PARM_DECL: + pp_cxx_parameter_declaration (pp, parameter); + break; + + case TEMPLATE_DECL: + break; + + default: + pp_unsupported_tree (pp, t); + break; + } +} + +/* Pretty-print a template parameter in the canonical form + "template-parameter-<level>-<position in parameter list>". */ + +void +pp_cxx_canonical_template_parameter (cxx_pretty_printer *pp, tree parm) +{ + const enum tree_code code = TREE_CODE (parm); + + /* Brings type template parameters to the canonical forms. */ + if (code == TEMPLATE_TYPE_PARM || code == TEMPLATE_TEMPLATE_PARM + || code == BOUND_TEMPLATE_TEMPLATE_PARM) + parm = TEMPLATE_TYPE_PARM_INDEX (parm); + + pp_cxx_begin_template_argument_list (pp); + pp->translate_string ("template-parameter-"); + pp_wide_integer (pp, TEMPLATE_PARM_LEVEL (parm)); + pp_minus (pp); + pp_wide_integer (pp, TEMPLATE_PARM_IDX (parm) + 1); + pp_cxx_end_template_argument_list (pp); +} + +/* + template-declaration: + export(opt) template < template-parameter-list > declaration */ + +static void +pp_cxx_template_declaration (cxx_pretty_printer *pp, tree t) +{ + tree tmpl = most_general_template (t); + tree level; + + pp_maybe_newline_and_indent (pp, 0); + for (level = DECL_TEMPLATE_PARMS (tmpl); level; level = TREE_CHAIN (level)) + { + pp_cxx_ws_string (pp, "template"); + pp_cxx_begin_template_argument_list (pp); + pp_cxx_template_parameter_list (pp, TREE_VALUE (level)); + pp_cxx_end_template_argument_list (pp); + pp_newline_and_indent (pp, 3); + } + if (TREE_CODE (t) == FUNCTION_DECL && DECL_SAVED_TREE (t)) + pp_cxx_function_definition (pp, t); + else + pp_cxx_simple_declaration (pp, t); +} + +static void +pp_cxx_explicit_specialization (cxx_pretty_printer *pp, tree t) +{ + pp_unsupported_tree (pp, t); +} + +static void +pp_cxx_explicit_instantiation (cxx_pretty_printer *pp, tree t) +{ + pp_unsupported_tree (pp, t); +} + +/* + declaration: + block-declaration + function-definition + template-declaration + explicit-instantiation + explicit-specialization + linkage-specification + namespace-definition + + block-declaration: + simple-declaration + asm-definition + namespace-alias-definition + using-declaration + using-directive + static_assert-declaration */ +void +cxx_pretty_printer::declaration (tree t) +{ + if (TREE_CODE (t) == STATIC_ASSERT) + { + pp_cxx_ws_string (this, "static_assert"); + pp_cxx_left_paren (this); + expression (STATIC_ASSERT_CONDITION (t)); + pp_cxx_separate_with (this, ','); + expression (STATIC_ASSERT_MESSAGE (t)); + pp_cxx_right_paren (this); + } + else if (!DECL_LANG_SPECIFIC (t)) + pp_cxx_simple_declaration (this, t); + else if (DECL_USE_TEMPLATE (t)) + switch (DECL_USE_TEMPLATE (t)) + { + case 1: + pp_cxx_template_declaration (this, t); + break; + + case 2: + pp_cxx_explicit_specialization (this, t); + break; + + case 3: + pp_cxx_explicit_instantiation (this, t); + break; + + default: + break; + } + else switch (TREE_CODE (t)) + { + case VAR_DECL: + case TYPE_DECL: + pp_cxx_simple_declaration (this, t); + break; + + case FUNCTION_DECL: + if (DECL_SAVED_TREE (t)) + pp_cxx_function_definition (this, t); + else + pp_cxx_simple_declaration (this, t); + break; + + case NAMESPACE_DECL: + if (DECL_NAMESPACE_ALIAS (t)) + pp_cxx_namespace_alias_definition (this, t); + else + pp_cxx_original_namespace_definition (this, t); + break; + + default: + pp_unsupported_tree (this, t); + break; + } +} + +static void +pp_cxx_typeid_expression (cxx_pretty_printer *pp, tree t) +{ + t = TREE_OPERAND (t, 0); + pp_cxx_ws_string (pp, "typeid"); + pp_cxx_left_paren (pp); + if (TYPE_P (t)) + pp->type_id (t); + else + pp->expression (t); + pp_cxx_right_paren (pp); +} + +void +pp_cxx_va_arg_expression (cxx_pretty_printer *pp, tree t) +{ + pp_cxx_ws_string (pp, "va_arg"); + pp_cxx_left_paren (pp); + pp->assignment_expression (TREE_OPERAND (t, 0)); + pp_cxx_separate_with (pp, ','); + pp->type_id (TREE_TYPE (t)); + pp_cxx_right_paren (pp); +} + +static bool +pp_cxx_offsetof_expression_1 (cxx_pretty_printer *pp, tree t) +{ + switch (TREE_CODE (t)) + { + case ARROW_EXPR: + if (TREE_CODE (TREE_OPERAND (t, 0)) == STATIC_CAST_EXPR + && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (t, 0)))) + { + pp->type_id (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0)))); + pp_cxx_separate_with (pp, ','); + return true; + } + return false; + case COMPONENT_REF: + if (!pp_cxx_offsetof_expression_1 (pp, TREE_OPERAND (t, 0))) + return false; + if (TREE_CODE (TREE_OPERAND (t, 0)) != ARROW_EXPR) + pp_cxx_dot (pp); + pp->expression (TREE_OPERAND (t, 1)); + return true; + case ARRAY_REF: + if (!pp_cxx_offsetof_expression_1 (pp, TREE_OPERAND (t, 0))) + return false; + pp_left_bracket (pp); + pp->expression (TREE_OPERAND (t, 1)); + pp_right_bracket (pp); + return true; + default: + return false; + } +} + +void +pp_cxx_offsetof_expression (cxx_pretty_printer *pp, tree t) +{ + pp_cxx_ws_string (pp, "offsetof"); + pp_cxx_left_paren (pp); + if (!pp_cxx_offsetof_expression_1 (pp, TREE_OPERAND (t, 0))) + pp->expression (TREE_OPERAND (t, 0)); + pp_cxx_right_paren (pp); +} + +void +pp_cxx_trait_expression (cxx_pretty_printer *pp, tree t) +{ + cp_trait_kind kind = TRAIT_EXPR_KIND (t); + + switch (kind) + { + case CPTK_HAS_NOTHROW_ASSIGN: + pp_cxx_ws_string (pp, "__has_nothrow_assign"); + break; + case CPTK_HAS_TRIVIAL_ASSIGN: + pp_cxx_ws_string (pp, "__has_trivial_assign"); + break; + case CPTK_HAS_NOTHROW_CONSTRUCTOR: + pp_cxx_ws_string (pp, "__has_nothrow_constructor"); + break; + case CPTK_HAS_TRIVIAL_CONSTRUCTOR: + pp_cxx_ws_string (pp, "__has_trivial_constructor"); + break; + case CPTK_HAS_NOTHROW_COPY: + pp_cxx_ws_string (pp, "__has_nothrow_copy"); + break; + case CPTK_HAS_TRIVIAL_COPY: + pp_cxx_ws_string (pp, "__has_trivial_copy"); + break; + case CPTK_HAS_TRIVIAL_DESTRUCTOR: + pp_cxx_ws_string (pp, "__has_trivial_destructor"); + break; + case CPTK_HAS_VIRTUAL_DESTRUCTOR: + pp_cxx_ws_string (pp, "__has_virtual_destructor"); + break; + case CPTK_IS_ABSTRACT: + pp_cxx_ws_string (pp, "__is_abstract"); + break; + case CPTK_IS_BASE_OF: + pp_cxx_ws_string (pp, "__is_base_of"); + break; + case CPTK_IS_CLASS: + pp_cxx_ws_string (pp, "__is_class"); + break; + case CPTK_IS_CONVERTIBLE_TO: + pp_cxx_ws_string (pp, "__is_convertible_to"); + break; + case CPTK_IS_EMPTY: + pp_cxx_ws_string (pp, "__is_empty"); + break; + case CPTK_IS_ENUM: + pp_cxx_ws_string (pp, "__is_enum"); + break; + case CPTK_IS_FINAL: + pp_cxx_ws_string (pp, "__is_final"); + break; + case CPTK_IS_POD: + pp_cxx_ws_string (pp, "__is_pod"); + break; + case CPTK_IS_POLYMORPHIC: + pp_cxx_ws_string (pp, "__is_polymorphic"); + break; + case CPTK_IS_STD_LAYOUT: + pp_cxx_ws_string (pp, "__is_std_layout"); + break; + case CPTK_IS_TRIVIAL: + pp_cxx_ws_string (pp, "__is_trivial"); + break; + case CPTK_IS_UNION: + pp_cxx_ws_string (pp, "__is_union"); + break; + case CPTK_IS_LITERAL_TYPE: + pp_cxx_ws_string (pp, "__is_literal_type"); + break; + + default: + gcc_unreachable (); + } + + pp_cxx_left_paren (pp); + pp->type_id (TRAIT_EXPR_TYPE1 (t)); + + if (kind == CPTK_IS_BASE_OF || kind == CPTK_IS_CONVERTIBLE_TO) + { + pp_cxx_separate_with (pp, ','); + pp->type_id (TRAIT_EXPR_TYPE2 (t)); + } + + pp_cxx_right_paren (pp); +} + +typedef c_pretty_print_fn pp_fun; + +/* Initialization of a C++ pretty-printer object. */ + +cxx_pretty_printer::cxx_pretty_printer () + : c_pretty_printer (), + enclosing_scope (global_namespace) +{ + pp_set_line_maximum_length (this, 0); + + type_specifier_seq = (pp_fun) pp_cxx_type_specifier_seq; + parameter_list = (pp_fun) pp_cxx_parameter_declaration_clause; +} |