digest-murmurhash 0.3.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3ae0e93d61ad1118ff16e6a8ee49e2624bfe93c6
-  data.tar.gz: 221199ad7ef8c94e0eba38d57ec6f0387652e051
+  metadata.gz: e4bb19a065230c4cf479bbc3e5d30a3ecacaab7e
+  data.tar.gz: 8b6b55cb5d5d3c398e9ac006b5b84359272c034d
 SHA512:
-  metadata.gz: 1b4b91306a2c297fb8809037693c9ec30ca87352bc047dcad25b099513183e4534b0b260104133ea94054c129eccf5192604331b493e5076361b8c3e104ca610
-  data.tar.gz: 58bad31ff82316ca28e66a37dd0709f08bbb59e7df2839f78b80ca1dee00799ee925a3e8f25dab272d1c5d893708a017ae2d8d882db5029aca73b09f475e82fa
+  metadata.gz: 09aa8502b047d0487b5727846236e91c33d06e7db3bfdc89f74ddc71f935d7f672232d3c6e27fc5c588fe6c90fb8d151e7611c356e2c168e216e20822862d07a
+  data.tar.gz: 1b6a03328a0428b3cc5455ca306fcc4d5bab0c5a8609300e9b7dbc774a499b8921d9f5b96b653ec3c72b8fa4d59cec5fcffe09447eac5d84f1c1b5ef4dc92771

data/.travis.yml

@@ -2,4 +2,5 @@ language: ruby
 rvm:
   - 1.9.3
   - 2.0.0
-  - 2.1.0
+  - 2.1.3
+  - 2.2.0

data/Rakefile

@@ -17,8 +17,7 @@ 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}"
+desc "gem reinstall"
 task :reinstall do |t|
   system "gem uninstall murmurhash"
   system "rake clean"

data/digest-murmurhash.gemspec

@@ -1,11 +1,8 @@
 # coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'digest/murmurhash/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "digest-murmurhash"
-  spec.version       = Digest::MurmurHash::VERSION
+  spec.version       = "1.0.0"
   spec.author        = "ksss"
   spec.email         = "co000ri@gmail.com"
   spec.description   = %q{Digest::MurmurHash is class collections of use algorithm MurmurHash desiged by Austin Appleby.}
@@ -19,9 +16,9 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
   spec.extensions    = ["ext/digest/murmurhash/extconf.rb"]
 
-  spec.add_runtime_dependency "digest-stringbuffer", ["~> 0.0.2"]
-  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_runtime_dependency "digest-simple"
+  spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec", ['~> 2.11']
-  spec.add_development_dependency "rake-compiler", ["~> 0.8.3"]
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rake-compiler"
 end

data/ext/digest/murmurhash/extconf.rb

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

data/ext/digest/murmurhash/murmurhash.c

@@ -8,246 +8,165 @@
 #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);
-}
+      cDigest_MurmurHash2,
+      cDigest_MurmurHash2A,
+      cDigest_MurmurHash64A,
+      cDigest_MurmurHash64B,
+      cDigest_MurmurHashNeutral2,
+      cDigest_MurmurHashAligned2;
+ID id_DEFAULT_SEED;
+ID iv_seed;
+ID iv_buffer;
 
-VALUE
-murmur_seed_get64(VALUE self)
+void
+assign_by_endian_32(uint8_t *digest, uint64_t h)
 {
-	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);
+  if (BIGENDIAN_P()) {
+    digest[0] = h >> 24;
+    digest[1] = h >> 16;
+    digest[2] = h >> 8;
+    digest[3] = h;
+  }
+  else {
+    digest[3] = h >> 24;
+    digest[2] = h >> 16;
+    digest[1] = h >> 8;
+    digest[0] = h;
+  }
 }
 
-VALUE
-murmur_seed_set64(VALUE self, VALUE obj)
+void
+assign_by_endian_64(uint8_t *digest, uint64_t h)
 {
-	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);
+  if (BIGENDIAN_P()) {
+    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;
+  }
+  else {
+    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;
+  }
 }
 
 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);
+  const char *seed = RSTRING_PTR(rb_ivar_get(self, iv_seed));
+  VALUE buffer = rb_ivar_get(self, iv_buffer);
+  return process(RSTRING_PTR(buffer), RSTRING_LEN(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);
+  const char *seed = RSTRING_PTR(rb_ivar_get(self, iv_seed));
+  VALUE buffer = rb_ivar_get(self, iv_buffer);
+  return process(RSTRING_PTR(buffer), RSTRING_LEN(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;
+  VALUE str;
+  const char *seed;
 
-	if (argc < 1)
-		rb_raise(rb_eArgError, "no data given");
+  if (argc < 1)
+    rb_raise(rb_eArgError, "no data given");
 
-	str = *argv;
+  str = *argv;
 
-	StringValue(str);
+  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));
-	}
+  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);
+  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;
+  VALUE str;
+  const char *seed;
 
-	if (argc < 1)
-		rb_raise(rb_eArgError, "no data given");
+  if (argc < 1)
+    rb_raise(rb_eArgError, "no data given");
 
-	str = *argv;
+  str = *argv;
 
-	StringValue(str);
+  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));
-	}
+  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;
+  return process(RSTRING_PTR(str), RSTRING_LEN(str), *(uint64_t*)seed);
 }
 
 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);
