Merge assert_p.h and math_support_p.h into compilersupport_p.h

And stop the unnecessary "must include assert_p.h last". Just use a
different macro name, that we control.

Signed-off-by: Thiago Macieira <[email protected]>

Author: thiagomacieira

src/assert_p.h

@@ -32,12 +32,9 @@
 #include "cborinternal_p.h"
 #include "compilersupport_p.h"
 
-#include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 
-#include "assert_p.h"       /* Always include last */
-
 /**
  * \defgroup CborEncoding Encoding to CBOR
  * \brief Group of functions used to encode data to CBOR.
@@ -136,7 +133,7 @@
  * Finally, the example below illustrates expands on the one above and also
  * deals with dynamically growing the buffer if the initial allocation wasn't
  * big enough. Note the two places where the error checking was replaced with
- * an assertion, showing where the author assumes no error can occur.
+ * an cbor_assertion, showing where the author assumes no error can occur.
  *
  * \code
  * uint8_t *encode_string_array(const char **strings, int n, size_t *bufsize)
@@ -156,7 +153,7 @@
  *
  *         cbor_encoder_init(&encoder, &buf, size, 0);
  *         err = cbor_encoder_create_array(&encoder, &arrayEncoder, n);
- *         assert(err);         // can't fail, the buffer is always big enough
+ *         cbor_assert(err);         // can't fail, the buffer is always big enough
  *
  *         for (i = 0; i < n; ++i) {
  *             err = cbor_encode_text_stringz(&arrayEncoder, strings[i]);
@@ -165,7 +162,7 @@
  *         }
  *
  *         err = cbor_encoder_close_container_checked(&encoder, &arrayEncoder);
- *         assert(err);         // shouldn't fail!
+ *         cbor_assert(err);         // shouldn't fail!
  *
  *         more_bytes = cbor_encoder_get_extra_bytes_needed(encoder);
  *         if (more_size) {
@@ -378,7 +375,7 @@ CborError cbor_encode_simple_value(CborEncoder *encoder, uint8_t value)
 CborError cbor_encode_floating_point(CborEncoder *encoder, CborType fpType, const void *value)
 {
     uint8_t buf[1 + sizeof(uint64_t)];
-    assert(fpType == CborHalfFloatType || fpType == CborFloatType || fpType == CborDoubleType);
+    cbor_assert(fpType == CborHalfFloatType || fpType == CborFloatType || fpType == CborDoubleType);
     buf[0] = fpType;
 
     unsigned size = 2U << (fpType - CborHalfFloatType);

src/cborencoder.c

@@ -32,10 +32,6 @@
 #include "cborinternal_p.h"
 #include "compilersupport_p.h"
 
-#include <assert.h>
-
-#include "assert_p.h"       /* Always include last */
-
 /**
  * \addtogroup CborEncoding
  * @{

src/cborencoder_close_container_checked.c

@@ -32,11 +32,8 @@
 #include "cborinternal_p.h"
 #include "compilersupport_p.h"
 
-#include <assert.h>
 #include <string.h>
 
-#include "assert_p.h"       /* Always include last */
-
 #ifndef CBOR_PARSER_MAX_RECURSIONS
 #  define CBOR_PARSER_MAX_RECURSIONS 1024
 #endif
@@ -281,7 +278,7 @@ static CborError preparse_value(CborValue *it)
         case 29:
         case 30:
         case Break:
-            assert(false);  /* these conditions can't be reached */
+            cbor_assert(false);  /* these conditions can't be reached */
             return CborErrorUnexpectedBreak;
         }
         return CborNoError;
