static void pp_c_initializer_list (c_pretty_printer *, tree);
static void pp_c_brace_enclosed_initializer_list (c_pretty_printer *, tree);
-static void pp_c_multiplicative_expression (c_pretty_printer *, tree);
static void pp_c_additive_expression (c_pretty_printer *, tree);
static void pp_c_shift_expression (c_pretty_printer *, tree);
static void pp_c_relational_expression (c_pretty_printer *, tree);
static void pp_c_exclusive_or_expression (c_pretty_printer *, tree);
static void pp_c_inclusive_or_expression (c_pretty_printer *, tree);
static void pp_c_logical_and_expression (c_pretty_printer *, tree);
-static void pp_c_conditional_expression (c_pretty_printer *, tree);
-static void pp_c_assignment_expression (c_pretty_printer *, tree);
/* declarations. */
if (TREE_OPERAND (e, 2))
{
pp_separate_with (this, ',');
- pp_c_expression (this, TREE_OPERAND (e, 2));
+ expression (TREE_OPERAND (e, 2));
}
pp_c_right_paren (this);
break;
break;
case MEM_REF:
- pp_c_expression (this, e);
+ expression (e);
break;
case COMPLEX_CST:
case VA_ARG_EXPR:
pp_c_ws_string (this, "__builtin_va_arg");
pp_c_left_paren (this);
- pp_assignment_expression (this, TREE_OPERAND (e, 0));
+ assignment_expression (TREE_OPERAND (e, 0));
pp_separate_with (this, ',');
pp_type_id (this, TREE_TYPE (e));
pp_c_right_paren (this);
__imag__ unary-expression */
void
-pp_c_unary_expression (c_pretty_printer *pp, tree e)
+c_pretty_printer::unary_expression (tree e)
{
enum tree_code code = TREE_CODE (e);
switch (code)
{
case PREINCREMENT_EXPR:
case PREDECREMENT_EXPR:
- pp_string (pp, code == PREINCREMENT_EXPR ? "++" : "--");
- pp_c_unary_expression (pp, TREE_OPERAND (e, 0));
+ pp_string (this, code == PREINCREMENT_EXPR ? "++" : "--");
+ unary_expression (TREE_OPERAND (e, 0));
break;
case ADDR_EXPR:
case CONJ_EXPR:
/* String literal are used by address. */
if (code == ADDR_EXPR && TREE_CODE (TREE_OPERAND (e, 0)) != STRING_CST)
- pp_ampersand (pp);
+ pp_ampersand (this);
else if (code == INDIRECT_REF)
- pp_c_star (pp);
+ pp_c_star (this);
else if (code == NEGATE_EXPR)
- pp_minus (pp);
+ pp_minus (this);
else if (code == BIT_NOT_EXPR || code == CONJ_EXPR)
- pp_complement (pp);
+ pp_complement (this);
else if (code == TRUTH_NOT_EXPR)
- pp_exclamation (pp);
- pp_c_cast_expression (pp, TREE_OPERAND (e, 0));
+ pp_exclamation (this);
+ pp_c_cast_expression (this, TREE_OPERAND (e, 0));
break;
case MEM_REF:
if (TREE_CODE (TREE_OPERAND (e, 0)) == ADDR_EXPR
&& integer_zerop (TREE_OPERAND (e, 1)))
- pp_c_expression (pp, TREE_OPERAND (TREE_OPERAND (e, 0), 0));
+ expression (TREE_OPERAND (TREE_OPERAND (e, 0), 0));
else
{
- pp_c_star (pp);
+ pp_c_star (this);
if (!integer_zerop (TREE_OPERAND (e, 1)))
{
- pp_c_left_paren (pp);
+ pp_c_left_paren (this);
if (!integer_onep (TYPE_SIZE_UNIT
(TREE_TYPE (TREE_TYPE (TREE_OPERAND (e, 0))))))
- pp_c_type_cast (pp, ptr_type_node);
+ pp_c_type_cast (this, ptr_type_node);
}
- pp_c_cast_expression (pp, TREE_OPERAND (e, 0));
+ pp_c_cast_expression (this, TREE_OPERAND (e, 0));
if (!integer_zerop (TREE_OPERAND (e, 1)))
{
- pp_plus (pp);
- pp_c_integer_constant (pp,
+ pp_plus (this);
+ pp_c_integer_constant (this,
fold_convert (ssizetype,
TREE_OPERAND (e, 1)));
- pp_c_right_paren (pp);
+ pp_c_right_paren (this);
}
}
break;
case REALPART_EXPR:
case IMAGPART_EXPR:
- pp_c_ws_string (pp, code == REALPART_EXPR ? "__real__" : "__imag__");
- pp_c_whitespace (pp);
- pp_unary_expression (pp, TREE_OPERAND (e, 0));
+ pp_c_ws_string (this, code == REALPART_EXPR ? "__real__" : "__imag__");
+ pp_c_whitespace (this);
+ unary_expression (TREE_OPERAND (e, 0));
break;
default:
- pp_postfix_expression (pp, e);
+ postfix_expression (e);
break;
}
}
multiplicative-expression / cast-expression
multiplicative-expression % cast-expression */
-static void
-pp_c_multiplicative_expression (c_pretty_printer *pp, tree e)
+void
+c_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:
- pp_multiplicative_expression (pp, TREE_OPERAND (e, 0));
- pp_c_whitespace (pp);
+ multiplicative_expression (TREE_OPERAND (e, 0));
+ pp_c_whitespace (this);
if (code == MULT_EXPR)
- pp_c_star (pp);
+ pp_c_star (this);
else if (code == TRUNC_DIV_EXPR)
- pp_slash (pp);
+ pp_slash (this);
else
- pp_modulo (pp);
- pp_c_whitespace (pp);
- pp_c_cast_expression (pp, TREE_OPERAND (e, 1));
+ pp_modulo (this);
+ pp_c_whitespace (this);
+ pp_c_cast_expression (this, TREE_OPERAND (e, 1));
break;
default:
- pp_c_cast_expression (pp, e);
+ pp_c_cast_expression (this, e);
break;
}
}
logical-OR-expression
logical-OR-expression ? expression : conditional-expression */
-static void
-pp_c_conditional_expression (c_pretty_printer *pp, tree e)
+void
+c_pretty_printer::conditional_expression (tree e)
{
if (TREE_CODE (e) == COND_EXPR)
{
- pp_c_logical_or_expression (pp, TREE_OPERAND (e, 0));
- pp_c_whitespace (pp);
- pp_question (pp);
- pp_c_whitespace (pp);
- pp_expression (pp, TREE_OPERAND (e, 1));
- pp_c_whitespace (pp);
- pp_colon (pp);
- pp_c_whitespace (pp);
- pp_c_conditional_expression (pp, TREE_OPERAND (e, 2));
+ pp_c_logical_or_expression (this, TREE_OPERAND (e, 0));
+ pp_c_whitespace (this);
+ pp_question (this);
+ pp_c_whitespace (this);
+ pp_expression (this, TREE_OPERAND (e, 1));
+ pp_c_whitespace (this);
+ pp_colon (this);
+ pp_c_whitespace (this);
+ conditional_expression (TREE_OPERAND (e, 2));
}
else
- pp_c_logical_or_expression (pp, e);
+ pp_c_logical_or_expression (this, e);
}
assignment-expression: one of
= *= /= %= += -= >>= <<= &= ^= |= */
-static void
-pp_c_assignment_expression (c_pretty_printer *pp, tree e)
+void
+c_pretty_printer::assignment_expression (tree e)
{
if (TREE_CODE (e) == MODIFY_EXPR
|| TREE_CODE (e) == INIT_EXPR)
{
- pp_c_unary_expression (pp, TREE_OPERAND (e, 0));
- pp_c_whitespace (pp);
- pp_equal (pp);
- pp_space (pp);
- pp_c_expression (pp, TREE_OPERAND (e, 1));
+ unary_expression (TREE_OPERAND (e, 0));
+ pp_c_whitespace (this);
+ pp_equal (this);
+ pp_space (this);
+ pp_expression (this, TREE_OPERAND (e, 1));
}
else
- pp_c_conditional_expression (pp, e);
+ conditional_expression (e);
}
/* expression:
chain, I take the liberty of dispatching nodes to the appropriate
functions. This makes some redundancy, but it worths it. That also
prevents a possible infinite recursion between pp_primary_expression ()
- and pp_c_expression (). */
+ and pp_expression (). */
void
-pp_c_expression (c_pretty_printer *pp, tree e)
+c_pretty_printer::expression (tree e)
{
switch (TREE_CODE (e))
{
case INTEGER_CST:
- pp_c_integer_constant (pp, e);
+ pp_c_integer_constant (this, e);
break;
case REAL_CST:
- pp_c_floating_constant (pp, e);
+ pp_c_floating_constant (this, e);
break;
case FIXED_CST:
- pp_c_fixed_constant (pp, e);
+ pp_c_fixed_constant (this, e);
break;
case STRING_CST:
- pp_c_string_literal (pp, e);
+ pp_c_string_literal (this, e);
break;
case IDENTIFIER_NODE:
case FIELD_DECL:
case LABEL_DECL:
case ERROR_MARK:
- pp_primary_expression (pp, e);
+ primary_expression (e);
break;
case SSA_NAME:
if (SSA_NAME_VAR (e)
&& !DECL_ARTIFICIAL (SSA_NAME_VAR (e)))
- pp_c_expression (pp, SSA_NAME_VAR (e));
+ expression (SSA_NAME_VAR (e));
else
- pp->translate_string ("<unknown>");
+ translate_string ("<unknown>");
break;
case POSTINCREMENT_EXPR:
case CONSTRUCTOR:
case COMPOUND_LITERAL_EXPR:
case VA_ARG_EXPR:
- pp_postfix_expression (pp, e);
+ postfix_expression (e);
break;
case CONJ_EXPR:
case PREDECREMENT_EXPR:
case REALPART_EXPR:
case IMAGPART_EXPR:
- pp_c_unary_expression (pp, e);
+ unary_expression (e);
break;
case FLOAT_EXPR:
case FIX_TRUNC_EXPR:
CASE_CONVERT:
case VIEW_CONVERT_EXPR:
- pp_c_cast_expression (pp, e);
+ pp_c_cast_expression (this, e);
break;
case MULT_EXPR:
case TRUNC_MOD_EXPR:
case TRUNC_DIV_EXPR:
- pp_multiplicative_expression (pp, e);
+ multiplicative_expression (e);
break;
case LSHIFT_EXPR:
case RSHIFT_EXPR:
- pp_c_shift_expression (pp, e);
+ pp_c_shift_expression (this, e);
break;
case LT_EXPR:
case GT_EXPR:
case LE_EXPR:
case GE_EXPR:
- pp_c_relational_expression (pp, e);
+ pp_c_relational_expression (this, e);
break;
case BIT_AND_EXPR:
- pp_c_and_expression (pp, e);
+ pp_c_and_expression (this, e);
break;
case BIT_XOR_EXPR:
case TRUTH_XOR_EXPR:
- pp_c_exclusive_or_expression (pp, e);
+ pp_c_exclusive_or_expression (this, e);
break;
case BIT_IOR_EXPR:
- pp_c_inclusive_or_expression (pp, e);
+ pp_c_inclusive_or_expression (this, e);
break;
case TRUTH_ANDIF_EXPR:
case TRUTH_AND_EXPR:
- pp_c_logical_and_expression (pp, e);
+ pp_c_logical_and_expression (this, e);
break;
case TRUTH_ORIF_EXPR:
case TRUTH_OR_EXPR:
- pp_c_logical_or_expression (pp, e);
+ pp_c_logical_or_expression (this, e);
break;
case EQ_EXPR:
case NE_EXPR:
- pp_c_equality_expression (pp, e);
+ pp_c_equality_expression (this, e);
break;
case COND_EXPR:
- pp_conditional_expression (pp, e);
+ conditional_expression (e);
break;
case POINTER_PLUS_EXPR:
case PLUS_EXPR:
case MINUS_EXPR:
- pp_c_additive_expression (pp, e);
+ pp_c_additive_expression (this, e);
break;
case MODIFY_EXPR:
case INIT_EXPR:
- pp_assignment_expression (pp, e);
+ assignment_expression (e);
break;
case COMPOUND_EXPR:
- pp_c_left_paren (pp);
- pp_expression (pp, TREE_OPERAND (e, 0));
- pp_separate_with (pp, ',');
- pp_assignment_expression (pp, TREE_OPERAND (e, 1));
- pp_c_right_paren (pp);
+ pp_c_left_paren (this);
+ expression (TREE_OPERAND (e, 0));
+ pp_separate_with (this, ',');
+ assignment_expression (TREE_OPERAND (e, 1));
+ pp_c_right_paren (this);
break;
case NON_LVALUE_EXPR:
case SAVE_EXPR:
- pp_expression (pp, TREE_OPERAND (e, 0));
+ expression (TREE_OPERAND (e, 0));
break;
case TARGET_EXPR:
- pp_postfix_expression (pp, TREE_OPERAND (e, 1));
+ postfix_expression (TREE_OPERAND (e, 1));
break;
case BIND_EXPR:
case GOTO_EXPR:
/* We don't yet have a way of dumping statements in a
human-readable format. */
- pp_string (pp, "({...})");
+ pp_string (this, "({...})");
break;
case C_MAYBE_CONST_EXPR:
- pp_c_expression (pp, C_MAYBE_CONST_EXPR_EXPR (e));
+ expression (C_MAYBE_CONST_EXPR_EXPR (e));
break;
default:
- pp_unsupported_tree (pp, e);
+ pp_unsupported_tree (this, e);
break;
}
}
statement = pp_c_statement;
- unary_expression = pp_c_unary_expression;
initializer = pp_c_initializer;
- multiplicative_expression = pp_c_multiplicative_expression;
- conditional_expression = pp_c_conditional_expression;
- assignment_expression = pp_c_assignment_expression;
- expression = pp_c_expression;
}
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_assignment_expression (cxx_pretty_printer *, tree);
-static void pp_cxx_expression (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);
skipfirst = false;
else
{
- pp_cxx_expression (this, arg);
+ expression (arg);
if (more_aggr_init_expr_args_p (&iter))
pp_cxx_separate_with (this, ',');
}
skipfirst = false;
else
{
- pp_cxx_expression (this, arg);
+ expression (arg);
if (more_call_expr_args_p (&iter))
pp_cxx_separate_with (this, ',');
}
pp_cxx_type_id (this, TREE_TYPE (t));
pp_cxx_end_template_argument_list (this);
pp_left_paren (this);
- pp_cxx_expression (this, TREE_OPERAND (t, 0));
+ expression (TREE_OPERAND (t, 0));
pp_right_paren (this);
break;
else if (init == void_zero_node)
; /* OK, empty initializer list. */
else
- pp_cxx_expression (pp, init);
+ pp_expression (pp, init);
pp_right_paren (pp);
}
break;
__alignof__ unary-expression
__alignof__ ( type-id ) */
-static void
-pp_cxx_unary_expression (cxx_pretty_printer *pp, tree t)
+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 (pp, t);
+ pp_cxx_new_expression (this, t);
break;
case DELETE_EXPR:
case VEC_DELETE_EXPR:
- pp_cxx_delete_expression (pp, t);
+ pp_cxx_delete_expression (this, t);
break;
case SIZEOF_EXPR:
if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
{
- pp_cxx_ws_string (pp, "sizeof");
- pp_cxx_ws_string (pp, "...");
- pp_cxx_whitespace (pp);
- pp_cxx_left_paren (pp);
+ 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)))
- pp_cxx_type_id (pp, TREE_OPERAND (t, 0));
+ pp_cxx_type_id (this, TREE_OPERAND (t, 0));
else
- pp_unary_expression (pp, TREE_OPERAND (t, 0));
- pp_cxx_right_paren (pp);
+ unary_expression (TREE_OPERAND (t, 0));
+ pp_cxx_right_paren (this);
break;
}
/* Fall through */
case ALIGNOF_EXPR:
- pp_cxx_ws_string (pp, code == SIZEOF_EXPR ? "sizeof" : "__alignof__");
- pp_cxx_whitespace (pp);
+ 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 (pp);
- pp_cxx_type_id (pp, TREE_TYPE (TREE_OPERAND (t, 0)));
- pp_cxx_right_paren (pp);
+ pp_cxx_left_paren (this);
+ pp_cxx_type_id (this, TREE_TYPE (TREE_OPERAND (t, 0)));
+ pp_cxx_right_paren (this);
}
else if (TYPE_P (TREE_OPERAND (t, 0)))
{
- pp_cxx_left_paren (pp);
- pp_cxx_type_id (pp, TREE_OPERAND (t, 0));
- pp_cxx_right_paren (pp);
+ pp_cxx_left_paren (this);
+ pp_cxx_type_id (this, TREE_OPERAND (t, 0));
+ pp_cxx_right_paren (this);
}
else
- pp_unary_expression (pp, TREE_OPERAND (t, 0));
+ unary_expression (TREE_OPERAND (t, 0));
break;
case AT_ENCODE_EXPR:
- pp_cxx_ws_string (pp, "@encode");
- pp_cxx_whitespace (pp);
- pp_cxx_left_paren (pp);
- pp_cxx_type_id (pp, TREE_OPERAND (t, 0));
- pp_cxx_right_paren (pp);
+ pp_cxx_ws_string (this, "@encode");
+ pp_cxx_whitespace (this);
+ pp_cxx_left_paren (this);
+ pp_cxx_type_id (this, TREE_OPERAND (t, 0));
+ pp_cxx_right_paren (this);
break;
case NOEXCEPT_EXPR:
- pp_cxx_ws_string (pp, "noexcept");
- pp_cxx_whitespace (pp);
- pp_cxx_left_paren (pp);
- pp_cxx_expression (pp, TREE_OPERAND (t, 0));
- pp_cxx_right_paren (pp);
+ 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 (pp);
- pp_cxx_cast_expression (pp, TREE_OPERAND (t, 0));
+ pp_plus (this);
+ pp_cxx_cast_expression (this, TREE_OPERAND (t, 0));
break;
default:
- pp_c_unary_expression (pp, t);
+ c_pretty_printer::unary_expression (t);
break;
}
}
multiplicative-expression / pm-expression
multiplicative-expression % pm-expression */
-static void
-pp_cxx_multiplicative_expression (cxx_pretty_printer *pp, tree e)
+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:
- pp_cxx_multiplicative_expression (pp, TREE_OPERAND (e, 0));
- pp_space (pp);
+ multiplicative_expression (TREE_OPERAND (e, 0));
+ pp_space (this);
if (code == MULT_EXPR)
- pp_star (pp);
+ pp_star (this);
else if (code == TRUNC_DIV_EXPR)
- pp_slash (pp);
+ pp_slash (this);
else
- pp_modulo (pp);
- pp_space (pp);
- pp_cxx_pm_expression (pp, TREE_OPERAND (e, 1));
+ pp_modulo (this);
+ pp_space (this);
+ pp_cxx_pm_expression (this, TREE_OPERAND (e, 1));
break;
default:
- pp_cxx_pm_expression (pp, e);
+ pp_cxx_pm_expression (this, e);
break;
}
}
logical-or-expression
logical-or-expression ? expression : assignment-expression */
-static void
-pp_cxx_conditional_expression (cxx_pretty_printer *pp, tree e)
+void
+cxx_pretty_printer::conditional_expression (tree e)
{
if (TREE_CODE (e) == COND_EXPR)
{
- pp_c_logical_or_expression (pp, TREE_OPERAND (e, 0));
- pp_space (pp);
- pp_question (pp);
- pp_space (pp);
- pp_cxx_expression (pp, TREE_OPERAND (e, 1));
- pp_space (pp);
- pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 2));
+ 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 (pp, e);
+ pp_c_logical_or_expression (this, e);
}
/* Pretty-print a compound assignment operator token as indicated by T. */
assignment-operator: one of
= *= /= %= += -= >>= <<= &= ^= |= */
-static void
-pp_cxx_assignment_expression (cxx_pretty_printer *pp, tree e)
+void
+cxx_pretty_printer::assignment_expression (tree e)
{
switch (TREE_CODE (e))
{
case MODIFY_EXPR:
case INIT_EXPR:
- pp_c_logical_or_expression (pp, TREE_OPERAND (e, 0));
- pp_space (pp);
- pp_equal (pp);
- pp_space (pp);
- pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 1));
+ 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 (pp, "throw");
+ pp_cxx_ws_string (this, "throw");
if (TREE_OPERAND (e, 0))
- pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 0));
+ assignment_expression (TREE_OPERAND (e, 0));
break;
case MODOP_EXPR:
- pp_c_logical_or_expression (pp, TREE_OPERAND (e, 0));
- pp_cxx_assignment_operator (pp, TREE_OPERAND (e, 1));
- pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 2));
+ 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:
- pp_cxx_conditional_expression (pp, e);
+ conditional_expression (e);
break;
}
}
-static void
-pp_cxx_expression (cxx_pretty_printer *pp, tree t)
+void
+cxx_pretty_printer::expression (tree t)
{
switch (TREE_CODE (t))
{
case INTEGER_CST:
case REAL_CST:
case COMPLEX_CST:
- pp_constant (pp, t);
+ constant (t);
break;
case USERDEF_LITERAL:
- pp_cxx_userdef_literal (pp, t);
+ pp_cxx_userdef_literal (this, t);
break;
case RESULT_DECL:
- pp_cxx_unqualified_id (pp, t);
+ pp_cxx_unqualified_id (this, t);
break;
#if 0
#endif
case SCOPE_REF:
case PTRMEM_CST:
- pp_cxx_qualified_id (pp, t);
+ pp_cxx_qualified_id (this, t);
break;
case OVERLOAD:
case TEMPLATE_PARM_INDEX:
case TEMPLATE_TEMPLATE_PARM:
case STMT_EXPR:
- pp_primary_expression (pp, t);
+ primary_expression (t);
break;
case CALL_EXPR:
case PSEUDO_DTOR_EXPR:
case AGGR_INIT_EXPR:
case ARROW_EXPR:
- pp_postfix_expression (pp, t);
+ postfix_expression (t);
break;
case NEW_EXPR:
case VEC_NEW_EXPR:
- pp_cxx_new_expression (pp, t);
+ pp_cxx_new_expression (this, t);
break;
case DELETE_EXPR:
case VEC_DELETE_EXPR:
- pp_cxx_delete_expression (pp, t);
+ pp_cxx_delete_expression (this, t);
break;
case SIZEOF_EXPR:
case ALIGNOF_EXPR:
case NOEXCEPT_EXPR:
- pp_cxx_unary_expression (pp, t);
+ unary_expression (t);
break;
case CAST_EXPR:
case IMPLICIT_CONV_EXPR:
- pp_cxx_cast_expression (pp, t);
+ pp_cxx_cast_expression (this, t);
break;
case OFFSET_REF:
case MEMBER_REF:
case DOTSTAR_EXPR:
- pp_cxx_pm_expression (pp, t);
+ pp_cxx_pm_expression (this, t);
break;
case MULT_EXPR:
case TRUNC_DIV_EXPR:
case TRUNC_MOD_EXPR:
- pp_cxx_multiplicative_expression (pp, t);
+ multiplicative_expression (t);
break;
case COND_EXPR:
- pp_cxx_conditional_expression (pp, t);
+ conditional_expression (t);
break;
case MODIFY_EXPR:
case INIT_EXPR:
case THROW_EXPR:
case MODOP_EXPR:
- pp_cxx_assignment_expression (pp, t);
+ assignment_expression (t);
break;
case NON_DEPENDENT_EXPR:
case MUST_NOT_THROW_EXPR:
- pp_cxx_expression (pp, TREE_OPERAND (t, 0));
+ expression (TREE_OPERAND (t, 0));
break;
case EXPR_PACK_EXPANSION:
- pp_cxx_expression (pp, PACK_EXPANSION_PATTERN (t));
- pp_cxx_ws_string (pp, "...");
+ expression (PACK_EXPANSION_PATTERN (t));
+ pp_cxx_ws_string (this, "...");
break;
case TEMPLATE_ID_EXPR:
- pp_cxx_template_id (pp, t);
+ pp_cxx_template_id (this, t);
break;
case NONTYPE_ARGUMENT_PACK:
for (i = 0; i < len; ++i)
{
if (i > 0)
- pp_cxx_separate_with (pp, ',');
- pp_cxx_expression (pp, TREE_VEC_ELT (args, i));
+ pp_cxx_separate_with (this, ',');
+ expression (TREE_VEC_ELT (args, i));
}
}
break;
case LAMBDA_EXPR:
- pp_cxx_ws_string (pp, "<lambda>");
+ pp_cxx_ws_string (this, "<lambda>");
break;
case PAREN_EXPR:
- pp_cxx_left_paren (pp);
- pp_cxx_expression (pp, TREE_OPERAND (t, 0));
- pp_cxx_right_paren (pp);
+ pp_cxx_left_paren (this);
+ expression (TREE_OPERAND (t, 0));
+ pp_cxx_right_paren (this);
break;
default:
- pp_c_expression (pp, t);
+ c_pretty_printer::expression (t);
break;
}
}
case DECLTYPE_TYPE:
pp_cxx_ws_string (pp, "decltype");
pp_cxx_left_paren (pp);
- pp_cxx_expression (pp, DECLTYPE_TYPE_EXPR (t));
+ pp_expression (pp, DECLTYPE_TYPE_EXPR (t));
pp_cxx_right_paren (pp);
break;
pp_cxx_whitespace (pp);
pp_equal (pp);
pp_cxx_whitespace (pp);
- pp_cxx_assignment_expression (pp, TREE_PURPOSE (types));
+ pp_assignment_expression (pp, TREE_PURPOSE (types));
}
}
pp_cxx_right_paren (pp);
if (DEFERRED_NOEXCEPT_SPEC_P (ex_spec))
pp_cxx_ws_string (pp, "<uninstantiated>");
else
- pp_cxx_expression (pp, TREE_PURPOSE (ex_spec));
+ pp_expression (pp, TREE_PURPOSE (ex_spec));
pp_cxx_right_paren (pp);
return;
}
&& TYPE_P (DECL_TEMPLATE_RESULT (arg))))
pp_cxx_type_id (pp, arg);
else
- pp_cxx_expression (pp, arg);
+ pp_expression (pp, arg);
}
}
}
pp_cxx_ws_string (pp, "if");
pp_cxx_whitespace (pp);
pp_cxx_left_paren (pp);
- pp_cxx_expression (pp, IF_COND (t));
+ pp_expression (pp, IF_COND (t));
pp_cxx_right_paren (pp);
pp_newline_and_indent (pp, 2);
pp_cxx_statement (pp, THEN_CLAUSE (t));
pp_cxx_ws_string (pp, "switch");
pp_space (pp);
pp_cxx_left_paren (pp);
- pp_cxx_expression (pp, SWITCH_STMT_COND (t));
+ pp_expression (pp, SWITCH_STMT_COND (t));
pp_cxx_right_paren (pp);
pp_indentation (pp) += 3;
pp_needs_newline (pp) = true;
pp_cxx_ws_string (pp, "while");
pp_space (pp);
pp_cxx_left_paren (pp);
- pp_cxx_expression (pp, WHILE_COND (t));
+ pp_expression (pp, WHILE_COND (t));
pp_cxx_right_paren (pp);
pp_newline_and_indent (pp, 3);
pp_cxx_statement (pp, WHILE_BODY (t));
pp_cxx_ws_string (pp, "while");
pp_space (pp);
pp_cxx_left_paren (pp);
- pp_cxx_expression (pp, DO_COND (t));
+ pp_expression (pp, DO_COND (t));
pp_cxx_right_paren (pp);
pp_cxx_semicolon (pp);
pp_needs_newline (pp) = true;
pp_needs_newline (pp) = false;
pp_cxx_whitespace (pp);
if (FOR_COND (t))
- pp_cxx_expression (pp, FOR_COND (t));
+ pp_expression (pp, FOR_COND (t));
pp_cxx_semicolon (pp);
pp_needs_newline (pp) = false;
pp_cxx_whitespace (pp);
if (FOR_EXPR (t))
- pp_cxx_expression (pp, FOR_EXPR (t));
+ pp_expression (pp, FOR_EXPR (t));
pp_cxx_right_paren (pp);
pp_newline_and_indent (pp, 3);
pp_cxx_statement (pp, FOR_BODY (t));
/* expression-statement:
expression(opt) ; */
case EXPR_STMT:
- pp_cxx_expression (pp, EXPR_STMT_EXPR (t));
+ pp_expression (pp, EXPR_STMT_EXPR (t));
pp_cxx_semicolon (pp);
pp_needs_newline (pp) = true;
break;
{
pp_cxx_ws_string (pp, "static_assert");
pp_cxx_left_paren (pp);
- pp_cxx_expression (pp, STATIC_ASSERT_CONDITION (t));
+ pp_expression (pp, STATIC_ASSERT_CONDITION (t));
pp_cxx_separate_with (pp, ',');
- pp_cxx_expression (pp, STATIC_ASSERT_MESSAGE (t));
+ pp_expression (pp, STATIC_ASSERT_MESSAGE (t));
pp_cxx_right_paren (pp);
}
else if (!DECL_LANG_SPECIFIC (t))
if (TYPE_P (t))
pp_cxx_type_id (pp, t);
else
- pp_cxx_expression (pp, t);
+ pp_expression (pp, t);
pp_cxx_right_paren (pp);
}
{
pp_cxx_ws_string (pp, "va_arg");
pp_cxx_left_paren (pp);
- pp_cxx_assignment_expression (pp, TREE_OPERAND (t, 0));
+ pp_assignment_expression (pp, TREE_OPERAND (t, 0));
pp_cxx_separate_with (pp, ',');
pp_cxx_type_id (pp, TREE_TYPE (t));
pp_cxx_right_paren (pp);
return false;
if (TREE_CODE (TREE_OPERAND (t, 0)) != ARROW_EXPR)
pp_cxx_dot (pp);
- pp_cxx_expression (pp, TREE_OPERAND (t, 1));
+ pp_expression (pp, 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_cxx_expression (pp, TREE_OPERAND (t, 1));
+ pp_expression (pp, TREE_OPERAND (t, 1));
pp_right_bracket (pp);
return true;
default:
pp_cxx_ws_string (pp, "offsetof");
pp_cxx_left_paren (pp);
if (!pp_cxx_offsetof_expression_1 (pp, TREE_OPERAND (t, 0)))
- pp_cxx_expression (pp, TREE_OPERAND (t, 0));
+ pp_expression (pp, TREE_OPERAND (t, 0));
pp_cxx_right_paren (pp);
}
simple_type_specifier = (pp_fun) pp_cxx_simple_type_specifier;
/* pp->statement = (pp_fun) pp_cxx_statement; */
-
- unary_expression = (pp_fun) pp_cxx_unary_expression;
- multiplicative_expression = (pp_fun) pp_cxx_multiplicative_expression;
- conditional_expression = (pp_fun) pp_cxx_conditional_expression;
- assignment_expression = (pp_fun) pp_cxx_assignment_expression;
- expression = (pp_fun) pp_cxx_expression;
}
git://gcc.gnu.org / gcc.git / commitdiff