rcstorable 0.1.3 → 0.1.4

data/VERSION

@@ -1 +1 @@
-0.1.3
+0.1.4

data/ext/rcstorable.c

@@ -5,50 +5,33 @@
 #include "ruby.h"
 
 VALUE thaw(VALUE, VALUE);
-VALUE read_object();
-int read_extended_size();
-int read_compact_size();
-void read_n_hash_pairs(VALUE, int);
-void read_n_array_entries(VALUE, int);
-VALUE read_string(bool);
-void read_magic_numbers();
-
-enum states
+static VALUE read_object();
+static int read_extended_size();
+static int read_compact_size();
+static void read_n_hash_pairs(VALUE, int);
+static void read_n_array_entries(VALUE, int);
+static VALUE read_string(bool);
+static void read_magic_numbers();
+static void check_pointer(unsigned char*);
+
+enum perl_types
 {
-  READ_EXTENDED_SIZE,
-  READ_COMPACT_SIZE,
-  READ_NEW_OBJECT
-};
-
-enum object_types
-{
-  O_STR       = 1,
-  O_ARRAY     = 2,
-  O_HASH      = 3,
-  O_UNDEFINED = 5
-};
-
-enum hash_key_types
-{
-  H_VECTOR     = 4,
-  H_EMPTY      = 5,
-  H_STRING     = 10,
-  H_STRING_ALT = 23
+  PT_HASH_KEY   = 1,
+  PT_ARRAY      = 2,
+  PT_HASH       = 3,
+  PT_VECTOR     = 4,
+  PT_UNDEF      = 5,
+  PT_STRING     = 10,
+  PT_STRING_ALT = 23
 };
 
 // Used globally. Raptors. I know.
-unsigned char *serialized;
-unsigned char *serialized_end;
-
-void
-check_pointer(unsigned char *ptr)
-{
-  extern unsigned char *serialized_end;
-  if (ptr > serialized_end) {
-    rb_raise(rb_eRangeError, "malformed data");
-  }
-}
+static unsigned char *serialized;
+static unsigned char *serialized_end;
 
+/*
+ * Given a perl Storable frozen blob, decode it into a ruby data structure.
+ */
 VALUE
 thaw(VALUE self, VALUE str)
 {
@@ -63,14 +46,35 @@ thaw(VALUE self, VALUE str)
   return read_object();
 }
 
-void
+/*
+ * Malformed strings can theoretically cause segfaults. Segfaults are bad.
+ * We'll check pretty much everything we do against the pre-computed end-of-string.
+ */
+static void
+check_pointer(unsigned char *ptr)
+{
+  extern unsigned char *serialized_end;
+  if (ptr > serialized_end) {
+    rb_raise(rb_eRangeError, "malformed data");
+  }
+}
+
+/*
+ * Certain test cases start with \005\006. Other ones don't.
+ * This will need to be fixed eventually.
+ */
+static void
 read_magic_numbers()
 {
   serialized++;
   serialized++;
 }
 
-VALUE
+/*
+ * Figure out what type of object is at the front of serialized, read it in, potentially
+ * recursively creating several other sub-objects in the process, and return it.
+ */
+static VALUE
 read_object()
 {
   extern unsigned char *serialized;
@@ -81,15 +85,15 @@ read_object()
   VALUE object;
 
   switch(type) {
-  case O_HASH:
+  case PT_HASH:
     object = rb_hash_new();
     read_n_hash_pairs(object, size);
     break;
-  case O_ARRAY:
+  case PT_ARRAY:
     object = rb_ary_new();
     read_n_array_entries(object, size);
     break;
-  case O_UNDEFINED:
+  case PT_UNDEF:
     object = Qnil;
     break;
   }
@@ -98,7 +102,11 @@ read_object()
 }
 
   
-void
+/*
+ * We've already created a hash, and read the size of it.
+ * Now we need to read in n items, and add them to the hash.
+ */
+static void
 read_n_hash_pairs(VALUE hash, int num)
 {
   extern unsigned char *serialized;
@@ -113,16 +121,16 @@ read_n_hash_pairs(VALUE hash, int num)
   VALUE str;
   
   switch(type) {
-  case H_EMPTY:
+  case PT_UNDEF:
     rb_hash_aset(hash, read_string(true), Qnil);
     break;
-  case H_VECTOR:
+  case PT_VECTOR:
     temp = read_object();
     str = read_string(true);
     rb_hash_aset(hash, str, temp);
     break;
-  case H_STRING:
-  case H_STRING_ALT:
+  case PT_STRING:
+  case PT_STRING_ALT:
     temp = read_string(false);
     rb_hash_aset(hash, read_string(true), temp);
     break;
@@ -131,7 +139,11 @@ read_n_hash_pairs(VALUE hash, int num)
   read_n_hash_pairs(hash, num-1);
 }
 
-void
+/*
+ * We've already created an array, and read the size of it.
+ * Now we need to read in n items, and add them to the array.
+ */
+static void
 read_n_array_entries(VALUE array, int num)
 {
   extern unsigned char *serialized;
@@ -145,7 +157,7 @@ read_n_array_entries(VALUE array, int num)
   int type = *serialized++;
 
   switch(type) {
-  case O_STR:
+  case PT_HASH_KEY:
     item = read_string(true);
     break;
   }
@@ -156,7 +168,12 @@ read_n_array_entries(VALUE array, int num)
 }
 
 
-VALUE
+/*
+ * Given a size, read in a string of that size. Note that Storable seems to use 319 as a
+ * magic value, meaning the string should be read until a very low character is found.
+ * I should test this more specifically, but it's somewhere lower than "0", aka 48.
+ */
+static VALUE
 read_string(bool extended_size)
 {
   extern unsigned char *serialized;
@@ -192,8 +209,9 @@ read_string(bool extended_size)
 
 /*
  * Extended sizes are given as [w,x,y,z], where the size is 256*y + z.
+ * This should really be read as a uint_32t, I guess.
  */
-int
+static int
 read_extended_size()
 {
   extern unsigned char *serialized;
@@ -211,7 +229,7 @@ read_extended_size()
 /*
  * Just one byte.
  */
-int
+static int
 read_compact_size() {
   check_pointer(serialized);
   extern unsigned char *serialized;

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rcstorable
 version: !ruby/object:Gem::Version 
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors: 
 - Burke Libbey