@@ -323,11 +320,11 @@ static CborError advance_internal(CborValue *it)
 {
     uint64_t length;
     CborError err = _cbor_value_extract_number(&it->ptr, it->parser->end, &length);
-    assert(err == CborNoError);
+    cbor_assert(err == CborNoError);
 
     if (it->type == CborByteStringType || it->type == CborTextStringType) {
-        assert(length == (size_t)length);
-        assert((it->flags & CborIteratorFlag_UnknownLength) == 0);
+        cbor_assert(length == (size_t)length);
+        cbor_assert((it->flags & CborIteratorFlag_UnknownLength) == 0);
         it->ptr += length;
     }
 
@@ -346,16 +343,16 @@ static CborError advance_internal(CborValue *it)
  */
 uint64_t _cbor_value_decode_int64_internal(const CborValue *value)
 {
-    assert(value->flags & CborIteratorFlag_IntegerValueTooLarge ||
-           value->type == CborFloatType || value->type == CborDoubleType);
+    cbor_assert(value->flags & CborIteratorFlag_IntegerValueTooLarge ||
+                value->type == CborFloatType || value->type == CborDoubleType);
 
     /* since the additional information can only be Value32Bit or Value64Bit,
      * we just need to test for the one bit those two options differ */
-    assert((*value->ptr & SmallValueMask) == Value32Bit || (*value->ptr & SmallValueMask) == Value64Bit);
+    cbor_assert((*value->ptr & SmallValueMask) == Value32Bit || (*value->ptr & SmallValueMask) == Value64Bit);
     if ((*value->ptr & 1) == (Value32Bit & 1))
         return get32(value->ptr + 1);
 
-    assert((*value->ptr & SmallValueMask) == Value64Bit);
+    cbor_assert((*value->ptr & SmallValueMask) == Value64Bit);
     return get64(value->ptr + 1);
 }
 
@@ -440,8 +437,8 @@ CborError cbor_parser_init(const uint8_t *buffer, size_t size, int flags, CborPa
  */
 CborError cbor_value_advance_fixed(CborValue *it)
 {
-    assert(it->type != CborInvalidType);
-    assert(is_fixed_type(it->type));
+    cbor_assert(it->type != CborInvalidType);
+    cbor_assert(is_fixed_type(it->type));
     if (!it->remaining)
         return CborErrorAdvancePastEOF;
     return advance_internal(it);
@@ -488,7 +485,7 @@ static CborError advance_recursive(CborValue *it, int nestingLevel)
  */
 CborError cbor_value_advance(CborValue *it)
 {
-    assert(it->type != CborInvalidType);
+    cbor_assert(it->type != CborInvalidType);
     if (!it->remaining)
         return CborErrorAdvancePastEOF;
     return advance_recursive(it, 0);
@@ -552,7 +549,7 @@ CborError cbor_value_skip_tag(CborValue *it)
 CborError cbor_value_enter_container(const CborValue *it, CborValue *recursed)
 {
     CborError err;
-    assert(cbor_value_is_container(it));
+    cbor_assert(cbor_value_is_container(it));
     *recursed = *it;
 
     if (it->flags & CborIteratorFlag_UnknownLength) {
@@ -567,7 +564,7 @@ CborError cbor_value_enter_container(const CborValue *it, CborValue *recursed)
     } else {
         uint64_t len;
         err = _cbor_value_extract_number(&recursed->ptr, recursed->parser->end, &len);
-        assert(err == CborNoError);
+        cbor_assert(err == CborNoError);
 
         recursed->remaining = (uint32_t)len;
         if (recursed->remaining != len || len == UINT32_MAX) {
@@ -608,8 +605,8 @@ CborError cbor_value_enter_container(const CborValue *it, CborValue *recursed)
  */
 CborError cbor_value_leave_container(CborValue *it, const CborValue *recursed)
 {
-    assert(cbor_value_is_container(it));
-    assert(recursed->type == CborInvalidType);
+    cbor_assert(cbor_value_is_container(it));
+    cbor_assert(recursed->type == CborInvalidType);
     it->ptr = recursed->ptr;
     return preparse_next_value(it);
 }
@@ -790,7 +787,7 @@ CborError cbor_value_leave_container(CborValue *it, const CborValue *recursed)
  */
 CborError cbor_value_get_int64_checked(const CborValue *value, int64_t *result)
 {
-    assert(cbor_value_is_integer(value));
+    cbor_assert(cbor_value_is_integer(value));
     uint64_t v = _cbor_value_extract_int64_helper(value);
 
     /* Check before converting, as the standard says (C11 6.3.1.3 paragraph 3):
@@ -829,7 +826,7 @@ CborError cbor_value_get_int64_checked(const CborValue *value, int64_t *result)
  */
 CborError cbor_value_get_int_checked(const CborValue *value, int *result)
 {
-    assert(cbor_value_is_integer(value));
+    cbor_assert(cbor_value_is_integer(value));
     uint64_t v = _cbor_value_extract_int64_helper(value);
 
     /* Check before converting, as the standard says (C11 6.3.1.3 paragraph 3):
@@ -965,7 +962,7 @@ static uintptr_t iterate_memcmp(char *s1, const uint8_t *s2, size_t len)
 static CborError iterate_string_chunks(const CborValue *value, char *buffer, size_t *buflen,
                                        bool *result, CborValue *next, IterateFunction func)
 {
-    assert(cbor_value_is_byte_string(value) || cbor_value_is_text_string(value));
+    cbor_assert(cbor_value_is_byte_string(value) || cbor_value_is_text_string(value));
 
     size_t total;
     CborError err;
@@ -1220,7 +1217,7 @@ CborError cbor_value_text_string_equals(const CborValue *value, const char *stri
  */
 CborError cbor_value_map_find_value(const CborValue *map, const char *string, CborValue *element)
 {
-    assert(cbor_value_is_map(map));
+    cbor_assert(cbor_value_is_map(map));
     size_t len = strlen(string);
     CborError err = cbor_value_enter_container(map, element);
     if (err)
@@ -1331,7 +1328,7 @@ CborError cbor_value_map_find_value(const CborValue *map, const char *string, Cb
  */
 CborError cbor_value_get_half_float(const CborValue *value, void *result)
 {
-    assert(cbor_value_is_half_float(value));
+    cbor_assert(cbor_value_is_half_float(value));
 
     /* size has been computed already */
     uint16_t v = get16(value->ptr + 1);

src/cborparser.c

@@ -29,6 +29,7 @@
 #endif
 
 #include "cbor.h"
+#include "compilersupport_p.h"
 #include <stdlib.h>
 
 /**
@@ -91,8 +92,8 @@
  */
 CborError _cbor_value_dup_string(const CborValue *value, void **buffer, size_t *buflen, CborValue *next)
 {
-    assert(buffer);
-    assert(buflen);
+    cbor_assert(buffer);
+    cbor_assert(buflen);
     *buflen = SIZE_MAX;
     CborError err = _cbor_value_copy_string(value, NULL, buflen, NULL);
     if (err)

src/cborparser_dup_string.c

@@ -31,7 +31,6 @@
 #include "cbor.h"
 #include "cborinternal_p.h"
 #include "compilersupport_p.h"
-#include "math_support_p.h"
 
 #include <float.h>
 #include <inttypes.h>

src/cborpretty.c

@@ -33,7 +33,6 @@
 #include "cbor.h"
 #include "cborjson.h"
 #include "compilersupport_p.h"
-#include "math_support_p.h"
 
 #include <float.h>
 #include <inttypes.h>
@@ -186,7 +185,7 @@ static CborError dump_bytestring_base16(char **result, CborValue *it)
     /* let cbor_value_copy_byte_string know we have an extra byte for the terminating NUL */
     ++n;
     err = cbor_value_copy_byte_string(it, buffer + n - 1, &n, it);
-    assert(err == CborNoError);
+    cbor_assert(err == CborNoError);
 
     for (i = 0; i < n; ++i) {
         uint8_t byte = buffer[n + i];
@@ -216,7 +215,7 @@ static CborError generic_dump_base64(char **result, CborValue *it, const char al
     /* let cbor_value_copy_byte_string know we have an extra byte for the terminating NUL */
     ++n;
     err = cbor_value_copy_byte_string(it, in, &n, it);
-    assert(err == CborNoError);
+    cbor_assert(err == CborNoError);
 
     uint_least32_t val = 0;
     for (i = 0; n - i >= 3; i += 3) {

src/cbortojson.c

@@ -35,6 +35,7 @@
 #endif
 #include <assert.h>
 #include <float.h>
+#include <math.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
@@ -61,6 +62,12 @@
 #  define inline    CBOR_INLINE
 #endif
 
+#ifdef NDEBUG
+#  define cbor_assert(cond)     do { if (!(cond)) unreachable(); } while (0)
+#else
+#  define cbor_assert(cond)     assert(cond)
+#endif
+
 #ifndef STRINGIFY
 #define STRINGIFY(x)            STRINGIFY2(x)
 #endif
@@ -230,5 +237,21 @@ static inline unsigned short encode_half(double val)
 #endif
 }
 
+/* this function was copied & adapted from RFC 7049 Appendix D */
+static inline double decode_half(unsigned short half)
+{
+#ifdef __F16C__
+    return _cvtsh_ss(half);
+#else
+    int exp = (half >> 10) & 0x1f;
+    int mant = half & 0x3ff;
+    double val;
+    if (exp == 0) val = ldexp(mant, -24);
+    else if (exp != 31) val = ldexp(mant + 1024, exp - 25);
+    else val = mant == 0 ? INFINITY : NAN;
+    return half & 0x8000 ? -val : val;
+#endif
+}
+
 #endif /* COMPILERSUPPORT_H */