bit-twiddle 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 13445e64bb55645046d83cb47ac06f5fa99bf6e1
-  data.tar.gz: 6502337f2795864ed19612dfa6dfcc8e8f07f474
+  metadata.gz: df07a55110e5af925bd93744a433285027625484
+  data.tar.gz: 83f5c1bc321432ca3e02337ed9753211059aafaa
 SHA512:
-  metadata.gz: e3d234cfb1f52c72d8a582a99c0a48054c1fa521aee7669ab8d9190b6939d00cc23755f5232758342acdde06916833497eb4074c88bc0729708c1eab3311b043
-  data.tar.gz: e082a8a0592ec1d07774e1841cadd597292d40b24c14c0b3209b1a5ad2662771a56e4aef479de349ce2d62c674a33e7f81c665d5a7bf60c6189867732f0215fe
+  metadata.gz: de3c177b4ca0b61c0b1382c9cff137bca48c6fe3cf8195390448e4e34e80c1eb4907359598201c476e87d34681bb24900d38258089ec86ae7fbb7a4cee56c085
+  data.tar.gz: 10813e14ff47ce9a9f7352fd0b800f499320779563421cd078fb3c8463ba96c0cdc970e30f4b02815eedab118dcd326544146513dbd1c3da45ddea3397e93580

data/ext/bit_twiddle/bit_twiddle.c

@@ -4,6 +4,13 @@
 #include <ruby.h>
 #include "bt_bignum.h"
 
+#ifndef HAVE_TYPE_ULONG
+typedef unsigned long ulong;
+#endif
+#ifndef HAVE_TYPE_UCHAR
+typedef unsigned char uchar;
+#endif
+
 #define fix_zero LONG2FIX(0L)
 #define BIGNUM_P(x) RB_TYPE_P((x), T_BIGNUM)
 
@@ -53,7 +60,7 @@ bnum_greater(VALUE bnum, BDIGIT value)
 }
 
 static long
-value_to_shiftdist(VALUE shiftdist, long bits)
+value_to_shiftdist(VALUE shiftdist, unsigned int bits)
 {
   for (;;) {
     if (FIXNUM_P(shiftdist)) {
@@ -84,12 +91,12 @@ value_to_rotdist(VALUE rotdist, long bits, long mask)
       rdist = FIX2LONG(rotdist) % bits;
       if (rdist < 0)
         rdist += bits;
-      return rdist;
+      return (ulong)rdist;
     } else if (BIGNUM_P(rotdist)) {
       rdist = *RBIGNUM_DIGITS(rotdist) & mask;
       if (RBIGNUM_NEGATIVE_P(rotdist))
         rdist = bits - rdist;
-      return rdist;
+      return (ulong)rdist;
     } else {
       rotdist = rb_to_int(rotdist);
     }
@@ -102,22 +109,22 @@ store_64_into_bnum(VALUE bnum, uint64_t int64)
   BDIGIT *dest = RBIGNUM_DIGITS(bnum);
   size_t  len  = RBIGNUM_LEN(bnum);
 
-  if (SIZEOF_BDIGIT == 8) {
+#if (SIZEOF_BDIGIT == 8)
     *dest = int64;
-  } else {
+#else
     if (len > 1) {
-      *dest     = int64;
-      *(dest+1) = int64 >> 32;
+      *dest     = (uint32_t)int64;
+      *(dest+1) = (uint32_t)(int64 >> 32);
     } else if ((int64 & (0xFFFFFFFFULL << 32)) == 0) {
       /* the high 4 bytes are zero anyways */
-      *dest = int64;
+      *dest = (uint32_t)int64;
     } else {
       rb_big_resize(bnum, 2);
       dest      = RBIGNUM_DIGITS(bnum); /* may have moved */
-      *dest     = int64;
-      *(dest+1) = int64 >> 32;
+      *dest     = (uint32_t)int64;
+      *(dest+1) = (uint32_t)(int64 >> 32);
     }
-  }
+#endif
 }
 
 static uint64_t
@@ -227,7 +234,7 @@ fnum_popcount(VALUE fnum)
   long value = FIX2LONG(fnum);
   if (value < 0)
     rb_raise(rb_eRangeError, "can't take popcount of a negative number");
-  return LONG2FIX(__builtin_popcountl(value));
+  return LONG2FIX(__builtin_popcountl((ulong)value));
 }
 
 static VALUE
