digest-murmurhash 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 83fe0d0927d2638319d39e938350a0a2211e0b8c
-  data.tar.gz: 53c869f210dc4225fa7aa011d36bce3c1c63e519
+  metadata.gz: 3ae0e93d61ad1118ff16e6a8ee49e2624bfe93c6
+  data.tar.gz: 221199ad7ef8c94e0eba38d57ec6f0387652e051
 SHA512:
-  metadata.gz: 59bd8b9afbcb440d8b21489c7c573f259bc73301eaa457e5f1f2cb16308d3ce615813d39ea33003c36434a04c7a4b756f0bbc5bbfbab6d0302f34c23de987726
-  data.tar.gz: 1657035e9d32261c7d2677403e568a93bd52210a38c99436fb0bd4086d5e51be9d6715f9631c8e8f17ddd5f21065cfe578f023500bbab9a47b9dc2bb9cb9d8e9
+  metadata.gz: 1b4b91306a2c297fb8809037693c9ec30ca87352bc047dcad25b099513183e4534b0b260104133ea94054c129eccf5192604331b493e5076361b8c3e104ca610
+  data.tar.gz: 58bad31ff82316ca28e66a37dd0709f08bbb59e7df2839f78b80ca1dee00799ee925a3e8f25dab272d1c5d893708a017ae2d8d882db5029aca73b09f475e82fa

data/README.md

@@ -10,6 +10,14 @@
 
 **Digest::MurmurHash2A** use algorithm MurmurHash2A(32-bit).
 
+**Digest::MurmurHash64A** use algorithm MurmurHash64A(64-bit).
+
+**Digest::MurmurHash64B** use algorithm MurmurHash64B(64-bit).
+
+**Digest::MurmurHashNeutral2** use algorithm MurmurHashNeutral2(32-bit).
+
+**Digest::MurmurHashAligned2** use algorithm MurmurHashAligned2(32-bit).
+
 (**Digest::MurmurHash** exist to write only version number)
 
 All classes compliance Digest API of Ruby.
@@ -40,6 +48,14 @@ p Digest::MurmurHash2.file("./LICENSE.txt").hexdigest #=> '78678326'
 
 **Digest::MurmurHash2A** < Digest::StringBuffer
 
+**Digest::MurmurHash64A** < Digest::StringBuffer
+
+**Digest::MurmurHash64B** < Digest::StringBuffer
+
+**Digest::MurmurHashNeutral2** < Digest::StringBuffer
+
+**Digest::MurmurHashAligned2** < Digest::StringBuffer
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/Rakefile

@@ -17,5 +17,15 @@ Rake::ExtensionTask.new('murmurhash', spec) do |ext|
   ext.lib_dir = 'lib/digest/murmurhash'
 end
 
+require 'digest/murmurhash/version'
+desc "gem reinstall v#{Digest::MurmurHash::VERSION}"
+task :reinstall do |t|
+  system "gem uninstall murmurhash"
+  system "rake clean"
+  system "bundle exec rake"
+  system "rake install"
+  system "irb -rdigest/murmurhash"
+end
+
 
-task :default => [:spec]
+task :default => [:spec, :build]

data/digest-murmurhash.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = Digest::MurmurHash::VERSION
   spec.author        = "ksss"
   spec.email         = "co000ri@gmail.com"
-  spec.description   = %q{Digest::MurmurHash1 is a class of use algorithm MurmurHash1(32-bit) desiged by Austin Appleby.}
-  spec.summary       = %q{Digest::MurmurHash1 is a class of use algorithm MurmurHash1(32-bit) desiged by Austin Appleby.}
+  spec.description   = %q{Digest::MurmurHash is class collections of use algorithm MurmurHash desiged by Austin Appleby.}
+  spec.summary       = %q{Digest::MurmurHash is class collections of use algorithm MurmurHash desiged by Austin Appleby.}
   spec.homepage      = ""
   spec.license       = "MIT"
 
