diff options
| -rw-r--r-- | gcc/ChangeLog | 49 | ||||
| -rw-r--r-- | gcc/Makefile.in | 3 | ||||
| -rw-r--r-- | gcc/c-lang.c | 20 | ||||
| -rw-r--r-- | gcc/c-pretty-print.c | 911 | ||||
| -rw-r--r-- | gcc/c-pretty-print.h | 103 | ||||
| -rw-r--r-- | gcc/cp/ChangeLog | 23 | ||||
| -rw-r--r-- | gcc/cp/cxx-pretty-print.c | 576 | ||||
| -rw-r--r-- | gcc/cp/cxx-pretty-print.h | 9 | ||||
| -rw-r--r-- | gcc/cp/error.c | 37 | ||||
| -rw-r--r-- | gcc/pretty-print.c | 28 | ||||
| -rw-r--r-- | gcc/pretty-print.h | 5 |
11 files changed, 1432 insertions, 332 deletions
diff --git a/gcc/ChangeLog b/gcc/ChangeLog index e94265e..407250f 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,52 @@ +2003-08-10 Gabriel Dos Reis <gdr@integrable-solutions.net> + + * pretty-print.c (pp_base_indent): Rename from pp_indent. + * c-pretty-print.h (pp_c_pretty_print_flag)s: New datatype. + (struct c_pretty_print_info): Add more fields. + (pp_c_left_paren): Move to c-pretty-print.c. + (pp_c_right_paren): Likewise. + (pp_c_left_brace): Likewise. + (pp_c_right_brace): Likewise. + (pp_c_left_bracket): Likewise. + (pp_c_right_bracket): Likewise. + (pp_c_declarator): Declare. + (pp_c_direct_declarator): Likewise. + (pp_c_specifier_qualifier_list): Likewise. + (pp_c_type_id): Likewise. + * c-pretty-print.c (pp_c_cv_qualifier): Change prootype. Rework.. + (pp_c_type_qualifier_list): New. + (pp_c_pointer): Likewise. + (pp_c_parameter_type_list): Likewise. + (pp_c_function_definition): Likewise. + (pp_c_id_expression): Likewise. + (pp_c_simple_type_specifier): Tidy. + (pp_c_unary_expression): Likewise. + (pp_c_expression): Likewise. + (pp_c_pretty_printer_init): Likewise. + (pp_c_specifier_qualifier_list): Rework.. + (pp_c_abstract_declarator): Likewise. + (pp_c_postfix_expression): Likewise. + (pp_c_primary_expression): Likewise. + (pp_c_cast_expression): Likewise. + (pp_c_direct_abstract_declarator): Likewise. + (pp_c_storage_class_specifier): Likewise. + (pp_c_function_specifier): Likewise. + (pp_c_declaration_specifiers): Likewise. + (pp_c_direct_declarator): Likewise. + (pp_c_declarator): Likewise. + (pp_c_declaration): Likewise. + (pp_c_statement): Likewise. + (pp_c_integer_constant): Rename from pp_c_integer_literal. + (pp_c_character_constant): Rename from pp_c_character_literal. + (pp_c_bool_constant): Rename from pp_c_bool_literal. + (pp_c_enumeration_constant): Rename from pp_c_enumerator. + (pp_c_floating_constant): Rename from pp_c_real_literal. + (pp_c_constant): Rename from pp_c_literal. + * c-lang.c: Include diagnostic.h and c-pretty-print.h + (LANG_HOOKS_INITIALIZE_DIAGNOSTITCS): Define. + (c_initialize_diagnostics): New. + * Makefile.in (c-lang.o): Update dependency. + 2003-08-10 Nathan Sidwell <nathan@codesourcery.com> * c-typeck.c (digest_init): Add conversion for VECTOR_TYPEs. diff --git a/gcc/Makefile.in b/gcc/Makefile.in index 9308c28..753e42b 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -1280,7 +1280,8 @@ c-decl.o : c-decl.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_H) \ $(LANGHOOKS_DEF_H) c-typeck.o : c-typeck.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_H) $(C_TREE_H) \ $(TARGET_H) flags.h intl.h output.h $(EXPR_H) $(RTL_H) toplev.h $(TM_P_H) -c-lang.o : c-lang.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_H) $(C_TREE_H) \ +c-lang.o : c-lang.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_H) \ + $(C_TREE_H) $(C_PRETTY_PRINT_H) $(DIAGNOSTIC_H) \ $(GGC_H) langhooks.h $(LANGHOOKS_DEF_H) $(C_COMMON_H) gtype-c.h c-lex.o : c-lex.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_H) \ $(RTL_H) debug.h $(C_TREE_H) $(C_COMMON_H) real.h c-incpath.h cppdefault.h \ diff --git a/gcc/c-lang.c b/gcc/c-lang.c index d998e19..6504501 100644 --- a/gcc/c-lang.c +++ b/gcc/c-lang.c @@ -30,6 +30,10 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "ggc.h" #include "langhooks.h" #include "langhooks-def.h" +#include "diagnostic.h" +#include "c-pretty-print.h" + +static void c_initialize_diagnostics (diagnostic_context *); enum c_language_kind c_language = clk_c; @@ -43,6 +47,8 @@ enum c_language_kind c_language = clk_c; #define LANG_HOOKS_FINISH c_common_finish #undef LANG_HOOKS_INIT_OPTIONS #define LANG_HOOKS_INIT_OPTIONS c_common_init_options +#undef LANG_HOOKS_INITIALIZE_DIAGNOSTITCS +#define LANG_HOOKS_INITIALIZE_DIAGNOSTITCS c_initialize_diagnostics #undef LANG_HOOKS_HANDLE_OPTION #define LANG_HOOKS_HANDLE_OPTION c_common_handle_option #undef LANG_HOOKS_MISSING_ARGUMENT @@ -218,4 +224,18 @@ finish_file (void) c_objc_common_finish_file (); } +static void +c_initialize_diagnostics (diagnostic_context *context) +{ + pretty_printer *base = context->printer; + c_pretty_printer pp = xmalloc (sizeof *pp); + memcpy (pp_base (pp), base, sizeof (pretty_printer)); + pp_c_pretty_printer_init (pp); + context->printer = (pretty_printer *) pp; + + /* It is safe to free this object because it was previously malloc()'d. */ + free (base); +} + + #include "gtype-c.h" diff --git a/gcc/c-pretty-print.c b/gcc/c-pretty-print.c index 58a66e0..ee4d2a4 100644 --- a/gcc/c-pretty-print.c +++ b/gcc/c-pretty-print.c @@ -34,18 +34,85 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA 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); @@ -60,14 +127,10 @@ 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_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); @@ -75,21 +138,60 @@ static void pp_c_function_specifier (c_pretty_printer, tree); /* 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); + } } /* @@ -115,7 +217,12 @@ pp_c_cv_qualifier (c_pretty_printer ppi, int cv) 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: @@ -137,7 +244,7 @@ pp_c_simple_type_specifier (c_pretty_printer ppi, tree t) 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: @@ -151,7 +258,7 @@ pp_c_simple_type_specifier (c_pretty_printer ppi, tree t) 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; @@ -169,38 +276,182 @@ pp_c_simple_type_specifier (c_pretty_printer ppi, tree t) 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 @@ -208,8 +459,13 @@ pp_c_storage_class_specifier (c_pretty_printer pp, tree t) { 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 @@ -219,27 +475,108 @@ pp_c_function_specifier (c_pretty_printer pp, tree t) 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) { @@ -253,6 +590,9 @@ 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) { @@ -293,6 +633,19 @@ pp_c_attributes (c_pretty_printer pp, tree attributes) 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); +} + /* Expressions. */ @@ -354,43 +707,67 @@ pp_c_string_literal (c_pretty_printer ppi, tree s) 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 @@ -398,8 +775,9 @@ pp_c_bool_literal (c_pretty_printer ppi, 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_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; @@ -410,86 +788,81 @@ pp_c_enumerator (c_pretty_printer ppi, tree e) ; 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) { @@ -518,7 +891,7 @@ 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: @@ -526,7 +899,7 @@ pp_c_primary_expression (c_pretty_printer ppi, tree e) 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)); @@ -544,7 +917,7 @@ pp_c_primary_expression (c_pretty_printer ppi, tree e) 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); @@ -552,7 +925,12 @@ pp_c_primary_expression (c_pretty_printer ppi, tree e) } } -/* 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) { @@ -561,9 +939,9 @@ 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)); @@ -572,6 +950,20 @@ pp_c_initializer (c_pretty_printer ppi, tree e) 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) { @@ -580,19 +972,19 @@ 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); @@ -607,6 +999,44 @@ pp_c_initializer_list (c_pretty_printer ppi, tree e) 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) { @@ -621,7 +1051,7 @@ 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: @@ -653,12 +1083,12 @@ pp_c_postfix_expression (c_pretty_printer ppi, tree e) 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)); } @@ -670,7 +1100,7 @@ pp_c_postfix_expression (c_pretty_printer ppi, tree e) 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) { @@ -687,7 +1117,7 @@ pp_c_postfix_expression (c_pretty_printer ppi, tree e) pp_c_expression (ppi, TREE_OPERAND (e, 1)); } - pp_right_brace (ppi); + pp_c_right_brace (ppi); break; case COMPOUND_LITERAL_EXPR: @@ -706,6 +1136,14 @@ pp_c_postfix_expression (c_pretty_printer ppi, tree e) 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; @@ -741,7 +1179,7 @@ pp_c_expression_list (c_pretty_printer ppi, tree e) __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); @@ -759,10 +1197,11 @@ pp_c_unary_expression (c_pretty_printer ppi, tree 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) @@ -783,7 +1222,7 @@ pp_c_unary_expression (c_pretty_printer ppi, tree e) 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: @@ -802,15 +1241,20 @@ pp_c_unary_expression (c_pretty_printer ppi, tree e) 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 @@ -822,10 +1266,10 @@ pp_c_multiplicative_expression (c_pretty_printer ppi, tree e) 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 @@ -855,7 +1299,7 @@ pp_c_additive_expression (c_pretty_printer ppi, tree e) 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: @@ -923,7 +1367,7 @@ pp_c_equality_expression (c_pretty_printer ppi, tree e) 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)); @@ -941,7 +1385,7 @@ pp_c_and_expression (c_pretty_printer ppi, tree e) 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)); @@ -971,7 +1415,7 @@ pp_c_inclusive_or_expression (c_pretty_printer ppi, tree e) 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)); @@ -986,7 +1430,7 @@ pp_c_logical_and_expression (c_pretty_printer ppi, tree e) 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)); @@ -1001,7 +1445,7 @@ pp_c_logical_or_expression (c_pretty_printer ppi, tree e) 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)); @@ -1016,7 +1460,7 @@ pp_c_conditional_expression (c_pretty_printer ppi, tree e) 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)); @@ -1053,11 +1497,11 @@ pp_c_expression (c_pretty_printer ppi, tree e) 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: @@ -1074,7 +1518,7 @@ pp_c_expression (c_pretty_printer ppi, tree e) case ERROR_MARK: case TARGET_EXPR: case STMT_EXPR: - pp_c_primary_expression (ppi, e); + pp_primary_expression (ppi, e); break; case POSTINCREMENT_EXPR: @@ -1091,7 +1535,7 @@ pp_c_expression (c_pretty_printer ppi, tree e) 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: @@ -1109,15 +1553,16 @@ pp_c_expression (c_pretty_printer ppi, tree e) 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: @@ -1152,17 +1597,23 @@ pp_c_expression (c_pretty_printer ppi, tree e) 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: @@ -1173,27 +1624,42 @@ pp_c_expression (c_pretty_printer ppi, tree e) 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; } } + /* 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"); @@ -1210,35 +1676,45 @@ pp_c_statement (c_pretty_printer ppi, tree stmt) } } 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); @@ -1257,29 +1733,36 @@ pp_c_statement (c_pretty_printer ppi, tree stmt) 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)); @@ -1289,34 +1772,43 @@ pp_c_statement (c_pretty_printer ppi, tree 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: @@ -1325,36 +1817,43 @@ pp_c_statement (c_pretty_printer ppi, tree 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: @@ -1383,7 +1882,7 @@ pp_c_statement (c_pretty_printer ppi, tree 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; @@ -1394,8 +1893,8 @@ pp_c_statement (c_pretty_printer ppi, tree stmt) 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: @@ -1413,14 +1912,18 @@ pp_c_pretty_printer_init (c_pretty_printer pp) 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; diff --git a/gcc/c-pretty-print.h b/gcc/c-pretty-print.h index c093300..8052662 100644 --- a/gcc/c-pretty-print.h +++ b/gcc/c-pretty-print.h @@ -27,6 +27,13 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #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; @@ -41,18 +48,24 @@ struct c_pretty_print_info 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; @@ -65,78 +78,50 @@ struct c_pretty_print_info #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 @@ -146,22 +131,28 @@ struct c_pretty_print_info 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 */ diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 47c1afc..fde090e 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,26 @@ +2003-08-10 Gabriel Dos Reis <gdr@integrable-solutions.net> + + * error.c (dump_expr): Tidy. + * cxx-pretty-print.c (pp_cxx_nonconsecutive_character): New. + (pp_cxx_begin_template_argument_list): Likewise. + (pp_cxx_end_template_argument_list): Likewise. + (is_destructor_name): Likewise. + (pp_cxx_unqualified_id): Likewise. + (pp_cxx_qualified_id): Likewise. + (pp_cxx_id_expression): Likewise. + (pp_cxx_new_expression): Likewise. + (pp_cxx_delete_expression): Likewise. + (pp_cxx_pm_expression): Likewise. + (pp_cxx_type_specifier): Rework. + (pp_cxx_type_id): Likewise. + (pp_cxx_primary_expression): Likewise. + (pp_cxx_postfix_expression): Likewise. + (pp_cxx_unary_expression): Likewise. + (pp_cxx_multiplicative_expression): Likewise. + (pp_cxx_conditional_expression): Likewise. + (pp_cxx_assignment_expression): Likewise. + (pp_cxx_pretty_printer_init): Tidy. + 2003-08-10 Nathan Sidwell <nathan@codesourcery.com> * cp-tree.h (TMPL_ARGS_HAVE_MULTIPLE_LEVELS): non-NULL diff --git a/gcc/cp/cxx-pretty-print.c b/gcc/cp/cxx-pretty-print.c index 1595ede..83e4381 100644 --- a/gcc/cp/cxx-pretty-print.c +++ b/gcc/cp/cxx-pretty-print.c @@ -26,7 +26,28 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #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); + +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 @@ -40,23 +61,55 @@ pp_cxx_declaration_specifiers (cxx_pretty_printer *pp, tree t) { 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 @@ -65,12 +118,78 @@ pp_cxx_parameter_declaration (cxx_pretty_printer *pp, tree t) 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 @@ -81,52 +200,470 @@ pp_cxx_statement (cxx_pretty_printer *pp, tree t) /* 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); } @@ -146,11 +683,12 @@ pp_cxx_pretty_printer_init (cxx_pretty_printer *pp) 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; diff --git a/gcc/cp/cxx-pretty-print.h b/gcc/cp/cxx-pretty-print.h index aa93ba4..514f253 100644 --- a/gcc/cp/cxx-pretty-print.h +++ b/gcc/cp/cxx-pretty-print.h @@ -27,6 +27,14 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #undef pp_c_base #define pp_c_base(PP) (&(PP)->c_base) +typedef enum +{ + /* Ask for an qualified-id. */ + pp_cxx_flag_qualified_id = 1 << pp_c_flag_last_bit, + pp_cxx_flag_global_scope = 1 << (pp_c_flag_last_bit + 1) + +} cxx_pretty_printer_flags; + typedef struct { struct c_pretty_print_info c_base; @@ -38,7 +46,6 @@ void pp_cxx_pretty_printer_init (cxx_pretty_printer *); void pp_cxx_declaration (cxx_pretty_printer *, tree); void pp_cxx_statement (cxx_pretty_printer *, tree); -void pp_cxx_expression (cxx_pretty_printer *, tree); #endif /* GCC_CXX_PRETTY_PRINT_H */ diff --git a/gcc/cp/error.c b/gcc/cp/error.c index cd44f15..380a526 100644 --- a/gcc/cp/error.c +++ b/gcc/cp/error.c @@ -1331,38 +1331,9 @@ dump_expr (tree t, int flags) break; case INTEGER_CST: - { - tree type = TREE_TYPE (t); - my_friendly_assert (type != 0, 81); - - /* If it's an enum, output its tag, rather than its value. */ - if (TREE_CODE (type) == ENUMERAL_TYPE) - { - tree values = TYPE_VALUES (type); - - for (; values; - values = TREE_CHAIN (values)) - if (tree_int_cst_equal (TREE_VALUE (values), t)) - break; - - if (values) - pp_tree_identifier (cxx_pp, TREE_PURPOSE (values)); - else - { - /* Value must have been cast. */ - pp_left_paren (cxx_pp); - dump_type (type, flags); - pp_right_paren (cxx_pp); - pp_c_integer_literal (pp_c_base (cxx_pp), t); - } - } - else - pp_c_integer_literal (pp_c_base (cxx_pp), t); - } - break; - + case STRING_CST: case REAL_CST: - pp_c_real_literal (pp_c_base (cxx_pp), t); + pp_c_constant (pp_c_base (cxx_pp), t); break; case PTRMEM_CST: @@ -1372,10 +1343,6 @@ dump_expr (tree t, int flags) pp_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t))); break; - case STRING_CST: - pp_c_string_literal (pp_c_base (cxx_pp), t); - break; - case COMPOUND_EXPR: pp_left_paren (cxx_pp); dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS); diff --git a/gcc/pretty-print.c b/gcc/pretty-print.c index 9d0ed01..d865107 100644 --- a/gcc/pretty-print.c +++ b/gcc/pretty-print.c @@ -90,19 +90,6 @@ pp_clear_state (pretty_printer *pp) pp_indentation (pp) = 0; } -/* Insert enough spaces into the output area of PRETTY-PRINTER to bring - the column position to the current indentation level, assuming that a - newline has just been written to the buffer. */ -static void -pp_indent (pretty_printer *pp) -{ - int n = pp_indentation (pp); - int i; - - for (i = 0; i < n; ++i) - pp_space (pp); -} - /* Flush the formatted text of PRETTY-PRINTER onto the attached stream. */ static inline void pp_write_text_to_stream (pretty_printer *pp) @@ -164,6 +151,19 @@ pp_append_r (pretty_printer *pp, const char *start, int length) pp->buffer->line_length += length; } +/* Insert enough spaces into the output area of PRETTY-PRINTER to bring + the column position to the current indentation level, assuming that a + newline has just been written to the buffer. */ +void +pp_base_indent (pretty_printer *pp) +{ + int n = pp_indentation (pp); + int i; + + for (i = 0; i < n; ++i) + pp_space (pp); +} + /* Format a message pointed to by TEXT. The following format specifiers are recognized as being client independent: %d, %i: (signed) integer in base ten. @@ -399,7 +399,7 @@ pp_base_emit_prefix (pretty_printer *pp) case DIAGNOSTICS_SHOW_PREFIX_ONCE: if (pp->emitted_prefix) { - pp_indent (pp); + pp_base_indent (pp); break; } pp_indentation (pp) += 3; diff --git a/gcc/pretty-print.h b/gcc/pretty-print.h index 484f691..0fd00b3 100644 --- a/gcc/pretty-print.h +++ b/gcc/pretty-print.h @@ -108,8 +108,6 @@ struct pretty_print_info /* The prefix for each new line. */ const char *prefix; - - pp_flags flags; /* Where to put whitespace around the entity being formatted. */ pp_padding padding; @@ -202,6 +200,8 @@ struct pretty_print_info do { \ pp_indentation (PP) += N; \ pp_newline (PP); \ + pp_base_indent (pp_base (PP)); \ + pp_needs_newline (PP) = false; \ } while (0) #define pp_separate_with(PP, C) \ do { \ @@ -251,6 +251,7 @@ extern void pp_base_flush (pretty_printer *); extern void pp_base_format_text (pretty_printer *, text_info *); extern void pp_base_format_verbatim (pretty_printer *, text_info *); +extern void pp_base_indent (pretty_printer *); extern void pp_base_newline (pretty_printer *); extern void pp_base_character (pretty_printer *, int); extern void pp_base_string (pretty_printer *, const char *); |