@@ -268,8 +275,8 @@ def_int_method(popcount);
 static VALUE
 str_popcount(VALUE str)
 {
-  char *p     = RSTRING_PTR(str);
-  int  length = RSTRING_LEN(str);
+  uchar *p    = (uchar*)RSTRING_PTR(str);
+  long length = RSTRING_LEN(str);
   long bits   = 0;
 
   /* This could be made faster by processing 4/8 bytes at a time */
@@ -343,7 +350,7 @@ static VALUE
 bnum_hi_bit(VALUE bnum)
 {
   BDIGIT *digit = RBIGNUM_DIGITS(bnum) + (RBIGNUM_LEN(bnum)-1);
-  long    bits  = (sizeof(BDIGIT) * 8) * RBIGNUM_LEN(bnum);
+  ulong   bits  = (sizeof(BDIGIT) * 8) * RBIGNUM_LEN(bnum);
 
   if (RBIGNUM_NEGATIVE_P(bnum))
     rb_raise(rb_eRangeError, "can't find highest 1 bit in a negative number");
@@ -376,14 +383,14 @@ fnum_bswap16(VALUE fnum)
   long value = FIX2LONG(fnum);
   if (value < 0)
     rb_raise(rb_eRangeError, "can't swap bytes in a negative number");
-  return LONG2FIX((value & ~0xFFFF) | __builtin_bswap16(value));
+  return LONG2FIX(((ulong)value & ~0xFFFFUL) | __builtin_bswap16((uint16_t)value));
 }
 
 static VALUE
 bnum_bswap16(VALUE bnum)
 {
   if (RBIGNUM_POSITIVE_P(bnum))
-    return modify_lo16_in_bignum(bnum, __builtin_bswap16(*RBIGNUM_DIGITS(bnum)));
+    return modify_lo16_in_bignum(bnum, __builtin_bswap16((uint16_t)*RBIGNUM_DIGITS(bnum)));
   else
     rb_raise(rb_eRangeError, "can't swap bytes in a negative number");
 }
@@ -415,7 +422,7 @@ fnum_bswap32(VALUE fnum)
      * That is why we have to use a '2NUM' function, not '2FIX' */
     return ULONG2NUM(__builtin_bswap32(FIX2LONG(fnum)));
   else
-    return LONG2FIX((value & ~0xFFFFFFFFL) | __builtin_bswap32(value));
+    return LONG2FIX(((ulong)value & ~0xFFFFFFFFUL) | __builtin_bswap32((uint32_t)value));
 }
 
 static VALUE
@@ -446,7 +453,7 @@ fnum_bswap64(VALUE fnum)
   long value = FIX2LONG(fnum);
   if (value < 0)
     rb_raise(rb_eRangeError, "can't swap bytes in a negative number");
-  return ULL2NUM(__builtin_bswap64(value));
+  return ULL2NUM(__builtin_bswap64((uint64_t)value));
 }
 
 static VALUE
@@ -490,13 +497,13 @@ static VALUE
 fnum_rrot8(VALUE fnum, VALUE rotdist)
 {
   long value = FIX2LONG(fnum);
-  return LONG2FIX((value & ~0xFFL) | rrot8(value, rotdist));
+  return LONG2FIX(((ulong)value & ~0xFFUL) | rrot8((uint8_t)value, rotdist));
 }
 
 static VALUE
 bnum_rrot8(VALUE bnum, VALUE rotdist)
 {
-  return modify_lo8_in_bignum(bnum, rrot8(*RBIGNUM_DIGITS(bnum), rotdist));
+  return modify_lo8_in_bignum(bnum, rrot8((uint8_t)*RBIGNUM_DIGITS(bnum), rotdist));
 }
 
 /* Document-method: Integer#rrot8
@@ -518,13 +525,13 @@ static VALUE
 fnum_rrot16(VALUE fnum, VALUE rotdist)
 {
   long value = FIX2LONG(fnum);
-  return LONG2FIX((value & ~0xFFFFL) | rrot16(value, rotdist));
+  return LONG2FIX(((ulong)value & ~0xFFFFUL) | rrot16((uint16_t)value, rotdist));
 }
 
 static VALUE
 bnum_rrot16(VALUE bnum, VALUE rotdist)
 {
-  return modify_lo16_in_bignum(bnum, rrot16(*RBIGNUM_DIGITS(bnum), rotdist));
+  return modify_lo16_in_bignum(bnum, rrot16((uint16_t)*RBIGNUM_DIGITS(bnum), rotdist));
 }
 
 /* Document-method: Integer#rrot16
@@ -547,15 +554,15 @@ fnum_rrot32(VALUE fnum, VALUE rotdist)
 {
   long     value  = FIX2LONG(fnum);
   if (SIZEOF_LONG == 8)
-    return LONG2FIX((value & ~0xFFFFFFFFL) | rrot32(value, rotdist));
+    return LONG2FIX(((ulong)value & ~0xFFFFFFFFUL) | rrot32((uint32_t)value, rotdist));
   else
-    return ULONG2NUM(rrot32(value, rotdist));
+    return ULONG2NUM(rrot32((uint32_t)value, rotdist));
 }
 
 static VALUE
 bnum_rrot32(VALUE bnum, VALUE rotdist)
 {
-  return modify_lo32_in_bignum(bnum, rrot32(*RBIGNUM_DIGITS(bnum), rotdist));
+  return modify_lo32_in_bignum(bnum, rrot32((uint32_t)*RBIGNUM_DIGITS(bnum), rotdist));
 }
 
 /* Document-method: Integer#rrot32
@@ -602,13 +609,13 @@ static VALUE
 fnum_lrot8(VALUE fnum, VALUE rotdist)
 {
   long value = FIX2LONG(fnum);
-  return LONG2FIX((value & ~0xFFL) | lrot8(value, rotdist));
+  return LONG2FIX(((ulong)value & ~0xFFUL) | lrot8((uint8_t)value, rotdist));
 }
 
 static VALUE
 bnum_lrot8(VALUE bnum, VALUE rotdist)
 {
-  return modify_lo8_in_bignum(bnum, lrot8(*RBIGNUM_DIGITS(bnum), rotdist));
+  return modify_lo8_in_bignum(bnum, lrot8((uint8_t)*RBIGNUM_DIGITS(bnum), rotdist));
 }
 
 /* Document-method: Integer#lrot8
@@ -630,13 +637,13 @@ static VALUE
 fnum_lrot16(VALUE fnum, VALUE rotdist)
 {
   long value = FIX2LONG(fnum);
-  return LONG2FIX((value & ~0xFFFFL) | lrot16(value, rotdist));
+  return LONG2FIX(((ulong)value & ~0xFFFFUL) | lrot16((uint16_t)value, rotdist));
 }
 
 static VALUE
 bnum_lrot16(VALUE bnum, VALUE rotdist)
 {
-  return modify_lo16_in_bignum(bnum, lrot16(*RBIGNUM_DIGITS(bnum), rotdist));
+  return modify_lo16_in_bignum(bnum, lrot16((uint16_t)*RBIGNUM_DIGITS(bnum), rotdist));
 }
 
 /* Document-method: Integer#lrot16
@@ -658,13 +665,13 @@ static VALUE
 fnum_lrot32(VALUE fnum, VALUE rotdist)
 {
   long value = FIX2LONG(fnum);
-  return LONG2FIX((value & ~0xFFFFFFFFL) | lrot32(value, rotdist));
+  return LONG2FIX(((ulong)value & ~0xFFFFFFFFUL) | lrot32((uint32_t)value, rotdist));
 }
 
 static VALUE
 bnum_lrot32(VALUE bnum, VALUE rotdist)
 {
-  return modify_lo32_in_bignum(bnum, lrot32(*RBIGNUM_DIGITS(bnum), rotdist));
+  return modify_lo32_in_bignum(bnum, lrot32((uint32_t)*RBIGNUM_DIGITS(bnum), rotdist));
 }
 
 /* Document-method: Integer#lrot32
@@ -752,7 +759,7 @@ fnum_lshift8(VALUE fnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return fnum;
   else
-    return LONG2FIX((value & ~0xFFL) | lshift8(value, shiftdist));
+    return LONG2FIX(((ulong)value & ~0xFFUL) | lshift8((uint8_t)value, shiftdist));
 }
 
 static VALUE
@@ -761,7 +768,7 @@ bnum_lshift8(VALUE bnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return bnum;
   else
-    return modify_lo8_in_bignum(bnum, lshift8(*RBIGNUM_DIGITS(bnum), shiftdist));
+    return modify_lo8_in_bignum(bnum, lshift8((uint8_t)*RBIGNUM_DIGITS(bnum), shiftdist));
 }
 
 /* Document-method: Integer#lshift8
@@ -787,7 +794,7 @@ fnum_lshift16(VALUE fnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return fnum;
   else
-    return LONG2FIX((value & ~0xFFFFL) | lshift16(value, shiftdist));
+    return LONG2FIX(((ulong)value & ~0xFFFFUL) | lshift16((uint16_t)value, shiftdist));
 }
 
 static VALUE
@@ -796,7 +803,7 @@ bnum_lshift16(VALUE bnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return bnum;
   else
-    return modify_lo16_in_bignum(bnum, lshift16(*RBIGNUM_DIGITS(bnum), shiftdist));
+    return modify_lo16_in_bignum(bnum, lshift16((uint16_t)*RBIGNUM_DIGITS(bnum), shiftdist));
 }
 
 /* Document-method: Integer#lshift16
@@ -822,7 +829,7 @@ fnum_lshift32(VALUE fnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return fnum;
   else
-    return LONG2FIX((value & ~0xFFFFFFFFL) | lshift32(value, shiftdist));
+    return LONG2FIX(((ulong)value & ~0xFFFFFFFFUL) | lshift32((uint32_t)value, shiftdist));
 }
 
 static VALUE
@@ -831,7 +838,7 @@ bnum_lshift32(VALUE bnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return bnum;
   else
-    return modify_lo32_in_bignum(bnum, lshift32(*RBIGNUM_DIGITS(bnum), shiftdist));
+    return modify_lo32_in_bignum(bnum, lshift32((uint32_t)*RBIGNUM_DIGITS(bnum), shiftdist));
 }
 
 /* Document-method: Integer#lshift32
@@ -897,7 +904,7 @@ fnum_rshift8(VALUE fnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return fnum;
   else
-    return LONG2FIX((value & ~0xFFL) | rshift8(value, shiftdist));
+    return LONG2FIX(((ulong)value & ~0xFFUL) | rshift8((uint8_t)value, shiftdist));
 }
 
 static VALUE
@@ -906,7 +913,7 @@ bnum_rshift8(VALUE bnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return bnum;
   else
-    return modify_lo8_in_bignum(bnum, rshift8(*RBIGNUM_DIGITS(bnum), shiftdist));
+    return modify_lo8_in_bignum(bnum, rshift8((uint8_t)*RBIGNUM_DIGITS(bnum), shiftdist));
 }
 
 /* Document-method: Integer#rshift8
@@ -932,7 +939,7 @@ fnum_rshift16(VALUE fnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return fnum;
   else
-    return LONG2FIX((value & ~0xFFFFL) | rshift16(value, shiftdist));
+    return LONG2FIX(((ulong)value & ~0xFFFFUL) | rshift16((uint16_t)value, shiftdist));
 }
 
 static VALUE
@@ -941,7 +948,7 @@ bnum_rshift16(VALUE bnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return bnum;
   else
-    return modify_lo16_in_bignum(bnum, rshift16(*RBIGNUM_DIGITS(bnum), shiftdist));
+    return modify_lo16_in_bignum(bnum, rshift16((uint16_t)*RBIGNUM_DIGITS(bnum), shiftdist));
 }
 
 /* Document-method: Integer#rshift16
@@ -967,7 +974,7 @@ fnum_rshift32(VALUE fnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return fnum;
   else
-    return LONG2FIX((value & ~0xFFFFFFFFL) | rshift32(value, shiftdist));
+    return LONG2FIX(((ulong)value & ~0xFFFFFFFFUL) | rshift32((uint32_t)value, shiftdist));
 }
 
 static VALUE
@@ -1042,7 +1049,7 @@ fnum_arith_rshift8(VALUE fnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return fnum;
   else
-    return LONG2FIX((value & ~0xFFUL) | arith_rshift8(value, shiftdist));
+    return LONG2FIX(((ulong)value & ~0xFFUL) | arith_rshift8((uint8_t)value, shiftdist));
 }
 
 static VALUE
@@ -1051,7 +1058,7 @@ bnum_arith_rshift8(VALUE bnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return bnum;
   else
-    return modify_lo8_in_bignum(bnum, arith_rshift8(*RBIGNUM_DIGITS(bnum), shiftdist));
+    return modify_lo8_in_bignum(bnum, arith_rshift8((uint8_t)*RBIGNUM_DIGITS(bnum), shiftdist));
 }
 
 /* Document-method: Integer#arith_rshift8
@@ -1077,7 +1084,7 @@ fnum_arith_rshift16(VALUE fnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return fnum;
   else
-    return LONG2FIX((value & ~0xFFFFUL) | arith_rshift16(value, shiftdist));
+    return LONG2FIX(((ulong)value & ~0xFFFFUL) | arith_rshift16((uint16_t)value, shiftdist));
 }
 
 static VALUE
@@ -1086,7 +1093,7 @@ bnum_arith_rshift16(VALUE bnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return bnum;
   else
-    return modify_lo16_in_bignum(bnum, arith_rshift16(*RBIGNUM_DIGITS(bnum), shiftdist));
+    return modify_lo16_in_bignum(bnum, arith_rshift16((uint16_t)*RBIGNUM_DIGITS(bnum), shiftdist));
 }
 
 /* Document-method: Integer#arith_rshift16
@@ -1112,7 +1119,7 @@ fnum_arith_rshift32(VALUE fnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return fnum;
   else
-    return LONG2FIX((value & ~0xFFFFFFFFUL) | arith_rshift32(value, shiftdist));
+    return LONG2FIX(((ulong)value & ~0xFFFFFFFFUL) | arith_rshift32((uint32_t)value, shiftdist));
 }
 
 static VALUE
@@ -1146,7 +1153,7 @@ fnum_arith_rshift64(VALUE fnum, VALUE shiftdist)
   if (shiftdist == fix_zero)
     return fnum;
   else
-    return ULONG2NUM(arith_rshift64(FIX2LONG(fnum), shiftdist));
+    return ULONG2NUM(arith_rshift64((uint64_t)FIX2LONG(fnum), shiftdist));
 }
 
 static VALUE
@@ -1200,7 +1207,7 @@ static inline uint8_t reverse8(uint8_t value)
     /* 64-bit CPU
      * Thanks to the Bit Twiddling Hacks page:
      * http://graphics.stanford.edu/~seander/bithacks.html */
-    return (value * 0x0202020202UL & 0x010884422010UL) % 1023;
+    return (uint8_t)((value * 0x0202020202UL & 0x010884422010UL) % 1023);
   else
     /* 32-bit CPU */
     return bitreverse_table[value];
@@ -1208,17 +1215,17 @@ static inline uint8_t reverse8(uint8_t value)
 
 static inline uint16_t reverse16(uint16_t value)
 {
-  return (bitreverse_table[value & 0xFF] << 8) | bitreverse_table[value >> 8];
+  return (uint16_t)(bitreverse_table[value & 0xFF] << 8) | bitreverse_table[value >> 8];
 }
 
 static inline uint32_t reverse32(uint32_t value)
 {
-  return ((uint32_t)reverse16(value) << 16) | reverse16(value >> 16);
+  return ((uint32_t)reverse16((uint16_t)value) << 16) | reverse16(value >> 16);
 }
 
 static inline uint64_t reverse64(uint64_t value)
 {
-  return ((uint64_t)reverse32(value) << 32) | reverse32(value >> 32);
+  return ((uint64_t)reverse32((uint32_t)value) << 32) | reverse32(value >> 32);
 }
 
 static VALUE
@@ -1227,7 +1234,7 @@ fnum_bitreverse8(VALUE fnum)
   long value = FIX2LONG(fnum);
   if (value < 0)
     rb_raise(rb_eRangeError, "can't reverse bits in a negative number");