@@ -23,5 +23,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec", ['~> 2.11']
-  spec.add_development_dependency "rake-compiler", ["~> 0.9.2"]
+  spec.add_development_dependency "rake-compiler", ["~> 0.8.3"]
 end

data/ext/digest/murmurhash/extconf.rb

@@ -1,7 +1,6 @@
 require 'mkmf'
 
-have_header('ruby/digest.h')
-
 $preload = %w[digest]
+$CFLAGS << " -Wall"
 
 create_makefile('digest/murmurhash/murmurhash')

data/ext/digest/murmurhash/murmurhash.c

@@ -0,0 +1,253 @@
+#include "murmurhash.h"
+#include "murmurhash1.h"
+#include "murmurhash2.h"
+#include "murmurhash2a.h"
+#include "murmurhash64a.h"
+#include "murmurhash64b.h"
+#include "murmurhash_neutral2.h"
+#include "murmurhash_aligned2.h"
+
+VALUE cDigest_MurmurHash1,
+	  cDigest_MurmurHash2,
+	  cDigest_MurmurHash2A,
+	  cDigest_MurmurHash64A,
+	  cDigest_MurmurHash64B,
+	  cDigest_MurmurHashNeutral2,
+	  cDigest_MurmurHashAligned2;
+ID id_seed,
+   id_DEFAULT_SEED;
+
+VALUE
+murmur_seed_get32(VALUE self)
+{
+	if (!rb_ivar_defined(self, id_seed)) {
+		rb_ivar_set(self, id_seed, rb_usascii_str_new(DEFAULT_SEED, 4));
+	}
+	return rb_ivar_get(self, id_seed);
+}
+
+VALUE
+murmur_seed_set32(VALUE self, VALUE obj)
+{
+	StringValue(obj);
+	if (RSTRING_LEN(obj) != 4) {
+		rb_raise(rb_eArgError, "seed string should 64 bit chars");
+	}
+	return rb_ivar_set(self, id_seed, obj);
+}
+
+VALUE
+murmur_seed_get64(VALUE self)
+{
+	if (!rb_ivar_defined(self, id_seed)) {
+		rb_ivar_set(self, id_seed, rb_usascii_str_new(DEFAULT_SEED, 8));
+	}
+	return rb_ivar_get(self, id_seed);
+}
+
+VALUE
+murmur_seed_set64(VALUE self, VALUE obj)
+{
+	StringValue(obj);
+	if (RSTRING_LEN(obj) != 8) {
+		rb_raise(rb_eArgError, "seed string should 64 bit chars");
+	}
+	return rb_ivar_set(self, id_seed, obj);
+}
+
+uint32_t
+_murmur_finish32(VALUE self, uint32_t (*process)(const char *, uint32_t, uint32_t))
+{
+	const char *seed = RSTRING_PTR(murmur_seed_get32(self));
+	MURMURHASH(self, ptr);
+	return process(ptr->buffer, ptr->p - ptr->buffer, *(uint32_t*)seed);
+}
+
+uint64_t
+_murmur_finish64(VALUE self, uint64_t (*process)(const char *, uint32_t, uint64_t))
+{
+	const char *seed = RSTRING_PTR(murmur_seed_get64(self));
+	MURMURHASH(self, ptr);
+	return process(ptr->buffer, ptr->p - ptr->buffer, *(uint64_t*)seed);
+}
+
+
+uint32_t
+_murmur_s_digest32(int argc, VALUE *argv, VALUE klass, uint32_t (*process)(const char *, uint32_t, uint32_t))
+{
+	VALUE str;
+	const char *seed;
+
+	if (argc < 1)
+		rb_raise(rb_eArgError, "no data given");
+
+	str = *argv;
+
+	StringValue(str);
+
+	if (1 < argc) {
+		StringValue(argv[1]);
+		if (RSTRING_LEN(argv[1]) != 4) {
+			rb_raise(rb_eArgError, "seed string should 32 bit chars");
+		}
+		seed = RSTRING_PTR(argv[1]);
+	} else {
+		seed = RSTRING_PTR(rb_const_get(klass, id_DEFAULT_SEED));
+	}
+
+	return process(RSTRING_PTR(str), RSTRING_LEN(str), *(uint32_t*)seed);
+}
+
+uint64_t
+_murmur_s_digest64(int argc, VALUE *argv, VALUE klass, uint64_t (*process)(const char *, uint32_t, uint64_t))
+{
+	VALUE str;
+	const char *seed;
+
+	if (argc < 1)
+		rb_raise(rb_eArgError, "no data given");
+
+	str = *argv;
+
+	StringValue(str);
+
+	if (1 < argc) {
+		StringValue(argv[1]);
+		if (RSTRING_LEN(argv[1]) != 8) {
+			rb_raise(rb_eArgError, "seed string should 64 bit chars");
+		}
+		seed = RSTRING_PTR(argv[1]);
+	} else {
+		seed = RSTRING_PTR(rb_const_get(klass, id_DEFAULT_SEED));
+	}
+
+	return process(RSTRING_PTR(str), RSTRING_LEN(str), *(uint64_t*)seed);
+}
+
+/*
+ * from https://github.com/ruby/ruby/blob/trunk/ext/digest/digest.c
+ * Copyright (C) 1995-2001 Yukihiro Matsumoto
+ * Copyright (C) 2001-2006 Akinori MUSHA
+ */
+VALUE
+hexencode_str_new(VALUE str_digest)
+{
+	char *digest;
+	size_t digest_len;
+	size_t i;
+	VALUE str;
+	char *p;
+	static const char hex[] = {
+		'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+		'a', 'b', 'c', 'd', 'e', 'f'
+	};
+
+	StringValue(str_digest);
+	digest = RSTRING_PTR(str_digest);
+	digest_len = RSTRING_LEN(str_digest);
+
+	if (LONG_MAX / 2 < digest_len) {
+		rb_raise(rb_eRuntimeError, "digest string too long");
+	}
+
+	str = rb_usascii_str_new(0, digest_len * 2);
+
+	for (i = 0, p = RSTRING_PTR(str); i < digest_len; i++) {
+		unsigned char byte = digest[i];
+
+		p[i + i]     = hex[byte >> 4];
+		p[i + i + 1] = hex[byte & 0x0f];
+	}
+
+	return str;
+}
+
+void
+Init_murmurhash(void)
+{
+	VALUE mDigest, cDigest_StringBuffer;
+
+	id_seed = rb_intern("seed");
+	id_DEFAULT_SEED = rb_intern("DEFAULT_SEED");
+
+	/* Digest::MurmurHash is require that Digest::StringBuffer */
+	mDigest = rb_path2class("Digest");
+	cDigest_StringBuffer = rb_path2class("Digest::StringBuffer");
+
+	/* class Digest::MurmurHash1 < Digest::StringBuffer */
+	cDigest_MurmurHash1 = rb_define_class_under(mDigest, "MurmurHash1", cDigest_StringBuffer);
+	rb_define_const(cDigest_MurmurHash1, "DEFAULT_SEED", rb_usascii_str_new(DEFAULT_SEED, 4));
+	rb_define_singleton_method(cDigest_MurmurHash1, "digest", murmur1_s_digest, -1);
+	rb_define_singleton_method(cDigest_MurmurHash1, "hexdigest", murmur1_s_hexdigest, -1);
+	rb_define_singleton_method(cDigest_MurmurHash1, "rawdigest", murmur1_s_rawdigest, -1);
+	rb_define_private_method(cDigest_MurmurHash1, "finish", murmur1_finish, 0);
+	rb_define_method(cDigest_MurmurHash1, "to_i", murmur1_to_i, 0);
+	rb_define_method(cDigest_MurmurHash1, "seed", murmur_seed_get32, 0);
+	rb_define_method(cDigest_MurmurHash1, "seed=", murmur_seed_set32, 1);
+
+	/* class Digest::MurmurHash2 < Digest::StringBuffer */
+	cDigest_MurmurHash2 = rb_define_class_under(mDigest, "MurmurHash2", cDigest_StringBuffer);
+	rb_define_const(cDigest_MurmurHash2, "DEFAULT_SEED", rb_usascii_str_new(DEFAULT_SEED, 4));
+	rb_define_singleton_method(cDigest_MurmurHash2, "digest", murmur2_s_digest, -1);
+	rb_define_singleton_method(cDigest_MurmurHash2, "hexdigest", murmur2_s_hexdigest, -1);
+	rb_define_singleton_method(cDigest_MurmurHash2, "rawdigest", murmur2_s_rawdigest, -1);
+	rb_define_private_method(cDigest_MurmurHash2, "finish", murmur2_finish, 0);
+	rb_define_method(cDigest_MurmurHash2, "to_i", murmur2_to_i, 0);
+	rb_define_method(cDigest_MurmurHash2, "seed", murmur_seed_get32, 0);
+	rb_define_method(cDigest_MurmurHash2, "seed=", murmur_seed_set32, 1);
+
+	/* class Digest::MurmurHash2A < Digest::StringBuffer */
+	cDigest_MurmurHash2A = rb_define_class_under(mDigest, "MurmurHash2A", cDigest_StringBuffer);
+	rb_define_const(cDigest_MurmurHash2A, "DEFAULT_SEED", rb_usascii_str_new(DEFAULT_SEED, 4));
+	rb_define_singleton_method(cDigest_MurmurHash2A, "digest", murmur2a_s_digest, -1);
+	rb_define_singleton_method(cDigest_MurmurHash2A, "hexdigest", murmur2a_s_hexdigest, -1);
+	rb_define_singleton_method(cDigest_MurmurHash2A, "rawdigest", murmur2a_s_rawdigest, -1);
+	rb_define_private_method(cDigest_MurmurHash2A, "finish", murmur2a_finish, 0);
+	rb_define_method(cDigest_MurmurHash2A, "to_i", murmur2a_to_i, 0);
+	rb_define_method(cDigest_MurmurHash2A, "seed", murmur_seed_get32, 0);
+	rb_define_method(cDigest_MurmurHash2A, "seed=", murmur_seed_set32, 1);
+
+	/* class Digest::MurmurHash64A < Digest::StringBuffer */
+	cDigest_MurmurHash64A = rb_define_class_under(mDigest, "MurmurHash64A", cDigest_StringBuffer);
+	rb_define_const(cDigest_MurmurHash64A, "DEFAULT_SEED", rb_usascii_str_new(DEFAULT_SEED, 8));
+	rb_define_singleton_method(cDigest_MurmurHash64A, "digest", murmur64a_s_digest, -1);
+	rb_define_singleton_method(cDigest_MurmurHash64A, "hexdigest", murmur64a_s_hexdigest, -1);
+	rb_define_singleton_method(cDigest_MurmurHash64A, "rawdigest", murmur64a_s_rawdigest, -1);
+	rb_define_private_method(cDigest_MurmurHash64A, "finish", murmur64a_finish, 0);
+	rb_define_method(cDigest_MurmurHash64A, "to_i", murmur64a_to_i, 0);
+	rb_define_method(cDigest_MurmurHash64A, "seed", murmur_seed_get64, 0);
+	rb_define_method(cDigest_MurmurHash64A, "seed=", murmur_seed_set64, 1);
+
+	/* class Digest::MurmurHash64B < Digest::StringBuffer */
+	cDigest_MurmurHash64B = rb_define_class_under(mDigest, "MurmurHash64B", cDigest_StringBuffer);
+	rb_define_const(cDigest_MurmurHash64B, "DEFAULT_SEED", rb_usascii_str_new(DEFAULT_SEED, 8));
+	rb_define_singleton_method(cDigest_MurmurHash64B, "digest", murmur64b_s_digest, -1);
+	rb_define_singleton_method(cDigest_MurmurHash64B, "hexdigest", murmur64b_s_hexdigest, -1);
+	rb_define_singleton_method(cDigest_MurmurHash64B, "rawdigest", murmur64b_s_rawdigest, -1);
+	rb_define_private_method(cDigest_MurmurHash64B, "finish", murmur64b_finish, 0);
+	rb_define_method(cDigest_MurmurHash64B, "to_i", murmur64b_to_i, 0);
+	rb_define_method(cDigest_MurmurHash64B, "seed", murmur_seed_get64, 0);
+	rb_define_method(cDigest_MurmurHash64B, "seed=", murmur_seed_set64, 1);
+
+	/* class Digest::MurmurHashNeutral2 < Digest::StringBuffer */
+	cDigest_MurmurHashNeutral2 = rb_define_class_under(mDigest, "MurmurHashNeutral2", cDigest_StringBuffer);
+	rb_define_const(cDigest_MurmurHashNeutral2, "DEFAULT_SEED", rb_usascii_str_new(DEFAULT_SEED, 4));
+	rb_define_singleton_method(cDigest_MurmurHashNeutral2, "digest", murmur_neutral2_s_digest, -1);
+	rb_define_singleton_method(cDigest_MurmurHashNeutral2, "hexdigest", murmur_neutral2_s_hexdigest, -1);
+	rb_define_singleton_method(cDigest_MurmurHashNeutral2, "rawdigest", murmur_neutral2_s_rawdigest, -1);
+	rb_define_private_method(cDigest_MurmurHashNeutral2, "finish", murmur_neutral2_finish, 0);
+	rb_define_method(cDigest_MurmurHashNeutral2, "to_i", murmur_neutral2_to_i, 0);
+	rb_define_method(cDigest_MurmurHashNeutral2, "seed", murmur_seed_get32, 0);
+	rb_define_method(cDigest_MurmurHashNeutral2, "seed=", murmur_seed_set32, 1);
+
+	/* class Digest::MurmurHashAligned2 < Digest::StringBuffer */
+	cDigest_MurmurHashAligned2 = rb_define_class_under(mDigest, "MurmurHashAligned2", cDigest_StringBuffer);
+	rb_define_const(cDigest_MurmurHashAligned2, "DEFAULT_SEED", rb_usascii_str_new(DEFAULT_SEED, 4));
+	rb_define_singleton_method(cDigest_MurmurHashAligned2, "digest", murmur_aligned2_s_digest, -1);
+	rb_define_singleton_method(cDigest_MurmurHashAligned2, "hexdigest", murmur_aligned2_s_hexdigest, -1);
+	rb_define_singleton_method(cDigest_MurmurHashAligned2, "rawdigest", murmur_aligned2_s_rawdigest, -1);
+	rb_define_private_method(cDigest_MurmurHashAligned2, "finish", murmur_aligned2_finish, 0);
+	rb_define_method(cDigest_MurmurHashAligned2, "to_i", murmur_aligned2_to_i, 0);
+	rb_define_method(cDigest_MurmurHashAligned2, "seed", murmur_seed_get32, 0);
+	rb_define_method(cDigest_MurmurHashAligned2, "seed=", murmur_seed_set32, 1);
+}

data/ext/digest/murmurhash/murmurhash.h

@@ -3,7 +3,51 @@
 
 #include "ruby.h"
 
+#if defined(_MSC_VER)
+#  define BIG_CONSTANT(x) (x)
+// Other compilers
+#else   // defined(_MSC_VER)
+#  define BIG_CONSTANT(x) (x##LLU)
+#endif // !defined(_MSC_VER)
+
+#define DEFAULT_SEED "\x00\x00\x00\x00\x00\x00\x00\x00"
 #define MURMURHASH_MAGIC 0x5bd1e995
+#define MURMURHASH_MAGIC64A BIG_CONSTANT(0xc6a4a7935bd1e995)
+#if INTEGER_PACK_LITTLE_ENDIAN
+#  define ASSINE_BY_ENDIAN_32(digest, h) do { \
+	(digest)[3] = (h) >> 24; \
+	(digest)[2] = (h) >> 16; \
+	(digest)[1] = (h) >> 8; \
+	(digest)[0] = (h); \
+} while (0)
+#  define ASSINE_BY_ENDIAN_64(digest, h) do { \
+	(digest)[7] = (h) >> 56; \
+	(digest)[6] = (h) >> 48; \
+	(digest)[5] = (h) >> 40; \
+	(digest)[4] = (h) >> 32; \
+	(digest)[3] = (h) >> 24; \
+	(digest)[2] = (h) >> 16; \
+	(digest)[1] = (h) >> 8; \
+	(digest)[0] = (h); \
+} while (0)
+#else
+#  define ASSINE_BY_ENDIAN_32(digest, h) do { \
+	(digest)[0] = (h) >> 24; \
+	(digest)[1] = (h) >> 16; \
+	(digest)[2] = (h) >> 8; \
+	(digest)[3] = (h); \
+} while (0)
+#  define ASSINE_BY_ENDIAN_64(digest, h) do { \
+	(digest)[0] = (h) >> 56; \
+	(digest)[1] = (h) >> 48; \
+	(digest)[2] = (h) >> 40; \
+	(digest)[3] = (h) >> 32; \
+	(digest)[4] = (h) >> 24; \
+	(digest)[5] = (h) >> 16; \
+	(digest)[6] = (h) >> 8; \
+	(digest)[7] = (h); \
+} while (0)
+#endif
 
 /* should be same type structure to digest/stringbuffer */
 typedef struct {
@@ -19,43 +63,16 @@ typedef struct {
 		rb_raise(rb_eArgError, "NULL found for " # name " when shouldn't be.'"); \
 	}
 
-/*
- * from https://github.com/ruby/ruby/blob/trunk/ext/digest/digest.c
- * Copyright (C) 1995-2001 Yukihiro Matsumoto
- * Copyright (C) 2001-2006 Akinori MUSHA
- */
-static VALUE
-hexencode_str_new(VALUE str_digest)
-{
-	char *digest;
-	size_t digest_len;
-	size_t i;
-	VALUE str;
-	char *p;
-	static const char hex[] = {
-		'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
-		'a', 'b', 'c', 'd', 'e', 'f'
-	};
-
-	StringValue(str_digest);
-	digest = RSTRING_PTR(str_digest);
-	digest_len = RSTRING_LEN(str_digest);
-
-	if (LONG_MAX / 2 < digest_len) {
-		rb_raise(rb_eRuntimeError, "digest string too long");
-	}
-
-	str = rb_usascii_str_new(0, digest_len * 2);
+VALUE murmur_seed_get32(VALUE self);
+VALUE murmur_seed_get64(VALUE self);
 
-	for (i = 0, p = RSTRING_PTR(str); i < digest_len; i++) {
-		unsigned char byte = digest[i];
-
-		p[i + i]     = hex[byte >> 4];
-		p[i + i + 1] = hex[byte & 0x0f];
-	}
+extern ID id_seed, id_DEFAULT_SEED;
 
-	return str;
-}
+uint32_t _murmur_finish32(VALUE self, uint32_t (*process)(const char *, uint32_t, uint32_t));
+uint64_t _murmur_finish64(VALUE self, uint64_t (*process)(const char *, uint32_t, uint64_t));
+uint32_t _murmur_s_digest32(int argc, VALUE *argv, VALUE klass, uint32_t (*process)(const char *, uint32_t, uint32_t));
+uint64_t _murmur_s_digest64(int argc, VALUE *argv, VALUE klass, uint64_t (*process)(const char *, uint32_t, uint64_t));
+VALUE hexencode_str_new(VALUE str_digest);
 
 #endif /* ifndef MURMURHASH_INCLUDED */
 

data/ext/digest/murmurhash/murmurhash1.c

@@ -4,27 +4,23 @@
 
 #include "murmurhash1.h"
 
-static inline size_t
-murmur1(uint32_t h, const uint8_t r)
-{
-	const uint32_t m = MURMURHASH_MAGIC;
-	h *= m;
-	h ^= h >> r;
-	return h;
-}
+#define murmur1(r) do { \
+	h *= m; \
+	h ^= h >> r; \
+} while(0)
 
 static uint32_t
-murmur_hash_process1(const char *data, uint32_t length)
+murmur_hash_process1(const char *data, uint32_t length, uint32_t seed)
 {
 	const uint32_t m = MURMURHASH_MAGIC;
 	const uint8_t r = 16;
 	uint32_t h;
 
-	h = length * m;
+	h = seed ^ (length * m);
 
 	while (4 <= length) {
 		h += *(uint32_t*)data;
-		h = murmur1(h, r);
+		murmur1(r);
 		data += 4;
 		length -= 4;
 	}
@@ -36,11 +32,11 @@ murmur_hash_process1(const char *data, uint32_t length)
 		h += data[1] << 8;
 	case 1:
 		h += data[0];
-		h = murmur1(h, r);
+		murmur1(r);
 	}
 
-	h = murmur1(h, 10);
-	h = murmur1(h, 17);
+	murmur1(10);
+	murmur1(17);
 
 	return h;
 }
@@ -48,49 +44,27 @@ murmur_hash_process1(const char *data, uint32_t length)
 VALUE
 murmur1_finish(VALUE self)
 {
-	uint32_t h;
 	uint8_t digest[4];
-	MURMURHASH(self, ptr);
-
-	h = murmur_hash_process1(ptr->buffer, ptr->p - ptr->buffer);
-
-	digest[0] = h >> 24;
-	digest[1] = h >> 16;
-	digest[2] = h >> 8;
-	digest[3] = h;
+	uint64_t h;
 
+	h = _murmur_finish32(self, murmur_hash_process1);
+	ASSINE_BY_ENDIAN_32(digest, h);
 	return rb_str_new((const char*) digest, 4);
 }
 
 VALUE
 murmur1_to_i(VALUE self)
 {
-	MURMURHASH(self, ptr);
-	return UINT2NUM(murmur_hash_process1(ptr->buffer, ptr->p - ptr->buffer));
+	return UINT2NUM(_murmur_finish32(self, murmur_hash_process1));
 }
 
 VALUE
 murmur1_s_digest(int argc, VALUE *argv, VALUE klass)
 {
-	VALUE str;
-	uint32_t h;
 	uint8_t digest[4];
-
-	if (argc < 1)
-		rb_raise(rb_eArgError, "no data given");
-
-	str = *argv++;
-	argc--;
-
-	StringValue(str);
-
-	h = murmur_hash_process1(RSTRING_PTR(str), RSTRING_LEN(str));
-
-	digest[0] = h >> 24;
-	digest[1] = h >> 16;
-	digest[2] = h >> 8;
-	digest[3] = h;
-
+	uint32_t h;
+	h = _murmur_s_digest32(argc, argv, klass, murmur_hash_process1);
+	ASSINE_BY_ENDIAN_32(digest, h);
 	return rb_str_new((const char*) digest, 4);
 }
 
@@ -103,15 +77,5 @@ murmur1_s_hexdigest(int argc, VALUE *argv, VALUE klass)
 VALUE
 murmur1_s_rawdigest(int argc, VALUE *argv, VALUE klass)
 {
-	VALUE str;
-
-	if (argc < 1)
-		rb_raise(rb_eArgError, "no data given");
-
-	str = *argv++;
-	argc--;
-
-	StringValue(str);
-
-	return UINT2NUM(murmur_hash_process1(RSTRING_PTR(str), RSTRING_LEN(str)));
+	return UINT2NUM(_murmur_s_digest32(argc, argv, klass, murmur_hash_process1));
 }