Merge branch 'master' of github.com:mruby/mruby

include/mruby/khash.h

@@ -44,6 +44,8 @@ static const uint8_t __m_either[] = {0x03, 0x0c, 0x30, 0xc0};
   v |= v >> 16;\
   v++;\
 } while (0)
+#define khash_mask(h) ((h)->n_buckets-1)
+#define khash_inc(h) ((h)->n_buckets/2-1)
 
 /* declare struct kh_xxx and kh_xxx_funcs
 
@@ -61,8 +63,6 @@ static const uint8_t __m_either[] = {0x03, 0x0c, 0x30, 0xc0};
     uint8_t *ed_flags;                                                  \
     khkey_t *keys;                                                      \
     khval_t *vals;                                                      \
-    khint_t mask;                                                       \
-    khint_t inc;                                                        \
   } kh_##name##_t;                                                      \
   void kh_alloc_##name(mrb_state *mrb, kh_##name##_t *h);               \
   kh_##name##_t *kh_init_##name##_size(mrb_state *mrb, khint_t size);   \
@@ -96,7 +96,7 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
   void kh_alloc_##name(mrb_state *mrb, kh_##name##_t *h)                \
   {                                                                     \
     khint_t sz = h->n_buckets;                                          \
-    int len = sizeof(khkey_t) + (kh_is_map ? sizeof(khval_t) : 0);      \
+    size_t len = sizeof(khkey_t) + (kh_is_map ? sizeof(khval_t) : 0);      \
     uint8_t *p = (uint8_t*)mrb_malloc(mrb, sizeof(uint8_t)*sz/4+len*sz); \
     h->size = h->n_occupied = 0;                                        \
     h->upper_bound = UPPER_BOUND(sz);                                   \
@@ -104,8 +104,6 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
     h->vals = kh_is_map ? (khval_t *)(p+sizeof(khkey_t)*sz) : NULL;     \
     h->ed_flags = p+len*sz;                                             \
     kh_fill_flags(h->ed_flags, 0xaa, sz/4);                             \
-    h->mask = sz-1;                                                     \
-    h->inc = sz/2-1;                                                    \
   }                                                                     \
   kh_##name##_t *kh_init_##name##_size(mrb_state *mrb, khint_t size) {  \
     kh_##name##_t *h = (kh_##name##_t*)mrb_calloc(mrb, 1, sizeof(kh_##name##_t)); \
@@ -136,13 +134,13 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
   }                                                                     \
   khint_t kh_get_##name(mrb_state *mrb, kh_##name##_t *h, khkey_t key)  \
   {                                                                     \
-    khint_t k = __hash_func(mrb,key) & (h->mask);                       \
+    khint_t k = __hash_func(mrb,key) & khash_mask(h);                   \
     (void)mrb;                                                          \
     while (!__ac_isempty(h->ed_flags, k)) {                             \
       if (!__ac_isdel(h->ed_flags, k)) {                                \
         if (__hash_equal(mrb,h->keys[k], key)) return k;                \
       }                                                                 \
-      k = (k+h->inc) & (h->mask);                                       \
+      k = (k+khash_inc(h)) & khash_mask(h);                             \
     }                                                                   \
     return h->n_buckets;                                                \
   }                                                                     \
@@ -175,10 +173,10 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
     if (h->n_occupied >= h->upper_bound) {                              \
       kh_resize_##name(mrb, h, h->n_buckets*2);                         \
     }                                                                   \
-    k = __hash_func(mrb,key) & (h->mask);                               \
+    k = __hash_func(mrb,key) & khash_mask(h);                           \
     while (!__ac_iseither(h->ed_flags, k)) {                            \
       if (__hash_equal(mrb,h->keys[k], key)) break;                     \
-      k = (k+h->inc) & (h->mask);                                       \
+      k = (k+khash_inc(h)) & khash_mask(h);                             \
     }                                                                   \
     if (__ac_isempty(h->ed_flags, k)) {                                 \
       /* put at empty */                                                \

include/mruby/proc.h

@@ -64,7 +64,7 @@ struct RProc *mrb_proc_new_cfunc_with_env(mrb_state*, mrb_func_t, mrb_int, const
 mrb_value mrb_cfunc_env_get(mrb_state*, mrb_int);
 
 #include "mruby/khash.h"
-KHASH_DECLARE(mt, mrb_sym, struct RProc*, 1)
+KHASH_DECLARE(mt, mrb_sym, struct RProc*, TRUE)
 
 #if defined(__cplusplus)
 }  /* extern "C" { */

mrbgems/mruby-symbol-ext/src/symbol.c

@@ -7,7 +7,7 @@ typedef struct symbol_name {
   const char *name;
 } symbol_name;
 
-KHASH_DECLARE(n2s, symbol_name, mrb_sym, 1)
+KHASH_DECLARE(n2s, symbol_name, mrb_sym, TRUE)
 
 /*
  *  call-seq:

src/class.c

@@ -16,7 +16,7 @@
 #include "mruby/error.h"
 #include "mruby/data.h"
 
-KHASH_DEFINE(mt, mrb_sym, struct RProc*, 1, kh_int_hash_func, kh_int_hash_equal)
+KHASH_DEFINE(mt, mrb_sym, struct RProc*, TRUE, kh_int_hash_func, kh_int_hash_equal)
 
 void
 mrb_gc_mark_mt(mrb_state *mrb, struct RClass *c)

src/hash.c

@@ -95,8 +95,8 @@ typedef struct {
   mrb_int n;
 } mrb_hash_value;
 
-KHASH_DECLARE(ht, mrb_value, mrb_hash_value, 1)
-KHASH_DEFINE (ht, mrb_value, mrb_hash_value, 1, mrb_hash_ht_hash_func, mrb_hash_ht_hash_equal)
+KHASH_DECLARE(ht, mrb_value, mrb_hash_value, TRUE)
+KHASH_DEFINE (ht, mrb_value, mrb_hash_value, TRUE, mrb_hash_ht_hash_func, mrb_hash_ht_hash_equal)
 
 static void mrb_hash_modify(mrb_state *mrb, mrb_value hash);
 

src/kernel.c

@@ -720,8 +720,8 @@ mrb_obj_is_kind_of_m(mrb_state *mrb, mrb_value self)
   return mrb_bool_value(kind_of_p);
 }
 
-KHASH_DECLARE(st, mrb_sym, char, 0)
-KHASH_DEFINE(st, mrb_sym, char, 0, kh_int_hash_func, kh_int_hash_equal)
+KHASH_DECLARE(st, mrb_sym, char, FALSE)
+KHASH_DEFINE(st, mrb_sym, char, FALSE, kh_int_hash_func, kh_int_hash_equal)
 
 static void
 method_entry_loop(mrb_state *mrb, struct RClass* klass, khash_t(st)* set)

src/symbol.c

@@ -31,8 +31,8 @@ sym_hash_func(mrb_state *mrb, const symbol_name s)
 }
 #define sym_hash_equal(mrb,a, b) (a.len == b.len && memcmp(a.name, b.name, a.len) == 0)
 
-KHASH_DECLARE(n2s, symbol_name, mrb_sym, 1)
-KHASH_DEFINE (n2s, symbol_name, mrb_sym, 1, sym_hash_func, sym_hash_equal)
+KHASH_DECLARE(n2s, symbol_name, mrb_sym, TRUE)
+KHASH_DEFINE (n2s, symbol_name, mrb_sym, TRUE, sym_hash_func, sym_hash_equal)
 /* ------------------------------------------------------ */
 static mrb_sym
 sym_intern(mrb_state *mrb, const char *name, size_t len, mrb_bool lit)

src/variable.c

@@ -289,8 +289,8 @@ iv_free(mrb_state *mrb, iv_tbl *t)
 #define MRB_IVHASH_INIT_SIZE 8
 #endif
 
-KHASH_DECLARE(iv, mrb_sym, mrb_value, 1)
-KHASH_DEFINE(iv, mrb_sym, mrb_value, 1, kh_int_hash_func, kh_int_hash_equal)
+KHASH_DECLARE(iv, mrb_sym, mrb_value, TRUE)
+KHASH_DEFINE(iv, mrb_sym, mrb_value, TRUE, kh_int_hash_func, kh_int_hash_equal)
 
 typedef struct iv_tbl {
   khash_t(iv) h;