+  id_DEFAULT_SEED = rb_intern("DEFAULT_SEED");
+  iv_seed = rb_intern("@seed");
+  iv_buffer = rb_intern("@buffer");
+
+  cDigest_MurmurHash1 = rb_path2class("Digest::MurmurHash1");
+  rb_define_singleton_method(cDigest_MurmurHash1, "digest", murmur1_s_digest, -1);
+  rb_define_singleton_method(cDigest_MurmurHash1, "rawdigest", murmur1_s_rawdigest, -1);
+  rb_define_private_method(cDigest_MurmurHash1, "finish", murmur1_finish, 0);
+
+  cDigest_MurmurHash2 = rb_path2class("Digest::MurmurHash2");
+  rb_define_singleton_method(cDigest_MurmurHash2, "digest", murmur2_s_digest, -1);
+  rb_define_singleton_method(cDigest_MurmurHash2, "rawdigest", murmur2_s_rawdigest, -1);
+  rb_define_private_method(cDigest_MurmurHash2, "finish", murmur2_finish, 0);
+
+  cDigest_MurmurHash2A = rb_path2class("Digest::MurmurHash2A");
+  rb_define_singleton_method(cDigest_MurmurHash2A, "digest", murmur2a_s_digest, -1);
+  rb_define_singleton_method(cDigest_MurmurHash2A, "rawdigest", murmur2a_s_rawdigest, -1);
+  rb_define_private_method(cDigest_MurmurHash2A, "finish", murmur2a_finish, 0);
+
+  cDigest_MurmurHash64A = rb_path2class("Digest::MurmurHash64A");
+  rb_define_singleton_method(cDigest_MurmurHash64A, "digest", murmur64a_s_digest, -1);
+  rb_define_singleton_method(cDigest_MurmurHash64A, "rawdigest", murmur64a_s_rawdigest, -1);
+  rb_define_private_method(cDigest_MurmurHash64A, "finish", murmur64a_finish, 0);
+
+  cDigest_MurmurHash64B = rb_path2class("Digest::MurmurHash64B");
+  rb_define_singleton_method(cDigest_MurmurHash64B, "digest", murmur64b_s_digest, -1);
+  rb_define_singleton_method(cDigest_MurmurHash64B, "rawdigest", murmur64b_s_rawdigest, -1);
+  rb_define_private_method(cDigest_MurmurHash64B, "finish", murmur64b_finish, 0);
+
+  cDigest_MurmurHashNeutral2 = rb_path2class("Digest::MurmurHashNeutral2");
+  rb_define_singleton_method(cDigest_MurmurHashNeutral2, "digest", murmur_neutral2_s_digest, -1);
+  rb_define_singleton_method(cDigest_MurmurHashNeutral2, "rawdigest", murmur_neutral2_s_rawdigest, -1);
+  rb_define_private_method(cDigest_MurmurHashNeutral2, "finish", murmur_neutral2_finish, 0);
+
+  cDigest_MurmurHashAligned2 = rb_path2class("Digest::MurmurHashAligned2");
+  rb_define_singleton_method(cDigest_MurmurHashAligned2, "digest", murmur_aligned2_s_digest, -1);
+  rb_define_singleton_method(cDigest_MurmurHashAligned2, "rawdigest", murmur_aligned2_s_rawdigest, -1);
+  rb_define_private_method(cDigest_MurmurHashAligned2, "finish", murmur_aligned2_finish, 0);
 }

data/ext/digest/murmurhash/murmurhash.h

@@ -10,69 +10,37 @@
 #  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)
+#ifdef DYNAMIC_ENDIAN
+  /* for universal binary of NEXTSTEP and MacOS X */
+  /* useless since autoconf 2.63? */
+  static int
+  is_bigendian(void)
+  {
+    static int init = 0;
+    static int endian_value;
+    char *p;
+
+    if (init) return endian_value;
+    init = 1;
+    p = (char*)&init;
+    return endian_value = p[0] ? 0 : 1;
+  }
+#  define BIGENDIAN_P() (is_bigendian())
+#elif defined(WORDS_BIGENDIAN)
+#  define BIGENDIAN_P() 1
 #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)
+#  define BIGENDIAN_P() 0
 #endif
 
-/* should be same type structure to digest/stringbuffer */
-typedef struct {
-	char* buffer;
-	char* p;
-	size_t memsize;
-} buffer_t;
-
-#define MURMURHASH(self, name) \
-	buffer_t* name; \
-	Data_Get_Struct(self, buffer_t, name); \
-	if (name == NULL) { \
-		rb_raise(rb_eArgError, "NULL found for " # name " when shouldn't be.'"); \
-	}
-
-VALUE murmur_seed_get32(VALUE self);
-VALUE murmur_seed_get64(VALUE self);
+#define MURMURHASH_MAGIC 0x5bd1e995
+#define MURMURHASH_MAGIC64A BIG_CONSTANT(0xc6a4a7935bd1e995)
 
-extern ID id_seed, id_DEFAULT_SEED;
+void assign_by_endian_32(uint8_t *digest, uint64_t h);
+void assign_by_endian_64(uint8_t *digest, uint64_t h);
 
 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 */
-