void
pp_c_init_declarator (c_pretty_printer *pp, tree t)
{
pp_declarator (pp, t);
/* We don't want to output function definitions here. There are handled
elsewhere (and the syntactic form is bogus anyway). */
if (TREE_CODE (t) != FUNCTION_DECL && DECL_INITIAL (t))
{
tree init = DECL_INITIAL (t);
/* This C++ bit is handled here because it is easier to do so.
In templates, the C++ parser builds a TREE_LIST for a
direct-initialization; the TREE_PURPOSE is the variable to
initialize and the TREE_VALUE is the initializer. */
if (TREE_CODE (init) == TREE_LIST)
{
pp_c_left_paren (pp);
pp_expression (pp, TREE_VALUE (init));
pp_right_paren (pp);
}
else
{
pp_space (pp);
pp_equal (pp);
pp_space (pp);
pp_c_initializer (pp, init);
}
}
}
static void
pp_c_initializer (c_pretty_printer *pp, tree e)
{
if (TREE_CODE (e) == CONSTRUCTOR)
pp_c_brace_enclosed_initializer_list (pp, e);
else
pp_expression (pp, e);
}
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;
}
}
void
pp_c_expression_list (c_pretty_printer *pp, tree e)
{
for (; e != NULL_TREE; e = TREE_CHAIN (e))
{
pp_expression (pp, TREE_VALUE (e));
if (TREE_CHAIN (e))
pp_separate_with (pp, ',');
}
}
void
pp_c_direct_abstract_declarator (c_pretty_printer *pp, tree t)
{
switch (TREE_CODE (t))
{
case POINTER_TYPE:
/* APPLE LOCAL blocks */
case BLOCK_POINTER_TYPE:
pp_abstract_declarator (pp, t);
break;
case FUNCTION_TYPE:
pp_c_parameter_type_list (pp, t);
pp_direct_abstract_declarator (pp, TREE_TYPE (t));
break;
case ARRAY_TYPE:
pp_c_left_bracket (pp);
if (TYPE_DOMAIN (t) && TYPE_MAX_VALUE (TYPE_DOMAIN (t)))
{
tree maxval = TYPE_MAX_VALUE (TYPE_DOMAIN (t));
tree type = TREE_TYPE (maxval);
if (host_integerp (maxval, 0))
pp_wide_integer (pp, tree_low_cst (maxval, 0) + 1);
else
pp_expression (pp, fold (build2 (PLUS_EXPR, type, maxval,
build_int_cst (type, 1))));
}
pp_c_right_bracket (pp);
pp_direct_abstract_declarator (pp, TREE_TYPE (t));
break;
case IDENTIFIER_NODE:
case VOID_TYPE:
case BOOLEAN_TYPE:
case INTEGER_TYPE:
case REAL_TYPE:
case ENUMERAL_TYPE:
case RECORD_TYPE:
case UNION_TYPE:
case VECTOR_TYPE:
case COMPLEX_TYPE:
case TYPE_DECL:
break;
default:
pp_unsupported_tree (pp, t);
break;
}
}
FOR_EACH_CONSTRUCTOR_VALUE (v, ix, value)
{
pp_expression (pp, value);
if (ix != VEC_length (constructor_elt, v) - 1)
pp_separate_with (pp, ',');
}
void
pp_c_postfix_expression (c_pretty_printer *pp, tree e)
{
enum tree_code code = TREE_CODE (e);
switch (code)
{
case POSTINCREMENT_EXPR:
case POSTDECREMENT_EXPR:
pp_postfix_expression (pp, TREE_OPERAND (e, 0));
pp_identifier (pp, code == POSTINCREMENT_EXPR ? "++" : "--");
break;
case ARRAY_REF:
pp_postfix_expression (pp, TREE_OPERAND (e, 0));
pp_c_left_bracket (pp);
pp_expression (pp, TREE_OPERAND (e, 1));
pp_c_right_bracket (pp);
break;
case CALL_EXPR:
pp_postfix_expression (pp, TREE_OPERAND (e, 0));
pp_c_call_argument_list (pp, TREE_OPERAND (e, 1));
break;
case UNORDERED_EXPR:
pp_c_identifier (pp, flag_isoc99
? "isunordered"
: "__builtin_isunordered");
goto two_args_fun;
case ORDERED_EXPR:
pp_c_identifier (pp, flag_isoc99
? "!isunordered"
: "!__builtin_isunordered");
goto two_args_fun;
case UNLT_EXPR:
pp_c_identifier (pp, flag_isoc99
? "!isgreaterequal"
: "!__builtin_isgreaterequal");
goto two_args_fun;
case UNLE_EXPR:
pp_c_identifier (pp, flag_isoc99
? "!isgreater"
: "!__builtin_isgreater");
goto two_args_fun;
case UNGT_EXPR:
pp_c_identifier (pp, flag_isoc99
? "!islessequal"
: "!__builtin_islessequal");
goto two_args_fun;
case UNGE_EXPR:
pp_c_identifier (pp, flag_isoc99
? "!isless"
: "!__builtin_isless");
goto two_args_fun;
case UNEQ_EXPR:
pp_c_identifier (pp, flag_isoc99
? "!islessgreater"
: "!__builtin_islessgreater");
goto two_args_fun;
case LTGT_EXPR:
pp_c_identifier (pp, flag_isoc99
? "islessgreater"
: "__builtin_islessgreater");
goto two_args_fun;
two_args_fun:
pp_c_left_paren (pp);
pp_expression (pp, TREE_OPERAND (e, 0));
pp_separate_with (pp, ',');
pp_expression (pp, TREE_OPERAND (e, 1));
pp_c_right_paren (pp);
break;
case ABS_EXPR:
pp_c_identifier (pp, "__builtin_abs");
pp_c_left_paren (pp);
pp_expression (pp, TREE_OPERAND (e, 0));
pp_c_right_paren (pp);
break;
case COMPONENT_REF:
{
tree object = TREE_OPERAND (e, 0);
if (TREE_CODE (object) == INDIRECT_REF)
{
pp_postfix_expression (pp, TREE_OPERAND (object, 0));
pp_c_arrow (pp);
}
else
{
pp_postfix_expression (pp, object);
pp_c_dot (pp);
}
pp_expression (pp, TREE_OPERAND (e, 1));
}
break;
case COMPLEX_CST:
case VECTOR_CST:
case COMPLEX_EXPR:
pp_c_compound_literal (pp, e);
break;
case COMPOUND_LITERAL_EXPR:
e = DECL_INITIAL (COMPOUND_LITERAL_EXPR_DECL (e));
/* Fall through. */
case CONSTRUCTOR:
pp_initializer (pp, e);
break;
case VA_ARG_EXPR:
pp_c_identifier (pp, "__builtin_va_arg");
pp_c_left_paren (pp);
pp_assignment_expression (pp, TREE_OPERAND (e, 0));
pp_separate_with (pp, ',');
pp_type_id (pp, TREE_TYPE (e));
pp_c_right_paren (pp);
break;
case ADDR_EXPR:
if (TREE_CODE (TREE_OPERAND (e, 0)) == FUNCTION_DECL)
{
pp_c_id_expression (pp, TREE_OPERAND (e, 0));
break;
}
/* else fall through. */
default:
pp_primary_expression (pp, e);
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);
}
/* Called during diagnostic message formatting process to print a
source-level entity onto BUFFER. The meaning of the format specifiers
is as follows:
%D: a general decl,
%E: an identifier or expression,
%F: a function declaration,
%T: a type.
These format specifiers form a subset of the format specifiers set used
by the C++ front-end.
Please notice when called, the `%' part was already skipped by the
diagnostic machinery. */
static bool
c_tree_printer (pretty_printer *pp, text_info *text, const char *spec,
int precision, bool wide, bool set_locus, bool hash)
{
tree t = va_arg (*text->args_ptr, tree);
tree name;
c_pretty_printer *cpp = (c_pretty_printer *) pp;
pp->padding = pp_none;
if (precision != 0 || wide || hash)
return false;
if (set_locus && text->locus)
*text->locus = DECL_SOURCE_LOCATION (t);
switch (*spec)
{
case 'D':
if (DECL_DEBUG_EXPR_IS_FROM (t) && DECL_DEBUG_EXPR (t))
{
t = DECL_DEBUG_EXPR (t);
if (!DECL_P (t))
{
pp_c_expression (cpp, t);
return true;
}
}
/* FALLTHRU */
case 'F':
if (DECL_NAME (t))
{
pp_identifier (cpp, lang_hooks.decl_printable_name (t, 2));
return true;
}
break;
case 'T':
gcc_assert (TYPE_P (t));
name = TYPE_NAME (t);
if (name && TREE_CODE (name) == TYPE_DECL)
{
if (DECL_NAME (name))
pp_identifier (cpp, lang_hooks.decl_printable_name (name, 2));
else
pp_type_id (cpp, t);
return true;
}
else
{
pp_type_id (cpp, t);
return true;
}
break;
case 'E':
if (TREE_CODE (t) == IDENTIFIER_NODE)
pp_identifier (cpp, IDENTIFIER_POINTER (t));
else
pp_expression (cpp, t);
return true;
default:
return false;
}
pp_string (cpp, _("({anonymous})"));
return true;
}
