Fix *some* C89/C90 issues in the code

This fixes the issues in all the headers (even in the private headers),
but not all of them in the .c files. I only fixed those that didn't make
the code look much uglier or those for which GCC complains with
-std=c90. The compiler only warns about mixed mixed variable
declarations and code, unless you use -pedantic-errors.

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

Author: thiagomacieira

src/cbor.h

@@ -409,10 +409,11 @@ CBOR_INLINE_API bool cbor_value_is_text_string(const CborValue *value)
 
 CBOR_INLINE_API CborError cbor_value_get_string_length(const CborValue *value, size_t *length)
 {
+    uint64_t v;
     assert(cbor_value_is_byte_string(value) || cbor_value_is_text_string(value));
     if (!cbor_value_is_length_known(value))
         return CborErrorUnknownLength;
-    uint64_t v = _cbor_value_extract_int64_helper(value);
+    v = _cbor_value_extract_int64_helper(value);
     *length = (size_t)v;
     if (*length != v)
         return CborErrorDataTooLarge;
@@ -462,10 +463,11 @@ CBOR_INLINE_API bool cbor_value_is_map(const CborValue *value)
 
 CBOR_INLINE_API CborError cbor_value_get_array_length(const CborValue *value, size_t *length)
 {
+    uint64_t v;
     assert(cbor_value_is_array(value));
     if (!cbor_value_is_length_known(value))
         return CborErrorUnknownLength;
-    uint64_t v = _cbor_value_extract_int64_helper(value);
+    v = _cbor_value_extract_int64_helper(value);
     *length = (size_t)v;
     if (*length != v)
         return CborErrorDataTooLarge;
@@ -474,10 +476,11 @@ CBOR_INLINE_API CborError cbor_value_get_array_length(const CborValue *value, si
 
 CBOR_INLINE_API CborError cbor_value_get_map_length(const CborValue *value, size_t *length)
 {
+    uint64_t v;
     assert(cbor_value_is_map(value));
     if (!cbor_value_is_length_known(value))
         return CborErrorUnknownLength;
-    uint64_t v = _cbor_value_extract_int64_helper(value);
+    v = _cbor_value_extract_int64_helper(value);
     *length = (size_t)v;
     if (*length != v)
         return CborErrorDataTooLarge;
@@ -495,9 +498,10 @@ CBOR_INLINE_API bool cbor_value_is_float(const CborValue *value)
 { return value->type == CborFloatType; }
 CBOR_INLINE_API CborError cbor_value_get_float(const CborValue *value, float *result)
 {
+    uint32_t data;
     assert(cbor_value_is_float(value));
     assert(value->flags & CborIteratorFlag_IntegerValueTooLarge);
-    uint32_t data = (uint32_t)_cbor_value_decode_int64_internal(value);
+    data = (uint32_t)_cbor_value_decode_int64_internal(value);
     memcpy(result, &data, sizeof(*result));
     return CborNoError;
 }
@@ -506,9 +510,10 @@ CBOR_INLINE_API bool cbor_value_is_double(const CborValue *value)
 { return value->type == CborDoubleType; }
 CBOR_INLINE_API CborError cbor_value_get_double(const CborValue *value, double *result)
 {
+    uint64_t data;
     assert(cbor_value_is_double(value));
     assert(value->flags & CborIteratorFlag_IntegerValueTooLarge);
-    uint64_t data = _cbor_value_decode_int64_internal(value);
+    data = _cbor_value_decode_int64_internal(value);
     memcpy(result, &data, sizeof(*result));
     return CborNoError;
 }

src/cborencoder.c

@@ -386,11 +386,12 @@ CborError cbor_encode_simple_value(CborEncoder *encoder, uint8_t value)
  */
 CborError cbor_encode_floating_point(CborEncoder *encoder, CborType fpType, const void *value)
 {
+    unsigned size;
     uint8_t buf[1 + sizeof(uint64_t)];
     cbor_assert(fpType == CborHalfFloatType || fpType == CborFloatType || fpType == CborDoubleType);
     buf[0] = fpType;
 
-    unsigned size = 2U << (fpType - CborHalfFloatType);
+    size = 2U << (fpType - CborHalfFloatType);
     if (size == 8)
         put64(buf + 1, *(const uint64_t*)value);
     else if (size == 4)

src/cborparser.c

@@ -165,6 +165,7 @@ static inline uint64_t get64(const uint8_t *ptr)
 
 CborError CBOR_INTERNAL_API_CC _cbor_value_extract_number(const uint8_t **ptr, const uint8_t *end, uint64_t *len)
 {
+    size_t bytesNeeded;
     uint8_t additional_information = **ptr & SmallValueMask;
     ++*ptr;
     if (additional_information < Value8Bit) {
@@ -174,7 +175,7 @@ CborError CBOR_INTERNAL_API_CC _cbor_value_extract_number(const uint8_t **ptr, c
     if (unlikely(additional_information > Value64Bit))
         return CborErrorIllegalNumber;
 
-    size_t bytesNeeded = (size_t)(1 << (additional_information - Value8Bit));
+    bytesNeeded = (size_t)(1 << (additional_information - Value8Bit));
     if (unlikely(bytesNeeded > (size_t)(end - *ptr))) {
         return CborErrorUnexpectedEOF;
     } else if (bytesNeeded == 1) {
@@ -479,6 +480,9 @@ CborError cbor_value_advance_fixed(CborValue *it)
 
 static CborError advance_recursive(CborValue *it, int nestingLevel)
 {
+    CborError err;
+    CborValue recursed;
+
     if (is_fixed_type(it->type))
         return advance_internal(it);
 
@@ -491,8 +495,6 @@ static CborError advance_recursive(CborValue *it, int nestingLevel)
     if (nestingLevel == 0)
         return CborErrorNestingTooDeep;
 
-    CborError err;
-    CborValue recursed;
     err = cbor_value_enter_container(it, &recursed);
     if (err)
         return err;
@@ -815,8 +817,9 @@ CborError cbor_value_leave_container(CborValue *it, const CborValue *recursed)
  */
 CborError cbor_value_get_int64_checked(const CborValue *value, int64_t *result)
 {
+    uint64_t v;
     cbor_assert(cbor_value_is_integer(value));
-    uint64_t v = _cbor_value_extract_int64_helper(value);
+    v = _cbor_value_extract_int64_helper(value);
 
     /* Check before converting, as the standard says (C11 6.3.1.3 paragraph 3):
      * "[if] the new type is signed and the value cannot be represented in it; either the
@@ -854,8 +857,9 @@ CborError cbor_value_get_int64_checked(const CborValue *value, int64_t *result)
  */
 CborError cbor_value_get_int_checked(const CborValue *value, int *result)
 {
+    uint64_t v;
     cbor_assert(cbor_value_is_integer(value));
-    uint64_t v = _cbor_value_extract_int64_helper(value);
+    v = _cbor_value_extract_int64_helper(value);
 
     /* Check before converting, as the standard says (C11 6.3.1.3 paragraph 3):
      * "[if] the new type is signed and the value cannot be represented in it; either the
@@ -1076,13 +1080,12 @@ static uintptr_t iterate_memcpy(char *dest, const uint8_t *src, size_t len)
 static CborError iterate_string_chunks(const CborValue *value, char *buffer, size_t *buflen,
                                        bool *result, CborValue *next, IterateFunction func)
 {
-    cbor_assert(cbor_value_is_byte_string(value) || cbor_value_is_text_string(value));
-
     CborError err;
     CborValue tmp;
     size_t total = 0;
     const void *ptr;
 
+    cbor_assert(cbor_value_is_byte_string(value) || cbor_value_is_text_string(value));
     if (!next)
         next = &tmp;
     *next = *value;
@@ -1215,6 +1218,7 @@ CborError _cbor_value_copy_string(const CborValue *value, void *buffer,
  */
 CborError cbor_value_text_string_equals(const CborValue *value, const char *string, bool *result)
 {
+    size_t len;
     CborValue copy = *value;
     CborError err = cbor_value_skip_tag(&copy);
     if (err)
@@ -1224,7 +1228,7 @@ CborError cbor_value_text_string_equals(const CborValue *value, const char *stri
         return CborNoError;
     }
 
-    size_t len = strlen(string);
+    len = strlen(string);
     return iterate_string_chunks(&copy, CONST_CAST(char *, string), &len, result, NULL, iterate_memcmp);
 }
 
@@ -1302,9 +1306,10 @@ 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)
 {
-    cbor_assert(cbor_value_is_map(map));
+    CborError err;
     size_t len = strlen(string);
-    CborError err = cbor_value_enter_container(map, element);
+    cbor_assert(cbor_value_is_map(map));
+    err = cbor_value_enter_container(map, element);
     if (err)
         goto error;
 
@@ -1413,10 +1418,11 @@ CborError cbor_value_map_find_value(const CborValue *map, const char *string, Cb
  */
 CborError cbor_value_get_half_float(const CborValue *value, void *result)
 {
+    uint16_t v;
     cbor_assert(cbor_value_is_half_float(value));
 
     /* size has been computed already */
-    uint16_t v = get16(value->ptr + 1);
+    v = get16(value->ptr + 1);
     memcpy(result, &v, sizeof(v));
     return CborNoError;
 }

src/cborparser_dup_string.c

@@ -96,10 +96,11 @@
  */
 CborError _cbor_value_dup_string(const CborValue *value, void **buffer, size_t *buflen, CborValue *next)
 {
+    CborError err;
     cbor_assert(buffer);
     cbor_assert(buflen);
     *buflen = SIZE_MAX;
-    CborError err = _cbor_value_copy_string(value, NULL, buflen, NULL);
+    err = _cbor_value_copy_string(value, NULL, buflen, NULL);
     if (err)
         return err;
 

src/cborpretty.c

@@ -151,6 +151,7 @@
 
 static inline bool convertToUint64(double v, uint64_t *absolute)
 {
+    double supremum;
     v = fabs(v);
 
     /* C11 standard section 6.3.1.4 "Real floating and integer" says:
@@ -170,7 +171,7 @@ static inline bool convertToUint64(double v, uint64_t *absolute)
      *    result is either the nearest higher or nearest lower representable
      *    value, chosen in an implementation-defined manner.
      */
-    double supremum = -2.0 * INT64_MIN;     /* -2 * (- 2^63) == 2^64 */
+    supremum = -2.0 * INT64_MIN;     /* -2 * (- 2^63) == 2^64 */
     if (v >= supremum)
         return false;
 
@@ -209,13 +210,13 @@ static CborError utf8EscapedDump(CborStreamFunction stream, void *out, const voi
 
         if (uc < 0x80) {
             /* single-byte UTF-8 */
+            unsigned char escaped = (unsigned char)uc;
             if (uc < 0x7f && uc >= 0x20 && uc != '\\' && uc != '"') {
                 err = stream(out, "%c", (char)uc);
                 continue;
             }
 
             /* print as an escape sequence */
-            char escaped = (char)uc;
             switch (uc) {
             case '"':
             case '\\':
@@ -311,13 +312,14 @@ static CborError value_to_pretty(CborStreamFunction stream, void *out, CborValue
 static CborError container_to_pretty(CborStreamFunction stream, void *out, CborValue *it, CborType containerType,
                                      int flags, int recursionsLeft)
 {
+    const char *comma = "";
+    CborError err = CborNoError;
+
     if (!recursionsLeft) {
         printRecursionLimit(stream, out);
-        return CborNoError; /* do allow the dumping to continue */
+        return err;     /* do allow the dumping to continue */
     }
 
-    const char *comma = "";
-    CborError err = CborNoError;
     while (!cbor_value_at_end(it) && !err) {
         err = stream(out, "%s", comma);
         comma = ", ";
@@ -490,6 +492,8 @@ static CborError value_to_pretty(CborStreamFunction stream, void *out, CborValue
         const char *suffix;
         double val;
         int r;
+        uint64_t ival;
+
         if (false) {
             float f;
     case CborFloatType:
@@ -519,7 +523,6 @@ static CborError value_to_pretty(CborStreamFunction stream, void *out, CborValue
                 suffix = "";
         }
 
-        uint64_t ival;
         if (convertToUint64(val, &ival)) {
             /* this double value fits in a 64-bit integer, so show it as such
              * (followed by a floating point suffix, to disambiguate) */

src/cborvalidation.c

@@ -294,6 +294,7 @@ static inline CborError validate_number(const CborValue *it, CborType type, uint
 {
     CborError err = CborNoError;
     const uint8_t *ptr = it->ptr;
+    size_t bytesUsed, bytesNeeded;
     uint64_t value;
 
     if ((flags & CborValidateShortestIntegrals) == 0)
@@ -305,8 +306,8 @@ static inline CborError validate_number(const CborValue *it, CborType type, uint
     if (err)
         return err;
 
-    size_t bytesUsed = (size_t)(ptr - it->ptr - 1);
-    size_t bytesNeeded = 0;
+    bytesUsed = (size_t)(ptr - it->ptr - 1);
+    bytesNeeded = 0;
     if (value >= Value8Bit)
         ++bytesNeeded;
     if (value > 0xffU)
@@ -376,6 +377,7 @@ static inline CborError validate_tag(CborValue *it, CborTag tag, uint32_t flags,
 static inline CborError validate_floating_point(CborValue *it, CborType type, uint32_t flags)
 {
     CborError err;
+    int r;
     double val;
     float valf;
     uint16_t valf16;
@@ -398,7 +400,7 @@ static inline CborError validate_floating_point(CborValue *it, CborType type, ui
     }
     cbor_assert(err == CborNoError);     /* can't fail */
 
-    int r = fpclassify(val);
+    r = fpclassify(val);
     if (r == FP_NAN || r == FP_INFINITE) {
         if (flags & CborValidateFiniteFloatingPoint)
             return CborErrorExcludedValue;

src/compilersupport_p.h

@@ -213,10 +213,11 @@ static inline unsigned short encode_half(double val)
     return _cvtss_sh((float)val, 3);
 #else
     uint64_t v;
+    int sign, exp, mant;
     memcpy(&v, &val, sizeof(v));
-    int sign = v >> 63 << 15;
-    int exp = (v >> 52) & 0x7ff;
-    int mant = v << 12 >> 12 >> (53-11);    /* keep only the 11 most significant bits of the mantissa */
+    sign = v >> 63 << 15;
+    exp = (v >> 52) & 0x7ff;
+    mant = v << 12 >> 12 >> (53-11);    /* keep only the 11 most significant bits of the mantissa */
     exp -= 1023;
     if (exp == 1024) {
         /* infinity or NaN */

src/utf8_p.h

@@ -31,7 +31,9 @@
 
 static inline uint32_t get_utf8(const uint8_t **buffer, const uint8_t *end)
 {
-    uint32_t uc;
+    int charsNeeded;
+    uint32_t uc, min_uc;
+    uint8_t b;
     ptrdiff_t n = end - *buffer;
     if (n == 0)
         return ~0U;
@@ -43,8 +45,6 @@ static inline uint32_t get_utf8(const uint8_t **buffer, const uint8_t *end)
     }
 
     /* multi-byte UTF-8, decode it */
-    int charsNeeded;
-    uint32_t min_uc;
     if (unlikely(uc <= 0xC1))
         return ~0U;
     if (uc < 0xE0) {
@@ -70,7 +70,7 @@ static inline uint32_t get_utf8(const uint8_t **buffer, const uint8_t *end)
         return ~0U;
 
     /* first continuation character */
-    uint8_t b = *(*buffer)++;
+    b = *(*buffer)++;
     if ((b & 0xc0) != 0x80)
         return ~0U;
     uc <<= 6;
@@ -101,4 +101,4 @@ static inline uint32_t get_utf8(const uint8_t **buffer, const uint8_t *end)
     return uc;
 }
 
-#endif // CBOR_UTF8_H
+#endif /* CBOR_UTF8_H */