/* primary-expression:
literal
this
:: identifier
:: operator-function-id
:: qualifier-id
( expression )
id-expression */
static void
pp_cxx_primary_expression (cxx_pretty_printer *pp, tree t)
{
switch (TREE_CODE (t))
{
case STRING_CST:
case INTEGER_CST:
case REAL_CST:
pp_c_constant (pp_c_base (pp), 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:
pp_cxx_id_expression (pp, t);
break;
case RESULT_DECL:
case TEMPLATE_TYPE_PARM:
case TEMPLATE_PARM_INDEX:
pp_cxx_unqualified_id (pp, t);
break;
default:
pp_c_primary_expression (pp_c_base (pp), t);
break;
}
}
void
pp_c_primary_expression (c_pretty_printer *pp, tree e)
{
switch (TREE_CODE (e))
{
case VAR_DECL:
case PARM_DECL:
case FIELD_DECL:
case CONST_DECL:
case FUNCTION_DECL:
case LABEL_DECL:
pp_c_tree_decl_identifier (pp, e);
break;
case IDENTIFIER_NODE:
pp_c_tree_identifier (pp, e);
break;
case ERROR_MARK:
pp_c_identifier (pp, "<erroneous-expression>");
break;
case RESULT_DECL:
pp_c_identifier (pp, "<return-value>");
break;
case INTEGER_CST:
case REAL_CST:
case STRING_CST:
pp_c_constant (pp, e);
break;
case TARGET_EXPR:
pp_c_identifier (pp, "__builtin_memcpy");
pp_c_left_paren (pp);
pp_ampersand (pp);
pp_primary_expression (pp, TREE_OPERAND (e, 0));
pp_separate_with (pp, ',');
pp_ampersand (pp);
pp_initializer (pp, TREE_OPERAND (e, 1));
if (TREE_OPERAND (e, 2))
{
pp_separate_with (pp, ',');
pp_c_expression (pp, TREE_OPERAND (e, 2));
}
pp_c_right_paren (pp);
break;
default:
/* FIXME: Make sure we won't get into an infinie loop. */
pp_c_left_paren (pp);
pp_expression (pp, e);
pp_c_right_paren (pp);
break;
}
}
static void
pp_c_initializer_list (c_pretty_printer *pp, tree e)
{
tree type = TREE_TYPE (e);
const enum tree_code code = TREE_CODE (type);
switch (code)
{
case RECORD_TYPE:
case UNION_TYPE:
case ARRAY_TYPE:
{
tree init = TREE_OPERAND (e, 0);
for (; init != NULL_TREE; init = TREE_CHAIN (init))
{
if (code == RECORD_TYPE || code == UNION_TYPE)
{
pp_c_dot (pp);
pp_c_primary_expression (pp, TREE_PURPOSE (init));
}
else
{
pp_c_left_bracket (pp);
if (TREE_PURPOSE (init))
pp_c_constant (pp, TREE_PURPOSE (init));
pp_c_right_bracket (pp);
}
pp_c_whitespace (pp);
pp_equal (pp);
pp_c_whitespace (pp);
pp_initializer (pp, TREE_VALUE (init));
if (TREE_CHAIN (init))
pp_separate_with (pp, ',');
}
}
return;
case VECTOR_TYPE:
if (TREE_CODE (e) == VECTOR_CST)
pp_c_expression_list (pp, TREE_VECTOR_CST_ELTS (e));
else if (TREE_CODE (e) == CONSTRUCTOR)
pp_c_constructor_elts (pp, CONSTRUCTOR_ELTS (e));
else
break;
return;
case COMPLEX_TYPE:
if (TREE_CODE (e) == CONSTRUCTOR)
pp_c_constructor_elts (pp, CONSTRUCTOR_ELTS (e));
else if (TREE_CODE (e) == COMPLEX_CST || TREE_CODE (e) == COMPLEX_EXPR)
{
const bool cst = TREE_CODE (e) == COMPLEX_CST;
pp_expression (pp, cst ? TREE_REALPART (e) : TREE_OPERAND (e, 0));
pp_separate_with (pp, ',');
pp_expression (pp, cst ? TREE_IMAGPART (e) : TREE_OPERAND (e, 1));
}
else
break;
return;
default:
break;
}
pp_unsupported_tree (pp, type);
}
static void
pp_cxx_expression (cxx_pretty_printer *pp, tree t)
{
switch (TREE_CODE (t))
{
case STRING_CST:
case INTEGER_CST:
case REAL_CST:
pp_c_constant (pp_c_base (pp), t);
break;
case RESULT_DECL:
pp_cxx_unqualified_id (pp, t);
break;
#if 0
case OFFSET_REF:
#endif
case SCOPE_REF:
case PTRMEM_CST:
pp_cxx_qualified_id (pp, 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:
pp_cxx_primary_expression (pp, 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:
pp_cxx_postfix_expression (pp, t);
break;
case NEW_EXPR:
case VEC_NEW_EXPR:
pp_cxx_new_expression (pp, t);
break;
case DELETE_EXPR:
case VEC_DELETE_EXPR:
pp_cxx_delete_expression (pp, t);
break;
case SIZEOF_EXPR:
case ALIGNOF_EXPR:
pp_cxx_unary_expression (pp, t);
break;
case CAST_EXPR:
pp_cxx_cast_expression (pp, t);
break;
case OFFSET_REF:
case MEMBER_REF:
case DOTSTAR_EXPR:
pp_cxx_pm_expression (pp, t);
break;
case MULT_EXPR:
case TRUNC_DIV_EXPR:
case TRUNC_MOD_EXPR:
pp_cxx_multiplicative_expression (pp, t);
break;
case COND_EXPR:
pp_cxx_conditional_expression (pp, t);
break;
case MODIFY_EXPR:
case INIT_EXPR:
case THROW_EXPR:
case MODOP_EXPR:
pp_cxx_assignment_expression (pp, t);
break;
case NON_DEPENDENT_EXPR:
case MUST_NOT_THROW_EXPR:
pp_cxx_expression (pp, t);
break;
default:
pp_c_expression (pp_c_base (pp), t);
break;
}
}
