Make our multi-case macros nicer for code beautifiers.

diff --git a/ast.c b/ast.c
index 883cd05..e7b503f 100644 (file)
--- a/ast.c
+++ b/ast.c
@@ -685,7 +685,7 @@ static void print_expression_prec(const expression_t *expression, unsigned top_p
        case EXPR_STRING_LITERAL:
                print_string_literal(&expression->string_literal);
                break;
-       EXPR_LITERAL_CASES
+       case EXPR_LITERAL_CASES:
                print_literal(&expression->literal);
                break;
        case EXPR_FUNCNAME:
@@ -697,7 +697,7 @@ static void print_expression_prec(const expression_t *expression, unsigned top_p
        case EXPR_CALL:
                print_call_expression(&expression->call);
                break;
-       EXPR_BINARY_CASES
+       case EXPR_BINARY_CASES:
                print_binary_expression(&expression->binary);
                break;
        case EXPR_REFERENCE:
@@ -710,7 +710,7 @@ static void print_expression_prec(const expression_t *expression, unsigned top_p
        case EXPR_LABEL_ADDRESS:
                print_label_address_expression(&expression->label_address);
                break;
-       EXPR_UNARY_CASES
+       case EXPR_UNARY_CASES:
                print_unary_expression(&expression->unary);
                break;
        case EXPR_SIZEOF:
@@ -1847,7 +1847,7 @@ static expression_classification_t is_object_with_constant_address(const express
 expression_classification_t is_constant_expression(const expression_t *expression)
 {
        switch (expression->kind) {
-       EXPR_LITERAL_CASES
+       case EXPR_LITERAL_CASES:
        case EXPR_CLASSIFY_TYPE:
        case EXPR_OFFSETOF:
        case EXPR_ALIGNOF:

diff --git a/ast2firm.c b/ast2firm.c
index 91ece40..06c60c2 100644 (file)
--- a/ast2firm.c
+++ b/ast2firm.c
@@ -2953,7 +2953,7 @@ static entity_t *get_expression_entity(const expression_t *expression)
 static unsigned get_cparser_entity_alignment(const entity_t *entity)
 {
        switch(entity->kind) {
-       DECLARATION_KIND_CASES
+       case DECLARATION_KIND_CASES:
                return entity->declaration.alignment;
        case ENTITY_STRUCT:
        case ENTITY_UNION:
@@ -3463,7 +3463,7 @@ static ir_node *_expression_to_firm(const expression_t *expression)
 #endif
 
        switch (expression->kind) {
-       EXPR_LITERAL_CASES
+       case EXPR_LITERAL_CASES:
                return literal_to_firm(&expression->literal);
        case EXPR_STRING_LITERAL:
                return string_to_firm(&expression->base.source_position, "str.%u",
@@ -3476,9 +3476,9 @@ static ir_node *_expression_to_firm(const expression_t *expression)
                return reference_expression_enum_value_to_firm(&expression->reference);
        case EXPR_CALL:
                return call_expression_to_firm(&expression->call);
-       EXPR_UNARY_CASES
+       case EXPR_UNARY_CASES:
                return unary_expression_to_firm(&expression->unary);
-       EXPR_BINARY_CASES
+       case EXPR_BINARY_CASES:
                return binary_expression_to_firm(&expression->binary);
        case EXPR_ARRAY_ACCESS:
                return array_access_to_firm(&expression->array_access);

diff --git a/ast_t.h b/ast_t.h
index 063cc60..31904c2 100644 (file)
--- a/ast_t.h
+++ b/ast_t.h
@@ -162,83 +162,83 @@ typedef enum funcname_kind_t {
 } funcname_kind_t;
 
 /* convenience macros */
-#define EXPR_BINARY_CASES                  \
-       case EXPR_BINARY_ADD:                  \
-       case EXPR_BINARY_SUB:                  \
-       case EXPR_BINARY_MUL:                  \
-       case EXPR_BINARY_DIV:                  \
-       case EXPR_BINARY_MOD:                  \
-       case EXPR_BINARY_EQUAL:                \
-       case EXPR_BINARY_NOTEQUAL:             \
-       case EXPR_BINARY_LESS:                 \
-       case EXPR_BINARY_LESSEQUAL:            \
-       case EXPR_BINARY_GREATER:              \
-       case EXPR_BINARY_GREATEREQUAL:         \
-       case EXPR_BINARY_BITWISE_AND:          \
-       case EXPR_BINARY_BITWISE_OR:           \
-       case EXPR_BINARY_BITWISE_XOR:          \
-       case EXPR_BINARY_LOGICAL_AND:          \
-       case EXPR_BINARY_LOGICAL_OR:           \
-       case EXPR_BINARY_SHIFTLEFT:            \
-       case EXPR_BINARY_SHIFTRIGHT:           \
-       case EXPR_BINARY_ASSIGN:               \
-       case EXPR_BINARY_MUL_ASSIGN:           \
-       case EXPR_BINARY_DIV_ASSIGN:           \
-       case EXPR_BINARY_MOD_ASSIGN:           \
-       case EXPR_BINARY_ADD_ASSIGN:           \
-       case EXPR_BINARY_SUB_ASSIGN:           \
-       case EXPR_BINARY_SHIFTLEFT_ASSIGN:     \
-       case EXPR_BINARY_SHIFTRIGHT_ASSIGN:    \
-       case EXPR_BINARY_BITWISE_AND_ASSIGN:   \
-       case EXPR_BINARY_BITWISE_XOR_ASSIGN:   \
-       case EXPR_BINARY_BITWISE_OR_ASSIGN:    \
-       case EXPR_BINARY_COMMA:                \
-       case EXPR_BINARY_ISGREATER:            \
-       case EXPR_BINARY_ISGREATEREQUAL:       \
-       case EXPR_BINARY_ISLESS:               \
-       case EXPR_BINARY_ISLESSEQUAL:          \
-       case EXPR_BINARY_ISLESSGREATER:        \
-       case EXPR_BINARY_ISUNORDERED:
+#define EXPR_BINARY_CASES              \
+            EXPR_BINARY_ADD:                \
+       case EXPR_BINARY_SUB:                \
+       case EXPR_BINARY_MUL:                \
+       case EXPR_BINARY_DIV:                \
+       case EXPR_BINARY_MOD:                \
+       case EXPR_BINARY_EQUAL:              \
+       case EXPR_BINARY_NOTEQUAL:           \
+       case EXPR_BINARY_LESS:               \
+       case EXPR_BINARY_LESSEQUAL:          \
+       case EXPR_BINARY_GREATER:            \
+       case EXPR_BINARY_GREATEREQUAL:       \
+       case EXPR_BINARY_BITWISE_AND:        \
+       case EXPR_BINARY_BITWISE_OR:         \
+       case EXPR_BINARY_BITWISE_XOR:        \
+       case EXPR_BINARY_LOGICAL_AND:        \
+       case EXPR_BINARY_LOGICAL_OR:         \
+       case EXPR_BINARY_SHIFTLEFT:          \
+       case EXPR_BINARY_SHIFTRIGHT:         \
+       case EXPR_BINARY_ASSIGN:             \
+       case EXPR_BINARY_MUL_ASSIGN:         \
+       case EXPR_BINARY_DIV_ASSIGN:         \
+       case EXPR_BINARY_MOD_ASSIGN:         \
+       case EXPR_BINARY_ADD_ASSIGN:         \
+       case EXPR_BINARY_SUB_ASSIGN:         \
+       case EXPR_BINARY_SHIFTLEFT_ASSIGN:   \
+       case EXPR_BINARY_SHIFTRIGHT_ASSIGN:  \
+       case EXPR_BINARY_BITWISE_AND_ASSIGN: \
+       case EXPR_BINARY_BITWISE_XOR_ASSIGN: \
+       case EXPR_BINARY_BITWISE_OR_ASSIGN:  \
+       case EXPR_BINARY_COMMA:              \
+       case EXPR_BINARY_ISGREATER:          \
+       case EXPR_BINARY_ISGREATEREQUAL:     \
+       case EXPR_BINARY_ISLESS:             \
+       case EXPR_BINARY_ISLESSEQUAL:        \
+       case EXPR_BINARY_ISLESSGREATER:      \
+       case EXPR_BINARY_ISUNORDERED
 
 /**
  * unary expression with mandatory operand
  */
-#define EXPR_UNARY_CASES_MANDATORY         \
-       case EXPR_UNARY_NEGATE:                \
-       case EXPR_UNARY_PLUS:                  \
-       case EXPR_UNARY_BITWISE_NEGATE:        \
-       case EXPR_UNARY_NOT:                   \
-       case EXPR_UNARY_DEREFERENCE:           \
-       case EXPR_UNARY_TAKE_ADDRESS:          \
-       case EXPR_UNARY_POSTFIX_INCREMENT:     \
-       case EXPR_UNARY_POSTFIX_DECREMENT:     \
-       case EXPR_UNARY_PREFIX_INCREMENT:      \
-       case EXPR_UNARY_PREFIX_DECREMENT:      \
-       case EXPR_UNARY_CAST:                  \
-       case EXPR_UNARY_ASSUME:                \
-       case EXPR_UNARY_DELETE:                \
-       case EXPR_UNARY_DELETE_ARRAY:
+#define EXPR_UNARY_CASES_MANDATORY   \
+            EXPR_UNARY_NEGATE:            \
+       case EXPR_UNARY_PLUS:              \
+       case EXPR_UNARY_BITWISE_NEGATE:    \
+       case EXPR_UNARY_NOT:               \
+       case EXPR_UNARY_DEREFERENCE:       \
+       case EXPR_UNARY_TAKE_ADDRESS:      \
+       case EXPR_UNARY_POSTFIX_INCREMENT: \
+       case EXPR_UNARY_POSTFIX_DECREMENT: \
+       case EXPR_UNARY_PREFIX_INCREMENT:  \
+       case EXPR_UNARY_PREFIX_DECREMENT:  \
+       case EXPR_UNARY_CAST:              \
+       case EXPR_UNARY_ASSUME:            \
+       case EXPR_UNARY_DELETE:            \
+       case EXPR_UNARY_DELETE_ARRAY
 
 /**
  * unary expression with optional operand
  */
 #define EXPR_UNARY_CASES_OPTIONAL \
-       case EXPR_UNARY_THROW:        \
-
-#define EXPR_UNARY_CASES       \
-       EXPR_UNARY_CASES_MANDATORY \
-       EXPR_UNARY_CASES_OPTIONAL
-
-#define EXPR_LITERAL_CASES                        \
-       case EXPR_LITERAL_BOOLEAN:                    \
-       case EXPR_LITERAL_INTEGER:                    \
-       case EXPR_LITERAL_INTEGER_OCTAL:              \
-       case EXPR_LITERAL_INTEGER_HEXADECIMAL:        \
-       case EXPR_LITERAL_FLOATINGPOINT:              \
-       case EXPR_LITERAL_FLOATINGPOINT_HEXADECIMAL:  \
-       case EXPR_LITERAL_CHARACTER:                  \
-       case EXPR_LITERAL_WIDE_CHARACTER:             \
-       case EXPR_LITERAL_MS_NOOP:
+       EXPR_UNARY_THROW
+
+#define EXPR_UNARY_CASES           \
+            EXPR_UNARY_CASES_MANDATORY: \
+       case EXPR_UNARY_CASES_OPTIONAL
+
+#define EXPR_LITERAL_CASES                     \
+            EXPR_LITERAL_BOOLEAN:                   \
+       case EXPR_LITERAL_INTEGER:                   \
+       case EXPR_LITERAL_INTEGER_OCTAL:             \
+       case EXPR_LITERAL_INTEGER_HEXADECIMAL:       \
+       case EXPR_LITERAL_FLOATINGPOINT:             \
+       case EXPR_LITERAL_FLOATINGPOINT_HEXADECIMAL: \
+       case EXPR_LITERAL_CHARACTER:                 \
+       case EXPR_LITERAL_WIDE_CHARACTER:            \
+       case EXPR_LITERAL_MS_NOOP
 
 /**
  * The base class of every expression.

diff --git a/attribute.c b/attribute.c
index 8f9b2e0..1ccdc5d 100644 (file)
--- a/attribute.c
+++ b/attribute.c
@@ -200,7 +200,7 @@ static void handle_attribute_aligned(const attribute_t *attribute,
        }
 
        switch (entity->kind) {
-       DECLARATION_KIND_CASES
+       case DECLARATION_KIND_CASES:
                entity->declaration.alignment = alignment;
        case ENTITY_TYPEDEF:
                entity->typedefe.alignment = alignment;

diff --git a/entity_t.h b/entity_t.h
index 4094caa..401b8b6 100644 (file)
--- a/entity_t.h
+++ b/entity_t.h
@@ -290,16 +290,16 @@ union entity_t {
        compound_member_t  compound_member;
 };
 
-#define DECLARATION_KIND_CASES        \
-       case ENTITY_FUNCTION:             \
-       case ENTITY_VARIABLE:             \
-       case ENTITY_PARAMETER:            \
-       case ENTITY_COMPOUND_MEMBER:
+#define DECLARATION_KIND_CASES \
+            ENTITY_FUNCTION:        \
+       case ENTITY_VARIABLE:        \
+       case ENTITY_PARAMETER:       \
+       case ENTITY_COMPOUND_MEMBER
 
 static inline bool is_declaration(const entity_t *entity)
 {
        switch(entity->kind) {
-       DECLARATION_KIND_CASES
+       case DECLARATION_KIND_CASES:
                return true;
        default:
                return false;

diff --git a/libfirm b/libfirm
index 63ad747..b255081 160000 (submodule)
--- a/libfirm
+++ b/libfirm
@@ -1 +1 @@
-Subproject commit 63ad74726b302ee843058f6c7d3e14f690415fb3
+Subproject commit b25508140d6b04b693038502fb5a51056d348c31

diff --git a/parser.c b/parser.c
index 8b26975..fdc013d 100644 (file)
--- a/parser.c
+++ b/parser.c
@@ -1521,7 +1521,7 @@ unary:
                        determine_lhs_ent(expr->va_starte.ap, lhs_ent);
                        return;
 
-               EXPR_LITERAL_CASES
+               case EXPR_LITERAL_CASES:
                case EXPR_ERROR:
                case EXPR_STRING_LITERAL:
                case EXPR_WIDE_STRING_LITERAL:
@@ -4745,7 +4745,7 @@ static bool expression_returns(expression_t const *const expr)
 
                case EXPR_REFERENCE:
                case EXPR_REFERENCE_ENUM_VALUE:
-               EXPR_LITERAL_CASES
+               case EXPR_LITERAL_CASES:
                case EXPR_STRING_LITERAL:
                case EXPR_WIDE_STRING_LITERAL:
                case EXPR_COMPOUND_LITERAL: // TODO descend into initialisers
@@ -4798,13 +4798,13 @@ static bool expression_returns(expression_t const *const expr)
                case EXPR_VA_COPY:
                        return expression_returns(expr->va_copye.src);
 
-               EXPR_UNARY_CASES_MANDATORY
+               case EXPR_UNARY_CASES_MANDATORY:
                        return expression_returns(expr->unary.value);
 
                case EXPR_UNARY_THROW:
                        return false;
 
-               EXPR_BINARY_CASES
+               case EXPR_BINARY_CASES:
                        // TODO handle constant lhs of && and ||
                        return
                                expression_returns(expr->binary.left) &&

diff --git a/walk.c b/walk.c
index 7183d38..3cbfc73 100644 (file)
--- a/walk.c
+++ b/walk.c
@@ -96,16 +96,16 @@ static void walk_expression(expression_t *const expr,
                walk_statement(expr->statement.statement, env);
                return;
 
-       EXPR_BINARY_CASES
+       case EXPR_BINARY_CASES:
                walk_expression(expr->binary.left, env);
                walk_expression(expr->binary.right, env);
                return;
 
-       EXPR_UNARY_CASES_OPTIONAL
+       case EXPR_UNARY_CASES_OPTIONAL:
                if (expr->unary.value == NULL)
                        return;
                /* FALLTHROUGH */
-       EXPR_UNARY_CASES_MANDATORY
+       case EXPR_UNARY_CASES_MANDATORY:
                walk_expression(expr->unary.value, env);
                return;
 
@@ -176,7 +176,7 @@ static void walk_expression(expression_t *const expr,
                walk_designator(expr->offsetofe.designator, env);
                return;
 
-       EXPR_LITERAL_CASES
+       case EXPR_LITERAL_CASES:
        case EXPR_REFERENCE:
        case EXPR_REFERENCE_ENUM_VALUE:
        case EXPR_STRING_LITERAL:

diff --git a/wrappergen/write_fluffy.c b/wrappergen/write_fluffy.c
index f3f752f..05c4f9c 100644 (file)
--- a/wrappergen/write_fluffy.c
+++ b/wrappergen/write_fluffy.c
@@ -225,7 +225,7 @@ static void write_expression(const expression_t *expression)
        case EXPR_LITERAL_INTEGER:
                fprintf(out, "%s", expression->literal.value.begin);
                break;
-       EXPR_UNARY_CASES
+       case EXPR_UNARY_CASES:
                write_unary_expression((const unary_expression_t*) expression);
                break;
        default:

diff --git a/wrappergen/write_jna.c b/wrappergen/write_jna.c
index f73d8fd..09ef6aa 100644 (file)
--- a/wrappergen/write_jna.c
+++ b/wrappergen/write_jna.c
@@ -321,10 +321,10 @@ static void write_expression(const expression_t *expression)
                fprintf(out, ".%s.val", entity->base.symbol->string);
                break;
        }
-       EXPR_UNARY_CASES
+       case EXPR_UNARY_CASES:
                write_unary_expression(&expression->unary);
                break;
-       EXPR_BINARY_CASES
+       case EXPR_BINARY_CASES:
                write_binary_expression(&expression->binary);
                break;
        default: