sereal 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 740e7a99360590057c85f528f9b73fd17415283d
-  data.tar.gz: 338ad8c8127e570f13a64ff876d59a547408110c
+  metadata.gz: 658547490d95c374a8fad16740ca8bdb463394cf
+  data.tar.gz: ff7871ff2e838a756d0a62c7094302068355e89f
 SHA512:
-  metadata.gz: b7c9123137dbc21efd1b803a5ae4d3ad6be6bffef51407f1279abe798ab0a2263ff79cb0d98434f081ed30efc1bd0ec95b6437598a1524ed3de733de17020557
-  data.tar.gz: 88f9ae7c6244c38ba9f28996ed5eb1505a603f9d5c0c16ef2b37ac296b7e1d52d3c3a784c0cf35df7b6fe3dc15453296b7a627720cbebb22490f803b4dc6ca41
+  metadata.gz: af647c218413b546b956392a909e97dc54302a5c729ed2b0f45eeec8c2431b611c7403c343025c9913421a5ebcda477921d5452f080bd02b29c47f93438f4f2e
+  data.tar.gz: fff160c78207616f73f61380d78384b148053a89bf2b31c2519bfda961fb2dbb261772517f87f0b977cf7c2a17172b8a99fa27c94c42519fc141855b90294f7f

data/bin/rsrl

@@ -1,5 +1,9 @@
 #!/usr/bin/env ruby
-require 'sereal'
+begin
+  require './lib/sereal'
+rescue LoadError
+  require 'sereal'
+end
 
 content = ARGF.read
 compress = Sereal::RAW
@@ -14,5 +18,5 @@ if content[0..3] == '=srl'
     STDOUT.write(x)
   end
 else
-  STDOUT.write(Sereal.encode(content, compress))
+  STDOUT.write(Sereal.encode(eval(content), compress))
 end

data/ext/sereal/buffer.h

@@ -16,6 +16,8 @@ static inline sereal_t * s_create(void) {
 }
 
 static inline void s_destroy(sereal_t *s) {
+        if (s->tracked != Qnil)
+                rb_gc_unregister_address(&s->tracked);
         if (s->data && (s->flags & FLAG_NOT_MINE) == 0)
                 free(s->data);
 
@@ -53,9 +55,16 @@ static inline void *s_get_p_at_pos(sereal_t *s, u32 pos,u32 req) {
         return &s->data[pos];
 }
 
+static inline void *s_get_p_at_pos_bang(sereal_t *s, u32 pos,u32 req) {
+        void *p = s_get_p_at_pos(s,pos,req);
+        s->pos += req;
+        return p;
+}
+
 static inline void *s_get_p(sereal_t *s) {
         return s_get_p_at_pos(s,s->pos,0);
 }
+
 static inline u8 s_get_u8(sereal_t *s) {
         return *((u8 *) s_get_p(s));
 }

data/ext/sereal/decode.c

@@ -5,7 +5,7 @@
 
 static VALUE s_default_reader(sereal_t *s, u8 tag) {
         // s_dump(s);
-        s_raise(s,rb_eTypeError,"unsupported tag %d",tag);
+        s_raise(s,rb_eTypeError,"unsupported tag %d [ 0x%x ]",tag,tag);
         return Qnil;
 }
 
@@ -42,19 +42,19 @@ static VALUE s_read_varint(sereal_t *s, u8 tag) {
 
 /* FLOAT */
 static VALUE s_read_float(sereal_t *s, u8 tag) {
-        float *f = (float *) s_get_p_at_pos(s,s->pos,sizeof(*f));
+        float *f = (float *) s_get_p_at_pos_bang(s,s->pos,sizeof(*f));
         return DBL2NUM((double) *f);
 }
 
 /* DOUBLE */
 static VALUE s_read_double(sereal_t *s, u8 tag) {
-        double *d = (double *) s_get_p_at_pos(s,s->pos,sizeof(*d));
+        double *d = (double *) s_get_p_at_pos_bang(s,s->pos,sizeof(*d));
         return DBL2NUM(*d);
 }
 
 /* LONG DOUBLE */
 static VALUE s_read_long_double(sereal_t *s, u8 tag) {
-        long double *d = (long double *) s_get_p_at_pos(s,s->pos,sizeof(*d));
+        long double *d = (long double *) s_get_p_at_pos_bang(s,s->pos,sizeof(*d));
         return DBL2NUM((double) *d);
 }
 
@@ -68,7 +68,7 @@ static VALUE s_read_small_negative_int(sereal_t *s, u8 tag) {
         return INT2FIX(tag - 32);
 }
 
-/* ARRAY */ 
+/* ARRAY */
 static inline VALUE s_read_array_with_len(sereal_t *s, u32 len) {
         VALUE arr[len];
         register u32 i;
@@ -98,24 +98,28 @@ static inline VALUE s_read_hash_with_len(sereal_t *s, u32 len) {
         }
         return hash;
 }
+
 /* HASH */ 
 static VALUE s_read_hash(sereal_t *s, u8 tag) {
         return s_read_hash_with_len(s,s_get_varint_bang(s));
 }
+
 /* HASH */ 
 static VALUE s_read_hashref(sereal_t *s, u8 tag) {
         return s_read_hash_with_len(s,tag  & SRL_MASK_HASHREF_COUNT);
 }
+
 static VALUE s_read_rb_string_bang(sereal_t *s,u8 t) {
         u32 len = 0;
         VALUE string;
-        #define RETURN_STRING(fx_l,fx_gen)              \
-        do {                                            \
-                len = fx_l;                             \
-                string = fx_gen;                        \
-                s_shift_position_bang(s,len);           \
-                return string;                          \
+#define RETURN_STRING(fx_l,fx_gen)              \
+        do {                                    \
+                len = fx_l;                     \
+                string = fx_gen;                \
+                s_shift_position_bang(s,len);   \
+                return string;                  \
         } while(0);
+
         if (t == SRL_HDR_STR_UTF8) {
                 RETURN_STRING(s_get_varint_bang(s),
                               rb_enc_str_new(s_get_p(s),len,
@@ -127,7 +131,7 @@ static VALUE s_read_rb_string_bang(sereal_t *s,u8 t) {
                 RETURN_STRING((t & SRL_MASK_SHORT_BINARY_LEN),
                               rb_str_new(s_get_p(s), len));
         }
-        #undef RETURN_STRING
+#undef RETURN_STRING
         s_raise(s,rb_eTypeError, "undefined string type %d",t);
 }
 
@@ -171,20 +175,46 @@ static VALUE s_read_pad(sereal_t *s, u8 tag) {
         /* just skip this byte and go forward */
         return sereal_to_rb_object(s);
 }
+
 static VALUE s_read_extend(sereal_t *s, u8 tag) {
         s_raise(s,rb_eArgError,"extend tags are not supported");
 }
 
+static VALUE s_read_ref(sereal_t *s, u8 tag) {
+        u64 off = s_get_varint_bang(s);
+        if (s->tracked == Qnil)
+                s_raise(s,rb_eArgError,"there are no references stored");
+        return rb_hash_aref(s->tracked,INT2FIX(off + s->hdr_end));
+}
+
+static VALUE s_read_copy(sereal_t *s, u8 tag) {
+        VALUE ref = s_red_ref(s,tag);
+        return rb_obj_dup(ref);
+}
+
 VALUE sereal_to_rb_object(sereal_t *s) {
-        u8 t;
+        u8 t, tracked;
         S_RECURSE_INC(s);
+        u32 pos;
         while (s->pos < s->size) {
                 t = s_get_u8_bang(s);
-                if (t & SRL_HDR_TRACK_FLAG)
-                        s_raise(s,rb_eArgError, "trackable objects are not supported");
+                tracked = (t & SRL_HDR_TRACK_FLAG ? 1 : 0);
+                t &= ~SRL_HDR_TRACK_FLAG;
+                pos = s->pos;
+
                 S_RECURSE_DEC(s);
-                return (*READERS[t])(s,t);
+
+                VALUE decoded = (*READERS[t])(s,t);
+                if (tracked) {
+                        if (s->tracked == Qnil) {
+                                s->tracked = rb_hash_new();
+                                rb_gc_register_address(&s->tracked);
+                        }
+                        rb_hash_aset(s->tracked,INT2FIX(pos),decoded);
+                }
+                return decoded;
         }
+        s_raise(s,rb_eArgError,"bad packet, or broken decoder");
         return Qnil;
 }
 
@@ -207,6 +237,7 @@ again:
         s->data = RSTRING_PTR(payload) + offset;
         s->size = RSTRING_LEN(payload) - offset;
         s->pos = 0;
+        s->tracked = Qnil;
         if (s->size < 6 || s_get_u32_bang(s) != SRL_MAGIC_STRING_LILIPUTIAN) 
                 s_raise(s,rb_eTypeError,"invalid header"); 
 
@@ -249,7 +280,7 @@ again:
                 s->pos = 0;
                 s->flags &= ~FLAG_NOT_MINE;
         }
-
+        s->hdr_end = s->pos;
         VALUE result = sereal_to_rb_object(s);
         if (is_compressed && have_block) {
                 free(s->data);

data/ext/sereal/decode.h

@@ -21,6 +21,8 @@ static VALUE s_read_true(sereal_t *s, u8 tag);
 static VALUE s_read_false(sereal_t *s, u8 tag);
 static VALUE s_read_pad(sereal_t *s, u8 tag);
 static VALUE s_read_extend(sereal_t *s, u8 tag);
+static VALUE s_read_ref(sereal_t *s, u8 tag);
+static VALUE s_read_copy(sereal_t *s, u8 tag);
 
 static VALUE (*READERS[256])(sereal_t *, u8) = {
         s_read_small_positive_int,                      // 0    SRL_HDR_POS_LOW
@@ -63,14 +65,14 @@ static VALUE (*READERS[256])(sereal_t *, u8) = {
         s_read_nil,                                     // 37   SRL_HDR_UNDEF
         s_read_rb_string_bang,                          // 38   SRL_HDR_BINARY
         s_read_rb_string_bang,                          // 39   SRL_HDR_STR_UTF8
-        s_default_reader, /* XXX */                     // 40   SRL_HDR_REFN
-        s_default_reader, /* XXX */                     // 41   SRL_HDR_REFP
+        s_read_pad,                                     // 40   SRL_HDR_REFN
+        s_read_ref,                                     // 41   SRL_HDR_REFP
         s_read_hash,                                    // 42   SRL_HDR_HASH
         s_read_array,                                   // 43   SRL_HDR_ARRAY
         s_default_reader, /* XXX */                     // 44   SRL_HDR_OBJECT
         s_default_reader, /* XXX */                     // 45   SRL_HDR_OBJECTV
-        s_default_reader, /* XXX */                     // 46   SRL_HDR_ALIAS
-        s_default_reader, /* XXX */                     // 47   SRL_HDR_COPY
+        s_read_ref,                                     // 46   SRL_HDR_ALIAS
+        s_read_copy,                                    // 47   SRL_HDR_COPY
         s_default_reader, /* XXX */                     // 48   SRL_HDR_WEAKEN
         s_read_regexp,                                  // 49   SRL_HDR_REGEXP
         s_default_reader, /* XXX */                     // 50   SRL_HDR_RESERVED_LOW

data/ext/sereal/sereal.h

@@ -54,6 +54,8 @@ struct _sereal {
         u32 rsize;
         u32 level;
         u8 flags;
+        VALUE tracked;
+        u32 hdr_end;
 };
 
 VALUE method_sereal_encode(VALUE self, VALUE args);
@@ -62,9 +64,9 @@ VALUE method_sereal_decode(VALUE self, VALUE payload);
 #define S_RECURSE_INC(s)                                          \
 do {                                                              \
         if((s)->level++ > MAX_RECURSION_DEPTH)                    \
-                rb_raise(rb_eArgError,                            \
-                         "max recursion depth reached: %d",       \
-                         MAX_RECURSION_DEPTH);                    \
+            s_raise((s),rb_eArgError,                             \
+                    "max recursion depth reached: %d (level: %d)",\
+                    MAX_RECURSION_DEPTH, s->level);               \
 } while(0);
 
 #define S_RECURSE_DEC(s) ((s)->level--)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sereal
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - Borislav Nikolov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-09 00:00:00.000000000 Z
+date: 2014-01-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -67,7 +67,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: Sereal encoder/decoder