-  return LONG2FIX((value & ~0xFFL) | reverse8(value));
+  return LONG2FIX((value & ~0xFFL) | reverse8((uint8_t)value));
 }
 
 static VALUE
@@ -1235,7 +1242,7 @@ bnum_bitreverse8(VALUE bnum)
 {
   if (RBIGNUM_NEGATIVE_P(bnum))
     rb_raise(rb_eRangeError, "can't reverse bits in a negative number");
-  return modify_lo8_in_bignum(bnum, reverse8(*RBIGNUM_DIGITS(bnum)));
+  return modify_lo8_in_bignum(bnum, reverse8((uint8_t)*RBIGNUM_DIGITS(bnum)));
 }
 
 /* Document-method: Integer#bitreverse8
@@ -1256,7 +1263,7 @@ fnum_bitreverse16(VALUE fnum)
   long value = FIX2LONG(fnum);
   if (value < 0)
     rb_raise(rb_eRangeError, "can't reverse bits in a negative number");
-  return LONG2FIX((value & ~0xFFFFL) | reverse16(value));
+  return LONG2FIX((value & ~0xFFFFL) | reverse16((uint16_t)value));
 }
 
 static VALUE
@@ -1264,7 +1271,7 @@ bnum_bitreverse16(VALUE bnum)
 {
   if (RBIGNUM_NEGATIVE_P(bnum))
     rb_raise(rb_eRangeError, "can't reverse bits in a negative number");
-  return modify_lo16_in_bignum(bnum, reverse16(*RBIGNUM_DIGITS(bnum)));
+  return modify_lo16_in_bignum(bnum, reverse16((uint16_t)*RBIGNUM_DIGITS(bnum)));
 }
 
 /* Document-method: Integer#bitreverse16
@@ -1283,7 +1290,7 @@ static VALUE
 fnum_bitreverse32(VALUE fnum)
 {
   long     value = FIX2LONG(fnum);
-  uint32_t lo32  = value;
+  uint32_t lo32  = (uint32_t)value;
   if (value < 0)
     rb_raise(rb_eRangeError, "can't reverse bits in a negative number");
   else if (SIZEOF_LONG == 4)
@@ -1318,7 +1325,7 @@ fnum_bitreverse64(VALUE fnum)
   long value = FIX2LONG(fnum);
   if (value < 0)
     rb_raise(rb_eRangeError, "can't reverse bits in a negative number");
-  return ULL2NUM(reverse64(value));
+  return ULL2NUM(reverse64((uint64_t)value));
 }
 
 static VALUE

data/ext/bit_twiddle/extconf.rb

@@ -7,7 +7,14 @@ if ENV['CC']
   RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC']
 end
 
-$CFLAGS << ' -Wall -Werror -O3 -march=native -mtune=native -std=c99 '
+$CFLAGS << ' -Wall ' # turn on all warnings for more thorough code checking
+# for clang; generated Makefile contains GCC-specific -W options which clang doesn't understand
+$CFLAGS << ' -Wno-unknown-warning-option '
+# for clang; ruby.h contains __error__ and __deprecated__, which clang chokes on
+$CFLAGS << ' -Wno-unknown-attributes -Wno-ignored-attributes '
+$CFLAGS << ' -Werror ' # convert all warnings to errors so we can't ignore them
+$CFLAGS << ' -O3 -march=native -mtune=native ' # full optimization
+$CFLAGS << ' -std=c99 ' # use a modern version of the C standard
 
 if RUBY_ENGINE == 'rbx'
   raise "bit-twiddle does not support Rubinius. Sorry!"
@@ -22,6 +29,11 @@ check_sizeof 'int'
 check_sizeof 'long'
 check_sizeof 'long long'
 
+# if we already have ulong, HAVE_TYPE_ULONG will be defined as a macro
+have_type 'ulong'
+# likewise for uchar
+have_type 'uchar'
+
 checking_for("whether >> on a signed long is arithmetic shift or logical shift", "%s") do
   is_arith = try_static_assert("(-1L >> (sizeof(long)/8)) == -1L")
   $defs.push("-DRSHIFT_IS_ARITH=#{is_arith ? '1' : '0'}")
@@ -34,4 +46,4 @@ checking_for("presence of __builtin_bswap16", "%s") do
   have_bswap16 ? "oh yeah" : "nope...but we can sure fix that"
 end
 
-create_makefile 'bit_twiddle'
+create_makefile 'bit_twiddle'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bit-twiddle
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - Alex Dowad
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-02 00:00:00.000000000 Z
+date: 2018-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec