rename bitwise_negate to complement

diff --git a/ast.c b/ast.c
index d08da8c..c38c2b0 100644 (file)
--- a/ast.c
+++ b/ast.c
@@ -124,7 +124,7 @@ static unsigned get_expression_precedence(expression_kind_t kind)
 
                [EXPR_UNARY_NEGATE]               = PREC_UNARY,
                [EXPR_UNARY_PLUS]                 = PREC_UNARY,
-               [EXPR_UNARY_BITWISE_NEGATE]       = PREC_UNARY,
+               [EXPR_UNARY_COMPLEMENT]           = PREC_UNARY,
                [EXPR_UNARY_NOT]                  = PREC_UNARY,
                [EXPR_UNARY_DEREFERENCE]          = PREC_UNARY,
                [EXPR_UNARY_TAKE_ADDRESS]         = PREC_UNARY,
@@ -359,7 +359,7 @@ static void print_unary_expression(const unary_expression_t *unexpr)
        case EXPR_UNARY_NEGATE:           print_char  ('-' ); break;
        case EXPR_UNARY_PLUS:             print_char  ('+' ); break;
        case EXPR_UNARY_NOT:              print_char  ('!' ); break;
-       case EXPR_UNARY_BITWISE_NEGATE:   print_char  ('~' ); break;
+       case EXPR_UNARY_COMPLEMENT:       print_char  ('~' ); break;
        case EXPR_UNARY_PREFIX_INCREMENT: print_string("++"); break;
        case EXPR_UNARY_PREFIX_DECREMENT: print_string("--"); break;
        case EXPR_UNARY_DEREFERENCE:      print_char  ('*' ); break;
@@ -1835,7 +1835,7 @@ check_type:
 
        case EXPR_UNARY_NEGATE:
        case EXPR_UNARY_PLUS:
-       case EXPR_UNARY_BITWISE_NEGATE:
+       case EXPR_UNARY_COMPLEMENT:
        case EXPR_UNARY_NOT:
                return is_constant_expression(expression->unary.value);
 

diff --git a/ast2firm.c b/ast2firm.c
index 129ffde..0decc0f 100644 (file)
--- a/ast2firm.c
+++ b/ast2firm.c
@@ -3194,7 +3194,7 @@ incdec:
        case EXPR_STATEMENT:                  return statement_expression_to_firm(    &expr->statement);
        case EXPR_STRING_LITERAL:             return string_to_firm(                  &expr->base.pos, "str.%u", &expr->string_literal.value);
        case EXPR_UNARY_ASSUME:               return handle_assume(                    expr->unary.value);
-       case EXPR_UNARY_BITWISE_NEGATE:       return complement_to_firm(              &expr->unary);
+       case EXPR_UNARY_COMPLEMENT:           return complement_to_firm(              &expr->unary);
        case EXPR_UNARY_DEREFERENCE:          return dereference_to_firm(             &expr->unary);
        case EXPR_UNARY_NEGATE:               return negate_to_firm(                  &expr->unary);
        case EXPR_UNARY_PLUS:                 return expression_to_value(              expr->unary.value);

