asciipack 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 99e8c97fe92ccf81fcf5f3a6d769b9a0bc7fff80
-  data.tar.gz: 37fe12bd66fc3ddb09637c544148dfd0102eec7d
+  metadata.gz: d1459faeca6230153b447a21394155ed54cee71f
+  data.tar.gz: 04fe8fa21164a3fc518dc6f18d4f817bd1abc446
 SHA512:
-  metadata.gz: b9df66b102da5d7724c8a9022a0005e634bfa2d018f981a64eeb01346a96f1120bc5c2536ea993c9a3abb301bb9ea75f31a6a224de3b78d2e331d96ffee8fa10
-  data.tar.gz: b88a190b4a8be5b532e884540769e4ab6da395e7a0259e9f2246bbb73d22e3a1554fdac982e3a77cb16d74007445d95b8adb858322dcbe83cc3247cbcdf23ec8
+  metadata.gz: db669a6873f4df13b32a65319a147c897828a25444a51e7bf95320ec815245fc3560cbe9767146d303c1c3ffc442d7a0421e3fc29856b31c3f3a101366d4ceee
+  data.tar.gz: 9a0b27bdcfbd0aa0c1cccbf6dcb3aa85c7bc6eecec3958fc5a90eaea6bacc289e7a5fdb2ad37e920317ad91e75f81e44fe4c5b7e3c5322324018c6b4443517aa

data/README.md

@@ -2,6 +2,10 @@
 
 [![Gem Version](https://badge.fury.io/rb/asciipack.png)](http://badge.fury.io/rb/asciipack)
 
+AsciiPack is an object serialization inspired by MessagePack.
+
+AsciiPack is use easy by Web. because all serialize object is only writed by ascii strings.
+
 ## Synopsis
 
 ```ruby

data/ext/asciipack/packer.c

@@ -1,24 +1,54 @@
-#include <stdio.h>
 #include "packer.h"
 
 VALUE cAsciiPack_Packer;
 
-static void Packer_write(packer_t* ptr, VALUE obj);
+static void Packer_write_value(packer_t* ptr, VALUE obj);
 
 static void
-packer_mark(packer_t* ptr)
+Packer_mark (packer_t* ptr)
 {
 }
 
+static void
+Packer_free (packer_t* ptr)
+{
+	tag_t* b = ptr->start;
+	tag_t* next;
+
+	while (b != NULL) {
+		next = b->next;
+		free(b);
+		b = next;
+	}
+	free(ptr->mem);
+}
+
 static VALUE
-Packer_alloc(VALUE klass)
+Packer_alloc (VALUE klass)
 {
 	packer_t *ptr = ALLOC(packer_t);
-	return Data_Wrap_Struct(klass, packer_mark, -1, ptr);
+	return Data_Wrap_Struct(klass, Packer_mark, Packer_free, ptr);
+}
+
+static void
+Packer_init (packer_t* ptr)
+{
+	tag_t* tag = (tag_t*) malloc(sizeof(tag_t));
+	char* mem = (char*) malloc(sizeof(char) * MEMSIZE_INIT);
+
+	ptr->mem = mem;
+	ptr->mem_end = mem;
+	ptr->memsize = MEMSIZE_INIT;
+	ptr->start = tag;
+	ptr->tag = ptr->start;
+	ptr->tag->begin = mem;
+	ptr->tag->end = mem;
+	ptr->tag->is_reference = 0;
+	ptr->tag->next = NULL;
 }
 
 static VALUE
-Packer_initialize(int argc, VALUE *argv, VALUE self)
+Packer_initialize (int argc, VALUE *argv, VALUE self)
 {
 	PACKER(self, ptr);
 
@@ -26,63 +56,133 @@ Packer_initialize(int argc, VALUE *argv, VALUE self)
 		rb_raise(rb_eArgError, "unallocated packer");
 	}
 
-	// TODO fix memory control
-	ptr->buffer = (char*) malloc(sizeof(char) * MEMSIZE_INIT);
-	ptr->ch = ptr->buffer;
-	ptr->memsize = MEMSIZE_INIT;
-
+	Packer_init(ptr);
 	return self;
 }
 
 static size_t
-Packer_buffer_rest_size (packer_t* ptr)
+Packer_tag_writed_size (packer_t* ptr)
+{
+	return ptr->tag->end - ptr->mem;
+}
+
+static size_t
+Packer_tag_rest_size (packer_t* ptr)
 {
-	return ptr->memsize - (ptr->ch - ptr->buffer);
+	return ptr->memsize - Packer_tag_writed_size(ptr);
 }
 
 static char*
 Packer_realloc (packer_t* ptr, size_t require)
 {
 	size_t newsize = ptr->memsize;
-	size_t len = ptr->ch - ptr->buffer;
+	size_t len = Packer_tag_writed_size(ptr);
 	size_t require_size = require + len;
+	char* mem;
+	tag_t* b = ptr->start;
 
 	while (newsize < require_size) {
 		newsize *= 2;
 	}
 
-	ptr->buffer = realloc(ptr->buffer, sizeof(char) * newsize);
-	ptr->ch = ptr->buffer + len;
+	mem = (char*) realloc(ptr->mem, sizeof(char) * newsize);
+	ptr->mem = mem;
 	ptr->memsize = newsize;
-	return ptr->buffer;
+	if (mem == NULL) {
+		return NULL;
+	}
+
+	while (1) {
+		if (!b->is_reference) {
+			len = b->end - b->begin;
+			b->begin = mem;
+			b->end = mem + len;
+			ptr->mem_end = b->end;
+			mem += len;
+		}
+		if (b->next == NULL) {
+			return ptr->mem;
+		}
+		b = b->next;
+	}
 }
 
 static void
 Packer_check (packer_t* ptr, size_t require)
 {
-	if (Packer_buffer_rest_size(ptr) < require) {
+	if (ptr->tag->is_reference) {
+		tag_t* tag_mem = (tag_t*) malloc(sizeof(tag_t));
+
+		ptr->tag->next = tag_mem;
+
+		tag_mem->begin = ptr->mem_end;
+		tag_mem->end = ptr->mem_end;
+		tag_mem->next = NULL;
+		tag_mem->is_reference = 0;
+		ptr->tag = tag_mem;
+	}
+	if (Packer_tag_rest_size(ptr) < require) {
 		if (Packer_realloc(ptr, require) == NULL) {
-			// raise!
+			rb_raise(rb_eNoMemError, "Packer can not realloc.");
 		}
 	}
 }
 
 static void
-Packer_write_buffer_1 (packer_t* ptr, char ch)
+Packer_write_tag_1 (packer_t* ptr, char ch)
+{
+	*ptr->tag->end++ = ch;
+}
+
+static void
+Packer_write_tag_cpy (packer_t* ptr, VALUE string)
 {
-	*ptr->ch++ = ch;
+	const char* p = RSTRING_PTR(string);
+	uint32_t len = RSTRING_LEN(string);
+
+	memcpy(ptr->tag->end, p, len);
+	ptr->tag->end += len;
 }
 
 static void
 Packer_write_positive_num_1 (packer_t* ptr, unsigned int word)
 {
 	if (word < 10) {
-		Packer_write_buffer_1(ptr, word + '0');
+		Packer_write_tag_1(ptr, word + '0');
 	} else {
-		Packer_write_buffer_1(ptr, word + 'a' - 10);
+		Packer_write_tag_1(ptr, word + 'a' - 10);
 	}
 }
 
+static void
+Packer_write_uint8 (packer_t* ptr, uint8_t n)
+{
+	Packer_write_positive_num_1(ptr, (n & 0xf0) >> 4);
+	Packer_write_positive_num_1(ptr, n & 0x0f);
+}
+
+static void
+Packer_write_uint16 (packer_t* ptr, uint16_t n)
+{
+	Packer_write_positive_num_1(ptr, (n & 0xf000) >> 12);
+	Packer_write_positive_num_1(ptr, (n & 0x0f00) >> 8);
+	Packer_write_positive_num_1(ptr, (n & 0x00f0) >> 4);
+	Packer_write_positive_num_1(ptr, n & 0x000f);
+}
+
+static void
+Packer_write_uint32 (packer_t* ptr, uint32_t n)
+{
+	Packer_write_positive_num_1(ptr, (n & 0xf0000000LL) >> 28);
+	Packer_write_positive_num_1(ptr, (n & 0x0f000000LL) >> 24);
+	Packer_write_positive_num_1(ptr, (n & 0x00f00000LL) >> 20);
+	Packer_write_positive_num_1(ptr, (n & 0x000f0000LL) >> 16);
+	Packer_write_positive_num_1(ptr, (n & 0x0000f000LL) >> 12);
+	Packer_write_positive_num_1(ptr, (n & 0x00000f00LL) >> 8);
+	Packer_write_positive_num_1(ptr, (n & 0x000000f0LL) >> 4);
+	Packer_write_positive_num_1(ptr, (n & 0x0000000fLL));
+}
+
 static void
 Packer_write_uint64 (packer_t* ptr, uint64_t n)
 {
@@ -109,60 +209,19 @@ Packer_write_ubignum(packer_t* ptr, VALUE ubignum)
 {
 	uint64_t n = rb_big2ull(ubignum);
 
-	Packer_write_buffer_1(ptr, 'j');
+	Packer_write_tag_1(ptr, 'j');
 	Packer_write_uint64(ptr, n);
 }
 
-static void
-Packer_write_positive_num (packer_t* ptr, uint64_t n, unsigned int bytesize)
-{
-	if (n == 0) {
-		return Packer_write_buffer_1(ptr, '0');
-	}
-
-	switch (bytesize) {
-	case 1:
-		Packer_write_positive_num_1(ptr, n & 0x0f);
-		break;
-
-	case 2:
-		Packer_write_positive_num_1(ptr, (n & 0xf0) >> 4);
-		Packer_write_positive_num_1(ptr, n & 0x0f);
-		break;
-
-	case 4:
-		Packer_write_positive_num_1(ptr, (n & 0xf000) >> 12);
-		Packer_write_positive_num_1(ptr, (n & 0x0f00) >> 8);
-		Packer_write_positive_num_1(ptr, (n & 0x00f0) >> 4);
-		Packer_write_positive_num_1(ptr, n & 0x000f);
-		break;
-
-	case 8:
-		Packer_write_positive_num_1(ptr, (n & 0xf0000000LL) >> 28);
-		Packer_write_positive_num_1(ptr, (n & 0x0f000000LL) >> 24);
-		Packer_write_positive_num_1(ptr, (n & 0x00f00000LL) >> 20);
-		Packer_write_positive_num_1(ptr, (n & 0x000f0000LL) >> 16);
-		Packer_write_positive_num_1(ptr, (n & 0x0000f000LL) >> 12);
-		Packer_write_positive_num_1(ptr, (n & 0x00000f00LL) >> 8);
-		Packer_write_positive_num_1(ptr, (n & 0x000000f0LL) >> 4);
-		Packer_write_positive_num_1(ptr, (n & 0x0000000fLL));
-		break;
-
-	case 16:
-		Packer_write_uint64(ptr, n);
-		break;
-	}
-}
-
 static void
 Packer_write_bignum(packer_t* ptr, VALUE bignum)
 {
 	int64_t v = rb_big2ll(bignum);
 	union unegative_int cb;
 
-	Packer_write_buffer_1(ptr, 'e');
+	Packer_write_tag_1(ptr, 'e');
 	cb.i64 = v;
-	Packer_write_positive_num(ptr, cb.ul, 16);
+	Packer_write_uint64(ptr, cb.ul);
 }
 
 static void
@@ -185,60 +244,60 @@ Packer_fixnum (packer_t* ptr, VALUE fixnum)
 	if (v < 0) {
 		if (-0x8 <= v) {
 			Packer_check(ptr, 2);
-			Packer_write_buffer_1(ptr, 'a');
+			Packer_write_tag_1(ptr, 'a');
 			cb.i4 = v;
-			Packer_write_positive_num(ptr, cb.ul, 1);
+			Packer_write_positive_num_1(ptr, cb.ul & 0x0f);
 		} else if (-0x80 <= v) {
 			Packer_check(ptr, 3);
-			Packer_write_buffer_1(ptr, 'b');
+			Packer_write_tag_1(ptr, 'b');
 			cb.i8 = v;
-			Packer_write_positive_num(ptr, cb.ul, 2);
+			Packer_write_uint8(ptr, cb.ul);
 		} else if (-0x8000L <= v) {
 			Packer_check(ptr, 5);
-			Packer_write_buffer_1(ptr, 'c');
+			Packer_write_tag_1(ptr, 'c');
 			cb.i16 = v;
-			Packer_write_positive_num(ptr, cb.ul, 4);
+			Packer_write_uint16(ptr, cb.ul);
 		} else if (-0x80000000LL <= v) {
 			Packer_check(ptr, 9);
-			Packer_write_buffer_1(ptr, 'd');
+			Packer_write_tag_1(ptr, 'd');
 			cb.i32 = v;
-			Packer_write_positive_num(ptr, cb.ul, 8);
+			Packer_write_uint32(ptr, cb.ul);
 		} else {
 			Packer_check(ptr, 17);
-			Packer_write_buffer_1(ptr, 'e');
+			Packer_write_tag_1(ptr, 'e');
 			cb.i64 = v;
-			Packer_write_positive_num(ptr, cb.ul, 16);
+			Packer_write_uint64(ptr, cb.ul);
 		}
 
 	} else {
 		if (v < 0x10) {
 			Packer_check(ptr, 1);
 			if (v < 0x0a) {
-				Packer_write_buffer_1(ptr, v + '0');
+				Packer_write_tag_1(ptr, v + '0');
 			} else {
-				Packer_write_buffer_1(ptr, v + 'A' - 10);
+				Packer_write_tag_1(ptr, v + 'A' - 10);
 			}
 			return;
 
 		} else if (v < 0x100) {
 			Packer_check(ptr, 3);
-			Packer_write_buffer_1(ptr, 'g');
-			Packer_write_positive_num(ptr, v, 2);
+			Packer_write_tag_1(ptr, 'g');
+			Packer_write_uint8(ptr, v);
 
 		} else if (v < 0x10000LL) {
 			Packer_check(ptr, 5);
-			Packer_write_buffer_1(ptr, 'h');
-			Packer_write_positive_num(ptr, v, 4);
+			Packer_write_tag_1(ptr, 'h');
+			Packer_write_uint16(ptr, v);
 
 		} else if (v < 0x100000000LL) {
 			Packer_check(ptr, 9);
-			Packer_write_buffer_1(ptr, 'i');
-			Packer_write_positive_num(ptr, v, 8);
+			Packer_write_tag_1(ptr, 'i');
+			Packer_write_uint32(ptr, v);
 
 		} else {
 			Packer_check(ptr, 17);
-			Packer_write_buffer_1(ptr, 'j');
-			Packer_write_positive_num(ptr, v, 16);
+			Packer_write_tag_1(ptr, 'j');
+			Packer_write_uint64(ptr, v);
 		}
 	}
 }
@@ -253,36 +312,77 @@ Packer_float (packer_t* ptr, VALUE floatnum)
 	} converter = {float64};
 
 	Packer_check(ptr, 17);
-	Packer_write_buffer_1(ptr, 'l');
+	Packer_write_tag_1(ptr, 'l');
 	Packer_write_uint64(ptr, converter.u64);
 }
 
 static void
-Packer_str (packer_t* ptr, VALUE string)
+Packer_write_string_header (packer_t* ptr, uint32_t len)
 {
-	uint32_t len = RSTRING_LEN(string);
-	char* p = RSTRING_PTR(string);
-
 	if (len < 0x10) {
 		Packer_check(ptr, 1);
-		Packer_write_buffer_1(ptr, 'G' + len);
+		Packer_write_tag_1(ptr, 'G' + len);
 	} else if (len < 0x100) {
 		Packer_check(ptr, 3);
-		Packer_write_buffer_1(ptr, 'n');
-		Packer_write_positive_num(ptr, len, 2);
+		Packer_write_tag_1(ptr, 'n');
+		Packer_write_uint8(ptr, len);
 	} else if (len < 0x10000) {
 		Packer_check(ptr, 5);
-		Packer_write_buffer_1(ptr, 'o');
-		Packer_write_positive_num(ptr, len, 4);
+		Packer_write_tag_1(ptr, 'o');
+		Packer_write_uint16(ptr, len);
 	} else {
 		Packer_check(ptr, 9);
-		Packer_write_buffer_1(ptr, 'p');
-		Packer_write_positive_num(ptr, len, 8);
+		Packer_write_tag_1(ptr, 'p');
+		Packer_write_uint32(ptr, len);
 	}
+}
+
+static void
+Packer_write_string_reference (packer_t* ptr, VALUE string)
+{
+	VALUE dup = rb_str_dup(string);
+	char* p = RSTRING_PTR(dup);
+	uint32_t len = RSTRING_LEN(dup);
+	tag_t* tag_reference = (tag_t*) malloc(sizeof(tag_t));
+
+	if (!ptr->tag->is_reference) {
+		ptr->mem_end = ptr->tag->end;
+	}
+
+	tag_reference->begin = p;
+	tag_reference->end = p + len;
+	tag_reference->next = NULL;
+	tag_reference->is_reference = 1;
+	ptr->tag->next = tag_reference;
+	ptr->tag = tag_reference;
+}
+
+static void
+Packer_str (packer_t* ptr, VALUE string)
+{
+	uint32_t len = RSTRING_LEN(string);
+
+	Packer_write_string_header(ptr, len);
+
+	if (len < 131072L) {
+		Packer_check(ptr, len);
+		Packer_write_tag_cpy(ptr, string);
+	} else {
+		Packer_write_string_reference(ptr, string);
+	}
+}
+
+static void
+Packer_symbol (packer_t* ptr, VALUE symbol)
+{
+	const char* p = rb_id2name(SYM2ID(symbol));
+	uint32_t len = strlen(p);
+
+	Packer_write_string_header(ptr, len);
 
 	Packer_check(ptr, len);
 	while (len--) {
-		Packer_write_buffer_1(ptr, *p++);
+		Packer_write_tag_1(ptr, *p++);
 	}
 }
 
@@ -294,25 +394,25 @@ Packer_array (packer_t* ptr, VALUE array)
 
 	if (len < 0x10) {
 		Packer_check(ptr, 2);
-		Packer_write_buffer_1(ptr, 'v');
-		Packer_write_positive_num(ptr, len, 1);
+		Packer_write_tag_1(ptr, 'v');
+		Packer_write_positive_num_1(ptr, len);
 	} else if (len < 0x100) {
 		Packer_check(ptr, 3);
-		Packer_write_buffer_1(ptr, 'w');
-		Packer_write_positive_num(ptr, len, 2);
+		Packer_write_tag_1(ptr, 'w');
+		Packer_write_uint8(ptr, len);
 	} else if (len < 0x10000) {
 		Packer_check(ptr, 5);
-		Packer_write_buffer_1(ptr, 'x');
-		Packer_write_positive_num(ptr, len, 4);
+		Packer_write_tag_1(ptr, 'x');
+		Packer_write_uint16(ptr, len);
 	} else {
 		Packer_check(ptr, 9);
-		Packer_write_buffer_1(ptr, 'y');
-		Packer_write_positive_num(ptr, len, 8);
+		Packer_write_tag_1(ptr, 'y');
+		Packer_write_uint32(ptr, len);
 	}
 
 	for (i = 0; i < len; i++) {
 		VALUE e = rb_ary_entry(array, i);
-		Packer_write(ptr, e);
+		Packer_write_value(ptr, e);
 	}
 }
 
@@ -320,8 +420,8 @@ static int
 Packer_write_hash_each (VALUE key, VALUE value, VALUE obj)
 {
 	packer_t* ptr = (packer_t*) obj;
-	Packer_write(ptr, key);
-	Packer_write(ptr, value);
+	Packer_write_value(ptr, key);
+	Packer_write_value(ptr, value);
 	return ST_CONTINUE;
 }
 
@@ -332,64 +432,120 @@ Packer_map (packer_t* ptr, VALUE hash)
 
 	if (len < 0x10) {
 		Packer_check(ptr, 2);
-		Packer_write_buffer_1(ptr, 'r');
-		Packer_write_positive_num(ptr, len, 1);
+		Packer_write_tag_1(ptr, 'r');
+		Packer_write_positive_num_1(ptr, len);
 	} else if (len < 0x100) {
 		Packer_check(ptr, 3);
-		Packer_write_buffer_1(ptr, 's');
-		Packer_write_positive_num(ptr, len, 2);
+		Packer_write_tag_1(ptr, 's');
+		Packer_write_uint8(ptr, len);
 	} else if (len < 0x10000) {
 		Packer_check(ptr, 5);
-		Packer_write_buffer_1(ptr, 't');
-		Packer_write_positive_num(ptr, len, 4);
+		Packer_write_tag_1(ptr, 't');
+		Packer_write_uint16(ptr, len);
 	} else {
 		Packer_check(ptr, 9);
-		Packer_write_buffer_1(ptr, 'u');
-		Packer_write_positive_num(ptr, len, 8);
+		Packer_write_tag_1(ptr, 'u');
+		Packer_write_uint32(ptr, len);
 	}
 
 	rb_hash_foreach(hash, Packer_write_hash_each, (VALUE) ptr);
 }
 
-
 static VALUE
-Packer_pack (VALUE self, VALUE obj)
+Packer_write_to_s (packer_t* ptr)
 {
-	VALUE str;
+	uint64_t length = ptr->start->end - ptr->mem;
+	uint64_t total_length = length;
+	tag_t* b = ptr->start->next;
+	char* p = NULL;
+	VALUE string;
+
+	while (b != NULL) {
+		total_length += b->end - b->begin;
+		b = b->next;
+	}
 
+	string = rb_str_new(NULL, total_length);
+	p = RSTRING_PTR(string);
+	memcpy(p, ptr->mem, length);
+	p += length;
+
+	b = ptr->start->next;
+	if (b == NULL) {
+		return string;
+	}
+	while (1) {
+		length = b->end - b->begin;
+		memcpy(p, b->begin, length);
+		if (b->next == NULL) {
+			return string;
+		}
+		p += length;
+		b = b->next;
+	}
+}
+
+static VALUE
+Packer_to_s (VALUE self)
+{
 	PACKER(self, ptr);
+	return Packer_write_to_s(ptr);
+}
 
-	Packer_write(ptr, obj);
+static void
+Packer_write_clear (packer_t* ptr)
+{
+	tag_t* b;
+	tag_t* next;
+
+	*ptr->mem = '\0';
+	ptr->mem_end = ptr->mem;
+
+	if (ptr->start->next != NULL) {
+		b = ptr->start->next;
+		while (b != NULL) {
+			next = b->next;
+			free(b);
+			b = next;
+		}
+	}
+	ptr->start->begin = ptr->mem;
+	ptr->start->end = ptr->mem;
+	ptr->start->next = NULL;
+	ptr->tag = ptr->start;
+}
 
-	*ptr->ch = '\0';
-	str = rb_str_new(ptr->buffer, ptr->ch - ptr->buffer);
-	free(ptr->buffer);
-	return str;
+static VALUE
+Packer_clear (VALUE self)
+{
+	PACKER(self, ptr);
+	Packer_write_clear(ptr);
+	return Qnil;
 }
 
 static void
 Packer_nil (packer_t* ptr)
 {
 	Packer_check(ptr, 1);
-	Packer_write_buffer_1(ptr, 'W');
+	Packer_write_tag_1(ptr, 'W');
 }
 
 static void
 Packer_false (packer_t* ptr)
 {
 	Packer_check(ptr, 1);
-	Packer_write_buffer_1(ptr, 'X');
+	Packer_write_tag_1(ptr, 'X');
 }
 
 static void
 Packer_true (packer_t* ptr)
 {
 	Packer_check(ptr, 1);
-	Packer_write_buffer_1(ptr, 'Y');
+	Packer_write_tag_1(ptr, 'Y');
 }
 
 static void
-Packer_write (packer_t* ptr, VALUE obj)
+Packer_write_value (packer_t* ptr, VALUE obj)
 {
 	switch (rb_type(obj)) {
 	case T_NIL:
@@ -410,6 +566,9 @@ Packer_write (packer_t* ptr, VALUE obj)
 	case T_FLOAT:
 		Packer_float(ptr, obj);
 		break;
+	case T_SYMBOL:
+		Packer_symbol(ptr, obj);
+		break;
 	case T_STRING:
 		Packer_str(ptr, obj);
 		break;
@@ -423,10 +582,37 @@ Packer_write (packer_t* ptr, VALUE obj)
 }
 
 static VALUE
-AsciiPack_pack (int argc, VALUE *argv, VALUE self)
+Packer_write (VALUE self, VALUE obj)
 {
-	VALUE packer = rb_funcall(cAsciiPack_Packer, rb_intern("new"), 0);
-	return rb_funcall(packer, rb_intern("pack"), 1, argv[0]);
+	PACKER(self, ptr);
+	Packer_write_value(ptr, obj);
+	return self;
+}
+
+static VALUE
+AsciiPack_pack (int argc, VALUE* argv)
+{
+	VALUE str;
+	VALUE v = *argv;
+	VALUE self = Packer_alloc(cAsciiPack_Packer);
+
+	PACKER(self, ptr);
+	if (!ptr) {
+		rb_raise(rb_eArgError, "unallocated packer");
+	}
+	Packer_init(ptr);
+
+	Packer_write_value(ptr, v);
+
+	str = Packer_write_to_s(ptr);
+
+	Packer_write_clear(ptr);
+	return str;
+}
+
+static VALUE AsciiPack_to_asciipack (int argc, VALUE* argv, VALUE self)
+{
+	return AsciiPack_pack(1, &self);
 }
 
 void
@@ -436,7 +622,21 @@ AsciiPack_Packer_init(VALUE mAsciiPack)
 	rb_define_alloc_func(cAsciiPack_Packer, Packer_alloc);
 
 	rb_define_method(cAsciiPack_Packer, "initialize", Packer_initialize, -1);
-	rb_define_method(cAsciiPack_Packer, "pack", Packer_pack, 1);
+	rb_define_method(cAsciiPack_Packer, "write", Packer_write, 1);
+	rb_define_alias(cAsciiPack_Packer, "pack", "write");
+	rb_define_method(cAsciiPack_Packer, "to_s", Packer_to_s, 0);
+	rb_define_method(cAsciiPack_Packer, "clear", Packer_clear, 0);
 
 	rb_define_module_function(mAsciiPack, "pack", AsciiPack_pack, -1);
+
+	rb_define_method(rb_cFixnum, "to_asciipack", AsciiPack_to_asciipack, -1);
+	rb_define_method(rb_cBignum, "to_asciipack", AsciiPack_to_asciipack, -1);
+	rb_define_method(rb_cFloat, "to_asciipack", AsciiPack_to_asciipack, -1);
+	rb_define_method(rb_cString, "to_asciipack", AsciiPack_to_asciipack, -1);
+	rb_define_method(rb_cSymbol, "to_asciipack", AsciiPack_to_asciipack, -1);
+	rb_define_method(rb_cHash, "to_asciipack", AsciiPack_to_asciipack, -1);
+	rb_define_method(rb_cArray, "to_asciipack", AsciiPack_to_asciipack, -1);
+	rb_define_method(rb_cNilClass, "to_asciipack", AsciiPack_to_asciipack, -1);
+	rb_define_method(rb_cFalseClass, "to_asciipack", AsciiPack_to_asciipack, -1);
+	rb_define_method(rb_cTrueClass, "to_asciipack", AsciiPack_to_asciipack, -1);
 }

data/ext/asciipack/packer.h

@@ -6,9 +6,43 @@
 
 #include <stdlib.h>
 
+/*
+ * packer:
+ * |      - memsize -      |
+ * +-----------------------+
+ * |     ||           |    |
+ * +-----------------------+
+ * ^mem  ^(tag)    ^mem_end
+ *
+ * main write strings memory.
+ * realloc when will write over size string.
+ * if will write too large stiring,
+ * it is skip and continue write from mem_end.
+ *
+ *
+ * tag:
+ * +--------------------------+
+ * | tag(too large string) |
+ * +--------------------------+ ... 
+ * ^begin                     ^end
+ *
+ * too large string tag to use Copy-on-Write.
+ * tag->next look packer or an another tag.
+ */
+
+struct tag {
+	char* begin;
+	char* end;
+	unsigned int is_reference:1;
+	struct tag* next;
+};
+typedef struct tag tag_t;
+
 struct packer {
-	char* buffer;
-	char* ch;
+	char* mem;
+	char* mem_end;
+	tag_t* tag;
+	tag_t* start;
 	size_t memsize;
 };
 typedef struct packer packer_t;
@@ -22,7 +56,7 @@ union unegative_int {
 	int64_t i64;
 };
 
-#define MEMSIZE_INIT 128
+#define MEMSIZE_INIT (1024*128)
 
 #define PACKER(from, name) \
 	packer_t* name; \

data/ext/asciipack/unpacker.c

@@ -2,7 +2,7 @@
 
 VALUE cAsciiPack_Unpacker;
 
-static VALUE Unpacker_read(unpacker_t* ptr);
+static VALUE Unpacker_buffer_read(unpacker_t* ptr);
 
 static void
 unpacker_mark(unpacker_t* ptr)
@@ -25,8 +25,8 @@ Unpacker_init(VALUE self, VALUE obj, int argc, VALUE *argv, VALUE size)
 		rb_raise(rb_eArgError, "unallocated unpacker");
 	}
 
-	ptr->buffer = RSTRING_PTR(obj);
-	ptr->ch = ptr->buffer;
+	ptr->buffer = NULL;
+	ptr->ch = NULL;
 
 	return self;
 }
@@ -100,8 +100,8 @@ Unpacker_str (unpacker_t* ptr, size_t len)
 	char* head = ptr->ch;
 
 	VALUE str = rb_str_new(head, len);
-	rb_funcall(str, rb_intern("force_encoding"), 1, rb_str_new2("utf-8"));
 	ptr->ch += len;
+	rb_funcall(str, rb_intern("force_encoding"), 1, rb_str_new2("utf-8"));
 	return str;
 }
 
@@ -111,8 +111,8 @@ Unpacker_map (unpacker_t* ptr, size_t len)
 	VALUE map = rb_hash_new();
 	VALUE key, value;
 	while (len--) {
-		key = Unpacker_read(ptr);
-		value = Unpacker_read(ptr);
+		key = Unpacker_buffer_read(ptr);
+		value = Unpacker_buffer_read(ptr);
 		rb_hash_aset(map, key, value);
 	}
 	return map;
@@ -123,13 +123,13 @@ Unpacker_array (unpacker_t* ptr, size_t len)
 {
 	VALUE array = rb_ary_new2(len);
 	while (len--) {
-		rb_ary_push(array, Unpacker_read(ptr));
+		rb_ary_push(array, Unpacker_buffer_read(ptr));
 	}
 	return array;
 }
 
 static VALUE
-Unpacker_read (unpacker_t* ptr)
+Unpacker_buffer_read (unpacker_t* ptr)
 {
 	uint64_t num;
 
@@ -270,17 +270,64 @@ Unpacker_read (unpacker_t* ptr)
 }
 
 static VALUE
-Unpacker_unpack (VALUE self)
+Unpacker_read (VALUE self)
+{
+	UNPACKER(self, ptr);
+
+	return Unpacker_buffer_read(ptr);
+}
+
+static void
+Unpacker_buffer_feed (unpacker_t* ptr, VALUE obj)
+{
+	if (rb_type(obj) != T_STRING) {
+		rb_raise(rb_eArgError, "can not unpack object");
+	}
+
+	char* p = RSTRING_PTR(obj);
+
+	ptr->buffer = p;
+	ptr->ch = p;
+}
+
+static VALUE
+Unpacker_feed (VALUE self, VALUE obj)
+{
+	UNPACKER(self, ptr);
+
+	Unpacker_buffer_feed(ptr, obj);
+
+	return self;
+}
+
+static void
+Unpacker_buffer_clear (unpacker_t* ptr)
+{
+	ptr->buffer = NULL;
+	ptr->ch = NULL;
+}
+
+static VALUE
+Unpacker_clear (VALUE self)
 {
 	UNPACKER(self, ptr);
-	return Unpacker_read(ptr);
+
+	Unpacker_buffer_clear(ptr);
+
+	return self;
 }
 
 static VALUE
-AsciiPack_unpack (int argc, VALUE *argv, VALUE self)
+AsciiPack_unpack (int argc, VALUE *argv)
 {
-	VALUE unpacker = rb_funcall(cAsciiPack_Unpacker, rb_intern("new"), 1, argv[0]);
-	return rb_funcall(unpacker, rb_intern("unpack"), 0);
+	VALUE v = argv[0];
+	VALUE self = Unpacker_alloc(cAsciiPack_Unpacker);
+
+	UNPACKER(self, ptr);
+
+	Unpacker_buffer_feed(ptr, v);
+
+	return Unpacker_buffer_read(ptr);
 }
 
 void
@@ -291,7 +338,10 @@ AsciiPack_Unpacker_init(VALUE mAsciiPack)
 	rb_define_alloc_func(cAsciiPack_Unpacker, Unpacker_alloc);
 
 	rb_define_method(cAsciiPack_Unpacker, "initialize", Unpacker_initialize, -1);
-	rb_define_method(cAsciiPack_Unpacker, "unpack", Unpacker_unpack, 0);
+	rb_define_method(cAsciiPack_Unpacker, "feed", Unpacker_feed, 1);
+	rb_define_method(cAsciiPack_Unpacker, "read", Unpacker_read, 0);
+	rb_define_alias(cAsciiPack_Unpacker, "<<", "feed");
+	rb_define_method(cAsciiPack_Unpacker, "clear", Unpacker_clear, 0);
 
 	rb_define_module_function(mAsciiPack, "unpack", AsciiPack_unpack, -1);
 }

data/lib/asciipack/version.rb

@@ -1,3 +1,3 @@
 module AsciiPack
-  VERSION = "0.2.2"
+  VERSION = "0.2.3"
 end

data/spec/bench.rb

@@ -1,6 +1,7 @@
 #! /usr/bin/env ruby
 
 lib = File.expand_path('../../lib', __FILE__)
+here = File.dirname(File.expand_path(__FILE__))
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 require 'asciipack'
@@ -8,11 +9,11 @@ require 'json'
 require 'msgpack'
 
 def count
-  10000
+  1
 end
 
 def reports (obj)
-  obj = [obj]
+  obj =[obj] * 1
   json = obj.to_json
   ap = AsciiPack.pack obj
   ms = Marshal.dump obj
@@ -39,31 +40,25 @@ def json_asciipack(name, obj)
     count.times {
       func.call
     }
-    results << "%.1f" % ((Time.now - t) * 1000)
+    results << "%.6f" % ((Time.now - t) * 1000)
   }
   puts results.join("|") + "|"
 end
 
 puts("|object|" + reports(0).keys.join("|") + "|")
-puts("|---|" + reports(0).keys.map{"---"}.join("|") + "|")
+puts("|---|" + reports(0).keys.map{"---:"}.join("|") + "|")
 
 map16 = {}
-0x100.times {|i| map16[i.to_s] = 0 }
+0x10000.times {|i| map16[i.to_s] = 0 }
 
 tt = Time.now
 {
-  "positive fixint" => 0,
-  "uint 64" => 0xffffffffffffffff,
-  "int 4" => -1,
-  "int 64" => -0x8000000000000000,
-  "float 64" => 1/3,
-  "fixstr" => "a",
-  "str 32" => 'a' * 0x10000,
-  "map 4" => {},
-  "map 16" => map16,
-  "array 4" => [],
-  "array 16" => Array.new(0x100,0),
-  "nil" => nil,
+  "float 64" => [1.0/3.0] * 100,
+  "str (1KB)" => ['a' * 1024],
+  "str (1MB)" => ['a' * 1024*1024],
+  "str (100MB)" => ['a' * 100*1024*1024],
+  "map 32" => map16,
+  "array 32" => Array.new(0x10000,0),
 }.each { |key, value|
   json_asciipack key, value
 }

data/spec/exception_spec.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe "AsciiPack:exception" do
+  it "unpacker raise error" do
+    expect{ AsciiPack.unpack(nil) }.to raise_error
+  end
+end

data/spec/format_spec.rb

@@ -12,6 +12,7 @@ describe AsciiPack do
   it "int 4" do
     format -1, T.int4, 2
     format -8, T.int4, 2
+    expect(-1.to_asciipack).to eq(T.int4 + 'f')
   end
 
   it "int 8" do
@@ -39,6 +40,7 @@ describe AsciiPack do
     format 0x1, T.positive_fixint_1, 1
     format 0xe, T.positive_fixint_E, 1
     format 0xf, T.positive_fixint_F, 1
+    expect(0.to_asciipack).to eq(T.positive_fixint_0)
   end
 
   it "uint 8" do
@@ -59,6 +61,7 @@ describe AsciiPack do
   it "uint 64" do
     format 0x100000000,        T.uint64, 17
     format 0xffffffffffffffff, T.uint64, 17
+    expect(0xffffffffffffffff.to_asciipack).to eq(T.uint64 + 'ffffffffffffffff')
   end
 
   it "float 64" do
@@ -70,11 +73,12 @@ describe AsciiPack do
     check_each_other(1.0, T.float64 + '3ff0000000000000')
     check_each_other(1.0000000000000002, T.float64 + '3ff0000000000001')
     check_each_other(1.0000000000000004, T.float64 + '3ff0000000000002')
-    check_each_other(1/3.0, T.float64 + '3fd5555555555555')
+    check_each_other(1.0/3.0, T.float64 + '3fd5555555555555')
     expect(AsciiPack.pack(Float::NAN)).to eq(T.float64 + '7ff8000000000000')
     expect(AsciiPack.unpack(T.float64 + '7ff8000000000000').nan?).to be true
     check_each_other(1 / 0.0, T.float64 + '7ff0000000000000')
     check_each_other(-1 / 0.0, T.float64 + 'fff0000000000000')
+    expect(1.0.to_asciipack).to eq(T.float64 + '3ff0000000000000')
   end
 
   it "fixstr" do
@@ -84,6 +88,7 @@ describe AsciiPack do
     format "漢字", T.fixstr_6, 7
     format " " * 0xe, T.fixstr_E, 15
     format " " * 0xf, T.fixstr_F, 16
+    expect("".to_asciipack).to eq(T.fixstr_0)
   end
 
   it "str 8" do
@@ -102,9 +107,14 @@ describe AsciiPack do
     # format "a" * 0xffffffff, T.str32, 9 + 0xffffffff
   end
 
+  it "symbol is converted to str" do
+    expect(:sym.to_asciipack).to eq(T.fixstr_3 + 'sym')
+  end
+
   it "map 4" do
     format_map 0, T.map4
     format_map 0xf, T.map4
+    expect({}.to_asciipack).to eq(T.map4 + '0')
   end
 
   it "map 8" do
@@ -126,6 +136,7 @@ describe AsciiPack do
   it "array 4" do
     format_array 0, T.array4
     format_array 0xf, T.array4
+    expect([].to_asciipack).to eq(T.array4 + '0')
   end
 
   it "array 8" do
@@ -154,14 +165,17 @@ describe AsciiPack do
 
   it "nil" do
     format nil, T.nil, 1
+    expect(nil.to_asciipack).to eq(T.nil)
   end
 
   it "false" do
     format false, T.false, 1
+    expect(false.to_asciipack).to eq(T.false)
   end
 
   it "true" do
     format true, T.true, 1
+    expect(true.to_asciipack).to eq(T.true)
   end
 end
 

data/spec/mem_spec.rb

@@ -2,14 +2,26 @@
 
 require 'spec_helper'
 
-here = File.dirname(File.expand_path(__FILE__))
-
-describe AsciiPack do
-  it "num" do
-    obj = [0,0xf,0xff,0xffff,0xffffffff,0xffffffffffffffff,-1,-0x80,-0x8000,-0x80000000,-0x8000000000000000,0.1,1.0000000000000002,-0.1,0.0,1/3,Float::INFINITY]
-    obj = obj * 1000
-    ap = AsciiPack.pack(obj)
-    expect(AsciiPack.unpack(ap)).to eq(obj)
+describe "AsciiPack:memory" do
+  it "packer:num" do
+    check([1,1.1,-1.1,1.0/3.0,0xffffffffffffffff,-0x8000000000000000,0,Float::INFINITY] * 3)
+  end
+
+  it "packer:str" do
+    check(["a"*100*1024*1024,"b"*1024*1024,"c"*1024] * 3)
+  end
+
+  def check (obj)
+    packer = AsciiPack::Packer.new
+    obj.each {|i|
+      packer.write i
+      GC.start
+      expect(AsciiPack.unpack(packer.to_s)).to eq(i)
+      GC.start
+      packer.clear
+      expect(packer.to_s).to eq("")
+    }
+    expect(AsciiPack.unpack(obj.to_asciipack)).to eq(obj)
   end
 end
 

data/spec/packer_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe AsciiPack::Packer do
+  let :packer do
+    AsciiPack::Packer.new
+  end
+
+  it "pack:to_s:clear" do
+    packer.write nil
+    expect(packer.to_s).to eq(T.nil)
+
+    packer.write 0
+    expect(packer.to_s).to eq(T.nil + T.positive_fixint_0)
+
+    packer.write "a"
+    expect(packer.to_s).to eq(T.nil + T.positive_fixint_0 + T.fixstr_1 + "a")
+
+    packer.clear
+    expect(packer.to_s).to eq("")
+
+    packer.write nil
+    expect(packer.to_s).to eq(T.nil)
+  end
+end

data/spec/unpacker_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe AsciiPack::Unpacker do
+  let :unpacker do
+    AsciiPack::Unpacker.new
+  end
+
+  it "read:to_s:clear" do
+    unpacker.feed "W"
+    expect(unpacker.read).to eq(nil)
+
+    unpacker.feed "X"
+    expect(unpacker.read).to eq(false)
+
+    unpacker.feed "Y"
+    expect(unpacker.read).to eq(true)
+  end
+end

metadata

@@ -1,69 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: asciipack
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - ksss
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-29 00:00:00.000000000 Z
+date: 2013-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.11'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.11'
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.8.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.8.3
 description: AsciiPack is an object serialization inspired by MessagePack.
@@ -73,7 +73,7 @@ extensions:
 - ext/asciipack/extconf.rb
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -88,9 +88,12 @@ files:
 - lib/asciipack.rb
 - lib/asciipack/version.rb
 - spec/bench.rb
+- spec/exception_spec.rb
 - spec/format_spec.rb
 - spec/mem_spec.rb
+- spec/packer_spec.rb
 - spec/spec_helper.rb
+- spec/unpacker_spec.rb
 homepage: http://ksss.github.io/AsciiPack
 licenses:
 - MIT
@@ -101,23 +104,26 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.6
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: AsciiPack is an object serialization inspired by MessagePack.
 test_files:
 - spec/bench.rb
+- spec/exception_spec.rb
 - spec/format_spec.rb
 - spec/mem_spec.rb
+- spec/packer_spec.rb
 - spec/spec_helper.rb
+- spec/unpacker_spec.rb
 has_rdoc: