Issue #62: Fixed wrong printf format specifiers. Changed cbits.h to use long long (guaranteed at least 64-bit) instead of int64_t for easier print.

Second part of #62 is due to a clang compiler bug, can be avoided by using c_foreach instead of c_forpair.

2 files changed, 41 insertions, 40 deletions

diff --git a/include/stc/cbits.h b/include/stc/cbits.h
index 8a6558bf..9463c82c 100644
--- a/include/stc/cbits.h
+++ b/include/stc/cbits.h
@@ -31,7 +31,7 @@ int main() {
     cbits_reset(&bset, 9);
     cbits_resize(&bset, 43, false);
 
-    printf("%4zu: ", cbits_size(&bset));
+    printf("%4lld: ", cbits_size(&bset));
     c_forrange (i, cbits_size(&bset))
         printf("%d", cbits_at(&bset, i));
     puts("");
@@ -41,7 +41,7 @@ int main() {
     cbits_resize(&bset, 102, true);
     cbits_set_value(&bset, 99, false);
 
-    printf("%4zu: ", cbits_size(&bset));
+    printf("%4lld: ", cbits_size(&bset));
     c_forrange (i, cbits_size(&bset))
         printf("%d", cbits_at(&bset, i));
     puts("");
@@ -55,7 +55,7 @@ int main() {
 #include <string.h>
 
 #define _cbits_bit(i) ((uint64_t)1 << ((i) & 63))
-#define _cbits_words(n) (int64_t)(((n) + 63)>>6)
+#define _cbits_words(n) (_llong)(((n) + 63)>>6)
 #define _cbits_bytes(n) (_cbits_words(n) * c_sizeof(uint64_t))
 
 #if defined(__GNUC__)
@@ -77,23 +77,23 @@ int main() {
     }
 #endif
 
-STC_INLINE int64_t _cbits_count(const uint64_t* set, const int64_t sz) {
-    const int64_t n = sz>>6;
-    int64_t count = 0;
-    for (int64_t i = 0; i < n; ++i)
+STC_INLINE _llong _cbits_count(const uint64_t* set, const _llong sz) {
+    const _llong n = sz>>6;
+    _llong count = 0;
+    for (_llong i = 0; i < n; ++i)
         count += cpopcount64(set[i]);
     if (sz & 63)
         count += cpopcount64(set[n] & (_cbits_bit(sz) - 1));
     return count;
 }
 
-STC_INLINE char* _cbits_to_str(const uint64_t* set, const int64_t sz, 
-                               char* out, int64_t start, int64_t stop) {
+STC_INLINE char* _cbits_to_str(const uint64_t* set, const _llong sz, 
+                               char* out, _llong start, _llong stop) {
     if (stop > sz) stop = sz;
     assert(start <= stop);
 
     c_memset(out, '0', stop - start);
-    for (int64_t i = start; i < stop; ++i) 
+    for (_llong i = start; i < stop; ++i) 
         if ((set[i>>6] & _cbits_bit(i)) != 0)
             out[i - start] = '1';
     out[stop - start] = '\0';
@@ -101,8 +101,8 @@ STC_INLINE char* _cbits_to_str(const uint64_t* set, const int64_t sz,
 }
 
 #define _cbits_OPR(OPR, VAL) \
-    const int64_t n = sz>>6; \
-    for (int64_t i = 0; i < n; ++i) \
+    const _llong n = sz>>6; \
+    for (_llong i = 0; i < n; ++i) \
         if ((set[i] OPR other[i]) != VAL) \
             return false; \
     if (!(sz & 63)) \
@@ -110,10 +110,10 @@ STC_INLINE char* _cbits_to_str(const uint64_t* set, const int64_t sz,
     const uint64_t i = (uint64_t)n, m = _cbits_bit(sz) - 1; \
     return ((set[i] OPR other[i]) & m) == (VAL & m)
 
-STC_INLINE bool _cbits_subset_of(const uint64_t* set, const uint64_t* other, const int64_t sz)
+STC_INLINE bool _cbits_subset_of(const uint64_t* set, const uint64_t* other, const _llong sz)
     { _cbits_OPR(|, set[i]); }
 
-STC_INLINE bool _cbits_disjoint(const uint64_t* set, const uint64_t* other, const int64_t sz)
+STC_INLINE bool _cbits_disjoint(const uint64_t* set, const uint64_t* other, const _llong sz)
     { _cbits_OPR(&, 0); }
 
 #endif // CBITS_H_INCLUDED
@@ -125,11 +125,11 @@ STC_INLINE bool _cbits_disjoint(const uint64_t* set, const uint64_t* other, cons
 #define _i_assert(x) assert(x)
 #define i_type cbits
 
-typedef struct { uint64_t *data64; int64_t _size; } i_type;
+typedef struct { uint64_t *data64; _llong _size; } i_type;
 
 STC_INLINE cbits   cbits_init(void) { return c_LITERAL(cbits){NULL}; }
 STC_INLINE void    cbits_drop(cbits* self) { c_free(self->data64); }
-STC_INLINE int64_t cbits_size(const cbits* self) { return self->_size; }
+STC_INLINE _llong  cbits_size(const cbits* self) { return self->_size; }
 
 STC_INLINE cbits* cbits_take(cbits* self, cbits other) {
     if (self->data64 != other.data64) {
@@ -140,7 +140,7 @@ STC_INLINE cbits* cbits_take(cbits* self, cbits other) {
 }
 
 STC_INLINE cbits cbits_clone(cbits other) {
-    const int64_t bytes = _cbits_bytes(other._size);
+    const _llong bytes = _cbits_bytes(other._size);
     cbits set = {(uint64_t *)c_memcpy(c_malloc(bytes), other.data64, bytes), other._size};
     return set;
 }
@@ -154,8 +154,8 @@ STC_INLINE cbits* cbits_copy(cbits* self, const cbits* other) {
     return self;
 }
 
-STC_INLINE void cbits_resize(cbits* self, const int64_t size, const bool value) {
-    const int64_t new_n = _cbits_words(size), osize = self->_size, old_n = _cbits_words(osize);
+STC_INLINE void cbits_resize(cbits* self, const _llong size, const bool value) {
+    const _llong new_n = _cbits_words(size), osize = self->_size, old_n = _cbits_words(osize);
     self->data64 = (uint64_t *)c_realloc(self->data64, new_n*8);
     self->_size = size;
     if (new_n >= old_n) {
@@ -177,13 +177,13 @@ STC_INLINE cbits cbits_move(cbits* self) {
     return tmp;
 }
 
-STC_INLINE cbits cbits_with_size(const int64_t size, const bool value) {
+STC_INLINE cbits cbits_with_size(const _llong size, const bool value) {
     cbits set = {(uint64_t *)c_malloc(_cbits_bytes(size)), size};
     cbits_set_all(&set, value);
     return set;
 }
 
-STC_INLINE cbits cbits_with_pattern(const int64_t size, const uint64_t pattern) {
+STC_INLINE cbits cbits_with_pattern(const _llong size, const uint64_t pattern) {
     cbits set = {(uint64_t *)c_malloc(_cbits_bytes(size)), size};
     cbits_set_pattern(&set, pattern);
     return set;
@@ -200,7 +200,7 @@ typedef struct { uint64_t data64[(i_capacity - 1)/64 + 1]; } i_type;
 
 STC_INLINE void     _i_memb(_init)(i_type* self) { memset(self->data64, 0, i_capacity*8); }
 STC_INLINE void     _i_memb(_drop)(i_type* self) {}
-STC_INLINE int64_t  _i_memb(_size)(const i_type* self) { return i_capacity; }
+STC_INLINE _llong   _i_memb(_size)(const i_type* self) { return i_capacity; }
 STC_INLINE i_type   _i_memb(_move)(i_type* self) { return *self; }
 
 STC_INLINE i_type*  _i_memb(_take)(i_type* self, i_type other)
@@ -215,13 +215,13 @@ STC_INLINE i_type* _i_memb(_copy)(i_type* self, const i_type* other)
 STC_INLINE void _i_memb(_set_all)(i_type *self, const bool value);
 STC_INLINE void _i_memb(_set_pattern)(i_type *self, const uint64_t pattern);
 
-STC_INLINE i_type _i_memb(_with_size)(const int64_t size, const bool value) {
+STC_INLINE i_type _i_memb(_with_size)(const _llong size, const bool value) {
     assert(size <= i_capacity);
     i_type set; _i_memb(_set_all)(&set, value);
     return set;
 }
 
-STC_INLINE i_type _i_memb(_with_pattern)(const int64_t size, const uint64_t pattern) {
+STC_INLINE i_type _i_memb(_with_pattern)(const _llong size, const uint64_t pattern) {
     assert(size <= i_capacity);
     i_type set; _i_memb(_set_pattern)(&set, pattern);
     return set;
@@ -234,36 +234,36 @@ STC_INLINE void _i_memb(_set_all)(i_type *self, const bool value)
     { c_memset(self->data64, value? ~0 : 0, _cbits_bytes(_i_memb(_size)(self))); }
 
 STC_INLINE void _i_memb(_set_pattern)(i_type *self, const uint64_t pattern) {
-    int64_t n = _cbits_words(_i_memb(_size)(self));
+    _llong n = _cbits_words(_i_memb(_size)(self));
     while (n--) self->data64[n] = pattern;
 }
 
-STC_INLINE bool _i_memb(_test)(const i_type* self, const int64_t i) 
+STC_INLINE bool _i_memb(_test)(const i_type* self, const _llong i) 
     { return (self->data64[i>>6] & _cbits_bit(i)) != 0; }
 
-STC_INLINE bool _i_memb(_at)(const i_type* self, const int64_t i)
+STC_INLINE bool _i_memb(_at)(const i_type* self, const _llong i)
     { return (self->data64[i>>6] & _cbits_bit(i)) != 0; }
 
-STC_INLINE void _i_memb(_set)(i_type *self, const int64_t i)
+STC_INLINE void _i_memb(_set)(i_type *self, const _llong i)
     { self->data64[i>>6] |= _cbits_bit(i); }
 
-STC_INLINE void _i_memb(_reset)(i_type *self, const int64_t i)
+STC_INLINE void _i_memb(_reset)(i_type *self, const _llong i)
     { self->data64[i>>6] &= ~_cbits_bit(i); }
 
-STC_INLINE void _i_memb(_set_value)(i_type *self, const int64_t i, const bool b) {
+STC_INLINE void _i_memb(_set_value)(i_type *self, const _llong i, const bool b) {
     self->data64[i>>6] ^= ((uint64_t)-(int)b ^ self->data64[i>>6]) & _cbits_bit(i);
 }
 
-STC_INLINE void _i_memb(_flip)(i_type *self, const int64_t i)
+STC_INLINE void _i_memb(_flip)(i_type *self, const _llong i)
     { self->data64[i>>6] ^= _cbits_bit(i); }
 
 STC_INLINE void _i_memb(_flip_all)(i_type *self) {
-    int64_t n = _cbits_words(_i_memb(_size)(self));
+    _llong n = _cbits_words(_i_memb(_size)(self));
     while (n--) self->data64[n] ^= ~(uint64_t)0;
 }
 
 STC_INLINE i_type _i_memb(_from)(const char* str) {
-    int64_t n = c_strlen(str);
+    _llong n = c_strlen(str);
     i_type set = _i_memb(_with_size)(n, false);
     while (n--) if (str[n] == '1') _i_memb(_set)(&set, n);
     return set;
@@ -272,26 +272,26 @@ STC_INLINE i_type _i_memb(_from)(const char* str) {
 /* Intersection */
 STC_INLINE void _i_memb(_intersect)(i_type *self, const i_type* other) {
     _i_assert(self->_size == other->_size);
-    int64_t n = _cbits_words(_i_memb(_size)(self));
+    _llong n = _cbits_words(_i_memb(_size)(self));
     while (n--) self->data64[n] &= other->data64[n];
 }
 /* Union */
 STC_INLINE void _i_memb(_union)(i_type *self, const i_type* other) {
     _i_assert(self->_size == other->_size);
-    int64_t n = _cbits_words(_i_memb(_size)(self));
+    _llong n = _cbits_words(_i_memb(_size)(self));
     while (n--) self->data64[n] |= other->data64[n];
 }
 /* Exclusive disjunction */
 STC_INLINE void _i_memb(_xor)(i_type *self, const i_type* other) {
     _i_assert(self->_size == other->_size);
-    int64_t n = _cbits_words(_i_memb(_size)(self));
+    _llong n = _cbits_words(_i_memb(_size)(self));
     while (n--) self->data64[n] ^= other->data64[n];
 }
 
-STC_INLINE int64_t _i_memb(_count)(const i_type* self)
+STC_INLINE _llong _i_memb(_count)(const i_type* self)
     { return _cbits_count(self->data64, _i_memb(_size)(self)); }
 
-STC_INLINE char* _i_memb(_to_str)(const i_type* self, char* out, int64_t start, int64_t stop)
+STC_INLINE char* _i_memb(_to_str)(const i_type* self, char* out, _llong start, _llong stop)
     { return _cbits_to_str(self->data64, _i_memb(_size)(self), out, start, stop); }
 
 STC_INLINE bool _i_memb(_subset_of)(const i_type* self, const i_type* other) { 
diff --git a/include/stc/ccommon.h b/include/stc/ccommon.h
index 63ce5b09..6f42bcc1 100644
--- a/include/stc/ccommon.h
+++ b/include/stc/ccommon.h
@@ -30,6 +30,7 @@
 #include <string.h>
 #include <assert.h>
 
+typedef long long _llong;
 #define c_NPOS INTPTR_MAX
 #define c_ZI PRIiPTR
 #define c_ZU PRIuPTR
@@ -200,9 +201,9 @@ STC_INLINE intptr_t cnextpow2(intptr_t n) {
 #define c_forrange_1(stop) c_forrange_3(_c_i, 0, stop)
 #define c_forrange_2(i, stop) c_forrange_3(i, 0, stop)
 #define c_forrange_3(i, start, stop) \
-    for (long long i=start, _end=(long long)(stop); i < _end; ++i)
+    for (_llong i=start, _end=(_llong)(stop); i < _end; ++i)
 #define c_forrange_4(i, start, stop, step) \
-    for (long long i=start, _inc=step, _end=(long long)(stop) - (_inc > 0) \
+    for (_llong i=start, _inc=step, _end=(_llong)(stop) - (_inc > 0) \
          ; (_inc > 0) ^ (i > _end); i += _inc)
 
 #ifndef __cplusplus