ox 1.6.2 → 1.6.3

data/README.md

@@ -20,7 +20,7 @@ A fast XML parser and Object marshaller as a Ruby gem.
 
 ## <a name="build_status">Build Status</a>
 
-[![Build Status](http://travis-ci.org/ohler55/ox.png)](http://travis-ci.org/ohler55/ox)
+[![Build Status](https://secure.travis-ci.org/ohler55/ox.png?branch=master)](http://travis-ci.org/ohler55/ox)
 
 ## <a name="links">Links of Interest</a>
 
@@ -34,9 +34,9 @@ A fast XML parser and Object marshaller as a Ruby gem.
 
 ## <a name="release">Release Notes</a>
 
-### Release 1.6.2
+### Release 1.6.3
 
- - Added check for Solaris and Linux builds to not use the timezone member of time struct (struct tm).
+ - Fixed compatibility issues with Linux (Ubuntu) mostly related to pointer sizes.
 
 ## <a name="description">Description</a>
 

data/ext/ox/cache8.c

@@ -8,29 +8,31 @@
 #include "ruby.h"
 #include "cache8.h"
 
-#define BITS            4
-#define MASK            0x000000000000000F
-#define SLOT_CNT        16
-#define DEPTH           16
+#define BITS		4
+#define MASK		0x000000000000000FULL
+#define SLOT_CNT	16
+#define DEPTH		16
+
+typedef union {
+    struct _Cache8	*child;
+    slot_t		value;
+} Bucket;
 
 struct _Cache8 {
-    union {
-        struct _Cache8  *slots[SLOT_CNT];
-        unsigned long   values[SLOT_CNT];
-    };
+    Bucket	buckets[SLOT_CNT];
 };
 
-static void     cache8_delete(Cache8 cache, int depth);
-static void     slot_print(Cache8 cache, VALUE key, unsigned int depth);
+static void	cache8_delete(Cache8 cache, int depth);
+static void	slot_print(Cache8 cache, sid_t key, unsigned int depth);
 
 void
 ox_cache8_new(Cache8 *cache) {
-    Cache8     *cp;
-    int         i;
+    Bucket	*b;
+    int		i;
     
     *cache = ALLOC(struct _Cache8);
-    for (i = SLOT_CNT, cp = (*cache)->slots; 0 < i; i--, cp++) {
-        *cp = 0;
+    for (i = SLOT_CNT, b = (*cache)->buckets; 0 < i; i--, b++) {
+	b->value = 0;
     }
 }
 
@@ -41,34 +43,35 @@ ox_cache8_delete(Cache8 cache) {
 
 static void
 cache8_delete(Cache8 cache, int depth) {
-    Cache8              *cp;
-    unsigned int        i;
+    Bucket		*b;
+    unsigned int	i;
 
-    for (i = 0, cp = cache->slots; i < SLOT_CNT; i++, cp++) {
-        if (0 != *cp) {
-            if (DEPTH - 1 != depth) {
-                cache8_delete(*cp, depth + 1);
-            }
-        }
+    for (i = 0, b = cache->buckets; i < SLOT_CNT; i++, b++) {
+	if (0 != b->child) {
+	    if (DEPTH - 1 != depth) {
+		cache8_delete(b->child, depth + 1);
+	    }
+	}
     }
     xfree(cache);
 }
 
 slot_t
-ox_cache8_get(Cache8 cache, VALUE key, slot_t **slot) {
-    Cache8      *cp;
-    int         i;
-    VALUE       k;
+ox_cache8_get(Cache8 cache, sid_t key, slot_t **slot) {
+    Bucket	*b;
+    int		i;
+    sid_t	k8 = (sid_t)key;
+    sid_t	k;
     
     for (i = 64 - BITS; 0 < i; i -= BITS) {
-        k = (key >> i) & MASK;
-        cp = cache->slots + k;
-        if (0 == *cp) {
-            ox_cache8_new(cp);
-        }
-        cache = *cp;
+	k = (k8 >> i) & MASK;
+	b = cache->buckets + k;
+	if (0 == b->child) {
+	    ox_cache8_new(&b->child);
+	}
+	cache = b->child;
     }
-    *slot = cache->values + (key & MASK);
+    *slot = &(cache->buckets + (k8 & MASK))->value;
 
     return **slot;
 }
@@ -80,20 +83,21 @@ ox_cache8_print(Cache8 cache) {
 }
 
 static void
-slot_print(Cache8 c, VALUE key, unsigned int depth) {
-    Cache8              *cp;
-    unsigned int        i;
-    unsigned long       k;
+slot_print(Cache8 c, sid_t key, unsigned int depth) {
+    Bucket		*b;
+    unsigned int	i;
+    sid_t		k8 = (sid_t)key;
+    sid_t		k;
 
-    for (i = 0, cp = c->slots; i < SLOT_CNT; i++, cp++) {
-        if (0 != *cp) {
-            k = (key << BITS) | i;
-            /*printf("*** key: 0x%016lx  depth: %u  i: %u\n", k, depth, i); */
-            if (DEPTH - 1 == depth) {
-                printf("0x%016lx: %4lu\n", k, (unsigned long)*cp);
-            } else {
-                slot_print(*cp, k, depth + 1);
-            }
-        }
+    for (i = 0, b = c->buckets; i < SLOT_CNT; i++, b++) {
+	if (0 != b->child) {
+	    k = (k8 << BITS) | i;
+	    /*printf("*** key: 0x%016llx  depth: %u  i: %u\n", k, depth, i); */
+	    if (DEPTH - 1 == depth) {
+		printf("0x%016llx: %4llu\n", k, b->value);
+	    } else {
+		slot_print(b->child, k, depth + 1);
+	    }
+	}
     }
 }

data/ext/ox/cache8.h

@@ -32,15 +32,17 @@
 #define __OX_CACHE8_H__
 
 #include "ruby.h"
+#include "stdint.h"
 
-typedef struct _Cache8  *Cache8;
-typedef unsigned long   slot_t;
+typedef struct _Cache8	*Cache8;
+typedef uint64_t	slot_t;
+typedef uint64_t	sid_t;
 
-extern void     ox_cache8_new(Cache8 *cache);
-extern void     ox_cache8_delete(Cache8 cache);
+extern void	ox_cache8_new(Cache8 *cache);
+extern void	ox_cache8_delete(Cache8 cache);
 
-extern slot_t   ox_cache8_get(Cache8 cache, VALUE key, slot_t **slot);
+extern slot_t	ox_cache8_get(Cache8 cache, sid_t key, slot_t **slot);
 
-extern void     ox_cache8_print(Cache8 cache);
+extern void	ox_cache8_print(Cache8 cache);
 
 #endif /* __OX_CACHE8_H__ */

data/ext/ox/cache8_test.c

@@ -32,13 +32,13 @@
 #include "cache8.h"
 
 static slot_t data[] = {
-    0x000000A0A0A0A0A0UL,
-    0x0000000000ABCDEFUL,
-    0x0123456789ABCDEFUL,
-    0x0000000000000001UL,
-    0x0000000000000002UL,
-    0x0000000000000003UL,
-    0x0000000000000004UL,
+    0x000000A0A0A0A0A0ULL,
+    0x0000000000ABCDEFULL,
+    0x0123456789ABCDEFULL,
+    0x0000000000000001ULL,
+    0x0000000000000002ULL,
+    0x0000000000000003ULL,
+    0x0000000000000004ULL,
     0
 };
 
@@ -55,13 +55,13 @@ ox_cache8_test() {
         v = ox_cache8_get(c, *d, &slot);
         if (0 == v) {
             if (0 == slot) {
-                printf("*** failed to get a slot for 0x%016lx\n", *d);
+                printf("*** failed to get a slot for 0x%016llx\n", *d);
             } else {
-                printf("*** adding 0x%016lx to cache with value %lu\n", *d, cnt);
+                printf("*** adding 0x%016llx to cache with value %llu\n", *d, cnt);
                 *slot = cnt++;
             }
         } else {
-            printf("*** get on 0x%016lx returned %lu\n", *d, v);
+            printf("*** get on 0x%016llx returned %llu\n", *d, v);
         }
         /*ox_cache8_print(c); */
     }

data/ext/ox/dump.c

@@ -229,9 +229,9 @@ ulong2str(ulong num, char *end) {
 
 static int
 check_circular(Out out, VALUE obj, Element e) {
-    ulong       *slot;
-    ulong       id;
-    int         result;
+    slot_t	*slot;
+    slot_t	id;
+    int		result;
     
     if (0 == (id = ox_cache8_get(out->circ_cache, obj, &slot))) {
         out->circ_cnt++;

data/lib/ox/node.rb

@@ -16,7 +16,7 @@ module Ox
     # @param [Object] other Object to compare _self_ to.
     def eql?(other)
       return false if (other.nil? or self.class != other.class)
-      other.value == @value
+      other.value == self.value
     end
     alias == eql?
 

data/lib/ox/version.rb

@@ -1,5 +1,5 @@
 
 module Ox
   # Current version of the module. 
-  VERSION = '1.6.2'
+  VERSION = '1.6.3'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ox
 version: !ruby/object:Gem::Version
-  version: 1.6.2
+  version: 1.6.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-07 00:00:00.000000000 Z
+date: 2012-10-22 00:00:00.000000000 Z
 dependencies: []
 description: ! "A fast XML parser and object serializer that uses only standard C
   lib.\n            \nOptimized XML (Ox), as the name implies was written to provide