From 76a8ecba5ea85da902faee400bfc6655693f7f66 Mon Sep 17 00:00:00 2001 From: Gabriel Dos Reis Date: Mon, 29 Jul 2002 23:42:26 +0000 Subject: c-pretty-print.h (struct c_pretty_print_info): Add new member. 2002-07-30 Gabriel Dos Reis * c-pretty-print.h (struct c_pretty_print_info): Add new member. (pp_initializer): New macro. (pp_c_initializer): Declare. * c-pretty-print.c (pp_c_primary_expression): HAndle TARGET_EXPR. (pp_c_initializer): Define. (pp_c_initializer_list): New function. (pp_c_postfix_expression): Handle ABS_EXPR, COMPLEX_CST, VECTOR_CST, CONSTRUCTOR. (pp_c_unary_expression): Handle CONJ_EXPR, REALPART_EXPR, IMAGPART_EXPR. (pp_c_cast_expression): Handle FLOAT_EXPR. (pp_c_assignment_expression): Handle INIT_EXPR. (pp_c_expression): Update. From-SVN: r55856 --- gcc/ChangeLog | 16 ++++++ gcc/c-pretty-print.c | 149 ++++++++++++++++++++++++++++++++++++++++++++++++--- gcc/c-pretty-print.h | 3 ++ 3 files changed, 162 insertions(+), 6 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 58f1ff3..fcf6420 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,19 @@ +2002-07-30 Gabriel Dos Reis + + * c-pretty-print.h (struct c_pretty_print_info): Add new member. + (pp_initializer): New macro. + (pp_c_initializer): Declare. + * c-pretty-print.c (pp_c_primary_expression): HAndle TARGET_EXPR. + (pp_c_initializer): Define. + (pp_c_initializer_list): New function. + (pp_c_postfix_expression): Handle ABS_EXPR, COMPLEX_CST, + VECTOR_CST, CONSTRUCTOR. + (pp_c_unary_expression): Handle CONJ_EXPR, REALPART_EXPR, + IMAGPART_EXPR. + (pp_c_cast_expression): Handle FLOAT_EXPR. + (pp_c_assignment_expression): Handle INIT_EXPR. + (pp_c_expression): Update. + 2002-07-30 Neil Booth * objc/objc-act.c (objc_init): Return immediately if filename diff --git a/gcc/c-pretty-print.c b/gcc/c-pretty-print.c index c859cd7..20a8003 100644 --- a/gcc/c-pretty-print.c +++ b/gcc/c-pretty-print.c @@ -35,6 +35,9 @@ static void pp_c_string_literal PARAMS ((c_pretty_print_info *, tree)); static void pp_c_primary_expression PARAMS ((c_pretty_print_info *, tree)); +/* postfix-expression */ +static void pp_c_initializer_list PARAMS ((c_pretty_print_info *, tree)); + static void pp_c_unary_expression PARAMS ((c_pretty_print_info *, tree)); static void pp_c_multiplicative_expression PARAMS ((c_pretty_print_info *, tree)); @@ -316,6 +319,22 @@ pp_c_primary_expression (ppi, e) pp_c_literal (ppi, 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_c_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); + default: /* Make sure this call won't cause any infinite loop. */ pp_c_left_paren (ppi); @@ -325,6 +344,65 @@ pp_c_primary_expression (ppi, e) } } +/* Print out a C initializer -- also support C compound-literals. */ +void +pp_c_initializer (ppi, e) + c_pretty_print_info *ppi; + 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_left_brace (ppi); + pp_c_initializer_list (ppi, e); + pp_right_brace (ppi); + } + else + pp_unsupported_tree (ppi, TREE_OPERAND (e, 1)); + } + else + pp_assignment_expression (ppi, e); +} + +static void +pp_c_initializer_list (ppi, e) + c_pretty_print_info *ppi; + tree e; +{ + tree type = TREE_TYPE (e); + const enum tree_code code = TREE_CODE (type); + + if (code == RECORD_TYPE || code == UNION_TYPE || code == ARRAY_TYPE) + { + tree init = TREE_OPERAND (e, 1); + for (; init != NULL_TREE; init = TREE_CHAIN (init)) + { + if (code == RECORD_TYPE || code == UNION_TYPE) + { + pp_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_right_bracket (ppi); + } + pp_c_whitespace (ppi); + pp_equal (ppi); + pp_c_whitespace (ppi); + pp_initializer (ppi, TREE_VALUE (init)); + if (TREE_CHAIN (init)) + pp_separate_with (ppi, ','); + } + } + else + pp_unsupported_tree (ppi, type); +} + void pp_c_postfix_expression (ppi, e) c_pretty_print_info *ppi; @@ -353,6 +431,13 @@ pp_c_postfix_expression (ppi, e) pp_c_right_paren (ppi); break; + case ABS_EXPR: + pp_c_identifier (ppi, "abs"); + pp_c_left_paren (ppi); + pp_c_expression (ppi, TREE_OPERAND (e, 0)); + pp_c_right_paren (ppi); + break; + case COMPONENT_REF: { tree object = TREE_OPERAND (e, 0); @@ -370,10 +455,34 @@ pp_c_postfix_expression (ppi, e) } break; - case CONSTRUCTOR: case COMPLEX_CST: case VECTOR_CST: - pp_unsupported_tree (ppi, e); + case COMPLEX_EXPR: + pp_c_left_paren (ppi); + pp_type_id (ppi, TREE_TYPE (e)); + pp_c_right_paren (ppi); + pp_left_brace (ppi); + + if (code == COMPLEX_CST) + { + pp_c_expression (ppi, TREE_REALPART (e)); + pp_separate_with (ppi, ','); + pp_c_expression (ppi, TREE_IMAGPART (e)); + } + else if (code == VECTOR_CST) + pp_c_expression_list (ppi, 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_right_brace (ppi); + break; + + case CONSTRUCTOR: + pp_initializer (ppi, e); break; default: @@ -416,13 +525,14 @@ pp_c_unary_expression (ppi, e) case NEGATE_EXPR: case BIT_NOT_EXPR: case TRUTH_NOT_EXPR: + case CONJ_EXPR: if (code == ADDR_EXPR) pp_ampersand (ppi); else if (code == INDIRECT_REF) pp_star (ppi); else if (code == NEGATE_EXPR) pp_minus (ppi); - else if (code == BIT_NOT_EXPR) + else if (code == BIT_NOT_EXPR || code == CONJ_EXPR) pp_complement (ppi); else if (code == TRUTH_NOT_EXPR) pp_exclamation (ppi); @@ -443,6 +553,13 @@ pp_c_unary_expression (ppi, e) pp_c_unary_expression (ppi, 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)); + break; + default: pp_postfix_expression (ppi, e); break; @@ -454,7 +571,7 @@ pp_c_cast_expression (ppi, e) c_pretty_print_info *ppi; tree e; { - if (TREE_CODE (e) == CONVERT_EXPR) + if (TREE_CODE (e) == CONVERT_EXPR || TREE_CODE (e) == FLOAT_EXPR) { pp_c_left_paren (ppi); pp_type_id (ppi, TREE_TYPE (e)); @@ -710,7 +827,7 @@ pp_c_assignment_expression (ppi, e) c_pretty_print_info *ppi; tree e; { - if (TREE_CODE (e) == MODIFY_EXPR) + 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); @@ -750,6 +867,7 @@ pp_c_expression (ppi, e) case FIELD_DECL: case LABEL_DECL: case ERROR_MARK: + case TARGET_EXPR: pp_c_primary_expression (ppi, e); break; @@ -758,13 +876,31 @@ pp_c_expression (ppi, e) case ARRAY_REF: case CALL_EXPR: case COMPONENT_REF: - case CONSTRUCTOR: case COMPLEX_CST: case VECTOR_CST: + case ABS_EXPR: + case CONSTRUCTOR: + case COMPLEX_EXPR: pp_c_postfix_expression (ppi, e); break; + case CONJ_EXPR: + case ADDR_EXPR: + case INDIRECT_REF: + case NEGATE_EXPR: + case BIT_NOT_EXPR: + case TRUTH_NOT_EXPR: + case PREINCREMENT_EXPR: + case PREDECREMENT_EXPR: + case SIZEOF_EXPR: + case ALIGNOF_EXPR: + case REALPART_EXPR: + case IMAGPART_EXPR: + pp_c_unary_expression (ppi, e); + break; + case CONVERT_EXPR: + case FLOAT_EXPR: pp_c_cast_expression (ppi, e); break; @@ -811,6 +947,7 @@ pp_c_expression (ppi, e) break; case MODIFY_EXPR: + case INIT_EXPR: pp_c_assignment_expression (ppi, e); break; diff --git a/gcc/c-pretty-print.h b/gcc/c-pretty-print.h index f9b1d6b..53ff32f 100644 --- a/gcc/c-pretty-print.h +++ b/gcc/c-pretty-print.h @@ -53,6 +53,7 @@ struct c_pretty_print_info c_pretty_print_fn primary_expression; c_pretty_print_fn postfix_expression; c_pretty_print_fn unary_expression; + c_pretty_print_fn initializer; c_pretty_print_fn multiplicative_expression; c_pretty_print_fn conditional_expression; c_pretty_print_fn assignment_expression; @@ -115,6 +116,7 @@ struct c_pretty_print_info #define pp_primary_expression(PPI, E) (*(PPI)->primary_expression) (PPI, E) #define pp_postfix_expression(PPI, E) (*(PPI)->postfix_expression) (PPI, E) #define pp_unary_expression(PPI, E) (*(PPI)->unary_expression) (PPI, E) +#define pp_initializer(PPI, E) (*(PPI)->initializer) (PPI, E) #define pp_multiplicative_expression(PPI, E)\ (*(PPI)->multiplicative_expression) (PPI, E) #define pp_conditional_expession(PPI, E) \ @@ -136,4 +138,5 @@ void pp_c_logical_or_expression PARAMS ((c_pretty_print_info *, tree)); void pp_c_expression_list PARAMS ((c_pretty_print_info *, tree)); void pp_c_cast_expression PARAMS ((c_pretty_print_info *, tree)); void pp_c_postfix_expression PARAMS ((c_pretty_print_info *, tree)); +void pp_c_initializer PARAMS ((c_pretty_print_info *, tree)); void pp_c_literal PARAMS ((c_pretty_print_info *, tree)); -- cgit v1.1