cleanup: Add and use macro MIN().

[cparser] / ast.c

diff --git a/ast.c b/ast.c
index fe99462..baa472d 100644 (file)
--- a/ast.c
+++ b/ast.c
@@ -9,24 +9,12 @@
 #include "type_t.h"
 #include "parser.h"
 #include "lang_features.h"
-#include "entity_t.h"
 #include "printer.h"
 #include "separator_t.h"
 #include "types.h"
 
-#include <assert.h>
-#include <stdio.h>
-#include <stdlib.h>
 #include <ctype.h>
 
-#if defined(__INTEL_COMPILER)
-#include <mathimf.h>
-#elif defined(__CYGWIN__)
-#include "win32/cygwin_math_ext.h"
-#else
-#include <math.h>
-#endif
-
 #include "adt/error.h"
 #include "adt/util.h"
 
@@ -1466,9 +1454,7 @@ expression_classification_t is_constant_initializer(const initializer_t *initial
                for (size_t i = 0; i < initializer->list.len; ++i) {
                        initializer_t *sub_initializer = initializer->list.initializers[i];
                        expression_classification_t const cur = is_constant_initializer(sub_initializer);
-                       if (all > cur) {
-                               all = cur;
-                       }
+                       all = MIN(all, cur);
                }
                return all;
        }
@@ -1511,7 +1497,7 @@ static expression_classification_t is_object_with_linker_constant_address(
        case EXPR_ARRAY_ACCESS: {
                expression_classification_t const ref = is_linker_constant(expression->array_access.array_ref);
                expression_classification_t const idx = is_constant_expression(expression->array_access.index);
-               return ref < idx ? ref : idx;
+               return MIN(ref, idx);
        }
 
        case EXPR_REFERENCE: {
@@ -1590,11 +1576,11 @@ expression_classification_t is_linker_constant(const expression_t *expression)
                if (is_type_pointer(ltype)) {
                        expression_classification_t const l = is_linker_constant(left);
                        expression_classification_t const r = is_constant_expression(right);
-                       return l < r ? l : r;
+                       return MIN(l, r);
                } else if (is_type_pointer(rtype)) {
                        expression_classification_t const l = is_constant_expression(left);
                        expression_classification_t const r = is_linker_constant(right);
-                       return l < r ? l : r;
+                       return MIN(l, r);
                } else if (!is_type_valid(ltype) || !is_type_valid(rtype)) {
                        return EXPR_CLASS_ERROR;
                } else {
@@ -1724,7 +1710,7 @@ static expression_classification_t is_object_with_constant_address(const express
                        return idx_class;
                expression_classification_t const ref_addr = is_object_with_constant_address(array_access->array_ref);
                expression_classification_t const ref_ptr  = is_constant_pointer(array_access->array_ref);
-               return ref_addr > ref_ptr ? ref_addr : ref_ptr;
+               return MAX(ref_addr, ref_ptr);
        }
 
        case EXPR_UNARY_DEREFERENCE:
@@ -1884,7 +1870,7 @@ check_type:
        case EXPR_BINARY_ISUNORDERED: {
                expression_classification_t const l = is_constant_expression(expression->binary.left);
                expression_classification_t const r = is_constant_expression(expression->binary.right);
-               return l < r ? l : r;
+               return MIN(l, r);
        }
 
        case EXPR_BINARY_LOGICAL_AND: {
@@ -1897,7 +1883,7 @@ check_type:
                        return EXPR_CLASS_INTEGER_CONSTANT;
                if (!fold_constant_to_bool(left))
                        return EXPR_CLASS_CONSTANT;
-               return rcls < EXPR_CLASS_CONSTANT ? rcls : EXPR_CLASS_CONSTANT;
+               return MIN(rcls, EXPR_CLASS_CONSTANT);
        }
 
        case EXPR_BINARY_LOGICAL_OR: {
@@ -1910,7 +1896,7 @@ check_type:
                        return EXPR_CLASS_INTEGER_CONSTANT;
                if (fold_constant_to_bool(left))
                        return EXPR_CLASS_CONSTANT;
-               return rcls < EXPR_CLASS_CONSTANT ? rcls : EXPR_CLASS_CONSTANT;
+               return MIN(rcls, EXPR_CLASS_CONSTANT);
        }
 
        case EXPR_COMPOUND_LITERAL:
@@ -1929,7 +1915,7 @@ check_type:
                    fcls == EXPR_CLASS_INTEGER_CONSTANT)
                        return EXPR_CLASS_INTEGER_CONSTANT;
                expression_classification_t const cls = fold_constant_to_bool(cond) ? tcls : fcls;
-               return cls < EXPR_CLASS_CONSTANT ? cls : EXPR_CLASS_CONSTANT;
+               return MIN(cls, EXPR_CLASS_CONSTANT);
        }
 
        case EXPR_ERROR: