diff --git a/c/unpack.c b/c/unpack.c
index 865e0d40..e90a29af 100644
--- a/c/unpack.c
+++ b/c/unpack.c
@@ -22,7 +22,7 @@
 
 typedef struct {
 	msgpack_zone* z;
-	bool* referenced;
+	bool referenced;
 } unpack_user;
 
 
@@ -131,7 +131,7 @@ static inline int template_callback_raw(unpack_user* u, const char* b, const cha
 	o->type = MSGPACK_OBJECT_RAW;
 	o->via.raw.ptr = p;
 	o->via.raw.size = l;
-	*u->referenced = true;
+	u->referenced = true;
 	return 0;
 }
 
@@ -139,32 +139,33 @@ static inline int template_callback_raw(unpack_user* u, const char* b, const cha
 
 
 #define CTX_CAST(m) ((template_context*)(m))
+#define CTX_REFERENCED(mpac) CTX_CAST((mpac)->ctx)->user.referenced
 
 
 static const size_t COUNTER_SIZE = sizeof(unsigned int);
 
-static inline void init_count(void* buf)
+static inline void init_count(void* buffer)
 {
-	*(volatile unsigned int*)buf = 1;
+	*(volatile unsigned int*)buffer = 1;
 }
 
-static inline void decl_count(void* buf)
+static inline void decl_count(void* buffer)
 {
-	//if(--*(unsigned int*)buf == 0) {
-	if(__sync_sub_and_fetch((unsigned int*)buf, 1) == 0) {
-		free(buf);
+	//if(--*(unsigned int*)buffer == 0) {
+	if(__sync_sub_and_fetch((unsigned int*)buffer, 1) == 0) {
+		free(buffer);
 	}
 }
 
-static inline void incr_count(void* buf)
+static inline void incr_count(void* buffer)
 {
-	//++*(unsigned int*)buf;
-	__sync_add_and_fetch((unsigned int*)buf, 1);
+	//++*(unsigned int*)buffer;
+	__sync_add_and_fetch((unsigned int*)buffer, 1);
 }
 
-static inline unsigned int get_count(void* buf)
+static inline unsigned int get_count(void* buffer)
 {
-	return *(volatile unsigned int*)buf;
+	return *(volatile unsigned int*)buffer;
 }
 
 
@@ -175,39 +176,38 @@ bool msgpack_unpacker_init(msgpack_unpacker* mpac, size_t initial_buffer_size)
 		initial_buffer_size = COUNTER_SIZE;
 	}
 
-	char* buf = (char*)malloc(initial_buffer_size);
-	if(buf == NULL) {
+	char* buffer = (char*)malloc(initial_buffer_size);
+	if(buffer == NULL) {
 		return false;
 	}
 
 	void* ctx = malloc(sizeof(template_context));
 	if(ctx == NULL) {
-		free(buf);
+		free(buffer);
 		return false;
 	}
 
 	msgpack_zone* z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
 	if(z == NULL) {
 		free(ctx);
-		free(buf);
+		free(buffer);
 		return false;
 	}
 
-	mpac->buf = buf;
+	mpac->buffer = buffer;
 	mpac->used = COUNTER_SIZE;
 	mpac->free = initial_buffer_size - mpac->used;
 	mpac->off = COUNTER_SIZE;
 	mpac->parsed = 0;
 	mpac->initial_buffer_size = initial_buffer_size;
 	mpac->z = z;
-	mpac->referenced = false;
 	mpac->ctx = ctx;
 
-	init_count(mpac->buf);
+	init_count(mpac->buffer);
 
 	template_init(CTX_CAST(mpac->ctx));
 	CTX_CAST(mpac->ctx)->user.z = mpac->z;
-	CTX_CAST(mpac->ctx)->user.referenced = &mpac->referenced;
+	CTX_CAST(mpac->ctx)->user.referenced = false;
 
 	return true;
 }
@@ -216,7 +216,7 @@ void msgpack_unpacker_destroy(msgpack_unpacker* mpac)
 {
 	msgpack_zone_free(mpac->z);
 	free(mpac->ctx);
-	decl_count(mpac->buf);
+	decl_count(mpac->buffer);
 }
 
 
@@ -241,10 +241,10 @@ void msgpack_unpacker_free(msgpack_unpacker* mpac)
 	free(mpac);
 }
 
-
 bool msgpack_unpacker_expand_buffer(msgpack_unpacker* mpac, size_t size)
 {
-	if(mpac->used == mpac->off && get_count(mpac->buf) == 1 && !mpac->referenced) {
+	if(mpac->used == mpac->off && get_count(mpac->buffer) == 1
+			&& !CTX_REFERENCED(mpac)) {
 		// rewind buffer
 		mpac->free += mpac->used - COUNTER_SIZE;
 		mpac->used = COUNTER_SIZE;
@@ -261,12 +261,12 @@ bool msgpack_unpacker_expand_buffer(msgpack_unpacker* mpac, size_t size)
 			next_size *= 2;
 		}
 
-		char* tmp = (char*)realloc(mpac->buf, next_size);
+		char* tmp = (char*)realloc(mpac->buffer, next_size);
 		if(tmp == NULL) {
 			return false;
 		}
 
-		mpac->buf = tmp;
+		mpac->buffer = tmp;
 		mpac->free = next_size - mpac->used;
 
 	} else {
@@ -283,19 +283,19 @@ bool msgpack_unpacker_expand_buffer(msgpack_unpacker* mpac, size_t size)
 
 		init_count(tmp);
 
-		if(mpac->referenced) {
-			if(!msgpack_zone_push_finalizer(mpac->z, decl_count, mpac->buf)) {
+		if(CTX_REFERENCED(mpac)) {
+			if(!msgpack_zone_push_finalizer(mpac->z, decl_count, mpac->buffer)) {
 				free(tmp);
 				return false;
 			}
-			mpac->referenced = false;
+			CTX_REFERENCED(mpac) = false;
 		} else {
-			decl_count(mpac->buf);
+			decl_count(mpac->buffer);
 		}
 
-		memcpy(tmp+COUNTER_SIZE, mpac->buf+mpac->off, not_parsed);
+		memcpy(tmp+COUNTER_SIZE, mpac->buffer+mpac->off, not_parsed);
 
-		mpac->buf = tmp;
+		mpac->buffer = tmp;
 		mpac->used = not_parsed + COUNTER_SIZE;
 		mpac->free = next_size - mpac->used;
 		mpac->off = COUNTER_SIZE;
@@ -308,7 +308,7 @@ int msgpack_unpacker_execute(msgpack_unpacker* mpac)
 {
 	size_t off = mpac->off;
 	int ret = template_execute(CTX_CAST(mpac->ctx),
-			mpac->buf, mpac->used, &mpac->off);
+			mpac->buffer, mpac->used, &mpac->off);
 	if(mpac->off > off) {
 		mpac->parsed += mpac->off - off;
 	}
@@ -326,26 +326,26 @@ msgpack_zone* msgpack_unpacker_release_zone(msgpack_unpacker* mpac)
 		return false;
 	}
 
-	msgpack_zone* z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
-	if(z == NULL) {
+	msgpack_zone* r = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
+	if(r == NULL) {
 		return NULL;
 	}
 
 	msgpack_zone* old = mpac->z;
-	mpac->z = z;
+	mpac->z = r;
 
 	return old;
 }
 
 bool msgpack_unpacker_flush_zone(msgpack_unpacker* mpac)
 {
-	if(mpac->referenced) {
-		if(!msgpack_zone_push_finalizer(mpac->z, decl_count, mpac->buf)) {
+	if(CTX_REFERENCED(mpac)) {
+		if(!msgpack_zone_push_finalizer(mpac->z, decl_count, mpac->buffer)) {
 			return false;
 		}
-		mpac->referenced = false;
+		CTX_REFERENCED(mpac) = false;
 
-		incr_count(mpac->buf);
+		incr_count(mpac->buffer);
 	}
 
 	return true;
@@ -354,6 +354,7 @@ bool msgpack_unpacker_flush_zone(msgpack_unpacker* mpac)
 void msgpack_unpacker_reset(msgpack_unpacker* mpac)
 {
 	template_init(CTX_CAST(mpac->ctx));
+	// don't reset referenced flag
 	mpac->parsed = 0;
 }
 
@@ -365,9 +366,8 @@ msgpack_unpack(const char* data, size_t len, size_t* off,
 	template_context ctx;
 	template_init(&ctx);
 
-	bool referenced = false;
 	ctx.user.z = z;
-	ctx.user.referenced = &referenced;
+	ctx.user.referenced = false;
 
 	size_t noff = 0;
 	if(off != NULL) { noff = *off; }
diff --git a/c/unpack.h b/c/unpack.h
index 779e2564..a9caf07b 100644
--- a/c/unpack.h
+++ b/c/unpack.h
@@ -29,13 +29,12 @@ extern "C" {
 
 
 typedef struct msgpack_unpacker {
-	char* buf;
+	char* buffer;
 	size_t used;
 	size_t free;
 	size_t off;
 	size_t parsed;
 	msgpack_zone* z;
-	bool referenced;
 	size_t initial_buffer_size;
 	void* ctx;
 } msgpack_unpacker;
@@ -91,7 +90,7 @@ bool msgpack_unpacker_reserve_buffer(msgpack_unpacker* mpac, size_t size)
 
 char* msgpack_unpacker_buffer(msgpack_unpacker* mpac)
 {
-	return mpac->buf + mpac->used;
+	return mpac->buffer + mpac->used;
 }
 
 size_t msgpack_unpacker_buffer_capacity(const msgpack_unpacker* mpac)
diff --git a/cpp/sbuffer.hpp b/cpp/sbuffer.hpp
index 2651b58d..ca06884e 100644
--- a/cpp/sbuffer.hpp
+++ b/cpp/sbuffer.hpp
@@ -28,77 +28,70 @@ class sbuffer : public msgpack_sbuffer {
 public:
 	sbuffer(size_t initsz = MSGPACK_SBUFFER_INIT_SIZE)
 	{
-		msgpack_sbuffer* sbuf = static_cast<msgpack_sbuffer*>(this);
-
-		sbuf->data = (char*)::malloc(initsz);
-		if(!sbuf->data) {
+		base::data = (char*)::malloc(initsz);
+		if(!base::data) {
 			throw std::bad_alloc();
 		}
 
-		sbuf->size = 0;
-		sbuf->alloc = initsz;
+		base::size = 0;
+		base::alloc = initsz;
 	}
 
 	~sbuffer()
 	{
-		msgpack_sbuffer* sbuf = static_cast<msgpack_sbuffer*>(this);
-		::free(sbuf->data);
+		::free(base::data);
 	}
 
 public:
 	void write(const char* buf, unsigned int len)
 	{
-		msgpack_sbuffer* sbuf = static_cast<msgpack_sbuffer*>(this);
-		if(sbuf->alloc - sbuf->size < len) {
+		if(base::alloc - base::size < len) {
 			expand_buffer(len);
 		}
-		memcpy(sbuf->data + sbuf->size, buf, len);
-		sbuf->size += len;
+		memcpy(base::data + base::size, buf, len);
+		base::size += len;
 	}
 
 	char* data()
 	{
-		msgpack_sbuffer* sbuf = static_cast<msgpack_sbuffer*>(this);
-		return sbuf->data;
+		return base::data;
 	}
 
 	const char* data() const
 	{
-		const msgpack_sbuffer* sbuf = static_cast<const msgpack_sbuffer*>(this);
-		return sbuf->data;
+		return base::data;
 	}
 
 	size_t size() const
 	{
-		const msgpack_sbuffer* sbuf = static_cast<const msgpack_sbuffer*>(this);
-		return sbuf->size;
+		return base::size;
 	}
 
 	char* release()
 	{
-		msgpack_sbuffer* sbuf = static_cast<msgpack_sbuffer*>(this);
-		return msgpack_sbuffer_release(sbuf);
+		return msgpack_sbuffer_release(this);
 	}
 
 private:
 	void expand_buffer(size_t len)
 	{
-		msgpack_sbuffer* sbuf = static_cast<msgpack_sbuffer*>(this);
-
-		size_t nsize = (sbuf->alloc) ?
-				sbuf->alloc * 2 : MSGPACK_SBUFFER_INIT_SIZE;
+		size_t nsize = (base::alloc) ?
+				base::alloc * 2 : MSGPACK_SBUFFER_INIT_SIZE;
 	
-		while(nsize < sbuf->size + len) { nsize *= 2; }
+		while(nsize < base::size + len) { nsize *= 2; }
 	
-		void* tmp = realloc(sbuf->data, nsize);
+		void* tmp = realloc(base::data, nsize);
 		if(!tmp) {
 			throw std::bad_alloc();
 		}
 	
-		sbuf->data = (char*)tmp;
-		sbuf->alloc = nsize;
+		base::data = (char*)tmp;
+		base::alloc = nsize;
 	}
 
+private:
+	typedef msgpack_sbuffer base;
+
 private:
 	sbuffer(const sbuffer&);
 };
diff --git a/cpp/unpack.hpp b/cpp/unpack.hpp
index e140b36a..38ac7ac8 100644
--- a/cpp/unpack.hpp
+++ b/cpp/unpack.hpp
@@ -39,7 +39,7 @@ struct unpack_error : public std::runtime_error {
 
 class unpacker : public msgpack_unpacker {
 public:
-	unpacker(size_t initial_buffer_size = MSGPACK_UNPACKER_DEFAULT_INITIAL_BUFFER_SIZE);
+	unpacker(size_t init_buffer_size = MSGPACK_UNPACKER_DEFAULT_INITIAL_BUFFER_SIZE);
 	~unpacker();
 
 public:
@@ -126,6 +126,9 @@ public:
 	// Note that reset() leaves non-parsed buffer.
 	void remove_nonparsed_buffer();
 
+private:
+	typedef msgpack_unpacker base;
+
 private:
 	unpacker(const unpacker&);
 };
@@ -207,9 +210,9 @@ inline zone* unpacker::release_zone()
 
 	zone* r = new zone();
 
-	msgpack_zone old = *this->z;
-	*this->z = *z;
-	*z = old;
+	msgpack_zone old = *base::z;
+	*base::z = *r;
+	*static_cast<msgpack_zone*>(r) = old;
 
 	return r;
 }
@@ -232,22 +235,22 @@ inline size_t unpacker::parsed_size() const
 
 inline char* unpacker::nonparsed_buffer()
 {
-	return buf + off;
+	return base::buffer + base::off;
 }
 
 inline size_t unpacker::nonparsed_size() const
 {
-	return used - off;
+	return base::used - base::off;
 }
 
 inline void unpacker::skip_nonparsed_buffer(size_t size)
 {
-	off += size;
+	base::off += size;
 }
 
 inline void unpacker::remove_nonparsed_buffer()
 {
-	used = off;
+	base::used = base::off;
 }