endian: add constant versions.

[ccan] / ccan / cast / cast.h

diff --git a/ccan/cast/cast.h b/ccan/cast/cast.h
index f3bb445d0f7c145158c2c67bed05cdbb8059d61b..1f3a7aac1e48640f37868c0564e3851e203113e6 100644 (file)
--- a/ccan/cast/cast.h
+++ b/ccan/cast/cast.h
@@ -1,6 +1,8 @@
+/* Licensed under LGPLv2.1+ - see LICENSE file for details */
 #ifndef CCAN_CAST_H
 #define CCAN_CAST_H
 #include "config.h"
+#include <stdint.h>
 #include <ccan/build_assert/build_assert.h>
 
 /**
@@ -13,8 +15,8 @@
  * only differs in signed/unsigned, not in type or const-ness.
  */
 #define cast_signed(type, expr)                                                \
-       ((type)(expr)                                                   \
-        + EXPR_BUILD_ASSERT(cast_sign_compatible(type, (expr))))
+       (0 ? BUILD_ASSERT_OR_ZERO(cast_sign_compatible(type, (expr))) : \
+        (type)(expr))
 
 /**
  * cast_const - remove a const qualifier from a pointer.
@@ -24,6 +26,10 @@
  * This ensures that you are only removing the const qualifier from an
  * expression.  The expression must otherwise match @type.
  *
+ * We cast via intptr_t to suppress gcc's -Wcast-qual (which SAMBA
+ * uses), and via the ? : so Sun CC doesn't complain about the result
+ * not being constant.
+ *
  * If @type is a pointer to a pointer, you must use cast_const2 (etc).
  *
  * Example:
@@ -37,9 +43,9 @@
  *             return NULL;
  *     }
  */
-#define cast_const(type, expr)                                 \
-       ((type)(expr)                                           \
-        + EXPR_BUILD_ASSERT(cast_const_compat1((expr), type)))
+#define cast_const(type, expr)                                         \
+        (0 ? BUILD_ASSERT_OR_ZERO(cast_const_compat1((expr), type)) :   \
+         (type)(intptr_t)(expr))
 
 /**
  * cast_const2 - remove a const qualifier from a pointer to a pointer.
@@ -49,9 +55,9 @@
  * This ensures that you are only removing the const qualifier from an
  * expression.  The expression must otherwise match @type.
  */
-#define cast_const2(type, expr)                                        \
-       ((type)(expr)                                           \
-        + EXPR_BUILD_ASSERT(cast_const_compat2((expr), type)))
+#define cast_const2(type, expr)                                                \
+        (0 ? BUILD_ASSERT_OR_ZERO(cast_const_compat2((expr), type)) :   \
+        (type)(intptr_t)(expr))
 
 /**
  * cast_const3 - remove a const from a pointer to a pointer to a pointer..
@@ -61,9 +67,9 @@
  * This ensures that you are only removing the const qualifier from an
  * expression.  The expression must otherwise match @type.
  */
-#define cast_const3(type, expr)                                        \
-       ((type)(expr)                                           \
-        + EXPR_BUILD_ASSERT(cast_const_compat3((expr), type)))
+#define cast_const3(type, expr)                                                \
+        (0 ? BUILD_ASSERT_OR_ZERO(cast_const_compat3((expr), type)) :   \
+        (type)(intptr_t)(expr))
 
 
 /**
@@ -104,11 +110,11 @@
          )
 
 #define cast_const_strip1(expr)                        \
-       __typeof__(*(struct { int z; __typeof__(expr) x; }){0}.x)
+       __typeof__(*(union { int z; __typeof__(expr) x; }){0}.x)
 #define cast_const_strip2(expr) \
-       __typeof__(**(struct { int z; __typeof__(expr) x; }){0}.x)
+       __typeof__(**(union { int z; __typeof__(expr) x; }){0}.x)
 #define cast_const_strip3(expr) \
-       __typeof__(***(struct { int z; __typeof__(expr) x; }){0}.x)
+       __typeof__(***(union { int z; __typeof__(expr) x; }){0}.x)
 #define cast_const_compat1(expr, type)                                 \
        __builtin_types_compatible_p(cast_const_strip1(expr),           \
                                     cast_const_strip1(type))
@@ -121,11 +127,8 @@
 #else
 #define cast_sign_compatible(type, expr)               \
        (sizeof(*(type)0) == 1 && sizeof(*(expr)) == 1)
-#define cast_const_compat1(expr, type)         \
-       (sizeof(*(expr)) == sizeof(*(type)0))
-#define cast_const_compat2(expr, type)         \
-       (sizeof(**(expr)) == sizeof(**(type)0))
-#define cast_const_compat3(expr, type)                 \
-       (sizeof(***(expr)) == sizeof(***(type)0))
+#define cast_const_compat1(expr, type)         (1)
+#define cast_const_compat2(expr, type)         (1)
+#define cast_const_compat3(expr, type)         (1)
 #endif
 #endif /* CCAN_CAST_H */