diff --git a/ast_t.h b/ast_t.h
index 917f2aa..5764883 100644 (file)
--- a/ast_t.h
+++ b/ast_t.h
@@ -93,7 +93,7 @@ typedef enum expression_kind_t {
        EXPR_UNARY_FIRST,
        EXPR_UNARY_NEGATE = EXPR_UNARY_FIRST,
        EXPR_UNARY_PLUS,
-       EXPR_UNARY_BITWISE_NEGATE,
+       EXPR_UNARY_COMPLEMENT,
        EXPR_UNARY_NOT,
        EXPR_UNARY_DEREFERENCE,
        EXPR_UNARY_TAKE_ADDRESS,
@@ -201,7 +201,7 @@ typedef enum funcname_kind_t {
 #define EXPR_UNARY_CASES_MANDATORY   \
             EXPR_UNARY_NEGATE:            \
        case EXPR_UNARY_PLUS:              \
-       case EXPR_UNARY_BITWISE_NEGATE:    \
+       case EXPR_UNARY_COMPLEMENT:        \
        case EXPR_UNARY_NOT:               \
        case EXPR_UNARY_DEREFERENCE:       \
        case EXPR_UNARY_TAKE_ADDRESS:      \

diff --git a/parser.c b/parser.c
index fe3e55f..d3f650e 100644 (file)
--- a/parser.c
+++ b/parser.c
@@ -1439,7 +1439,7 @@ static void mark_vars_read(expression_t *const expr, entity_t *lhs_ent)
 
                case EXPR_UNARY_NEGATE:
                case EXPR_UNARY_PLUS:
-               case EXPR_UNARY_BITWISE_NEGATE:
+               case EXPR_UNARY_COMPLEMENT:
                case EXPR_UNARY_NOT:
                case EXPR_UNARY_TAKE_ADDRESS:
                case EXPR_UNARY_POSTFIX_INCREMENT:
@@ -7568,7 +7568,7 @@ static void semantic_not(unary_expression_t *expression)
        expression->base.type = c_mode & _CXX ? type_bool : type_int;
 }
 
-static void semantic_unexpr_integer(unary_expression_t *expression)
+static void semantic_complement(unary_expression_t *expression)
 {
        type_t *const orig_type = expression->value->base.type;
        type_t *const type      = skip_typeref(orig_type);
@@ -7673,8 +7673,8 @@ CREATE_UNARY_EXPRESSION_PARSER('*', EXPR_UNARY_DEREFERENCE,
                                semantic_dereference)
 CREATE_UNARY_EXPRESSION_PARSER('&', EXPR_UNARY_TAKE_ADDRESS,
                                semantic_take_addr)
-CREATE_UNARY_EXPRESSION_PARSER('~', EXPR_UNARY_BITWISE_NEGATE,
-                               semantic_unexpr_integer)
+CREATE_UNARY_EXPRESSION_PARSER('~', EXPR_UNARY_COMPLEMENT,
+                               semantic_complement)
 CREATE_UNARY_EXPRESSION_PARSER(T_PLUSPLUS,   EXPR_UNARY_PREFIX_INCREMENT,
                                semantic_incdec)
 CREATE_UNARY_EXPRESSION_PARSER(T_MINUSMINUS, EXPR_UNARY_PREFIX_DECREMENT,
@@ -8378,7 +8378,7 @@ static bool expression_has_effect(const expression_t *const expr)
 
                case EXPR_UNARY_NEGATE:               return false;
                case EXPR_UNARY_PLUS:                 return false;
-               case EXPR_UNARY_BITWISE_NEGATE:       return false;
+               case EXPR_UNARY_COMPLEMENT:           return false;
                case EXPR_UNARY_NOT:                  return false;
                case EXPR_UNARY_DEREFERENCE:          return false;
                case EXPR_UNARY_TAKE_ADDRESS:         return false;
@@ -8624,7 +8624,7 @@ static void init_expression_parsers(void)
        register_expression_parser(parse_EXPR_UNARY_NEGATE,           '-');
        register_expression_parser(parse_EXPR_UNARY_PLUS,             '+');
        register_expression_parser(parse_EXPR_UNARY_NOT,              '!');
-       register_expression_parser(parse_EXPR_UNARY_BITWISE_NEGATE,   '~');
+       register_expression_parser(parse_EXPR_UNARY_COMPLEMENT,       '~');
        register_expression_parser(parse_EXPR_UNARY_DEREFERENCE,      '*');
        register_expression_parser(parse_EXPR_UNARY_TAKE_ADDRESS,     '&');
        register_expression_parser(parse_EXPR_UNARY_PREFIX_INCREMENT, T_PLUSPLUS);