much easier o add extensions and nifty pretty-printing effects that
takes expresssion or declaration contexts into account. */
+
+#define pp_c_whitespace(PP) \
+ do { \
+ pp_space (PP); \
+ pp_base (PP)->padding = pp_none; \
+ } while (0)
+#define pp_c_maybe_whitespace(PP) \
+ do { \
+ if (pp_base (PP)->padding == pp_before) \
+ pp_c_whitespace (PP); \
+ } while (0)
+
+#define pp_c_left_paren(PP) \
+ do { \
+ pp_left_paren (PP); \
+ pp_base (PP)->padding = pp_none; \
+ } while (0)
+
+#define pp_c_right_paren(PP) \
+ do { \
+ pp_right_paren (PP); \
+ pp_base (PP)->padding = pp_none; \
+ } while (0)
+
+#define pp_c_left_brace(PP) \
+ do { \
+ pp_left_brace (PP); \
+ pp_base (PP)->padding = pp_none; \
+ } while (0)
+
+#define pp_c_right_brace(PP) \
+ do { \
+ pp_right_brace (PP); \
+ pp_base (PP)->padding = pp_none; \
+ } while (0)
+
+#define pp_c_left_bracket(PP) \
+ do { \
+ pp_left_bracket (PP); \
+ pp_base (PP)->padding = pp_none; \
+ } while (0)
+
+#define pp_c_right_bracket(PP) \
+ do { \
+ pp_right_bracket (PP); \
+ pp_base (PP)->padding = pp_none; \
+ } while (0)
+
+#define pp_c_arrow(PP) \
+ do { \
+ pp_arrow (PP); \
+ pp_base (PP)->padding = pp_none; \
+ } while (0)
+
+#define pp_c_star(PP) \
+ do { \
+ pp_star (PP); \
+ pp_base (PP)->padding = pp_none; \
+ } while (0)
+
+#define pp_c_dot(PP) \
+ do { \
+ pp_dot (PP); \
+ pp_base (PP)->padding = pp_none; \
+ } while (0)
+
+#define pp_c_semicolon(PP) \
+ do { \
+ pp_semicolon (PP); \
+ pp_base (PP)->padding = pp_none; \
+ } while (0)
+
/* literal */
static void pp_c_char (c_pretty_printer, int);
-static void pp_c_character_literal (c_pretty_printer, tree);
-static void pp_c_bool_literal (c_pretty_printer, tree);
-static bool pp_c_enumerator (c_pretty_printer, tree);
-
static void pp_c_primary_expression (c_pretty_printer, tree);
/* postfix-expression */
static void pp_c_initializer_list (c_pretty_printer, tree);
-static void pp_c_unary_expression (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);
/* declarations. */
static void pp_c_declaration_specifiers (c_pretty_printer, tree);
+static void pp_c_direct_abstract_declarator (c_pretty_printer, tree);
static void pp_c_init_declarator (c_pretty_printer, tree);
-static void pp_c_declarator (c_pretty_printer, tree);
-static void pp_c_direct_declarator (c_pretty_printer, tree);
-static void pp_c_abstract_declarator (c_pretty_printer, tree);
-static void pp_c_specifier_qualifier_list (c_pretty_printer, tree);
static void pp_c_simple_type_specifier (c_pretty_printer, tree);
static void pp_c_parameter_declaration (c_pretty_printer, tree);
-static void pp_c_type_id (c_pretty_printer, tree);
static void pp_c_storage_class_specifier (c_pretty_printer, tree);
static void pp_c_function_specifier (c_pretty_printer, tree);
\f
/* Declarations. */
-/* Print out CV-qualifiers. Take care of possible extensions.
- cv-qualifier:
- const
- volatile
- restrict
- __restrict__ */
+static void
+pp_c_cv_qualifier (c_pretty_printer pp, const char *cv)
+{
+ const char *p = pp_last_position_in_text (pp);
+ if (p != NULL && *p == '*')
+ pp_c_whitespace (pp);
+ pp_c_identifier (pp, cv);
+}
+
+/* C++ cv-qualifiers are called type-qualifiers in C. Print out the
+ cv-qualifiers of T. If T is a declaration then it is the cv-qualifier
+ of its type. Take care of possible extensions.
+ cv-qualifier:
+ const
+ volatile
+ restrict
+ __restrict__ */
void
-pp_c_cv_qualifier (c_pretty_printer ppi, int cv)
+pp_c_type_qualifier_list (c_pretty_printer pp, tree t)
{
- if (cv & TYPE_QUAL_CONST)
- pp_c_identifier (ppi, "const");
- if (cv & TYPE_QUAL_VOLATILE)
- pp_c_identifier (ppi, "volatile");
- if (cv & TYPE_QUAL_RESTRICT)
- pp_c_identifier (ppi, flag_isoc99 ? "restrict" : "__restrict__");
+ int qualifiers;
+
+ if (!TYPE_P (t))
+ t = TREE_TYPE (t);
+
+ qualifiers = TYPE_QUALS (t);
+ if (qualifiers & TYPE_QUAL_CONST)
+ pp_c_cv_qualifier (pp, "const");
+ if (qualifiers & TYPE_QUAL_VOLATILE)
+ pp_c_cv_qualifier (pp, "volatile");
+ if (qualifiers & TYPE_QUAL_RESTRICT)
+ pp_c_cv_qualifier (pp, flag_isoc99 ? "restrict" : "__restrict__");
+}
+
+/* pointer:
+ * type-qualifier-list(opt)
+ * type-qualifier-list(opt) pointer */
+static void
+pp_c_pointer (c_pretty_printer pp, tree t)
+{
+ if (!TYPE_P (t) && TREE_CODE (t) != TYPE_DECL)
+ t = TREE_TYPE (t);
+ switch (TREE_CODE (t))
+ {
+ case POINTER_TYPE:
+ if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE)
+ pp_c_pointer (pp, TREE_TYPE (t));
+ pp_c_star (pp);
+ pp_c_type_qualifier_list (pp, t);
+ break;
+
+ default:
+ pp_unsupported_tree (pp, t);
+ }
}
/*
static void
pp_c_simple_type_specifier (c_pretty_printer ppi, tree t)
{
- const enum tree_code code = TREE_CODE (t);
+ enum tree_code code;
+
+ if (DECL_P (t) && TREE_CODE (t) != TYPE_DECL)
+ t = TREE_TYPE (t);
+
+ code = TREE_CODE (t);
switch (code)
{
case ERROR_MARK:
case CHAR_TYPE:
case INTEGER_TYPE:
case REAL_TYPE:
- pp_c_tree_identifier (ppi, DECL_NAME (t));
+ pp_c_simple_type_specifier (ppi, TYPE_NAME (t));
break;
case COMPLEX_TYPE:
case TYPE_DECL:
if (DECL_NAME (t))
- pp_c_tree_identifier (ppi, DECL_NAME (t));
+ pp_id_expression (ppi, t);
else
pp_c_identifier (ppi, "<typedef-error>");
break;
pp_c_identifier (ppi, "<tag-error>");
if (TYPE_NAME (t))
- pp_c_tree_identifier (ppi, TYPE_NAME (t));
+ pp_id_expression (ppi, TYPE_NAME (t));
else
pp_c_identifier (ppi, "<anonymous>");
break;
+ case POINTER_TYPE:
+ case ARRAY_TYPE:
+ case FUNCTION_TYPE:
+ pp_c_simple_type_specifier (ppi, TREE_TYPE (t));
+ break;
+
default:
pp_unsupported_tree (ppi, t);
+ break;
}
}
/* specifier-qualifier-list:
type-specifier specifier-qualifier-list-opt
- cv-qualifier specifier-qualifier-list-opt */
-static inline void
-pp_c_specifier_qualifier_list (c_pretty_printer ppi, tree t)
+ cv-qualifier specifier-qualifier-list-opt
+
+
+ Implementation note: Because of the non-linearities in array or
+ function declarations, this routinie prints not just the
+ specifier-qualifier-list of such entities or types of such entities,
+ but also the 'pointer' production part of their declarators. The
+ remaining part is done by pp_declarator or pp_c_abstract_declarator. */
+void
+pp_c_specifier_qualifier_list (c_pretty_printer pp, tree t)
{
- pp_c_simple_type_specifier (ppi, TYPE_MAIN_VARIANT (TREE_TYPE (t)));
- pp_c_cv_qualifier (ppi, TYPE_QUALS (t));
+ if (TREE_CODE (t) != POINTER_TYPE)
+ pp_c_type_qualifier_list (pp, t);
+ switch (TREE_CODE (t))
+ {
+ case POINTER_TYPE:
+ {
+ /* Get the types-specifier of this type. */
+ tree pointee = TREE_TYPE (t);
+ while (TREE_CODE (pointee) == POINTER_TYPE)
+ pointee = TREE_TYPE (pointee);
+ pp_c_specifier_qualifier_list (pp, pointee);
+ if (TREE_CODE (pointee) == ARRAY_TYPE
+ || TREE_CODE (pointee) == FUNCTION_TYPE)
+ {
+ pp_c_whitespace (pp);
+ pp_c_left_paren (pp);
+ }
+ pp_c_pointer (pp, t);
+ if (TREE_CODE (pointee) != FUNCTION_TYPE
+ && TREE_CODE (pointee) != ARRAY_TYPE)
+ pp_c_whitespace (pp);
+ }
+ break;
+
+ case FUNCTION_TYPE:
+ case ARRAY_TYPE:
+ pp_c_specifier_qualifier_list (pp, TREE_TYPE (t));
+ break;
+
+ case VECTOR_TYPE:
+ case COMPLEX_TYPE:
+ pp_c_specifier_qualifier_list (pp, TREE_TYPE (t));
+ pp_space (pp);
+ pp_c_simple_type_specifier (pp, t);
+ break;
+
+ default:
+ pp_c_simple_type_specifier (pp, t);
+ break;
+ }
}
+/* parameter-type-list:
+ parameter-list
+ parameter-list , ...
+
+ parameter-list:
+ parameter-declaration
+ parameter-list , parameter-declaration
+
+ parameter-declaration:
+ declaration-specifiers declarator
+ declaration-specifiers abstract-declarator(opt) */
static void
-pp_c_abstract_declarator (c_pretty_printer ppi, tree t)
+pp_c_parameter_type_list (c_pretty_printer pp, tree t)
{
- pp_unsupported_tree (ppi, t);
+ pp_c_left_paren (pp);
+ if (t == void_list_node)
+ pp_c_identifier (pp, "void");
+ else
+ {
+ bool first = true;
+ bool want_parm_decl = t && DECL_P (t);
+ for ( ; t != NULL && t != void_list_node; t = TREE_CHAIN (t))
+ {
+ if (!first)
+ pp_separate_with (pp, ',');
+ first = false;
+ pp_declaration_specifiers (pp, want_parm_decl ? t : TREE_VALUE (t));
+ if (want_parm_decl)
+ pp_declarator (pp, t);
+ else
+ pp_abstract_declarator (pp, TREE_VALUE (t));
+ }
+ }
+ pp_c_right_paren (pp);
}
-
+/* abstract-declarator:
+ pointer
+ pointer(opt) direct-abstract-declarator */
static inline void
+pp_c_abstract_declarator (c_pretty_printer pp, tree t)
+{
+ if (TREE_CODE (t) == POINTER_TYPE)
+ {
+ if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
+ || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
+ pp_c_right_paren (pp);
+ t = TREE_TYPE (t);
+ }
+
+ pp_c_direct_abstract_declarator (pp, t);
+}
+
+/* direct-abstract-declarator:
+ ( abstract-declarator )
+ direct-abstract-declarator(opt) [ assignment-expression(opt) ]
+ direct-abstract-declarator(opt) [ * ]
+ direct-abstract-declarator(opt) ( parameter-type-list(opt) ) */
+static void
+pp_c_direct_abstract_declarator (c_pretty_printer pp, tree t)
+{
+ switch (TREE_CODE (t))
+ {
+ case POINTER_TYPE:
+ pp_c_abstract_declarator (pp, t);
+ break;
+
+ case FUNCTION_TYPE:
+ pp_c_parameter_type_list (pp, TYPE_ARG_TYPES (t));
+ pp_c_direct_abstract_declarator (pp, TREE_TYPE (t));
+ break;
+
+ case ARRAY_TYPE:
+ pp_c_left_bracket (pp);
+ if (TYPE_DOMAIN (t))
+ pp_c_expression (pp, TYPE_MAX_VALUE (TYPE_DOMAIN (t)));
+ pp_c_right_bracket (pp);
+ pp_c_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;
+ }
+}
+
+void
pp_c_type_id (c_pretty_printer ppi, tree t)
{
pp_c_specifier_qualifier_list (ppi, t);
- pp_c_abstract_declarator (ppi, t);
+ pp_abstract_declarator (ppi, t);
}
static inline void
{
if (TREE_CODE (t) == TYPE_DECL)
pp_c_identifier (pp, "typedef");
- else if (DECL_REGISTER (t))
- pp_c_identifier (pp, "register");
+ else if (DECL_P (t))
+ {
+ if (DECL_REGISTER (t))
+ pp_c_identifier (pp, "register");
+ else if (TREE_STATIC (t) && TREE_CODE (t) == VAR_DECL)
+ pp_c_identifier (pp, "static");
+ }
}
static inline void
pp_c_identifier (pp, "inline");
}
+/* declaration-specifiers:
+ storage-class-specifier declaration-specifiers(opt)
+ type-specifier declaration-specifiers(opt)
+ type-qualifier declaration-specifiers(opt)
+ function-specifier declaration-specifiers(opt) */
static inline void
pp_c_declaration_specifiers (c_pretty_printer pp, tree t)
{
- pp_c_storage_class_specifier (pp, t);
- pp_c_function_specifier (pp, t);
- pp_type_specifier (pp, TYPE_MAIN_VARIANT (TREE_TYPE (t)));
- pp_c_cv_qualifier (pp, TYPE_QUALS (TREE_TYPE (t)));
+ pp_storage_class_specifier (pp, t);
+ pp_function_specifier (pp, t);
+ pp_c_specifier_qualifier_list (pp, DECL_P (t) ? TREE_TYPE (t) : t);
}
-static inline void
+/* direct-declarator
+ identifier
+ ( declarator )
+ direct-declarator [ type-qualifier-list(opt) assignment-expression(opt) ]
+ direct-declarator [ static type-qualifier-list(opt) assignment-expression(opt)]
+ direct-declarator [ type-qualifier-list static assignment-exression ]
+ direct-declarator [ type-qualifier-list * ]
+ direct-declaratpr ( parameter-type-list )
+ direct-declarator ( identifier-list(opt) ) */
+void
pp_c_direct_declarator (c_pretty_printer pp, tree t)
{
- pp_unsupported_tree (pp, t);
+ switch (TREE_CODE (t))
+ {
+ case VAR_DECL:
+ case PARM_DECL:
+ case TYPE_DECL:
+ case FIELD_DECL:
+ case LABEL_DECL:
+ pp_c_tree_identifier (pp, DECL_NAME (t));
+ case ARRAY_TYPE:
+ case POINTER_TYPE:
+ pp_abstract_declarator (pp, TREE_TYPE (t));
+ break;
+
+ case FUNCTION_TYPE:
+ pp_c_parameter_type_list (pp, TYPE_ARG_TYPES (t));
+ pp_c_abstract_declarator (pp, TREE_TYPE (t));
+ break;
+
+ case FUNCTION_DECL:
+ pp_c_tree_identifier (pp, DECL_NAME (t));
+ if (pp_c_base (pp)->flags & pp_c_flag_abstract)
+ pp_c_abstract_declarator (pp, TREE_TYPE (t));
+ else
+ {
+ pp_c_parameter_type_list (pp, DECL_ARGUMENTS (t));
+ pp_c_abstract_declarator (pp, TREE_TYPE (TREE_TYPE (t)));
+ }
+ break;
+
+ case INTEGER_TYPE:
+ case REAL_TYPE:
+ case ENUMERAL_TYPE:
+ case UNION_TYPE:
+ case RECORD_TYPE:
+ break;
+
+ default:
+ pp_unsupported_tree (pp, t);
+ break;
+ }
}
-static inline void
+
+/* declarator:
+ pointer(opt) direct-declarator */
+void
pp_c_declarator (c_pretty_printer pp, tree t)
{
- pp_unsupported_tree (pp, t);
+ switch (TREE_CODE (t))
+ {
+ case INTEGER_TYPE:
+ case REAL_TYPE:
+ case ENUMERAL_TYPE:
+ case UNION_TYPE:
+ case RECORD_TYPE:
+ break;
+
+ case VAR_DECL:
+ case PARM_DECL:
+ case FIELD_DECL:
+ case ARRAY_TYPE:
+ case FUNCTION_TYPE:
+ case FUNCTION_DECL:
+ case TYPE_DECL:
+ pp_direct_declarator (pp, t);
+ break;
+
+
+ default:
+ pp_unsupported_tree (pp, t);
+ break;
+ }
}
+/* init-declarator:
+ declarator:
+ declarator = initializer */
static inline void
pp_c_init_declarator (c_pretty_printer pp, tree t)
{
}
}
+/* declaration:
+ declaration-specifiers init-declarator-list(opt) ; */
+
void
pp_c_declaration (c_pretty_printer pp, tree t)
{
pp_c_right_paren (pp);
}
+/* function-definition:
+ declaration-specifiers declarator compound-statement */
+void
+pp_c_function_definition (c_pretty_printer pp, tree t)
+{
+ pp_declaration_specifiers (pp, t);
+ pp_declarator (pp, t);
+ pp_needs_newline (pp) = true;
+ pp_statement (pp, DECL_SAVED_TREE (t));
+ pp_newline (pp);
+ pp_flush (pp);
+}
+
\f
/* Expressions. */
pp_doublequote (ppi);
}
+static void
+pp_c_integer_constant (c_pretty_printer pp, tree i)
+{
+ if (host_integerp (i, 0))
+ pp_wide_integer (pp, TREE_INT_CST_LOW (i));
+ else
+ {
+ if (tree_int_cst_sgn (i) < 0)
+ {
+ pp_c_char (pp, '-');
+ i = build_int_2 (-TREE_INT_CST_LOW (i),
+ ~TREE_INT_CST_HIGH (i) + !TREE_INT_CST_LOW (i));
+ }
+ sprintf (pp_buffer (pp)->digit_buffer,
+ HOST_WIDE_INT_PRINT_DOUBLE_HEX,
+ TREE_INT_CST_HIGH (i), TREE_INT_CST_LOW (i));
+ pp_string (pp, pp_buffer (pp)->digit_buffer);
+ }
+}
+
/* Print out a CHARACTER literal. */
static inline void
-pp_c_character_literal (c_pretty_printer ppi, tree c)
+pp_c_character_constant (c_pretty_printer pp, tree c)
{
tree type = TREE_TYPE (c);
- pp_quote (ppi);
+ if (type == wchar_type_node)
+ pp_character (pp, 'L');
+ pp_quote (pp);
if (host_integerp (c, TREE_UNSIGNED (type)))
- pp_c_char (ppi, tree_low_cst (c, TREE_UNSIGNED (type)));
+ pp_c_char (pp, tree_low_cst (c, TREE_UNSIGNED (type)));
else
- pp_scalar (ppi, "\\x%x", (unsigned) TREE_INT_CST_LOW (c));
- pp_quote (ppi);
+ pp_scalar (pp, "\\x%x", (unsigned) TREE_INT_CST_LOW (c));
+ pp_quote (pp);
}
/* Print out a BOOLEAN literal. */
-void
-pp_c_bool_literal (c_pretty_printer ppi, tree b)
+static void
+pp_c_bool_constant (c_pretty_printer pp, tree b)
{
- if (b == boolean_false_node || integer_zerop (b))
+ if (b == boolean_false_node)
{
if (c_dialect_cxx ())
- pp_c_identifier (ppi, "false");
+ pp_c_identifier (pp, "false");
else if (flag_isoc99)
- pp_c_identifier (ppi, "_False");
+ pp_c_identifier (pp, "_False");
else
- pp_unsupported_tree (ppi, b);
+ pp_unsupported_tree (pp, b);
}
else if (b == boolean_true_node)
{
if (c_dialect_cxx ())
- pp_c_identifier (ppi, "true");
+ pp_c_identifier (pp, "true");
else if (flag_isoc99)
- pp_c_identifier (ppi, "_True");
+ pp_c_identifier (pp, "_True");
else
- pp_unsupported_tree (ppi, b);
+ pp_unsupported_tree (pp, b);
}
+ else if (TREE_CODE (b) == INTEGER_CST)
+ pp_c_integer_constant (pp, b);
else
- pp_unsupported_tree (ppi, b);
+ pp_unsupported_tree (pp, b);
}
/* Attempt to print out an ENUMERATOR. Return true on success. Else return
print out the type-id part of the cast-expression -- the casted value
is then printed by pp_c_integer_literal. */
static bool
-pp_c_enumerator (c_pretty_printer ppi, tree e)
+pp_c_enumeration_constant (c_pretty_printer ppi, tree e)
{
+ bool value_is_named = true;
tree type = TREE_TYPE (e);
tree value;
;
if (value != NULL_TREE)
- pp_c_tree_identifier (ppi, TREE_PURPOSE (value));
+ pp_id_expression (ppi, TREE_PURPOSE (value));
else
{
/* Value must have been cast. */
pp_c_left_paren (ppi);
pp_type_id (ppi, type);
pp_c_right_paren (ppi);
- return false;
+ value_is_named = false;
}
- return true;
-}
-
-/* Print out an INTEGER constant value. */
-void
-pp_c_integer_literal (c_pretty_printer ppi, tree i)
-{
- tree type = TREE_TYPE (i);
-
- if (type == boolean_type_node)
- pp_c_bool_literal (ppi, i);
- else if (type == char_type_node)
- pp_c_character_literal (ppi, i);
- else if (TREE_CODE (type) == ENUMERAL_TYPE
- && pp_c_enumerator (ppi, i))
- ;
- else
- {
- if (host_integerp (i, 0))
- pp_wide_integer (ppi, TREE_INT_CST_LOW (i));
- else
- {
- if (tree_int_cst_sgn (i) < 0)
- {
- pp_c_char (ppi, '-');
- i = build_int_2 (-TREE_INT_CST_LOW (i),
- ~TREE_INT_CST_HIGH (i) + !TREE_INT_CST_LOW (i));
- sprintf (pp_buffer (ppi)->digit_buffer,
- HOST_WIDE_INT_PRINT_DOUBLE_HEX,
- TREE_INT_CST_HIGH (i), TREE_INT_CST_LOW (i));
- pp_string (ppi, pp_buffer (ppi)->digit_buffer);
- }
- }
- }
+ return value_is_named;
}
/* Print out a REAL value. */
-void
-pp_c_real_literal (c_pretty_printer ppi, tree r)
+static inline void
+pp_c_floating_constant (c_pretty_printer pp, tree r)
{
- real_to_decimal (pp_buffer (ppi)->digit_buffer, &TREE_REAL_CST (r),
- sizeof (pp_buffer (ppi)->digit_buffer), 0, 1);
- pp_string (ppi, pp_buffer(ppi)->digit_buffer);
+ real_to_decimal (pp_buffer (pp)->digit_buffer, &TREE_REAL_CST (r),
+ sizeof (pp_buffer (pp)->digit_buffer), 0, 1);
+ pp_string (pp, pp_buffer(pp)->digit_buffer);
}
-
+/* constant:
+ integer-constant
+ floating-constant
+ enumeration-constant
+ chatracter-constant */
void
-pp_c_literal (c_pretty_printer ppi, tree e)
+pp_c_constant (c_pretty_printer pp, tree e)
{
switch (TREE_CODE (e))
{
case INTEGER_CST:
- pp_c_integer_literal (ppi, e);
+ {
+ tree type = TREE_TYPE (e);
+ if (type == boolean_type_node)
+ pp_c_bool_constant (pp, e);
+ else if (type == char_type_node)
+ pp_c_character_constant (pp, e);
+ else if (TREE_CODE (type) == ENUMERAL_TYPE
+ && pp_c_enumeration_constant (pp, e))
+ ;
+ else
+ pp_c_integer_constant (pp, e);
+ }
break;
case REAL_CST:
- pp_c_real_literal (ppi, e);
+ pp_c_floating_constant (pp, e);
break;
case STRING_CST:
- pp_c_string_literal (ppi, e);
+ pp_c_string_literal (pp, e);
break;
default:
- pp_unsupported_tree (ppi, e);
+ pp_unsupported_tree (pp, e);
break;
}
}
-/* Pretty-print a C primary-expression. */
+void
+pp_c_identifier (c_pretty_printer pp, const char *id)
+{
+ pp_c_maybe_whitespace (pp);
+ pp_identifier (pp, id);
+ pp_base (pp)->padding = pp_before;
+}
+
+/* Pretty-print a C primary-expression.
+ primary-expression:
+ identifier
+ constant
+ string-literal
+ ( expression ) */
static void
pp_c_primary_expression (c_pretty_printer ppi, tree e)
{
case INTEGER_CST:
case REAL_CST:
case STRING_CST:
- pp_c_literal (ppi, e);
+ pp_c_constant (ppi, e);
break;
case TARGET_EXPR:
pp_c_identifier (ppi, "__builtin_memcpy");
pp_c_left_paren (ppi);
pp_ampersand (ppi);
- pp_c_primary_expression (ppi, TREE_OPERAND (e, 0));
+ pp_primary_expression (ppi, TREE_OPERAND (e, 0));
pp_separate_with (ppi, ',');
pp_ampersand (ppi);
pp_initializer (ppi, TREE_OPERAND (e, 1));
break;
default:
- /* Make sure this call won't cause any infinite loop. */
+ /* FIXME: Make sure we won't get into an infinie loop. */
pp_c_left_paren (ppi);
pp_c_expression (ppi, e);
pp_c_right_paren (ppi);
}
}
-/* Print out a C initializer -- also support C compound-literals. */
+/* Print out a C initializer -- also support C compound-literals.
+ initializer:
+ assignment-expression:
+ { initializer-list }
+ { initializer-list , } */
+
void
pp_c_initializer (c_pretty_printer ppi, tree e)
{
enum tree_code code = TREE_CODE (TREE_TYPE (e));
if (code == RECORD_TYPE || code == UNION_TYPE || code == ARRAY_TYPE)
{
- pp_left_brace (ppi);
+ pp_c_left_brace (ppi);
pp_c_initializer_list (ppi, e);
- pp_right_brace (ppi);
+ pp_c_right_brace (ppi);
}
else
pp_unsupported_tree (ppi, TREE_OPERAND (e, 1));
pp_assignment_expression (ppi, e);
}
+/* initializer-list:
+ designation(opt) initializer
+ initializer-list , designation(opt) initializer
+
+ designation:
+ designator-list =
+
+ designator-list:
+ designator
+ designator-list designator
+
+ designator:
+ [ constant-expression ]
+ identifier */
static void
pp_c_initializer_list (c_pretty_printer ppi, tree e)
{
if (code == RECORD_TYPE || code == UNION_TYPE || code == ARRAY_TYPE)
{
- tree init = TREE_OPERAND (e, 1);
+ tree init = TREE_OPERAND (e, 0);
for (; init != NULL_TREE; init = TREE_CHAIN (init))
{
if (code == RECORD_TYPE || code == UNION_TYPE)
{
- pp_dot (ppi);
+ pp_c_dot (ppi);
pp_c_primary_expression (ppi, TREE_PURPOSE (init));
}
else
{
pp_c_left_bracket (ppi);
if (TREE_PURPOSE (init))
- pp_c_literal (ppi, TREE_PURPOSE (init));
+ pp_c_constant (ppi, TREE_PURPOSE (init));
pp_c_right_bracket (ppi);
}
pp_c_whitespace (ppi);
pp_unsupported_tree (ppi, type);
}
+/* This is a convenient function, used to bridge gap between C and C++
+ grammars.
+
+ id-expression:
+ identifier */
+void
+pp_c_id_expression (c_pretty_printer pp, tree t)
+{
+ switch (TREE_CODE (t))
+ {
+ case VAR_DECL:
+ case PARM_DECL:
+ case CONST_DECL:
+ case TYPE_DECL:
+ case FUNCTION_DECL:
+ case FIELD_DECL:
+ case LABEL_DECL:
+ t = DECL_NAME (t);
+ case IDENTIFIER_NODE:
+ pp_c_tree_identifier (pp, t);
+ break;
+
+ default:
+ pp_unsupported_tree (pp, t);
+ break;
+ }
+}
+
+/* postfix-expression:
+ primary-expression
+ postfix-expression [ expression ]
+ postfix-expression ( argument-expression-list(opt) )
+ postfix-expression . identifier
+ postfix-expression -> identifier
+ postfix-expression ++
+ postfix-expression --
+ ( type-name ) { initializer-list }
+ ( type-name ) { initializer-list , } */
void
pp_c_postfix_expression (c_pretty_printer ppi, tree e)
{
case ARROW_EXPR:
pp_postfix_expression (ppi, TREE_OPERAND (e, 0));
- pp_arrow (ppi);
+ pp_c_arrow (ppi);
break;
case ARRAY_REF:
if (TREE_CODE (object) == INDIRECT_REF)
{
pp_postfix_expression (ppi, TREE_OPERAND (object, 0));
- pp_arrow (ppi);
+ pp_c_arrow (ppi);
}
else
{
pp_postfix_expression (ppi, object);
- pp_dot (ppi);
+ pp_c_dot (ppi);
}
pp_c_expression (ppi, TREE_OPERAND (e, 1));
}
pp_c_left_paren (ppi);
pp_type_id (ppi, TREE_TYPE (e));
pp_c_right_paren (ppi);
- pp_left_brace (ppi);
+ pp_c_left_brace (ppi);
if (code == COMPLEX_CST)
{
pp_c_expression (ppi, TREE_OPERAND (e, 1));
}
- pp_right_brace (ppi);
+ pp_c_right_brace (ppi);
break;
case COMPOUND_LITERAL_EXPR:
pp_c_right_paren (ppi);
break;
+ case ADDR_EXPR:
+ if (TREE_CODE (TREE_OPERAND (e, 0)) == FUNCTION_DECL)
+ {
+ pp_c_id_expression (ppi, TREE_OPERAND (e, 0));
+ break;
+ }
+ /* else fall through. */
+
default:
pp_primary_expression (ppi, e);
break;
__alignof__ ( type-id )
__real__ unary-expression
__imag__ unary-expression */
-static void
+void
pp_c_unary_expression (c_pretty_printer ppi, tree e)
{
enum tree_code code = TREE_CODE (e);
case BIT_NOT_EXPR:
case TRUTH_NOT_EXPR:
case CONJ_EXPR:
- if (code == ADDR_EXPR)
+ /* String literal are used by address. */
+ if (code == ADDR_EXPR && TREE_CODE (TREE_OPERAND (e, 0)) != STRING_CST)
pp_ampersand (ppi);
else if (code == INDIRECT_REF)
- pp_star (ppi);
+ pp_c_star (ppi);
else if (code == NEGATE_EXPR)
pp_minus (ppi);
else if (code == BIT_NOT_EXPR || code == CONJ_EXPR)
pp_c_right_paren (ppi);
}
else
- pp_c_unary_expression (ppi, TREE_OPERAND (e, 0));
+ pp_unary_expression (ppi, TREE_OPERAND (e, 0));
break;
case REALPART_EXPR:
void
pp_c_cast_expression (c_pretty_printer ppi, tree e)
{
- if (TREE_CODE (e) == CONVERT_EXPR || TREE_CODE (e) == FLOAT_EXPR)
+ switch (TREE_CODE (e))
{
+ case FLOAT_EXPR:
+ case FIX_TRUNC_EXPR:
+ case CONVERT_EXPR:
pp_c_left_paren (ppi);
pp_type_id (ppi, TREE_TYPE (e));
pp_c_right_paren (ppi);
pp_c_cast_expression (ppi, TREE_OPERAND (e, 0));
+ break;
+
+ default:
+ pp_unary_expression (ppi, e);
}
- else
- pp_unary_expression (ppi, e);
}
static void
case MULT_EXPR:
case TRUNC_DIV_EXPR:
case TRUNC_MOD_EXPR:
- pp_c_multiplicative_expression (ppi, TREE_OPERAND (e, 0));
+ pp_multiplicative_expression (ppi, TREE_OPERAND (e, 0));
pp_c_whitespace (ppi);
if (code == MULT_EXPR)
- pp_star (ppi);
+ pp_c_star (ppi);
else if (code == TRUNC_DIV_EXPR)
pp_slash (ppi);
else
else
pp_minus (ppi);
pp_c_whitespace (ppi);
- pp_multiplicative_expression (ppi, TREE_OPERAND (e, 1));
+ pp_multiplicative_expression (ppi, TREE_OPERAND (e, 1));
break;
default:
case EQ_EXPR:
case NE_EXPR:
pp_c_equality_expression (ppi, TREE_OPERAND (e, 0));
- pp_c_maybe_whitespace (ppi);
+ pp_c_whitespace (ppi);
pp_identifier (ppi, code == EQ_EXPR ? "==" : "!=");
pp_c_whitespace (ppi);
pp_c_relational_expression (ppi, TREE_OPERAND (e, 1));
if (TREE_CODE (e) == BIT_AND_EXPR)
{
pp_c_and_expression (ppi, TREE_OPERAND (e, 0));
- pp_c_maybe_whitespace (ppi);
+ pp_c_whitespace (ppi);
pp_ampersand (ppi);
pp_c_whitespace (ppi);
pp_c_equality_expression (ppi, TREE_OPERAND (e, 1));
if (TREE_CODE (e) == BIT_IOR_EXPR)
{
pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 0));
- pp_c_maybe_whitespace (ppi);
+ pp_c_whitespace (ppi);
pp_bar (ppi);
pp_c_whitespace (ppi);
pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 1));
if (TREE_CODE (e) == TRUTH_ANDIF_EXPR)
{
pp_c_logical_and_expression (ppi, TREE_OPERAND (e, 0));
- pp_c_maybe_whitespace (ppi);
+ pp_c_whitespace (ppi);
pp_identifier (ppi, "&&");
pp_c_whitespace (ppi);
pp_c_inclusive_or_expression (ppi, TREE_OPERAND (e, 1));
if (TREE_CODE (e) == TRUTH_ORIF_EXPR)
{
pp_c_logical_or_expression (ppi, TREE_OPERAND (e, 0));
- pp_c_maybe_whitespace (ppi);
+ pp_c_whitespace (ppi);
pp_identifier (ppi, "||");
pp_c_whitespace (ppi);
pp_c_logical_and_expression (ppi, TREE_OPERAND (e, 1));
if (TREE_CODE (e) == COND_EXPR)
{
pp_c_logical_or_expression (ppi, TREE_OPERAND (e, 0));
- pp_c_maybe_whitespace (ppi);
+ pp_c_whitespace (ppi);
pp_question (ppi);
pp_c_whitespace (ppi);
pp_c_expression (ppi, TREE_OPERAND (e, 1));
switch (TREE_CODE (e))
{
case INTEGER_CST:
- pp_c_integer_literal (ppi, e);
+ pp_c_integer_constant (ppi, e);
break;
case REAL_CST:
- pp_c_real_literal (ppi, e);
+ pp_c_floating_constant (ppi, e);
break;
case STRING_CST:
case ERROR_MARK:
case TARGET_EXPR:
case STMT_EXPR:
- pp_c_primary_expression (ppi, e);
+ pp_primary_expression (ppi, e);
break;
case POSTINCREMENT_EXPR:
case COMPOUND_LITERAL_EXPR:
case COMPLEX_EXPR:
case VA_ARG_EXPR:
- pp_c_postfix_expression (ppi, e);
+ pp_postfix_expression (ppi, e);
break;
case CONJ_EXPR:
pp_c_unary_expression (ppi, e);
break;
- case CONVERT_EXPR:
case FLOAT_EXPR:
+ case FIX_TRUNC_EXPR:
+ case CONVERT_EXPR:
pp_c_cast_expression (ppi, e);
break;
case MULT_EXPR:
case TRUNC_MOD_EXPR:
case TRUNC_DIV_EXPR:
- pp_c_multiplicative_expression (ppi, e);
+ pp_multiplicative_expression (ppi, e);
break;
case LSHIFT_EXPR:
pp_c_logical_or_expression (ppi, e);
break;
+ case EQ_EXPR:
+ case NE_EXPR:
+ pp_c_equality_expression (ppi, e);
+ break;
+
case COND_EXPR:
- pp_c_conditional_expression (ppi, e);
+ pp_conditional_expression (ppi, e);
break;
- case MODIFY_EXPR:
- case INIT_EXPR:
- pp_c_assignment_expression (ppi, e);
+ case PLUS_EXPR:
+ case MINUS_EXPR:
+ pp_c_additive_expression (ppi, e);
break;
- case NOP_EXPR:
- pp_c_expression (ppi, TREE_OPERAND (e, 0));
+ case MODIFY_EXPR:
+ case INIT_EXPR:
+ pp_assignment_expression (ppi, e);
break;
case COMPOUND_EXPR:
pp_c_right_paren (ppi);
break;
-
+ case NOP_EXPR:
+ case NON_LVALUE_EXPR:
+ case SAVE_EXPR:
+ case UNSAVE_EXPR:
+ pp_c_expression (ppi, TREE_OPERAND (e, 0));
+ break;
+
default:
pp_unsupported_tree (ppi, e);
break;
}
}
+
\f
/* Statements. */
void
pp_c_statement (c_pretty_printer ppi, tree stmt)
{
- const enum tree_code code = TREE_CODE (stmt);
+ enum tree_code code;
+
+ if (stmt == NULL)
+ return;
+
+ code = TREE_CODE (stmt);
switch (code)
{
case LABEL_STMT:
case CASE_LABEL:
- pp_newline (ppi);
+ if (pp_needs_newline (ppi))
+ pp_newline_and_indent (ppi, -3);
+ else
+ pp_indentation (ppi) -= 3;
if (code == LABEL_STMT)
pp_tree_identifier (ppi, DECL_NAME (LABEL_STMT_LABEL (stmt)));
- else if (code == LABEL_STMT)
+ else if (code == CASE_LABEL)
{
if (CASE_LOW (stmt) == NULL_TREE)
pp_identifier (ppi, "default");
}
}
pp_colon (ppi);
- pp_newline_and_indent (ppi, 3);
+ pp_indentation (ppi) += 3;
+ pp_needs_newline (ppi) = true;
break;
case COMPOUND_STMT:
- pp_left_brace (ppi);
+ if (pp_needs_newline (ppi))
+ pp_newline_and_indent (ppi, 0);
+ pp_c_left_brace (ppi);
pp_newline_and_indent (ppi, 3);
for (stmt = COMPOUND_BODY (stmt); stmt; stmt = TREE_CHAIN (stmt))
pp_c_statement (ppi, stmt);
pp_newline_and_indent (ppi, -3);
- pp_right_brace (ppi);
- pp_newline (ppi);
+ pp_c_right_brace (ppi);
+ pp_needs_newline (ppi) = true;
break;
case EXPR_STMT:
case CLEANUP_STMT:
- pp_newline (ppi);
- pp_c_expression (ppi, code == EXPR_STMT
- ? EXPR_STMT_EXPR (stmt)
- : CLEANUP_EXPR (stmt));
- pp_semicolon (ppi);
- pp_newline (ppi);
+ if (pp_needs_newline (ppi))
+ pp_newline_and_indent (ppi, 0);
+ {
+ tree e = code == EXPR_STMT
+ ? EXPR_STMT_EXPR (stmt)
+ : CLEANUP_EXPR (stmt);
+ if (e)
+ pp_c_expression (ppi, e);
+ }
+ pp_c_semicolon (ppi);
+ pp_needs_newline (ppi) = true;
break;
case IF_STMT:
+ if (pp_needs_newline (ppi))
+ pp_newline_and_indent (ppi, 0);
pp_c_identifier (ppi, "if");
- pp_space (ppi);
+ pp_c_whitespace (ppi);
pp_c_left_paren (ppi);
pp_c_expression (ppi, IF_COND (stmt));
- pp_right_paren (ppi);
+ pp_c_right_paren (ppi);
pp_newline_and_indent (ppi, 3);
pp_statement (ppi, THEN_CLAUSE (stmt));
pp_newline_and_indent (ppi, -3);
break;
case SWITCH_STMT:
- pp_newline (ppi);
+ if (pp_needs_newline (ppi))
+ pp_newline_and_indent (ppi, 0);
pp_c_identifier (ppi, "switch");
pp_space (ppi);
pp_c_left_paren (ppi);
pp_c_expression (ppi, SWITCH_COND (stmt));
- pp_right_paren (ppi);
- pp_newline_and_indent (ppi, 3);
+ pp_c_right_paren (ppi);
+ pp_indentation (ppi) += 3;
+ pp_needs_newline (ppi) = true;
pp_statement (ppi, SWITCH_BODY (stmt));
pp_newline_and_indent (ppi, -3);
break;
case WHILE_STMT:
+ if (pp_needs_newline (ppi))
+ pp_newline_and_indent (ppi, 0);
pp_c_identifier (ppi, "while");
pp_space (ppi);
pp_c_left_paren (ppi);
pp_c_expression (ppi, WHILE_COND (stmt));
- pp_right_paren (ppi);
+ pp_c_right_paren (ppi);
pp_newline_and_indent (ppi, 3);
pp_statement (ppi, WHILE_BODY (stmt));
- pp_newline_and_indent (ppi, -3);
+ pp_indentation (ppi) -= 3;
+ pp_needs_newline (ppi) = true;
break;
case DO_STMT:
+ if (pp_needs_newline (ppi))
+ pp_newline_and_indent (ppi, 0);
pp_c_identifier (ppi, "do");
pp_newline_and_indent (ppi, 3);
pp_statement (ppi, DO_BODY (stmt));
pp_c_left_paren (ppi);
pp_c_expression (ppi, DO_COND (stmt));
pp_c_right_paren (ppi);
- pp_semicolon (ppi);
- pp_newline (ppi);
+ pp_c_semicolon (ppi);
+ pp_needs_newline (ppi) = true;
break;
case FOR_STMT:
+ if (pp_needs_newline (ppi))
+ pp_newline_and_indent (ppi, 0);
pp_c_identifier (ppi, "for");
pp_space (ppi);
pp_c_left_paren (ppi);
- pp_statement (ppi, FOR_INIT_STMT (stmt));
+ if (FOR_INIT_STMT (stmt))
+ pp_statement (ppi, FOR_INIT_STMT (stmt));
+ else
+ pp_c_semicolon (ppi);
+ pp_needs_newline (ppi) = false;
pp_c_whitespace (ppi);
if (FOR_COND (stmt))
pp_c_expression (ppi, FOR_COND (stmt));
- pp_semicolon (ppi);
+ pp_c_semicolon (ppi);
+ pp_needs_newline (ppi) = false;
pp_c_whitespace (ppi);
if (FOR_EXPR (stmt))
pp_c_expression (ppi, FOR_EXPR (stmt));
- pp_right_paren (ppi);
+ pp_c_right_paren (ppi);
pp_newline_and_indent (ppi, 3);
pp_statement (ppi, FOR_BODY (stmt));
- pp_newline_and_indent (ppi, -3);
+ pp_indentation (ppi) -= 3;
+ pp_needs_newline (ppi) = true;
break;
case BREAK_STMT:
case CONTINUE_STMT:
- pp_newline (ppi);
+ if (pp_needs_newline (ppi))
+ pp_newline_and_indent (ppi, 0);
pp_identifier (ppi, code == BREAK_STMT ? "break" : "continue");
- pp_semicolon (ppi);
- pp_newline (ppi);
+ pp_c_semicolon (ppi);
+ pp_needs_newline (ppi) = true;
break;
case RETURN_STMT:
tree e = code == RETURN_STMT
? RETURN_STMT_EXPR (stmt)
: GOTO_DESTINATION (stmt);
-
- pp_newline (ppi);
+ if (pp_needs_newline (ppi))
+ pp_newline_and_indent (ppi, 0);
pp_c_identifier (ppi, code == RETURN_STMT ? "return" : "goto");
if (e)
pp_c_expression (ppi, e);
- pp_semicolon (ppi);
- pp_newline (ppi);
+ pp_c_semicolon (ppi);
+ pp_needs_newline (ppi) = true;
}
break;
case SCOPE_STMT:
if (!SCOPE_NULLIFIED_P (stmt) && SCOPE_NO_CLEANUPS_P (stmt))
- {
- if (SCOPE_BEGIN_P (stmt))
- {
- pp_left_brace (ppi);
- pp_newline_and_indent (ppi, 3);
- }
- else if (SCOPE_END_P (stmt))
- {
- pp_right_brace (ppi);
- pp_newline_and_indent (ppi, -3);
- }
- }
+ {
+ int i = 0;
+ if (pp_needs_newline (ppi))
+ pp_newline_and_indent (ppi, 0);
+ if (SCOPE_BEGIN_P (stmt))
+ {
+ pp_left_brace (ppi);
+ i = 3;
+ }
+ else if (SCOPE_END_P (stmt))
+ {
+ pp_right_brace (ppi);
+ i = -3;
+ }
+ pp_indentation (ppi) += i;
+ pp_needs_newline (ppi) = true;
+ }
break;
case DECL_STMT:
+ if (pp_needs_newline (ppi))
+ pp_newline_and_indent (ppi, 0);
pp_declaration (ppi, DECL_STMT_DECL (stmt));
- pp_semicolon (ppi);
- pp_newline (ppi);
+ pp_c_semicolon (ppi);
+ pp_needs_newline (ppi) = true;
break;
case ASM_STMT:
if (ASM_CLOBBERS (stmt))
pp_c_expression (ppi, ASM_CLOBBERS (stmt));
}
- pp_right_paren (ppi);
+ pp_c_right_paren (ppi);
pp_newline (ppi);
}
break;
pp_equal (ppi);
pp_c_whitespace (ppi);
pp_c_identifier (ppi, FILE_STMT_FILENAME (stmt));
- pp_semicolon (ppi);
- pp_newline (ppi);
+ pp_c_semicolon (ppi);
+ pp_needs_newline (ppi) = true;
break;
default:
pp->declaration = pp_c_declaration;
pp->declaration_specifiers = pp_c_declaration_specifiers;
- pp->type_specifier = pp_c_simple_type_specifier;
pp->declarator = pp_c_declarator;
pp->direct_declarator = pp_c_direct_declarator;
+ pp->type_specifier = pp_c_simple_type_specifier;
+ pp->abstract_declarator = pp_c_abstract_declarator;
pp->parameter_declaration = pp_c_parameter_declaration;
pp->type_id = pp_c_type_id;
+ pp->function_specifier = pp_c_function_specifier;
+ pp->storage_class_specifier = pp_c_storage_class_specifier;
pp->statement = pp_c_statement;
+ pp->id_expression = pp_c_id_expression;
pp->primary_expression = pp_c_primary_expression;
pp->postfix_expression = pp_c_postfix_expression;
pp->unary_expression = pp_c_unary_expression;
#include "pretty-print.h"
+typedef enum
+ {
+ pp_c_flag_abstract = 1 << 1,
+ pp_c_flag_last_bit = 2
+ } pp_c_pretty_print_flags;
+
+
/* The data type used to bundle information necessary for pretty-printing
a C or C++ entity. */
typedef struct c_pretty_print_info *c_pretty_printer;
Not used yet. */
int *offset_list;
+ pp_flags flags;
+
/* These must be overridden by each of the C and C++ front-end to
reflect their understanding of syntactic productions when they differ. */
c_pretty_print_fn declaration;
c_pretty_print_fn declaration_specifiers;
- c_pretty_print_fn type_specifier;
c_pretty_print_fn declarator;
+ c_pretty_print_fn abstract_declarator;
+ c_pretty_print_fn type_specifier;
c_pretty_print_fn direct_declarator;
c_pretty_print_fn parameter_declaration;
c_pretty_print_fn type_id;
+ c_pretty_print_fn function_specifier;
+ c_pretty_print_fn storage_class_specifier;
c_pretty_print_fn statement;
+ c_pretty_print_fn id_expression;
c_pretty_print_fn primary_expression;
c_pretty_print_fn postfix_expression;
c_pretty_print_fn unary_expression;
#undef pp_base
#define pp_base(PP) (&pp_c_base (PP)->base)
-#define pp_c_left_paren(PPI) \
- do { \
- pp_left_paren (PPI); \
- pp_c_base (PPI)->base.padding = pp_none; \
- } while (0)
-#define pp_c_right_paren(PPI) \
- do { \
- pp_right_paren (PPI); \
- pp_c_base (PPI)->base.padding = pp_none; \
- } while (0)
-#define pp_c_left_bracket(PPI) \
- do { \
- pp_left_bracket (PPI); \
- pp_c_base (PPI)->base.padding = pp_none; \
- } while (0)
-#define pp_c_right_bracket(PPI) \
- do { \
- pp_right_bracket (PPI); \
- pp_c_base (PPI)->base.padding = pp_none; \
- } while (0)
-#define pp_c_whitespace(PPI) \
- do { \
- pp_space (PPI); \
- pp_c_base (PPI)->base.padding = pp_none; \
- } while (0)
-#define pp_c_maybe_whitespace(PPI) \
- do { \
- if (pp_c_base (PPI)->base.padding != pp_none) \
- pp_c_whitespace (PPI); \
- } while (0)
-#define pp_c_identifier(PPI, ID) \
- do { \
- pp_c_maybe_whitespace (PPI); \
- pp_identifier (PPI, ID); \
- pp_c_base (PPI)->base.padding = pp_before; \
- } while (0)
#define pp_c_tree_identifier(PPI, ID) \
pp_c_identifier (PPI, IDENTIFIER_POINTER (ID))
#define pp_declaration(PPI, T) \
- (*pp_c_base (PPI)->declaration) (pp_c_base (PPI), T)
+ pp_c_base (PPI)->declaration (pp_c_base (PPI), T)
#define pp_declaration_specifiers(PPI, D) \
- (*pp_c_base (PPI)->declaration_specifiers) (pp_c_base (PPI), D)
+ pp_c_base (PPI)->declaration_specifiers (pp_c_base (PPI), D)
+#define pp_abstract_declarator(PP, D) \
+ pp_c_base (PP)->abstract_declarator (pp_c_base (PP), D)
#define pp_type_specifier(PPI, D) \
- (*pp_c_base (PPI)->type_specifier) (pp_c_base (PPI), D)
+ pp_c_base (PPI)->type_specifier (pp_c_base (PPI), D)
#define pp_declarator(PPI, D) \
- (*pp_c_base (PPI)->declarator) (pp_c_base (PPI), D)
+ pp_c_base (PPI)->declarator (pp_c_base (PPI), D)
#define pp_direct_declarator(PPI, D) \
- (*pp_c_base (PPI)->direct_declarator) (pp_c_base (PPI), D)
+ pp_c_base (PPI)->direct_declarator (pp_c_base (PPI), D)
#define pp_parameter_declaration(PPI, T) \
- (*pp_c_base (PPI)->parameter_declaration) (pp_c_base (PPI), T)
+ pp_c_base (PPI)->parameter_declaration (pp_c_base (PPI), T)
#define pp_type_id(PPI, D) \
- (*pp_c_base (PPI)->type_id) (pp_c_base (PPI), D)
+ pp_c_base (PPI)->type_id (pp_c_base (PPI), D)
+#define pp_function_specifier(PP, D) \
+ pp_c_base (PP)->function_specifier (pp_c_base (PP), D)
+#define pp_storage_class_specifier(PP, D) \
+ pp_c_base (PP)->storage_class_specifier (pp_c_base (PP), D);
#define pp_statement(PPI, S) \
- (*pp_c_base (PPI)->statement) (pp_c_base (PPI), S)
+ pp_c_base (PPI)->statement (pp_c_base (PPI), S)
+#define pp_id_expression(PP, E) \
+ pp_c_base (PP)->id_expression (pp_c_base (PP), E)
#define pp_primary_expression(PPI, E) \
- (*pp_c_base (PPI)->primary_expression) (pp_c_base (PPI), E)
+ pp_c_base (PPI)->primary_expression (pp_c_base (PPI), E)
#define pp_postfix_expression(PPI, E) \
- (*pp_c_base (PPI)->postfix_expression) (pp_c_base (PPI), E)
+ pp_c_base (PPI)->postfix_expression (pp_c_base (PPI), E)
#define pp_unary_expression(PPI, E) \
- (*pp_c_base (PPI)->unary_expression) (pp_c_base (PPI), E)
+ pp_c_base (PPI)->unary_expression (pp_c_base (PPI), E)
#define pp_initializer(PPI, E) \
- (*pp_c_base (PPI)->initializer) (pp_c_base (PPI), E)
+ pp_c_base (PPI)->initializer (pp_c_base (PPI), E)
#define pp_multiplicative_expression(PPI, E) \
- (*pp_c_base (PPI)->multiplicative_expression) (pp_c_base (PPI), E)
+ pp_c_base (PPI)->multiplicative_expression (pp_c_base (PPI), E)
#define pp_conditional_expression(PPI, E) \
- (*pp_c_base (PPI)->conditional_expression) (pp_c_base (PPI), E)
+ pp_c_base (PPI)->conditional_expression (pp_c_base (PPI), E)
#define pp_assignment_expression(PPI, E) \
- (*pp_c_base (PPI)->assignment_expression) (pp_c_base (PPI), E)
+ pp_c_base (PPI)->assignment_expression (pp_c_base (PPI), E)
/* Returns the c_pretty_printer base object of PRETTY-PRINTER. This
extern void pp_c_pretty_printer_init (c_pretty_printer);
/* Declarations. */
+void pp_c_function_definition (c_pretty_printer, tree);
void pp_c_attributes (c_pretty_printer, tree);
-void pp_c_cv_qualifier (c_pretty_printer, int);
+void pp_c_type_qualifier_list (c_pretty_printer, tree);
void pp_c_parameter_declaration_clause (c_pretty_printer, tree);
void pp_c_declaration (c_pretty_printer, tree);
+void pp_c_declarator (c_pretty_printer, tree);
+void pp_c_direct_declarator (c_pretty_printer, tree);
+void pp_c_specifier_qualifier_list (c_pretty_printer, tree);
+void pp_c_type_id (c_pretty_printer, tree);
/* Statements. */
void pp_c_statement (c_pretty_printer, tree);
/* Expressions. */
void pp_c_expression (c_pretty_printer, tree);
void pp_c_logical_or_expression (c_pretty_printer, tree);
void pp_c_expression_list (c_pretty_printer, tree);
+void pp_c_unary_expression (c_pretty_printer, tree);
void pp_c_cast_expression (c_pretty_printer, tree);
void pp_c_postfix_expression (c_pretty_printer, tree);
void pp_c_initializer (c_pretty_printer, tree);
-void pp_c_literal (c_pretty_printer, tree);
+void pp_c_constant (c_pretty_printer, tree);
+void pp_c_id_expression (c_pretty_printer, tree);
+void pp_c_identifier (c_pretty_printer, const char *);
void pp_c_string_literal (c_pretty_printer, tree);
-void pp_c_real_literal (c_pretty_printer, tree);
-void pp_c_integer_literal (c_pretty_printer, tree);
#endif /* GCC_C_PRETTY_PRINTER */
#include "real.h"
#include "cxx-pretty-print.h"
#include "cp-tree.h"
+
+static void pp_cxx_unqualified_id (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_template_argument_list (cxx_pretty_printer *, tree);
\f
+
+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_space (pp);
+ pp_character (pp, c);
+}
+
+#define pp_cxx_begin_template_argument_list(PP) \
+ pp_cxx_nonconsecutive_character (PP, '<')
+#define pp_cxx_end_template_argument_list(PP) \
+ pp_cxx_nonconsecutive_character (PP, '>')
+
/* Declarations. */
void
{
pp_unsupported_tree (pp, t);
}
+/* type-specifier:
+ simple-type-specifier
+ class-specifier
+ enum-specifier
+ elaborated-type-specifier
+ cv-qualifer */
static void
pp_cxx_type_specifier (cxx_pretty_printer *pp, tree t)
{
- pp_unsupported_tree (pp, t);
+ pp_c_type_qualifier_list (pp_c_base (pp), t);
+
+ switch (TREE_CODE (t))
+ {
+ case TEMPLATE_DECL:
+ case TYPE_DECL:
+ if (pp->enclosing_scope != DECL_CONTEXT (t))
+ pp_cxx_qualified_id (pp, t);
+ else
+ pp_cxx_unqualified_id (pp, t);
+ break;
+
+ case TYPEOF_TYPE:
+ pp_c_identifier (pp_c_base (pp), "__typeof__");
+ pp_left_paren (pp);
+ pp_c_expression (pp_c_base (pp), TYPE_FIELDS (t));
+ pp_right_paren (pp);
+ break;
+
+ default:
+ pp_c_specifier_qualifier_list (pp_c_base (pp), t);
+ }
}
static void
pp_cxx_declarator (cxx_pretty_printer *pp, tree t)
{
- pp_unsupported_tree (pp, t);
+ switch (TREE_CODE (t))
+ {
+ default:
+ pp_c_declarator (pp_c_base (pp), t);
+ break;
+ }
}
static void
pp_cxx_direct_declarator (cxx_pretty_printer *pp, tree t)
{
- pp_unsupported_tree (pp, t);
+ pp_c_direct_declarator (pp_c_base (pp), t);
}
static void
pp_unsupported_tree (pp, t);
}
+
+
+/* type-id:
+ type-specifier-seq abstract-declarator(opt) */
static void
pp_cxx_type_id (cxx_pretty_printer *pp, tree t)
+{
+ pp_flags saved_flags = pp_c_base (pp)->flags;
+ pp_c_base (pp)->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 TEMPLATE_ID_EXPR:
+ /* FIXME: Should be pp_cxx_type_specifier_seq. */
+ pp_cxx_type_specifier (pp, t);
+ pp_cxx_declarator (pp, t);
+ break;
+
+ default:
+ pp_c_type_id (pp_c_base (pp), t);
+ break;
+ }
+
+ pp_c_base (pp)->flags = saved_flags;
+}
+
+static void
+pp_cxx_initializer (cxx_pretty_printer *pp, tree t)
{
pp_unsupported_tree (pp, t);
}
+/* template-argument-list:
+ template-argument
+ template-argument-list, template-argument
+
+ template-argument:
+ assignment-expression
+ type-id
+ template-name */
+static void
+pp_cxx_template_argument_list (cxx_pretty_printer *pp, tree t)
+{
+ int i;
+ if (t == NULL)
+ return;
+ for (i = 0; i < TREE_VEC_LENGTH (t); ++i)
+ {
+ tree arg = TREE_VEC_ELT (t, i);
+ if (i != 0)
+ pp_separate_with (pp, ',');
+ if (TYPE_P (arg) || (TREE_CODE (arg) == TEMPLATE_DECL
+ && TYPE_P (DECL_TEMPLATE_RESULT (arg))))
+ pp_cxx_type_id (pp, arg);
+ else
+ pp_c_expression (pp_c_base (pp), arg);
+ }
+}
+
+
/* Statements. */
void
/* Expressions. */
+static inline bool
+is_destructor_name (tree name)
+{
+ return name == complete_dtor_identifier
+ || name == base_dtor_identifier
+ || name == deleting_dtor_identifier;
+}
+
+/* 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 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:
+ t = DECL_NAME (t);
+
+ case IDENTIFIER_NODE:
+ if (IDENTIFIER_TYPENAME_P (t))
+ {
+ pp_c_identifier (pp_c_base (pp), "operator");
+ /* FIXME: should be pp_cxx_type_specifier_seq */
+ pp_cxx_type_specifier (pp, TREE_TYPE (t));
+ /* FIXME: should be pp_cxx_conversion_declarator. */
+ pp_cxx_type_id (pp, TREE_TYPE (t));
+ }
+ else if (IDENTIFIER_OPNAME_P (t))
+ {
+ const char *name = operator_name_info[TREE_CODE (t)].name;
+ pp_c_identifier (pp_c_base (pp), "operator");
+ if (ISALPHA (name[0]))
+ pp_space (pp);
+ pp_base (pp)->padding = pp_none;
+ pp_c_identifier (pp_c_base (pp), name);
+ }
+ else
+ {
+ if (is_destructor_name (t))
+ {
+ pp_complement (pp);
+ t = constructor_name (TREE_TYPE (t));
+ }
+ pp_c_tree_identifier (pp_c_base (pp), t);
+ }
+ break;
+
+ case TEMPLATE_ID_EXPR:
+ pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 0));
+ pp_less (pp);
+ pp_cxx_template_argument_list (pp, TREE_OPERAND (t, 1));
+ pp_greater (pp);
+ break;
+
+ default:
+ pp_unsupported_tree (pp, t);
+ }
+}
+
+/* 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))
+ {
+ case PTRMEM_CST:
+ pp_cxx_qualified_id (pp, PTRMEM_CST_CLASS (t));
+ pp_colon_colon (pp);
+ pp_cxx_unqualified_id (pp, PTRMEM_CST_MEMBER (t));
+ break;
+
+ case OFFSET_REF:
+ case SCOPE_REF:
+ pp_cxx_qualified_id (pp, TREE_OPERAND (t, 0));
+ pp_colon_colon (pp);
+ pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 1));
+ break;
+
+ default:
+ {
+ tree scope = DECL_CONTEXT (t);
+ if (scope == pp->enclosing_scope)
+ pp_cxx_unqualified_id (pp, t);
+ else
+ {
+ pp_cxx_qualified_id (pp, scope);
+ pp_colon_colon (pp);
+ if (TYPE_P (scope) && dependent_type_p (scope)
+ && TREE_CODE (t) == TEMPLATE_DECL)
+ pp_c_identifier (pp_c_base (pp), "template");
+ pp_cxx_unqualified_id (pp, t);
+ }
+ }
+ break;
+ }
+}
+
+/* id-expression:
+ unaqualified-id
+ qualified-id */
+static inline void
+pp_cxx_id_expression (cxx_pretty_printer *pp, tree t)
+{
+ if (pp_c_base (pp)->flags
+ & (pp_cxx_flag_qualified_id | pp_cxx_flag_global_scope))
+ pp_cxx_qualified_id (pp, t);
+ else
+ pp_cxx_unqualified_id (pp, t);
+}
+
+/* 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)
{
- pp_unsupported_tree (pp, t);
+ switch (TREE_CODE (t))
+ {
+ case STRING_CST:
+ case INTEGER_CST:
+ case REAL_CST:
+ pp_c_constant (pp_c_base (pp), t);
+ break;
+
+ default:
+ if (pp_c_base (pp)->flags & pp_cxx_flag_qualified_id)
+ pp_cxx_qualified_id (pp, t);
+ else
+ {
+ if (pp_c_base (pp)->flags & pp_cxx_flag_global_scope)
+ pp_colon_colon (pp);
+ pp_cxx_unqualified_id (pp, 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 )
+ typeif ( type-id ) */
+
static void
pp_cxx_postfix_expression (cxx_pretty_printer *pp, tree t)
{
- pp_unsupported_tree (pp, t);
+ enum tree_code code = TREE_CODE (t);
+
+ switch (code)
+ {
+ case DYNAMIC_CAST_EXPR:
+ case STATIC_CAST_EXPR:
+ case REINTERPRET_CAST_EXPR:
+ case CONST_CAST_EXPR:
+ if (code == DYNAMIC_CAST_EXPR)
+ pp_identifier (pp, "dynamic_cast");
+ else if (code == STATIC_CAST_EXPR)
+ pp_identifier (pp, "static_cast");
+ else if (code == REINTERPRET_CAST_EXPR)
+ pp_identifier (pp, "reinterpret_cast");
+ else
+ pp_identifier (pp, "const_cast");
+ pp_cxx_begin_template_argument_list (pp);
+ pp_cxx_type_id (pp, TREE_TYPE (t));
+ pp_cxx_end_template_argument_list (pp);
+ pp_left_paren (pp);
+ pp_c_expression (pp_c_base (pp), TREE_OPERAND (t, 0));
+ pp_right_paren (pp);
+ break;
+
+ case EMPTY_CLASS_EXPR:
+ pp_cxx_type_id (pp, TREE_TYPE (t));
+ pp_left_paren (pp);
+ pp_right_paren (pp);
+ break;
+
+ case TYPEID_EXPR:
+ t = TREE_OPERAND (t, 0);
+ pp_c_identifier (pp_c_base (pp), "typeid");
+ pp_left_paren (pp);
+ if (TYPE_P (t))
+ pp_cxx_type_id (pp, t);
+ else
+ pp_c_expression (pp_c_base (pp), t);
+ pp_right_paren (pp);
+ break;
+
+ case PSEUDO_DTOR_EXPR:
+ pp_cxx_postfix_expression (pp, TREE_OPERAND (t, 0));
+ pp_dot (pp);
+ pp_cxx_qualified_id (pp, TREE_OPERAND (t, 1));
+ pp_colon_colon (pp);
+ pp_complement (pp);
+ pp_cxx_unqualified_id (pp, TREE_OPERAND (t, 2));
+ break;
+
+ default:
+ pp_c_postfix_expression (pp_c_base (pp), 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_unary_expression (cxx_pretty_printer *pp, tree t)
+pp_cxx_new_expression (cxx_pretty_printer *pp, tree t)
{
- pp_unsupported_tree (pp, t);
+ enum tree_code code = TREE_CODE (t);
+ switch (code)
+ {
+ case NEW_EXPR:
+ case VEC_NEW_EXPR:
+ if (NEW_EXPR_USE_GLOBAL (t))
+ pp_colon_colon (pp);
+ pp_c_identifier (pp_c_base (pp), "new");
+ if (TREE_OPERAND (t, 0))
+ {
+ pp_left_paren (pp);
+ pp_c_expression_list (pp_c_base (pp), TREE_OPERAND (t, 0));
+ pp_right_paren (pp);
+ pp_space (pp);
+ }
+ /* FIXME: array-types are built with one more element. */
+ pp_cxx_type_id (pp, TREE_OPERAND (t, 1));
+ if (TREE_OPERAND (t, 2))
+ {
+ pp_left_paren (pp);
+ t = TREE_OPERAND (t, 2);
+ if (TREE_CODE (t) == TREE_LIST)
+ pp_c_expression_list (pp_c_base (pp), t);
+ else if (t == void_zero_node)
+ ; /* OK, empty initializer list. */
+ else
+ pp_c_expression (pp_c_base (pp), t);
+ 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_initializer (cxx_pretty_printer *pp, tree t)
+pp_cxx_delete_expression (cxx_pretty_printer *pp, tree t)
{
- pp_unsupported_tree (pp, t);
+ enum tree_code code = TREE_CODE (t);
+ switch (code)
+ {
+ case DELETE_EXPR:
+ case VEC_DELETE_EXPR:
+ if (DELETE_EXPR_USE_GLOBAL (t))
+ pp_colon_colon (pp);
+ pp_c_identifier (pp_c_base (pp), "delete");
+ if (code == VEC_DELETE_EXPR)
+ {
+ pp_left_bracket (pp);
+ pp_right_bracket (pp);
+ }
+ pp_c_cast_expression (pp_c_base (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 )
+ new-expression
+ delete-expression
+
+ unary-operator: one of
+ * & + - !
+
+ GNU extensions:
+ __alignof__ unary-expression
+ __alignof__ ( type-id ) */
static void
-pp_cxx_multiplicatice_expression (cxx_pretty_printer *pp, tree t)
+pp_cxx_unary_expression (cxx_pretty_printer *pp, tree t)
{
- pp_unsupported_tree (pp, t);
+ enum tree_code code = TREE_CODE (t);
+ switch (code)
+ {
+ 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;
+
+ default:
+ pp_c_unary_expression (pp_c_base (pp), t);
+ break;
+ }
}
+/* pm-expression:
+ cast-expression
+ pm-expression .* cast-expression
+ pm-expression ->* cast-expression */
static void
-pp_cxx_conditional_expression (cxx_pretty_printer *pp, tree t)
+pp_cxx_pm_expression (cxx_pretty_printer *pp, tree t)
{
- pp_unsupported_tree (pp, t);
+ switch (TREE_CODE (t))
+ {
+ /* Handle unfortunate OFFESET_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));
+ pp_dot (pp);
+ pp_star(pp);
+ pp_c_cast_expression (pp_c_base (pp), TREE_OPERAND (t, 1));
+ break;
+
+
+ default:
+ pp_c_cast_expression (pp_c_base (pp), t);
+ break;
+ }
}
+/* multiplicative-expression:
+ pm-expression
+ multiplicative-expression * pm-expression
+ multiplicative-expression / pm-expression
+ multiplicative-expression % pm-expression */
static void
-pp_cxx_assignment_expression (cxx_pretty_printer *pp, tree t)
+pp_cxx_multiplicative_expression (cxx_pretty_printer *pp, tree e)
{
- pp_unsupported_tree (pp, t);
+ 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);
+ if (code == MULT_EXPR)
+ pp_star (pp);
+ else if (code == TRUNC_DIV_EXPR)
+ pp_slash (pp);
+ else
+ pp_modulo (pp);
+ pp_space (pp);
+ pp_cxx_pm_expression (pp, TREE_OPERAND (e, 1));
+ break;
+
+ default:
+ pp_cxx_pm_expression (pp, e);
+ break;
+ }
}
-void
-pp_cxx_expression (cxx_pretty_printer *pp, tree t)
+
+/* conditional-expression:
+ logical-or-expression
+ logical-or-expression ? expression : assignment-expression */
+static void
+pp_cxx_conditional_expression (cxx_pretty_printer *pp, tree e)
{
- pp_unsupported_tree (pp, t);
+ if (TREE_CODE (e) == COND_EXPR)
+ {
+ pp_c_logical_or_expression (pp_c_base (pp), TREE_OPERAND (e, 0));
+ pp_space (pp);
+ pp_question (pp);
+ pp_space (pp);
+ pp_c_expression (pp_c_base (pp), TREE_OPERAND (e, 1));
+ pp_space (pp);
+ pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 2));
+ }
+ else
+ pp_c_logical_or_expression (pp_c_base (pp), e);
+}
+
+/* assignment-expression:
+ conditional-expression
+ logical-or-expression assignment-operator assignment-expression
+
+ assignment-expression: one of
+ = *= /= %= += -= >>= <<= &= ^= |= */
+static void
+pp_cxx_assignment_expression (cxx_pretty_printer *pp, tree e)
+{
+ if (TREE_CODE (e) == MODIFY_EXPR)
+ {
+ pp_c_logical_or_expression (pp_c_base (pp), TREE_OPERAND (e, 0));
+ pp_space (pp);
+ pp_equal (pp);
+ pp_space (pp);
+ pp_cxx_assignment_expression (pp, TREE_OPERAND (e, 1));
+ }
+ else
+ pp_cxx_conditional_expression (pp, e);
}
pp->c_base.parameter_declaration = (pp_fun) pp_cxx_parameter_declaration;
pp->c_base.type_id = (pp_fun) pp_cxx_type_id;
pp->c_base.statement = (pp_fun) pp_cxx_statement;
+ pp->c_base.id_expression = (pp_fun) pp_cxx_id_expression;
pp->c_base.primary_expression = (pp_fun) pp_cxx_primary_expression;
pp->c_base.postfix_expression = (pp_fun) pp_cxx_postfix_expression;
pp->c_base.unary_expression = (pp_fun) pp_cxx_unary_expression;
pp->c_base.initializer = (pp_fun) pp_cxx_initializer;
- pp->c_base.multiplicative_expression = (pp_fun) pp_cxx_multiplicatice_expression;
+ pp->c_base.multiplicative_expression = (pp_fun) pp_cxx_multiplicative_expression;
pp->c_base.conditional_expression = (pp_fun) pp_cxx_conditional_expression;
pp->c_base.assignment_expression = (pp_fun) pp_cxx_assignment_expression;
pp->enclosing_scope = NULL;
git://gcc.gnu.org / gcc.git / commitdiff