X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gcc%2Fc-pretty-print.c;h=922d987ab28153d3321aa832c67b57e42acfeade;hb=12ea3302e694f467891a1ff072d5906d266413fc;hp=6e12d6134d85150bb8be560efc30728d9d9bc0bc;hpb=81f7282f978588f883d8363e8cd5e69d090bc331;p=platform%2Fupstream%2Fgcc.git diff --git a/gcc/c-pretty-print.c b/gcc/c-pretty-print.c index 6e12d61..922d987 100644 --- a/gcc/c-pretty-print.c +++ b/gcc/c-pretty-print.c @@ -35,29 +35,12 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA takes expression 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); \ @@ -82,64 +65,86 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA 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_primary_expression (c_pretty_printer, tree); +static void pp_c_char (c_pretty_printer *, int); /* postfix-expression */ -static void pp_c_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_equality_expression (c_pretty_printer, tree); -static void pp_c_and_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); +static void pp_c_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_equality_expression (c_pretty_printer *, tree); +static void pp_c_and_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. */ -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_simple_type_specifier (c_pretty_printer, tree); -static void pp_c_parameter_declaration (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); - -/* Declarations. */ +/* Helper functions. */ + +void +pp_c_whitespace (c_pretty_printer *pp) +{ + pp_space (pp); + pp_base (pp)->padding = pp_none; +} + +void +pp_c_left_paren (c_pretty_printer *pp) +{ + pp_left_paren (pp); + pp_base (pp)->padding = pp_none; +} + +void +pp_c_right_paren (c_pretty_printer *pp) +{ + pp_right_paren (pp); + pp_base (pp)->padding = pp_none; +} + +void +pp_c_dot (c_pretty_printer *pp) +{ + pp_dot (pp); + pp_base (pp)->padding = pp_none; +} + +void +pp_c_ampersand (c_pretty_printer *pp) +{ + pp_ampersand (pp); + pp_base (pp)->padding = pp_none; +} + +void +pp_c_arrow (c_pretty_printer *pp) +{ + pp_arrow (pp); + pp_base (pp)->padding = pp_none; +} + +void +pp_c_semicolon(c_pretty_printer *pp) +{ + pp_semicolon (pp); + pp_base (pp)->padding = pp_none; +} static void -pp_c_cv_qualifier (c_pretty_printer pp, const char *cv) +pp_c_cv_qualifier (c_pretty_printer *pp, const char *cv) { const char *p = pp_last_position_in_text (pp); if (p != NULL && *p == '*') @@ -147,16 +152,45 @@ pp_c_cv_qualifier (c_pretty_printer pp, const char *cv) pp_c_identifier (pp, cv); } +/* Pretty-print T using the type-cast notation '( type-name )'. */ +static inline void +pp_c_type_cast (c_pretty_printer *pp, tree t) +{ + pp_c_left_paren (pp); + pp_type_id (pp, t); + pp_c_right_paren (pp); +} + +void +pp_c_space_for_pointer_operator (c_pretty_printer *pp, tree t) +{ + if (POINTER_TYPE_P (t)) + { + tree pointee = strip_pointer_operator (TREE_TYPE (t)); + if (TREE_CODE (pointee) != ARRAY_TYPE + && TREE_CODE (pointee) != FUNCTION_TYPE) + pp_c_whitespace (pp); + } +} + + +/* Declarations. */ + /* 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: + + type-qualifier-list: + type-qualifier + type-qualifier-list type-qualifier + + type-qualifier: const - volatile - restrict - __restrict__ */ + restrict -- C99 + __restrict__ -- GNU C + volatile */ void -pp_c_type_qualifier_list (c_pretty_printer pp, tree t) +pp_c_type_qualifier_list (c_pretty_printer *pp, tree t) { int qualifiers; @@ -176,16 +210,21 @@ pp_c_type_qualifier_list (c_pretty_printer pp, tree t) * type-qualifier-list(opt) * type-qualifier-list(opt) pointer */ static void -pp_c_pointer (c_pretty_printer pp, tree t) +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: + /* It is easier to handle C++ reference types here. */ + case REFERENCE_TYPE: if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE) pp_c_pointer (pp, TREE_TYPE (t)); - pp_c_star (pp); + if (TREE_CODE (t) == POINTER_TYPE) + pp_c_star (pp); + else + pp_c_ampersand (pp); pp_c_type_qualifier_list (pp, t); break; @@ -194,49 +233,39 @@ pp_c_pointer (c_pretty_printer pp, tree t) } } -/* - simple-type-specifier: - void - char - short - int - long - float - double - signed - unsigned - _Bool -- C99 - _Complex -- C99 - _Imaginary -- C99 - typedef-name. +/* type-specifier: + void + char + short + int + long + float + double + signed + unsigned + _Bool -- C99 + _Complex -- C99 + _Imaginary -- C99 + struct-or-union-specifier + enum-specifier + typedef-name. GNU extensions. simple-type-specifier: __complex__ __vector__ */ -static void -pp_c_simple_type_specifier (c_pretty_printer ppi, tree t) +void +pp_c_type_specifier (c_pretty_printer *pp, tree t) { - enum tree_code code; - - if (DECL_P (t) && TREE_CODE (t) != TYPE_DECL) - t = TREE_TYPE (t); - - code = TREE_CODE (t); + const enum tree_code code = TREE_CODE (t); switch (code) { case ERROR_MARK: - pp_c_identifier (ppi, ""); - break; - -#if 0 - case UNKNOWN_TYPE: - pp_c_identifier (ppi, ""); + pp_c_identifier (pp, ""); break; -#endif case IDENTIFIER_NODE: - pp_c_tree_identifier (ppi, t); + pp_c_tree_identifier (pp, t); break; case VOID_TYPE: @@ -244,58 +273,43 @@ pp_c_simple_type_specifier (c_pretty_printer ppi, tree t) case CHAR_TYPE: case INTEGER_TYPE: case REAL_TYPE: - pp_c_simple_type_specifier (ppi, TYPE_NAME (t)); - break; - - case COMPLEX_TYPE: - case VECTOR_TYPE: - pp_c_simple_type_specifier (ppi, TYPE_MAIN_VARIANT (TREE_TYPE (t))); - if (code == COMPLEX_TYPE) - pp_c_identifier (ppi, flag_isoc99 ? "_Complex" : "__complex__"); - else if (code == VECTOR_TYPE) - pp_c_identifier (ppi, "__vector__"); + pp_c_type_specifier (pp, TYPE_NAME (t)); break; case TYPE_DECL: if (DECL_NAME (t)) - pp_id_expression (ppi, t); + pp_id_expression (pp, t); else - pp_c_identifier (ppi, ""); + pp_c_identifier (pp, ""); break; case UNION_TYPE: case RECORD_TYPE: case ENUMERAL_TYPE: if (code == UNION_TYPE) - pp_c_identifier (ppi, "union"); + pp_c_identifier (pp, "union"); else if (code == RECORD_TYPE) - pp_c_identifier (ppi, "struct"); + pp_c_identifier (pp, "struct"); else if (code == ENUMERAL_TYPE) - pp_c_identifier (ppi, "enum"); + pp_c_identifier (pp, "enum"); else - pp_c_identifier (ppi, ""); + pp_c_identifier (pp, ""); if (TYPE_NAME (t)) - pp_id_expression (ppi, TYPE_NAME (t)); + pp_id_expression (pp, TYPE_NAME (t)); else - pp_c_identifier (ppi, ""); - break; - - case POINTER_TYPE: - case ARRAY_TYPE: - case FUNCTION_TYPE: - pp_c_simple_type_specifier (ppi, TREE_TYPE (t)); + pp_c_identifier (pp, ""); break; default: - pp_unsupported_tree (ppi, t); + pp_unsupported_tree (pp, t); break; } } /* specifier-qualifier-list: type-specifier specifier-qualifier-list-opt - cv-qualifier specifier-qualifier-list-opt + type-qualifier specifier-qualifier-list-opt Implementation note: Because of the non-linearities in array or @@ -304,18 +318,19 @@ pp_c_simple_type_specifier (c_pretty_printer ppi, tree t) 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_specifier_qualifier_list (c_pretty_printer *pp, tree t) { + const enum tree_code code = TREE_CODE (t); + if (TREE_CODE (t) != POINTER_TYPE) pp_c_type_qualifier_list (pp, t); - switch (TREE_CODE (t)) + switch (code) { + case REFERENCE_TYPE: 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); + tree pointee = strip_pointer_operator (TREE_TYPE (t)); pp_c_specifier_qualifier_list (pp, pointee); if (TREE_CODE (pointee) == ARRAY_TYPE || TREE_CODE (pointee) == FUNCTION_TYPE) @@ -323,10 +338,7 @@ pp_c_specifier_qualifier_list (c_pretty_printer pp, tree t) 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); + pp_ptr_operator (pp, t); } break; @@ -338,12 +350,14 @@ pp_c_specifier_qualifier_list (c_pretty_printer pp, tree t) 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); + if (code == COMPLEX_TYPE) + pp_c_identifier (pp, flag_isoc99 ? "_Complex" : "__complex__"); + else if (code == VECTOR_TYPE) + pp_c_identifier (pp, "__vector__"); break; default: - pp_c_simple_type_specifier (pp, t); + pp_simple_type_specifier (pp, t); break; } } @@ -359,26 +373,28 @@ pp_c_specifier_qualifier_list (c_pretty_printer pp, tree t) parameter-declaration: declaration-specifiers declarator declaration-specifiers abstract-declarator(opt) */ -static void -pp_c_parameter_type_list (c_pretty_printer pp, tree t) +void +pp_c_parameter_type_list (c_pretty_printer *pp, tree t) { + bool want_parm_decl = DECL_P (t) && !(pp->flags & pp_c_flag_abstract); + tree parms = want_parm_decl ? DECL_ARGUMENTS (t) : TYPE_ARG_TYPES (t); pp_c_left_paren (pp); - if (t == void_list_node) + if (parms == 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)) + for ( ; parms && parms != void_list_node; parms = TREE_CHAIN (parms)) { if (!first) pp_separate_with (pp, ','); first = false; - pp_declaration_specifiers (pp, want_parm_decl ? t : TREE_VALUE (t)); + pp_declaration_specifiers + (pp, want_parm_decl ? parms : TREE_VALUE (parms)); if (want_parm_decl) - pp_declarator (pp, t); + pp_declarator (pp, parms); else - pp_abstract_declarator (pp, TREE_VALUE (t)); + pp_abstract_declarator (pp, TREE_VALUE (parms)); } } pp_c_right_paren (pp); @@ -388,7 +404,7 @@ pp_c_parameter_type_list (c_pretty_printer pp, tree t) pointer pointer(opt) direct-abstract-declarator */ static inline void -pp_c_abstract_declarator (c_pretty_printer pp, tree t) +pp_c_abstract_declarator (c_pretty_printer *pp, tree t) { if (TREE_CODE (t) == POINTER_TYPE) { @@ -398,7 +414,7 @@ pp_c_abstract_declarator (c_pretty_printer pp, tree t) t = TREE_TYPE (t); } - pp_c_direct_abstract_declarator (pp, t); + pp_direct_abstract_declarator (pp, t); } /* direct-abstract-declarator: @@ -406,26 +422,26 @@ pp_c_abstract_declarator (c_pretty_printer pp, tree t) 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) +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); + pp_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)); + 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)) - pp_c_expression (pp, TYPE_MAX_VALUE (TYPE_DOMAIN (t))); + pp_expression (pp, TYPE_MAX_VALUE (TYPE_DOMAIN (t))); pp_c_right_bracket (pp); - pp_c_direct_abstract_declarator (pp, TREE_TYPE (t)); + pp_direct_abstract_declarator (pp, TREE_TYPE (t)); break; case IDENTIFIER_NODE: @@ -447,15 +463,23 @@ pp_c_direct_abstract_declarator (c_pretty_printer pp, tree t) } } +/* type-name: + specifier-qualifier-list abstract-declarator(opt) */ void -pp_c_type_id (c_pretty_printer ppi, tree t) +pp_c_type_id (c_pretty_printer *pp, tree t) { - pp_c_specifier_qualifier_list (ppi, t); - pp_abstract_declarator (ppi, t); + pp_c_specifier_qualifier_list (pp, t); + pp_abstract_declarator (pp, t); } -static inline void -pp_c_storage_class_specifier (c_pretty_printer pp, tree t) +/* storage-class-specifier: + typedef + extern + static + auto + register */ +void +pp_c_storage_class_specifier (c_pretty_printer *pp, tree t) { if (TREE_CODE (t) == TYPE_DECL) pp_c_identifier (pp, "typedef"); @@ -468,8 +492,10 @@ pp_c_storage_class_specifier (c_pretty_printer pp, tree t) } } -static inline void -pp_c_function_specifier (c_pretty_printer pp, tree t) +/* function-specifier: + inline */ +void +pp_c_function_specifier (c_pretty_printer *pp, tree t) { if (TREE_CODE (t) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (t)) pp_c_identifier (pp, "inline"); @@ -480,8 +506,8 @@ pp_c_function_specifier (c_pretty_printer pp, tree t) 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) +void +pp_c_declaration_specifiers (c_pretty_printer *pp, tree t) { pp_storage_class_specifier (pp, t); pp_function_specifier (pp, t); @@ -498,7 +524,7 @@ pp_c_declaration_specifiers (c_pretty_printer pp, tree t) direct-declaratpr ( parameter-type-list ) direct-declarator ( identifier-list(opt) ) */ void -pp_c_direct_declarator (c_pretty_printer pp, tree t) +pp_c_direct_declarator (c_pretty_printer *pp, tree t) { switch (TREE_CODE (t)) { @@ -507,25 +533,30 @@ pp_c_direct_declarator (c_pretty_printer pp, tree t) case TYPE_DECL: case FIELD_DECL: case LABEL_DECL: - pp_c_tree_identifier (pp, DECL_NAME (t)); + if (DECL_NAME (t)) + { + pp_c_space_for_pointer_operator (pp, TREE_TYPE (t)); + 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)); + pp_parameter_list (pp, t); + pp_abstract_declarator (pp, TREE_TYPE (t)); break; case FUNCTION_DECL: + pp_c_space_for_pointer_operator (pp, TREE_TYPE (TREE_TYPE (t))); 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)); + pp_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))); + pp_parameter_list (pp, t); + pp_abstract_declarator (pp, TREE_TYPE (TREE_TYPE (t))); } break; @@ -546,7 +577,7 @@ pp_c_direct_declarator (c_pretty_printer pp, tree t) /* declarator: pointer(opt) direct-declarator */ void -pp_c_declarator (c_pretty_printer pp, tree t) +pp_c_declarator (c_pretty_printer *pp, tree t) { switch (TREE_CODE (t)) { @@ -574,41 +605,18 @@ pp_c_declarator (c_pretty_printer pp, tree t) } } -/* init-declarator: - declarator: - declarator = initializer */ -static inline void -pp_c_init_declarator (c_pretty_printer pp, tree t) -{ - pp_declarator (pp, t); - if (DECL_INITIAL (t)) - { - pp_space (pp); - pp_equal (pp); - pp_space (pp); - pp_c_initializer (pp, DECL_INITIAL (t)); - } -} - /* declaration: declaration-specifiers init-declarator-list(opt) ; */ - void -pp_c_declaration (c_pretty_printer pp, tree t) +pp_c_declaration (c_pretty_printer *pp, tree t) { pp_declaration_specifiers (pp, t); pp_c_init_declarator (pp, t); } -static void -pp_c_parameter_declaration (c_pretty_printer pp, tree t) -{ - pp_unsupported_tree (pp, t); -} - /* Pretty-print ATTRIBUTES using GNU C extension syntax. */ void -pp_c_attributes (c_pretty_printer pp, tree attributes) +pp_c_attributes (c_pretty_printer *pp, tree attributes) { if (attributes == NULL_TREE) return; @@ -620,11 +628,7 @@ pp_c_attributes (c_pretty_printer pp, tree attributes) { pp_tree_identifier (pp, TREE_PURPOSE (attributes)); if (TREE_VALUE (attributes)) - { - pp_c_left_paren (pp); - pp_c_expression_list (pp, TREE_VALUE (attributes)); - pp_c_right_paren (pp); - } + pp_c_call_argument_list (pp, TREE_VALUE (attributes)); if (TREE_CHAIN (attributes)) pp_separate_with (pp, ','); @@ -636,7 +640,7 @@ pp_c_attributes (c_pretty_printer pp, tree attributes) /* function-definition: declaration-specifiers declarator compound-statement */ void -pp_c_function_definition (c_pretty_printer pp, tree t) +pp_c_function_definition (c_pretty_printer *pp, tree t) { pp_declaration_specifiers (pp, t); pp_declarator (pp, t); @@ -651,64 +655,64 @@ pp_c_function_definition (c_pretty_printer pp, tree t) /* Print out a c-char. */ static void -pp_c_char (c_pretty_printer ppi, int c) +pp_c_char (c_pretty_printer *pp, int c) { switch (c) { case TARGET_NEWLINE: - pp_string (ppi, "\\n"); + pp_string (pp, "\\n"); break; case TARGET_TAB: - pp_string (ppi, "\\t"); + pp_string (pp, "\\t"); break; case TARGET_VT: - pp_string (ppi, "\\v"); + pp_string (pp, "\\v"); break; case TARGET_BS: - pp_string (ppi, "\\b"); + pp_string (pp, "\\b"); break; case TARGET_CR: - pp_string (ppi, "\\r"); + pp_string (pp, "\\r"); break; case TARGET_FF: - pp_string (ppi, "\\f"); + pp_string (pp, "\\f"); break; case TARGET_BELL: - pp_string (ppi, "\\a"); + pp_string (pp, "\\a"); break; case '\\': - pp_string (ppi, "\\\\"); + pp_string (pp, "\\\\"); break; case '\'': - pp_string (ppi, "\\'"); + pp_string (pp, "\\'"); break; case '\"': - pp_string (ppi, "\\\""); + pp_string (pp, "\\\""); break; default: if (ISPRINT (c)) - pp_character (ppi, c); + pp_character (pp, c); else - pp_scalar (ppi, "\\%03o", (unsigned) c); + pp_scalar (pp, "\\%03o", (unsigned) c); break; } } /* Print out a STRING literal. */ void -pp_c_string_literal (c_pretty_printer ppi, tree s) +pp_c_string_literal (c_pretty_printer *pp, tree s) { const char *p = TREE_STRING_POINTER (s); int n = TREE_STRING_LENGTH (s) - 1; int i; - pp_doublequote (ppi); + pp_doublequote (pp); for (i = 0; i < n; ++i) - pp_c_char (ppi, p[i]); - pp_doublequote (ppi); + pp_c_char (pp, p[i]); + pp_doublequote (pp); } static void -pp_c_integer_constant (c_pretty_printer pp, tree i) +pp_c_integer_constant (c_pretty_printer *pp, tree i) { if (host_integerp (i, 0)) pp_wide_integer (pp, TREE_INT_CST_LOW (i)); @@ -729,7 +733,7 @@ pp_c_integer_constant (c_pretty_printer pp, tree i) /* Print out a CHARACTER literal. */ static inline void -pp_c_character_constant (c_pretty_printer pp, tree c) +pp_c_character_constant (c_pretty_printer *pp, tree c) { tree type = TREE_TYPE (c); if (type == wchar_type_node) @@ -744,7 +748,7 @@ pp_c_character_constant (c_pretty_printer pp, tree c) /* Print out a BOOLEAN literal. */ static void -pp_c_bool_constant (c_pretty_printer pp, tree b) +pp_c_bool_constant (c_pretty_printer *pp, tree b) { if (b == boolean_false_node) { @@ -775,7 +779,7 @@ pp_c_bool_constant (c_pretty_printer pp, tree b) 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_enumeration_constant (c_pretty_printer ppi, tree e) +pp_c_enumeration_constant (c_pretty_printer *pp, tree e) { bool value_is_named = true; tree type = TREE_TYPE (e); @@ -788,13 +792,11 @@ pp_c_enumeration_constant (c_pretty_printer ppi, tree e) ; if (value != NULL_TREE) - pp_id_expression (ppi, TREE_PURPOSE (value)); + pp_id_expression (pp, TREE_PURPOSE (value)); else { /* Value must have been cast. */ - pp_c_left_paren (ppi); - pp_type_id (ppi, type); - pp_c_right_paren (ppi); + pp_c_type_cast (pp, type); value_is_named = false; } @@ -803,7 +805,7 @@ pp_c_enumeration_constant (c_pretty_printer ppi, tree e) /* Print out a REAL value. */ static inline void -pp_c_floating_constant (c_pretty_printer pp, tree r) +pp_c_floating_constant (c_pretty_printer *pp, tree r) { real_to_decimal (pp_buffer (pp)->digit_buffer, &TREE_REAL_CST (r), sizeof (pp_buffer (pp)->digit_buffer), 0, 1); @@ -816,7 +818,7 @@ pp_c_floating_constant (c_pretty_printer pp, tree r) enumeration-constant chatracter-constant */ void -pp_c_constant (c_pretty_printer pp, tree e) +pp_c_constant (c_pretty_printer *pp, tree e) { switch (TREE_CODE (e)) { @@ -850,7 +852,7 @@ pp_c_constant (c_pretty_printer pp, tree e) } void -pp_c_identifier (c_pretty_printer pp, const char *id) +pp_c_identifier (c_pretty_printer *pp, const char *id) { pp_c_maybe_whitespace (pp); pp_identifier (pp, id); @@ -863,8 +865,8 @@ pp_c_identifier (c_pretty_printer pp, const char *id) constant string-literal ( expression ) */ -static void -pp_c_primary_expression (c_pretty_printer ppi, tree e) +void +pp_c_primary_expression (c_pretty_printer *pp, tree e) { switch (TREE_CODE (e)) { @@ -877,50 +879,34 @@ pp_c_primary_expression (c_pretty_printer ppi, tree e) e = DECL_NAME (e); /* Fall through. */ case IDENTIFIER_NODE: - pp_c_tree_identifier (ppi, e); + pp_c_tree_identifier (pp, e); break; case ERROR_MARK: - pp_c_identifier (ppi, ""); + pp_c_identifier (pp, ""); break; case RESULT_DECL: - pp_c_identifier (ppi, ""); + pp_c_identifier (pp, ""); break; case INTEGER_CST: case REAL_CST: case STRING_CST: - pp_c_constant (ppi, e); + pp_c_constant (pp, e); break; - case TARGET_EXPR: - pp_c_left_paren (ppi); - pp_c_identifier (ppi, "__builtin_memcpy"); - pp_c_left_paren (ppi); - pp_ampersand (ppi); - pp_primary_expression (ppi, TREE_OPERAND (e, 0)); - pp_separate_with (ppi, ','); - pp_ampersand (ppi); - pp_initializer (ppi, TREE_OPERAND (e, 1)); - if (TREE_OPERAND (e, 2)) - { - pp_separate_with (ppi, ','); - pp_c_expression (ppi, TREE_OPERAND (e, 2)); - } - pp_c_right_paren (ppi); - case STMT_EXPR: - pp_c_left_paren (ppi); - pp_statement (ppi, STMT_EXPR_STMT (e)); - pp_c_right_paren (ppi); + pp_c_left_paren (pp); + pp_statement (pp, STMT_EXPR_STMT (e)); + pp_c_right_paren (pp); break; default: /* 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); + pp_c_left_paren (pp); + pp_expression (pp, e); + pp_c_right_paren (pp); break; } } @@ -931,23 +917,53 @@ pp_c_primary_expression (c_pretty_printer ppi, tree e) { initializer-list } { initializer-list , } */ -void -pp_c_initializer (c_pretty_printer ppi, tree e) +static void +pp_c_initializer (c_pretty_printer *pp, tree e) { if (TREE_CODE (e) == CONSTRUCTOR) { enum tree_code code = TREE_CODE (TREE_TYPE (e)); if (code == RECORD_TYPE || code == UNION_TYPE || code == ARRAY_TYPE) { - pp_c_left_brace (ppi); - pp_c_initializer_list (ppi, e); - pp_c_right_brace (ppi); + pp_c_left_brace (pp); + pp_c_initializer_list (pp, e); + pp_c_right_brace (pp); } else - pp_unsupported_tree (ppi, TREE_OPERAND (e, 1)); + pp_unsupported_tree (pp, TREE_OPERAND (e, 1)); } else - pp_assignment_expression (ppi, e); + pp_expression (pp, e); +} + +/* init-declarator: + declarator: + declarator = initializer */ +void +pp_c_init_declarator (c_pretty_printer *pp, tree t) +{ + pp_declarator (pp, t); + if (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); + } + } } /* initializer-list: @@ -965,7 +981,7 @@ pp_c_initializer (c_pretty_printer ppi, tree e) [ constant-expression ] identifier */ static void -pp_c_initializer_list (c_pretty_printer ppi, tree e) +pp_c_initializer_list (c_pretty_printer *pp, tree e) { tree type = TREE_TYPE (e); const enum tree_code code = TREE_CODE (type); @@ -977,26 +993,26 @@ pp_c_initializer_list (c_pretty_printer ppi, tree e) { if (code == RECORD_TYPE || code == UNION_TYPE) { - pp_c_dot (ppi); - pp_c_primary_expression (ppi, TREE_PURPOSE (init)); + pp_c_dot (pp); + pp_c_primary_expression (pp, TREE_PURPOSE (init)); } else { - pp_c_left_bracket (ppi); + pp_c_left_bracket (pp); if (TREE_PURPOSE (init)) - pp_c_constant (ppi, TREE_PURPOSE (init)); - pp_c_right_bracket (ppi); + pp_c_constant (pp, TREE_PURPOSE (init)); + pp_c_right_bracket (pp); } - pp_c_whitespace (ppi); - pp_equal (ppi); - pp_c_whitespace (ppi); - pp_initializer (ppi, TREE_VALUE (init)); + pp_c_whitespace (pp); + pp_equal (pp); + pp_c_whitespace (pp); + pp_initializer (pp, TREE_VALUE (init)); if (TREE_CHAIN (init)) - pp_separate_with (ppi, ','); + pp_separate_with (pp, ','); } } else - pp_unsupported_tree (ppi, type); + pp_unsupported_tree (pp, type); } /* This is a convenient function, used to bridge gap between C and C++ @@ -1005,7 +1021,7 @@ pp_c_initializer_list (c_pretty_printer ppi, tree e) id-expression: identifier */ void -pp_c_id_expression (c_pretty_printer pp, tree t) +pp_c_id_expression (c_pretty_printer *pp, tree t) { switch (TREE_CODE (t)) { @@ -1038,43 +1054,41 @@ pp_c_id_expression (c_pretty_printer pp, tree t) ( type-name ) { initializer-list } ( type-name ) { initializer-list , } */ void -pp_c_postfix_expression (c_pretty_printer ppi, tree e) +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 (ppi, TREE_OPERAND (e, 0)); - pp_identifier (ppi, code == POSTINCREMENT_EXPR ? "++" : "--"); + pp_postfix_expression (pp, TREE_OPERAND (e, 0)); + pp_identifier (pp, code == POSTINCREMENT_EXPR ? "++" : "--"); break; case ARROW_EXPR: - pp_postfix_expression (ppi, TREE_OPERAND (e, 0)); - pp_c_arrow (ppi); + pp_postfix_expression (pp, TREE_OPERAND (e, 0)); + pp_c_arrow (pp); break; case ARRAY_REF: - pp_postfix_expression (ppi, TREE_OPERAND (e, 0)); - pp_c_left_bracket (ppi); - pp_c_expression (ppi, TREE_OPERAND (e, 1)); - pp_c_right_bracket (ppi); + 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 (ppi, TREE_OPERAND (e, 0)); - pp_c_left_paren (ppi); - pp_c_expression_list (ppi, TREE_OPERAND (e, 1)); - pp_c_right_paren (ppi); + pp_postfix_expression (pp, TREE_OPERAND (e, 0)); + pp_c_call_argument_list (pp, TREE_OPERAND (e, 1)); break; case ABS_EXPR: case FFS_EXPR: - pp_c_identifier (ppi, + pp_c_identifier (pp, code == ABS_EXPR ? "__builtin_abs" : "__builtin_ffs"); - pp_c_left_paren (ppi); - pp_c_expression (ppi, TREE_OPERAND (e, 0)); - pp_c_right_paren (ppi); + pp_c_left_paren (pp); + pp_expression (pp, TREE_OPERAND (e, 0)); + pp_c_right_paren (pp); break; case COMPONENT_REF: @@ -1082,86 +1096,94 @@ pp_c_postfix_expression (c_pretty_printer ppi, tree e) tree object = TREE_OPERAND (e, 0); if (TREE_CODE (object) == INDIRECT_REF) { - pp_postfix_expression (ppi, TREE_OPERAND (object, 0)); - pp_c_arrow (ppi); + pp_postfix_expression (pp, TREE_OPERAND (object, 0)); + pp_c_arrow (pp); } else { - pp_postfix_expression (ppi, object); - pp_c_dot (ppi); + pp_postfix_expression (pp, object); + pp_c_dot (pp); } - pp_c_expression (ppi, TREE_OPERAND (e, 1)); + pp_expression (pp, TREE_OPERAND (e, 1)); } break; case COMPLEX_CST: case VECTOR_CST: case COMPLEX_EXPR: - pp_c_left_paren (ppi); - pp_type_id (ppi, TREE_TYPE (e)); - pp_c_right_paren (ppi); - pp_c_left_brace (ppi); + pp_c_type_cast (pp, TREE_TYPE (e)); + pp_c_left_brace (pp); if (code == COMPLEX_CST) { - pp_c_expression (ppi, TREE_REALPART (e)); - pp_separate_with (ppi, ','); - pp_c_expression (ppi, TREE_IMAGPART (e)); + pp_expression (pp, TREE_REALPART (e)); + pp_separate_with (pp, ','); + pp_expression (pp, TREE_IMAGPART (e)); } else if (code == VECTOR_CST) - pp_c_expression_list (ppi, TREE_VECTOR_CST_ELTS (e)); + pp_c_expression_list (pp, TREE_VECTOR_CST_ELTS (e)); else if (code == COMPLEX_EXPR) { - pp_c_expression (ppi, TREE_OPERAND (e, 0)); - pp_separate_with (ppi, ','); - pp_c_expression (ppi, TREE_OPERAND (e, 1)); + pp_expression (pp, TREE_OPERAND (e, 0)); + pp_separate_with (pp, ','); + pp_expression (pp, TREE_OPERAND (e, 1)); } - pp_c_right_brace (ppi); + pp_c_right_brace (pp); break; case COMPOUND_LITERAL_EXPR: e = DECL_INITIAL (e); /* Fall through. */ case CONSTRUCTOR: - pp_initializer (ppi, e); + pp_initializer (pp, e); break; case VA_ARG_EXPR: - pp_c_identifier (ppi, "__builtin_va_arg"); - pp_c_left_paren (ppi); - pp_assignment_expression (ppi, TREE_OPERAND (e, 0)); - pp_separate_with (ppi, ','); - pp_type_id (ppi, TREE_TYPE (e)); - pp_c_right_paren (ppi); + 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 (ppi, TREE_OPERAND (e, 0)); + pp_c_id_expression (pp, TREE_OPERAND (e, 0)); break; } /* else fall through. */ default: - pp_primary_expression (ppi, e); + pp_primary_expression (pp, e); break; } } /* Print out an expression-list; E is expected to be a TREE_LIST */ void -pp_c_expression_list (c_pretty_printer ppi, tree e) +pp_c_expression_list (c_pretty_printer *pp, tree e) { for (; e != NULL_TREE; e = TREE_CHAIN (e)) { - pp_c_assignment_expression (ppi, TREE_VALUE (e)); + pp_expression (pp, TREE_VALUE (e)); if (TREE_CHAIN (e)) - pp_separate_with (ppi, ','); + pp_separate_with (pp, ','); } } +/* Print out an expression-list in parens, as in a function call. */ +void +pp_c_call_argument_list (c_pretty_printer *pp, tree t) +{ + pp_c_left_paren (pp); + if (t && TREE_CODE (t) == TREE_LIST) + pp_c_expression_list (pp, t); + pp_c_right_paren (pp); +} + /* unary-expression: postfix-expression ++ cast-expression @@ -1180,15 +1202,15 @@ pp_c_expression_list (c_pretty_printer ppi, tree e) __real__ unary-expression __imag__ unary-expression */ void -pp_c_unary_expression (c_pretty_printer ppi, tree e) +pp_c_unary_expression (c_pretty_printer *pp, tree e) { enum tree_code code = TREE_CODE (e); switch (code) { case PREINCREMENT_EXPR: case PREDECREMENT_EXPR: - pp_identifier (ppi, code == PREINCREMENT_EXPR ? "++" : "--"); - pp_c_unary_expression (ppi, TREE_OPERAND (e, 0)); + pp_identifier (pp, code == PREINCREMENT_EXPR ? "++" : "--"); + pp_c_unary_expression (pp, TREE_OPERAND (e, 0)); break; case ADDR_EXPR: @@ -1199,66 +1221,68 @@ pp_c_unary_expression (c_pretty_printer ppi, tree e) case CONJ_EXPR: /* String literal are used by address. */ if (code == ADDR_EXPR && TREE_CODE (TREE_OPERAND (e, 0)) != STRING_CST) - pp_ampersand (ppi); + pp_ampersand (pp); else if (code == INDIRECT_REF) - pp_c_star (ppi); + pp_c_star (pp); else if (code == NEGATE_EXPR) - pp_minus (ppi); + pp_minus (pp); else if (code == BIT_NOT_EXPR || code == CONJ_EXPR) - pp_complement (ppi); + pp_complement (pp); else if (code == TRUTH_NOT_EXPR) - pp_exclamation (ppi); - pp_c_cast_expression (ppi, TREE_OPERAND (e, 0)); + pp_exclamation (pp); + pp_c_cast_expression (pp, TREE_OPERAND (e, 0)); break; case SIZEOF_EXPR: case ALIGNOF_EXPR: - pp_c_identifier (ppi, code == SIZEOF_EXPR ? "sizeof" : "__alignof__"); - pp_c_whitespace (ppi); + pp_c_identifier (pp, code == SIZEOF_EXPR ? "sizeof" : "__alignof__"); + pp_c_whitespace (pp); if (TYPE_P (TREE_OPERAND (e, 0))) - { - pp_c_left_paren (ppi); - pp_type_id (ppi, TREE_OPERAND (e, 0)); - pp_c_right_paren (ppi); - } + pp_c_type_cast (pp, TREE_OPERAND (e, 0)); else - pp_unary_expression (ppi, TREE_OPERAND (e, 0)); + pp_unary_expression (pp, TREE_OPERAND (e, 0)); break; case REALPART_EXPR: case IMAGPART_EXPR: - pp_c_identifier (ppi, code == REALPART_EXPR ? "__real__" : "__imag__"); - pp_c_whitespace (ppi); - pp_unary_expression (ppi, TREE_OPERAND (e, 0)); + pp_c_identifier (pp, code == REALPART_EXPR ? "__real__" : "__imag__"); + pp_c_whitespace (pp); + pp_unary_expression (pp, TREE_OPERAND (e, 0)); break; default: - pp_postfix_expression (ppi, e); + pp_postfix_expression (pp, e); break; } } +/* cast-expression: + unary-expression + ( type-name ) cast-expression */ void -pp_c_cast_expression (c_pretty_printer ppi, tree e) +pp_c_cast_expression (c_pretty_printer *pp, tree e) { 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)); + pp_c_type_cast (pp, TREE_TYPE (e)); + pp_c_cast_expression (pp, TREE_OPERAND (e, 0)); break; default: - pp_unary_expression (ppi, e); + pp_unary_expression (pp, e); } } +/* multiplicative-expression: + cast-expression + multiplicative-expression * cast-expression + multiplicative-expression / cast-expression + multiplicative-expression % cast-expression */ static void -pp_c_multiplicative_expression (c_pretty_printer ppi, tree e) +pp_c_multiplicative_expression (c_pretty_printer *pp, tree e) { enum tree_code code = TREE_CODE (e); switch (code) @@ -1266,70 +1290,84 @@ pp_c_multiplicative_expression (c_pretty_printer ppi, tree e) case MULT_EXPR: case TRUNC_DIV_EXPR: case TRUNC_MOD_EXPR: - pp_multiplicative_expression (ppi, TREE_OPERAND (e, 0)); - pp_c_whitespace (ppi); + pp_multiplicative_expression (pp, TREE_OPERAND (e, 0)); + pp_c_whitespace (pp); if (code == MULT_EXPR) - pp_c_star (ppi); + pp_c_star (pp); else if (code == TRUNC_DIV_EXPR) - pp_slash (ppi); + pp_slash (pp); else - pp_modulo (ppi); - pp_c_whitespace (ppi); - pp_c_cast_expression (ppi, TREE_OPERAND (e, 1)); + pp_modulo (pp); + pp_c_whitespace (pp); + pp_c_cast_expression (pp, TREE_OPERAND (e, 1)); break; default: - pp_c_cast_expression (ppi, e); + pp_c_cast_expression (pp, e); break; } } +/* additive-expression: + multiplicative-expression + additive-expression + multiplicative-expression + additive-expression - multiplicative-expression */ static inline void -pp_c_additive_expression (c_pretty_printer ppi, tree e) +pp_c_additive_expression (c_pretty_printer *pp, tree e) { enum tree_code code = TREE_CODE (e); switch (code) { case PLUS_EXPR: case MINUS_EXPR: - pp_c_additive_expression (ppi, TREE_OPERAND (e, 0)); - pp_c_whitespace (ppi); + pp_c_additive_expression (pp, TREE_OPERAND (e, 0)); + pp_c_whitespace (pp); if (code == PLUS_EXPR) - pp_plus (ppi); + pp_plus (pp); else - pp_minus (ppi); - pp_c_whitespace (ppi); - pp_multiplicative_expression (ppi, TREE_OPERAND (e, 1)); + pp_minus (pp); + pp_c_whitespace (pp); + pp_multiplicative_expression (pp, TREE_OPERAND (e, 1)); break; default: - pp_multiplicative_expression (ppi, e); + pp_multiplicative_expression (pp, e); break; } } +/* additive-expression: + additive-expression + shift-expression << additive-expression + shift-expression >> additive-expression */ static inline void -pp_c_shift_expression (c_pretty_printer ppi, tree e) +pp_c_shift_expression (c_pretty_printer *pp, tree e) { enum tree_code code = TREE_CODE (e); switch (code) { case LSHIFT_EXPR: case RSHIFT_EXPR: - pp_c_shift_expression (ppi, TREE_OPERAND (e, 0)); - pp_c_whitespace (ppi); - pp_identifier (ppi, code == LSHIFT_EXPR ? "<<" : ">>"); - pp_c_whitespace (ppi); - pp_c_additive_expression (ppi, TREE_OPERAND (e, 1)); + pp_c_shift_expression (pp, TREE_OPERAND (e, 0)); + pp_c_whitespace (pp); + pp_identifier (pp, code == LSHIFT_EXPR ? "<<" : ">>"); + pp_c_whitespace (pp); + pp_c_additive_expression (pp, TREE_OPERAND (e, 1)); break; default: - pp_c_additive_expression (ppi, e); + pp_c_additive_expression (pp, e); } } +/* relational-expression: + shift-expression + relational-expression < shift-expression + relational-expression > shift-expression + relational-expression <= shift-expression + relational-expression >= shift-expression */ static void -pp_c_relational_expression (c_pretty_printer ppi, tree e) +pp_c_relational_expression (c_pretty_printer *pp, tree e) { enum tree_code code = TREE_CODE (e); switch (code) @@ -1338,176 +1376,212 @@ pp_c_relational_expression (c_pretty_printer ppi, tree e) case GT_EXPR: case LE_EXPR: case GE_EXPR: - pp_c_relational_expression (ppi, TREE_OPERAND (e, 0)); - pp_c_whitespace (ppi); + pp_c_relational_expression (pp, TREE_OPERAND (e, 0)); + pp_c_whitespace (pp); if (code == LT_EXPR) - pp_less (ppi); + pp_less (pp); else if (code == GT_EXPR) - pp_greater (ppi); + pp_greater (pp); else if (code == LE_EXPR) - pp_identifier (ppi, "<="); + pp_identifier (pp, "<="); else if (code == GE_EXPR) - pp_identifier (ppi, ">="); - pp_c_whitespace (ppi); - pp_c_shift_expression (ppi, TREE_OPERAND (e, 1)); + pp_identifier (pp, ">="); + pp_c_whitespace (pp); + pp_c_shift_expression (pp, TREE_OPERAND (e, 1)); break; default: - pp_c_shift_expression (ppi, e); + pp_c_shift_expression (pp, e); break; } } +/* equality-expression: + relational-expression + equality-expression == relational-expression + equality-equality != relational-expression */ static inline void -pp_c_equality_expression (c_pretty_printer ppi, tree e) +pp_c_equality_expression (c_pretty_printer *pp, tree e) { enum tree_code code = TREE_CODE (e); switch (code) { case EQ_EXPR: case NE_EXPR: - pp_c_equality_expression (ppi, TREE_OPERAND (e, 0)); - pp_c_whitespace (ppi); - pp_identifier (ppi, code == EQ_EXPR ? "==" : "!="); - pp_c_whitespace (ppi); - pp_c_relational_expression (ppi, TREE_OPERAND (e, 1)); + pp_c_equality_expression (pp, TREE_OPERAND (e, 0)); + pp_c_whitespace (pp); + pp_identifier (pp, code == EQ_EXPR ? "==" : "!="); + pp_c_whitespace (pp); + pp_c_relational_expression (pp, TREE_OPERAND (e, 1)); break; default: - pp_c_relational_expression (ppi, e); + pp_c_relational_expression (pp, e); break; } } +/* AND-expression: + equality-expression + AND-expression & equality-equality */ static inline void -pp_c_and_expression (c_pretty_printer ppi, tree e) +pp_c_and_expression (c_pretty_printer *pp, tree e) { if (TREE_CODE (e) == BIT_AND_EXPR) { - pp_c_and_expression (ppi, TREE_OPERAND (e, 0)); - pp_c_whitespace (ppi); - pp_ampersand (ppi); - pp_c_whitespace (ppi); - pp_c_equality_expression (ppi, TREE_OPERAND (e, 1)); + pp_c_and_expression (pp, TREE_OPERAND (e, 0)); + pp_c_whitespace (pp); + pp_ampersand (pp); + pp_c_whitespace (pp); + pp_c_equality_expression (pp, TREE_OPERAND (e, 1)); } else - pp_c_equality_expression (ppi, e); + pp_c_equality_expression (pp, e); } +/* exclusive-OR-expression: + AND-expression + exclusive-OR-expression ^ AND-expression */ static inline void -pp_c_exclusive_or_expression (c_pretty_printer ppi, tree e) +pp_c_exclusive_or_expression (c_pretty_printer *pp, tree e) { if (TREE_CODE (e) == BIT_XOR_EXPR) { - pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 0)); - pp_c_maybe_whitespace (ppi); - pp_carret (ppi); - pp_c_whitespace (ppi); - pp_c_and_expression (ppi, TREE_OPERAND (e, 1)); + pp_c_exclusive_or_expression (pp, TREE_OPERAND (e, 0)); + pp_c_maybe_whitespace (pp); + pp_carret (pp); + pp_c_whitespace (pp); + pp_c_and_expression (pp, TREE_OPERAND (e, 1)); } else - pp_c_and_expression (ppi, e); + pp_c_and_expression (pp, e); } +/* inclusive-OR-expression: + exclusive-OR-expression + inclusive-OR-expression | exclusive-OR-expression */ static inline void -pp_c_inclusive_or_expression (c_pretty_printer ppi, tree e) +pp_c_inclusive_or_expression (c_pretty_printer *pp, tree e) { if (TREE_CODE (e) == BIT_IOR_EXPR) { - pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 0)); - pp_c_whitespace (ppi); - pp_bar (ppi); - pp_c_whitespace (ppi); - pp_c_exclusive_or_expression (ppi, TREE_OPERAND (e, 1)); + pp_c_exclusive_or_expression (pp, TREE_OPERAND (e, 0)); + pp_c_whitespace (pp); + pp_bar (pp); + pp_c_whitespace (pp); + pp_c_exclusive_or_expression (pp, TREE_OPERAND (e, 1)); } else - pp_c_exclusive_or_expression (ppi, e); + pp_c_exclusive_or_expression (pp, e); } +/* logical-AND-expression: + inclusive-OR-expression + logical-AND-expression && inclusive-OR-expression */ static inline void -pp_c_logical_and_expression (c_pretty_printer ppi, tree e) +pp_c_logical_and_expression (c_pretty_printer *pp, tree e) { if (TREE_CODE (e) == TRUTH_ANDIF_EXPR) { - pp_c_logical_and_expression (ppi, TREE_OPERAND (e, 0)); - pp_c_whitespace (ppi); - pp_identifier (ppi, "&&"); - pp_c_whitespace (ppi); - pp_c_inclusive_or_expression (ppi, TREE_OPERAND (e, 1)); + pp_c_logical_and_expression (pp, TREE_OPERAND (e, 0)); + pp_c_whitespace (pp); + pp_identifier (pp, "&&"); + pp_c_whitespace (pp); + pp_c_inclusive_or_expression (pp, TREE_OPERAND (e, 1)); } else - pp_c_inclusive_or_expression (ppi, e); + pp_c_inclusive_or_expression (pp, e); } +/* logical-OR-expression: + logical-AND-expression + logical-OR-expression || logical-AND-expression */ void -pp_c_logical_or_expression (c_pretty_printer ppi, tree e) +pp_c_logical_or_expression (c_pretty_printer *pp, tree e) { if (TREE_CODE (e) == TRUTH_ORIF_EXPR) { - pp_c_logical_or_expression (ppi, TREE_OPERAND (e, 0)); - pp_c_whitespace (ppi); - pp_identifier (ppi, "||"); - pp_c_whitespace (ppi); - pp_c_logical_and_expression (ppi, TREE_OPERAND (e, 1)); + pp_c_logical_or_expression (pp, TREE_OPERAND (e, 0)); + pp_c_whitespace (pp); + pp_identifier (pp, "||"); + pp_c_whitespace (pp); + pp_c_logical_and_expression (pp, TREE_OPERAND (e, 1)); } else - pp_c_logical_and_expression (ppi, e); + pp_c_logical_and_expression (pp, e); } +/* conditional-expression: + logical-OR-expression + logical-OR-expression ? expression : conditional-expression */ static void -pp_c_conditional_expression (c_pretty_printer ppi, tree e) +pp_c_conditional_expression (c_pretty_printer *pp, tree e) { if (TREE_CODE (e) == COND_EXPR) { - pp_c_logical_or_expression (ppi, TREE_OPERAND (e, 0)); - pp_c_whitespace (ppi); - pp_question (ppi); - pp_c_whitespace (ppi); - pp_c_expression (ppi, TREE_OPERAND (e, 1)); - pp_c_maybe_whitespace (ppi); - pp_colon (ppi); - pp_c_whitespace (ppi); - pp_c_conditional_expression (ppi, TREE_OPERAND (e, 2)); + 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)); } else - pp_c_logical_or_expression (ppi, e); + pp_c_logical_or_expression (pp, e); } -/* Pretty-print a C assignment-expression. */ +/* assignment-expression: + conditional-expression + unary-expression assignment-operator assignment-expression + + assignment-expression: one of + = *= /= %= += -= >>= <<= &= ^= |= */ static void -pp_c_assignment_expression (c_pretty_printer ppi, tree e) +pp_c_assignment_expression (c_pretty_printer *pp, tree e) { if (TREE_CODE (e) == MODIFY_EXPR || TREE_CODE (e) == INIT_EXPR) { - pp_c_unary_expression (ppi, TREE_OPERAND (e, 0)); - pp_c_maybe_whitespace (ppi); - pp_equal (ppi); - pp_space (ppi); - pp_c_assignment_expression (ppi, TREE_OPERAND (e, 1)); + 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)); } else - pp_c_conditional_expression (ppi, e); + pp_c_conditional_expression (pp, e); } -/* Pretty-print an expression. */ +/* expression: + assignment-expression + expression , assignment-expression + + Implementation note: instead of going through the usual recursion + 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_c_primary_expression () + and pp_c_expression (). */ void -pp_c_expression (c_pretty_printer ppi, tree e) +pp_c_expression (c_pretty_printer *pp, tree e) { switch (TREE_CODE (e)) { case INTEGER_CST: - pp_c_integer_constant (ppi, e); + pp_c_integer_constant (pp, e); break; case REAL_CST: - pp_c_floating_constant (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; + case IDENTIFIER_NODE: case FUNCTION_DECL: case VAR_DECL: case CONST_DECL: @@ -1516,9 +1590,8 @@ pp_c_expression (c_pretty_printer ppi, tree e) case FIELD_DECL: case LABEL_DECL: case ERROR_MARK: - case TARGET_EXPR: case STMT_EXPR: - pp_primary_expression (ppi, e); + pp_primary_expression (pp, e); break; case POSTINCREMENT_EXPR: @@ -1535,7 +1608,7 @@ pp_c_expression (c_pretty_printer ppi, tree e) case COMPOUND_LITERAL_EXPR: case COMPLEX_EXPR: case VA_ARG_EXPR: - pp_postfix_expression (ppi, e); + pp_postfix_expression (pp, e); break; case CONJ_EXPR: @@ -1550,89 +1623,93 @@ pp_c_expression (c_pretty_printer ppi, tree e) case ALIGNOF_EXPR: case REALPART_EXPR: case IMAGPART_EXPR: - pp_c_unary_expression (ppi, e); + pp_c_unary_expression (pp, e); break; case FLOAT_EXPR: case FIX_TRUNC_EXPR: case CONVERT_EXPR: - pp_c_cast_expression (ppi, e); + pp_c_cast_expression (pp, e); break; case MULT_EXPR: case TRUNC_MOD_EXPR: case TRUNC_DIV_EXPR: - pp_multiplicative_expression (ppi, e); + pp_multiplicative_expression (pp, e); break; case LSHIFT_EXPR: case RSHIFT_EXPR: - pp_c_shift_expression (ppi, e); + pp_c_shift_expression (pp, e); break; case LT_EXPR: case GT_EXPR: case LE_EXPR: case GE_EXPR: - pp_c_relational_expression (ppi, e); + pp_c_relational_expression (pp, e); break; case BIT_AND_EXPR: - pp_c_and_expression (ppi, e); + pp_c_and_expression (pp, e); break; case BIT_XOR_EXPR: - pp_c_exclusive_or_expression (ppi, e); + pp_c_exclusive_or_expression (pp, e); break; case BIT_IOR_EXPR: - pp_c_inclusive_or_expression (ppi, e); + pp_c_inclusive_or_expression (pp, e); break; case TRUTH_ANDIF_EXPR: - pp_c_logical_and_expression (ppi, e); + pp_c_logical_and_expression (pp, e); break; case TRUTH_ORIF_EXPR: - pp_c_logical_or_expression (ppi, e); + pp_c_logical_or_expression (pp, e); break; case EQ_EXPR: case NE_EXPR: - pp_c_equality_expression (ppi, e); + pp_c_equality_expression (pp, e); break; case COND_EXPR: - pp_conditional_expression (ppi, e); + pp_conditional_expression (pp, e); break; case PLUS_EXPR: case MINUS_EXPR: - pp_c_additive_expression (ppi, e); + pp_c_additive_expression (pp, e); break; case MODIFY_EXPR: case INIT_EXPR: - pp_assignment_expression (ppi, e); + pp_assignment_expression (pp, e); break; case COMPOUND_EXPR: - pp_c_left_paren (ppi); - pp_c_expression (ppi, TREE_OPERAND (e, 0)); - pp_separate_with (ppi, ','); - pp_assignment_expression (ppi, TREE_OPERAND (e, 1)); - pp_c_right_paren (ppi); + 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); break; case NOP_EXPR: case NON_LVALUE_EXPR: case SAVE_EXPR: case UNSAVE_EXPR: - pp_c_expression (ppi, TREE_OPERAND (e, 0)); + pp_expression (pp, TREE_OPERAND (e, 0)); + break; + + case TARGET_EXPR: + pp_postfix_expression (pp, TREE_OPERAND (e, 1)); break; default: - pp_unsupported_tree (ppi, e); + pp_unsupported_tree (pp, e); break; } } @@ -1640,8 +1717,16 @@ pp_c_expression (c_pretty_printer ppi, tree e) /* Statements. */ + +/* statement: + labeled-statement + coumpound-statement + expression-statement + selection-statement + iteration-statement + jump-statement */ void -pp_c_statement (c_pretty_printer ppi, tree stmt) +pp_c_statement (c_pretty_printer *pp, tree stmt) { enum tree_code code; @@ -1651,164 +1736,193 @@ pp_c_statement (c_pretty_printer ppi, tree stmt) code = TREE_CODE (stmt); switch (code) { + /* labeled-statement: + identifier : statement + case constant-expression : statement + default : statement */ case LABEL_STMT: case CASE_LABEL: - if (pp_needs_newline (ppi)) - pp_newline_and_indent (ppi, -3); + if (pp_needs_newline (pp)) + pp_newline_and_indent (pp, -3); else - pp_indentation (ppi) -= 3; + pp_indentation (pp) -= 3; if (code == LABEL_STMT) - pp_tree_identifier (ppi, DECL_NAME (LABEL_STMT_LABEL (stmt))); + pp_tree_identifier (pp, DECL_NAME (LABEL_STMT_LABEL (stmt))); else if (code == CASE_LABEL) { if (CASE_LOW (stmt) == NULL_TREE) - pp_identifier (ppi, "default"); + pp_identifier (pp, "default"); else { - pp_c_identifier (ppi, "case"); - pp_c_whitespace (ppi); - pp_conditional_expression (ppi, CASE_LOW (stmt)); + pp_c_identifier (pp, "case"); + pp_c_whitespace (pp); + pp_conditional_expression (pp, CASE_LOW (stmt)); if (CASE_HIGH (stmt)) { - pp_identifier (ppi, "..."); - pp_conditional_expression (ppi, CASE_HIGH (stmt)); + pp_identifier (pp, "..."); + pp_conditional_expression (pp, CASE_HIGH (stmt)); } } } - pp_colon (ppi); - pp_indentation (ppi) += 3; - pp_needs_newline (ppi) = true; + pp_colon (pp); + pp_indentation (pp) += 3; + pp_needs_newline (pp) = true; break; + /* coumpound-statement: + { block-item-list(opt) } + + block-item-list: + block-item + block-item-list block-item + + block-item: + declaration + statement */ case COMPOUND_STMT: - if (pp_needs_newline (ppi)) - pp_newline_and_indent (ppi, 0); - pp_c_left_brace (ppi); - pp_newline_and_indent (ppi, 3); + if (pp_needs_newline (pp)) + pp_newline_and_indent (pp, 0); + pp_c_left_brace (pp); + pp_newline_and_indent (pp, 3); for (stmt = COMPOUND_BODY (stmt); stmt; stmt = TREE_CHAIN (stmt)) - pp_c_statement (ppi, stmt); - pp_newline_and_indent (ppi, -3); - pp_c_right_brace (ppi); - pp_needs_newline (ppi) = true; + pp_statement (pp, stmt); + pp_newline_and_indent (pp, -3); + pp_c_right_brace (pp); + pp_needs_newline (pp) = true; break; + /* expression-statement: + expression(opt) ; */ case EXPR_STMT: case CLEANUP_STMT: - if (pp_needs_newline (ppi)) - pp_newline_and_indent (ppi, 0); + if (pp_needs_newline (pp)) + pp_newline_and_indent (pp, 0); { tree e = code == EXPR_STMT ? EXPR_STMT_EXPR (stmt) : CLEANUP_EXPR (stmt); if (e) - pp_c_expression (ppi, e); + pp_expression (pp, e); } - pp_c_semicolon (ppi); - pp_needs_newline (ppi) = true; + pp_c_semicolon (pp); + pp_needs_newline (pp) = true; break; + /* selection-statement: + if ( expression ) statement + if ( expression ) statement else statement + switch ( expression ) statement */ case IF_STMT: - if (pp_needs_newline (ppi)) - pp_newline_and_indent (ppi, 0); - pp_c_identifier (ppi, "if"); - pp_c_whitespace (ppi); - pp_c_left_paren (ppi); - pp_c_expression (ppi, IF_COND (stmt)); - pp_c_right_paren (ppi); - pp_newline_and_indent (ppi, 3); - pp_statement (ppi, THEN_CLAUSE (stmt)); - pp_newline_and_indent (ppi, -3); + if (pp_needs_newline (pp)) + pp_newline_and_indent (pp, 0); + pp_c_identifier (pp, "if"); + pp_c_whitespace (pp); + pp_c_left_paren (pp); + pp_expression (pp, IF_COND (stmt)); + pp_c_right_paren (pp); + pp_newline_and_indent (pp, 3); + pp_statement (pp, THEN_CLAUSE (stmt)); + pp_newline_and_indent (pp, -3); if (ELSE_CLAUSE (stmt)) { tree else_clause = ELSE_CLAUSE (stmt); - pp_c_identifier (ppi, "else"); + pp_c_identifier (pp, "else"); if (TREE_CODE (else_clause) == IF_STMT) - pp_c_whitespace (ppi); + pp_c_whitespace (pp); else - pp_newline_and_indent (ppi, 3); - pp_statement (ppi, else_clause); + pp_newline_and_indent (pp, 3); + pp_statement (pp, else_clause); if (TREE_CODE (else_clause) != IF_STMT) - pp_newline_and_indent (ppi, -3); + pp_newline_and_indent (pp, -3); } break; case SWITCH_STMT: - 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_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; - + if (pp_needs_newline (pp)) + pp_newline_and_indent (pp, 0); + pp_c_identifier (pp, "switch"); + pp_space (pp); + pp_c_left_paren (pp); + pp_expression (pp, SWITCH_COND (stmt)); + pp_c_right_paren (pp); + pp_indentation (pp) += 3; + pp_needs_newline (pp) = true; + pp_statement (pp, SWITCH_BODY (stmt)); + pp_newline_and_indent (pp, -3); + break; + + /* iteration-statement: + while ( expression ) statement + do statement while ( expression ) ; + for ( expression(opt) ; expression(opt) ; expression(opt) ) statement + for ( declaration expression(opt) ; expression(opt) ) statement */ case WHILE_STMT: - 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_c_right_paren (ppi); - pp_newline_and_indent (ppi, 3); - pp_statement (ppi, WHILE_BODY (stmt)); - pp_indentation (ppi) -= 3; - pp_needs_newline (ppi) = true; + if (pp_needs_newline (pp)) + pp_newline_and_indent (pp, 0); + pp_c_identifier (pp, "while"); + pp_space (pp); + pp_c_left_paren (pp); + pp_expression (pp, WHILE_COND (stmt)); + pp_c_right_paren (pp); + pp_newline_and_indent (pp, 3); + pp_statement (pp, WHILE_BODY (stmt)); + pp_indentation (pp) -= 3; + pp_needs_newline (pp) = 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_newline_and_indent (ppi, -3); - pp_c_identifier (ppi, "while"); - pp_space (ppi); - pp_c_left_paren (ppi); - pp_c_expression (ppi, DO_COND (stmt)); - pp_c_right_paren (ppi); - pp_c_semicolon (ppi); - pp_needs_newline (ppi) = true; + if (pp_needs_newline (pp)) + pp_newline_and_indent (pp, 0); + pp_c_identifier (pp, "do"); + pp_newline_and_indent (pp, 3); + pp_statement (pp, DO_BODY (stmt)); + pp_newline_and_indent (pp, -3); + pp_c_identifier (pp, "while"); + pp_space (pp); + pp_c_left_paren (pp); + pp_expression (pp, DO_COND (stmt)); + pp_c_right_paren (pp); + pp_c_semicolon (pp); + pp_needs_newline (pp) = 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); + if (pp_needs_newline (pp)) + pp_newline_and_indent (pp, 0); + pp_c_identifier (pp, "for"); + pp_space (pp); + pp_c_left_paren (pp); if (FOR_INIT_STMT (stmt)) - pp_statement (ppi, FOR_INIT_STMT (stmt)); + pp_statement (pp, FOR_INIT_STMT (stmt)); else - pp_c_semicolon (ppi); - pp_needs_newline (ppi) = false; - pp_c_whitespace (ppi); + pp_c_semicolon (pp); + pp_needs_newline (pp) = false; + pp_c_whitespace (pp); if (FOR_COND (stmt)) - pp_c_expression (ppi, FOR_COND (stmt)); - pp_c_semicolon (ppi); - pp_needs_newline (ppi) = false; - pp_c_whitespace (ppi); + pp_expression (pp, FOR_COND (stmt)); + pp_c_semicolon (pp); + pp_needs_newline (pp) = false; + pp_c_whitespace (pp); if (FOR_EXPR (stmt)) - pp_c_expression (ppi, FOR_EXPR (stmt)); - pp_c_right_paren (ppi); - pp_newline_and_indent (ppi, 3); - pp_statement (ppi, FOR_BODY (stmt)); - pp_indentation (ppi) -= 3; - pp_needs_newline (ppi) = true; - break; - + pp_expression (pp, FOR_EXPR (stmt)); + pp_c_right_paren (pp); + pp_newline_and_indent (pp, 3); + pp_statement (pp, FOR_BODY (stmt)); + pp_indentation (pp) -= 3; + pp_needs_newline (pp) = true; + break; + + /* jump-statement: + goto identifier; + continue ; + return expression(opt) ; */ case BREAK_STMT: case CONTINUE_STMT: - if (pp_needs_newline (ppi)) - pp_newline_and_indent (ppi, 0); - pp_identifier (ppi, code == BREAK_STMT ? "break" : "continue"); - pp_c_semicolon (ppi); - pp_needs_newline (ppi) = true; + if (pp_needs_newline (pp)) + pp_newline_and_indent (pp, 0); + pp_identifier (pp, code == BREAK_STMT ? "break" : "continue"); + pp_c_semicolon (pp); + pp_needs_newline (pp) = true; break; case RETURN_STMT: @@ -1817,13 +1931,19 @@ pp_c_statement (c_pretty_printer ppi, tree stmt) tree e = code == RETURN_STMT ? RETURN_STMT_EXPR (stmt) : GOTO_DESTINATION (stmt); - if (pp_needs_newline (ppi)) - pp_newline_and_indent (ppi, 0); - pp_c_identifier (ppi, code == RETURN_STMT ? "return" : "goto"); + if (pp_needs_newline (pp)) + pp_newline_and_indent (pp, 0); + pp_c_identifier (pp, code == RETURN_STMT ? "return" : "goto"); + pp_c_whitespace (pp); if (e) - pp_c_expression (ppi, e); - pp_c_semicolon (ppi); - pp_needs_newline (ppi) = true; + { + if (TREE_CODE (e) == INIT_EXPR + && TREE_CODE (TREE_OPERAND (e, 0)) == RESULT_DECL) + e = TREE_OPERAND (e, 1); + pp_expression (pp, e); + } + pp_c_semicolon (pp); + pp_needs_newline (pp) = true; } break; @@ -1831,29 +1951,28 @@ pp_c_statement (c_pretty_printer ppi, tree stmt) if (!SCOPE_NULLIFIED_P (stmt) && SCOPE_NO_CLEANUPS_P (stmt)) { int i = 0; - if (pp_needs_newline (ppi)) - pp_newline_and_indent (ppi, 0); + if (pp_needs_newline (pp)) + pp_newline_and_indent (pp, 0); if (SCOPE_BEGIN_P (stmt)) { - pp_left_brace (ppi); + pp_left_brace (pp); i = 3; } else if (SCOPE_END_P (stmt)) { - pp_right_brace (ppi); + pp_right_brace (pp); i = -3; } - pp_indentation (ppi) += i; - pp_needs_newline (ppi) = true; + pp_indentation (pp) += i; + pp_needs_newline (pp) = true; } break; case DECL_STMT: - if (pp_needs_newline (ppi)) - pp_newline_and_indent (ppi, 0); - pp_declaration (ppi, DECL_STMT_DECL (stmt)); - pp_c_semicolon (ppi); - pp_needs_newline (ppi) = true; + if (pp_needs_newline (pp)) + pp_newline_and_indent (pp, 0); + pp_declaration (pp, DECL_STMT_DECL (stmt)); + pp_needs_newline (pp) = true; break; case ASM_STMT: @@ -1861,52 +1980,51 @@ pp_c_statement (c_pretty_printer ppi, tree stmt) bool has_volatile_p = ASM_VOLATILE_P (stmt); bool is_extended = has_volatile_p || ASM_INPUTS (stmt) || ASM_OUTPUTS (stmt) || ASM_CLOBBERS (stmt); - pp_c_identifier (ppi, is_extended ? "__asm__" : "asm"); + pp_c_identifier (pp, is_extended ? "__asm__" : "asm"); if (has_volatile_p) - pp_c_identifier (ppi, "__volatile__"); - pp_space (ppi); - pp_c_left_paren (ppi); - pp_c_string_literal (ppi, ASM_STRING (stmt)); + pp_c_identifier (pp, "__volatile__"); + pp_space (pp); + pp_c_left_paren (pp); + pp_c_string_literal (pp, ASM_STRING (stmt)); if (is_extended) { - pp_space (ppi); - pp_separate_with (ppi, ':'); + pp_space (pp); + pp_separate_with (pp, ':'); if (ASM_OUTPUTS (stmt)) - pp_c_expression (ppi, ASM_OUTPUTS (stmt)); - pp_space (ppi); - pp_separate_with (ppi, ':'); + pp_expression (pp, ASM_OUTPUTS (stmt)); + pp_space (pp); + pp_separate_with (pp, ':'); if (ASM_INPUTS (stmt)) - pp_c_expression (ppi, ASM_INPUTS (stmt)); - pp_space (ppi); - pp_separate_with (ppi, ':'); + pp_expression (pp, ASM_INPUTS (stmt)); + pp_space (pp); + pp_separate_with (pp, ':'); if (ASM_CLOBBERS (stmt)) - pp_c_expression (ppi, ASM_CLOBBERS (stmt)); + pp_expression (pp, ASM_CLOBBERS (stmt)); } - pp_c_right_paren (ppi); - pp_newline (ppi); + pp_c_right_paren (pp); + pp_newline (pp); } break; case FILE_STMT: - pp_c_identifier (ppi, "__FILE__"); - pp_space (ppi); - pp_equal (ppi); - pp_c_whitespace (ppi); - pp_c_identifier (ppi, FILE_STMT_FILENAME (stmt)); - pp_c_semicolon (ppi); - pp_needs_newline (ppi) = true; + pp_c_identifier (pp, "__FILE__"); + pp_space (pp); + pp_equal (pp); + pp_c_whitespace (pp); + pp_c_identifier (pp, FILE_STMT_FILENAME (stmt)); + pp_c_semicolon (pp); + pp_needs_newline (pp) = true; break; default: - pp_unsupported_tree (ppi, stmt); + pp_unsupported_tree (pp, stmt); } - } /* Initialize the PRETTY-PRINTER for handling C codes. */ void -pp_c_pretty_printer_init (c_pretty_printer pp) +pp_c_pretty_printer_init (c_pretty_printer *pp) { pp->offset_list = 0; @@ -1914,10 +2032,13 @@ pp_c_pretty_printer_init (c_pretty_printer pp) pp->declaration_specifiers = pp_c_declaration_specifiers; pp->declarator = pp_c_declarator; pp->direct_declarator = pp_c_direct_declarator; - pp->type_specifier = pp_c_simple_type_specifier; + pp->type_specifier_seq = pp_c_specifier_qualifier_list; pp->abstract_declarator = pp_c_abstract_declarator; - pp->parameter_declaration = pp_c_parameter_declaration; + pp->direct_abstract_declarator = pp_c_direct_abstract_declarator; + pp->ptr_operator = pp_c_pointer; + pp->parameter_list = pp_c_parameter_type_list; pp->type_id = pp_c_type_id; + pp->simple_type_specifier = pp_c_type_specifier; pp->function_specifier = pp_c_function_specifier; pp->storage_class_specifier = pp_c_storage_class_specifier; @@ -1931,4 +2052,5 @@ pp_c_pretty_printer_init (c_pretty_printer pp) pp->multiplicative_expression = pp_c_multiplicative_expression; pp->conditional_expression = pp_c_conditional_expression; pp->assignment_expression = pp_c_assignment_expression; + pp->expression = pp_c_expression; }