webruby 0.2.4 → 0.2.5

data/modules/mruby/include/mruby/khash.h

@@ -63,17 +63,16 @@ static const uint8_t __m_either[8] = {0x03, 0x0c, 0x30, 0xc0};
     khval_t *vals;                                                      \
     khint_t mask;                                                       \
     khint_t inc;                                                        \
-    mrb_state *mrb;                                                     \
   } kh_##name##_t;                                                      \
-  void kh_alloc_##name(kh_##name##_t *h);                               \
+  void kh_alloc_##name(mrb_state *mrb, kh_##name##_t *h);               \
   kh_##name##_t *kh_init_##name##_size(mrb_state *mrb, khint_t size);   \
   kh_##name##_t *kh_init_##name(mrb_state *mrb);                        \
-  void kh_destroy_##name(kh_##name##_t *h);                             \
-  void kh_clear_##name(kh_##name##_t *h);                               \
-  khint_t kh_get_##name(kh_##name##_t *h, khkey_t key);                 \
-  khint_t kh_put_##name(kh_##name##_t *h, khkey_t key);                 \
-  void kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets);       \
-  void kh_del_##name(kh_##name##_t *h, khint_t x);                      \
+  void kh_destroy_##name(mrb_state *mrb, kh_##name##_t *h);             \
+  void kh_clear_##name(mrb_state *mrb, kh_##name##_t *h);               \
+  khint_t kh_get_##name(mrb_state *mrb, kh_##name##_t *h, khkey_t key);           \
+  khint_t kh_put_##name(mrb_state *mrb, kh_##name##_t *h, khkey_t key);           \
+  void kh_resize_##name(mrb_state *mrb, kh_##name##_t *h, khint_t new_n_buckets); \
+  void kh_del_##name(mrb_state *mrb, kh_##name##_t *h, khint_t x);                \
   kh_##name##_t *kh_copy_##name(mrb_state *mrb, kh_##name##_t *h);
 
 static inline void
@@ -94,11 +93,11 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
    __hash_equal: hash comparation function
 */
 #define KHASH_DEFINE(name, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \
-  void kh_alloc_##name(kh_##name##_t *h)                                \
+  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);      \
-    uint8_t *p = mrb_malloc(h->mrb, sizeof(uint8_t)*sz/4+len*sz);       \
+    uint8_t *p = mrb_malloc(mrb, sizeof(uint8_t)*sz/4+len*sz);          \
     h->size = h->n_occupied = 0;                                        \
     h->upper_bound = UPPER_BOUND(sz);                                   \
     h->keys = (khkey_t *)p;                                             \
@@ -114,39 +113,38 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
       size = KHASH_MIN_SIZE;                                            \
     khash_power2(size);                                                 \
     h->n_buckets = size;                                                \
-    h->mrb = mrb;                                                       \
-    kh_alloc_##name(h);                                                 \
+    kh_alloc_##name(mrb, h);                                            \
     return h;                                                           \
   }                                                                     \
   kh_##name##_t *kh_init_##name(mrb_state *mrb){                        \
     return kh_init_##name##_size(mrb, KHASH_DEFAULT_SIZE);              \
   }                                                                     \
-  void kh_destroy_##name(kh_##name##_t *h)                              \
+  void kh_destroy_##name(mrb_state *mrb, kh_##name##_t *h)              \
   {                                                                     \
     if (h) {                                                            \
-      mrb_free(h->mrb, h->keys);                                        \
-      mrb_free(h->mrb, h);                                              \
+      mrb_free(mrb, h->keys);                                           \
+      mrb_free(mrb, h);                                                 \
     }                                                                   \
   }                                                                     \
-  void kh_clear_##name(kh_##name##_t *h)                                \
+  void kh_clear_##name(mrb_state *mrb, kh_##name##_t *h)                \
   {                                                                     \
     if (h && h->ed_flags) {                                             \
       kh_fill_flags(h->ed_flags, 0xaa, h->n_buckets/4);                 \
       h->size = h->n_occupied = 0;                                      \
     }                                                                   \
   }                                                                     \
-  khint_t kh_get_##name(kh_##name##_t *h, khkey_t key)                  \
+  khint_t kh_get_##name(mrb_state *mrb, kh_##name##_t *h, khkey_t key)  \
   {                                                                     \
-    khint_t k = __hash_func(h->mrb,key) & (h->mask);                    \
+    khint_t k = __hash_func(mrb,key) & (h->mask);                       \
     while (!__ac_isempty(h->ed_flags, k)) {                             \
       if (!__ac_isdel(h->ed_flags, k)) {                                \
-        if (__hash_equal(h->mrb,h->keys[k], key)) return k;             \
+        if (__hash_equal(mrb,h->keys[k], key)) return k;                \
       }                                                                 \
       k = (k+h->inc) & (h->mask);                                       \
     }                                                                   \
     return h->n_buckets;                                                \
   }                                                                     \
-  void kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets)        \
+  void kh_resize_##name(mrb_state *mrb, kh_##name##_t *h, khint_t new_n_buckets) \
   {                                                                     \
     if (new_n_buckets < KHASH_MIN_SIZE)                                 \
       new_n_buckets = KHASH_MIN_SIZE;                                   \
@@ -158,26 +156,26 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
       khint_t old_n_buckets = h->n_buckets;                             \
       khint_t i;                                                        \
       h->n_buckets = new_n_buckets;                                     \
-      kh_alloc_##name(h);                                               \
+      kh_alloc_##name(mrb, h);                                          \
       /* relocate */                                                    \
       for (i=0 ; i<old_n_buckets ; i++) {                               \
         if (!__ac_iseither(old_ed_flags, i)) {                          \
-          khint_t k = kh_put_##name(h, old_keys[i]);                    \
-          if (kh_is_map) kh_value(h,k) = old_vals[i];			\
+          khint_t k = kh_put_##name(mrb, h, old_keys[i]);               \
+          if (kh_is_map) kh_value(h,k) = old_vals[i];                   \
         }                                                               \
       }                                                                 \
-      mrb_free(h->mrb, old_keys);                                       \
+      mrb_free(mrb, old_keys);                                          \
     }                                                                   \
   }                                                                     \
-  khint_t kh_put_##name(kh_##name##_t *h, khkey_t key)                  \
+  khint_t kh_put_##name(mrb_state *mrb, kh_##name##_t *h, khkey_t key)  \
   {                                                                     \
     khint_t k;                                                          \
     if (h->n_occupied >= h->upper_bound) {                              \
-      kh_resize_##name(h, h->n_buckets*2);                              \
+      kh_resize_##name(mrb, h, h->n_buckets*2);                         \
     }                                                                   \
-    k = __hash_func(h->mrb,key) & (h->mask);                            \
+    k = __hash_func(mrb,key) & (h->mask);                               \
     while (!__ac_iseither(h->ed_flags, k)) {                            \
-      if (__hash_equal(h->mrb,h->keys[k], key)) break;                  \
+      if (__hash_equal(mrb,h->keys[k], key)) break;                     \
       k = (k+h->inc) & (h->mask);                                       \
     }                                                                   \
     if (__ac_isempty(h->ed_flags, k)) {                                 \
@@ -194,7 +192,7 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
     }                                                                   \
     return k;                                                           \
   }                                                                     \
-  void kh_del_##name(kh_##name##_t *h, khint_t x)                       \
+  void kh_del_##name(mrb_state *mrb, kh_##name##_t *h, khint_t x)       \
   {                                                                     \
     h->ed_flags[x/4] |= __m_del[x%4];                                   \
     h->size--;                                                          \
@@ -207,7 +205,7 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
     h2 = kh_init_##name(mrb);                                           \
     for (k = kh_begin(h); k != kh_end(h); k++) {                        \
       if (kh_exist(h, k)) {                                             \
-        k2 = kh_put_##name(h2, kh_key(h, k));                           \
+        k2 = kh_put_##name(mrb, h2, kh_key(h, k));                      \
         if(kh_is_map) kh_value(h2, k2) = kh_value(h, k);                \
       }                                                                 \
     }                                                                   \
@@ -219,12 +217,12 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
 
 #define kh_init_size(name,mrb,size) kh_init_##name##_size(mrb,size)
 #define kh_init(name,mrb) kh_init_##name(mrb)
-#define kh_destroy(name, h) kh_destroy_##name(h)
-#define kh_clear(name, h) kh_clear_##name(h)
-#define kh_resize(name, h, s) kh_resize_##name(h, s)
-#define kh_put(name, h, k) kh_put_##name(h, k)
-#define kh_get(name, h, k) kh_get_##name(h, k)
-#define kh_del(name, h, k) kh_del_##name(h, k)
+#define kh_destroy(name, mrb, h) kh_destroy_##name(mrb, h)
+#define kh_clear(name, mrb, h) kh_clear_##name(mrb, h)
+#define kh_resize(name, mrb, h, s) kh_resize_##name(mrb, h, s)
+#define kh_put(name, mrb, h, k) kh_put_##name(mrb, h, k)
+#define kh_get(name, mrb, h, k) kh_get_##name(mrb, h, k)
+#define kh_del(name, mrb, h, k) kh_del_##name(mrb, h, k)
 #define kh_copy(name, mrb, h) kh_copy_##name(mrb, h)
 
 #define kh_exist(h, x) (!__ac_iseither((h)->ed_flags, (x)))

data/modules/mruby/include/mruby/string.h

@@ -32,6 +32,9 @@ struct RString {
 #define RSTRING_CAPA(s)   (RSTRING(s)->aux.capa)
 #define RSTRING_END(s)    (RSTRING(s)->ptr + RSTRING(s)->len)
 
+#define MRB_STR_SHARED    1
+#define MRB_STR_NOFREE    2
+
 void mrb_gc_free_str(mrb_state*, struct RString*);
 void mrb_str_modify(mrb_state*, struct RString*);
 mrb_value mrb_str_literal(mrb_state*, mrb_value);

data/modules/mruby/include/mruby.h

@@ -188,7 +188,7 @@ struct RClass * mrb_class_get_under(mrb_state *mrb, struct RClass *outer, const
 
 mrb_value mrb_obj_dup(mrb_state *mrb, mrb_value obj);
 mrb_value mrb_check_to_integer(mrb_state *mrb, mrb_value val, const char *method);
-mrb_bool mrb_obj_respond_to(struct RClass* c, mrb_sym mid);
+mrb_bool mrb_obj_respond_to(mrb_state *mrb, struct RClass* c, mrb_sym mid);
 struct RClass * mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, struct RClass *super);
 struct RClass * mrb_define_module_under(mrb_state *mrb, struct RClass *outer, const char *name);
 
@@ -230,6 +230,8 @@ mrb_value mrb_funcall_argv(mrb_state*, mrb_value, mrb_sym, int, mrb_value*);
 mrb_value mrb_funcall_with_block(mrb_state*, mrb_value, mrb_sym, int, mrb_value*, mrb_value);
 mrb_sym mrb_intern_cstr(mrb_state*,const char*);
 mrb_sym mrb_intern(mrb_state*,const char*,size_t);
+mrb_sym mrb_intern_static(mrb_state*,const char*,size_t);
+#define mrb_intern_lit(mrb, lit) mrb_intern_static(mrb, (lit), sizeof(lit) - 1)
 mrb_sym mrb_intern_str(mrb_state*,mrb_value);
 mrb_value mrb_check_intern_cstr(mrb_state*,const char*);
 mrb_value mrb_check_intern(mrb_state*,const char*,size_t);
@@ -239,8 +241,6 @@ const char *mrb_sym2name_len(mrb_state*,mrb_sym,size_t*);
 mrb_value mrb_sym2str(mrb_state*,mrb_sym);
 mrb_value mrb_str_format(mrb_state *, int, const mrb_value *, mrb_value);
 
-#define mrb_intern_lit(mrb, lit) mrb_intern(mrb, (lit), sizeof(lit) - 1)
-
 void *mrb_malloc(mrb_state*, size_t);         /* raise RuntimeError if no mem */
 void *mrb_calloc(mrb_state*, size_t, size_t); /* ditto */
 void *mrb_realloc(mrb_state*, void*, size_t); /* ditto */

data/modules/mruby/mrblib/string.rb

@@ -137,6 +137,9 @@ class String
   ##
   # ISO 15.2.10.5.5
   def =~(re)
+    if re.respond_to? :to_str
+      raise TypeError, "type mismatch: String given"
+    end
     re =~ self
   end
 

data/modules/mruby/src/class.c

@@ -46,7 +46,7 @@ mrb_gc_mark_mt_size(mrb_state *mrb, struct RClass *c)
 void
 mrb_gc_free_mt(mrb_state *mrb, struct RClass *c)
 {
-  kh_destroy(mt, c->mt);
+  kh_destroy(mt, mrb, c->mt);
 }
 
 void
@@ -297,7 +297,7 @@ mrb_define_method_raw(mrb_state *mrb, struct RClass *c, mrb_sym mid, struct RPro
   khiter_t k;
 
   if (!h) h = c->mt = kh_init(mt, mrb);
-  k = kh_put(mt, h, mid);
+  k = kh_put(mt, mrb, h, mid);
   kh_value(h, k) = p;
   if (p) {
     mrb_field_write_barrier(mrb, (struct RBasic *)c, (struct RBasic *)p);
@@ -330,7 +330,7 @@ mrb_define_method_vm(mrb_state *mrb, struct RClass *c, mrb_sym name, mrb_value b
   struct RProc *p;
 
   if (!h) h = c->mt = kh_init(mt, mrb);
-  k = kh_put(mt, h, name);
+  k = kh_put(mt, mrb, h, name);
   p = mrb_proc_ptr(body);
   kh_value(h, k) = p;
   if (p) {
@@ -995,7 +995,7 @@ mrb_method_search_vm(mrb_state *mrb, struct RClass **cp, mrb_sym mid)
     khash_t(mt) *h = c->mt;
 
     if (h) {
-      k = kh_get(mt, h, mid);
+      k = kh_get(mt, mrb, h, mid);
       if (k != kh_end(h)) {
         m = kh_value(h, k);
         if (!m) break;
@@ -1180,7 +1180,7 @@ mrb_bob_missing(mrb_state *mrb, mrb_value mod)
 }
 
 mrb_bool
-mrb_obj_respond_to(struct RClass* c, mrb_sym mid)
+mrb_obj_respond_to(mrb_state *mrb, struct RClass* c, mrb_sym mid)
 {
   khiter_t k;
 
@@ -1188,7 +1188,7 @@ mrb_obj_respond_to(struct RClass* c, mrb_sym mid)
     khash_t(mt) *h = c->mt;
 
     if (h) {
-      k = kh_get(mt, h, mid);
+      k = kh_get(mt, mrb, h, mid);
       if (k != kh_end(h)) {
         if (kh_value(h, k)) {
           return TRUE;  /* method exists */
@@ -1206,7 +1206,7 @@ mrb_obj_respond_to(struct RClass* c, mrb_sym mid)
 mrb_bool
 mrb_respond_to(mrb_state *mrb, mrb_value obj, mrb_sym mid)
 {
-  return mrb_obj_respond_to(mrb_class(mrb, obj), mid);
+  return mrb_obj_respond_to(mrb, mrb_class(mrb, obj), mid);
 }
 
 mrb_value
@@ -1442,7 +1442,7 @@ undef_method(mrb_state *mrb, struct RClass *c, mrb_sym a)
 {
   mrb_value m;
 
-  if (!mrb_obj_respond_to(c, a)) {
+  if (!mrb_obj_respond_to(mrb, c, a)) {
     mrb_name_error(mrb, a, "undefined method '%S' for class '%S'", mrb_sym2str(mrb, a), mrb_obj_value(c));
   }
   else {
@@ -1713,7 +1713,7 @@ mrb_mod_method_defined(mrb_state *mrb, mrb_value mod)
 
   id = get_sym_or_str_arg(mrb);
   if (mrb_symbol_p(id)) {
-    method_defined_p = mrb_obj_respond_to(mrb_class_ptr(mod), mrb_symbol(id));
+    method_defined_p = mrb_obj_respond_to(mrb, mrb_class_ptr(mod), mrb_symbol(id));
   }
   else {
     mrb_value sym = mrb_check_intern_str(mrb, id);
@@ -1721,7 +1721,7 @@ mrb_mod_method_defined(mrb_state *mrb, mrb_value mod)
       method_defined_p = FALSE;
     }
     else {
-      method_defined_p = mrb_obj_respond_to(mrb_class_ptr(mod), mrb_symbol(sym));
+      method_defined_p = mrb_obj_respond_to(mrb, mrb_class_ptr(mod), mrb_symbol(sym));
     }
   }
   return mrb_bool_value(method_defined_p);
@@ -1735,9 +1735,9 @@ remove_method(mrb_state *mrb, mrb_value mod, mrb_sym mid)
   khiter_t k;
 
   if (h) {
-    k = kh_get(mt, h, mid);
+    k = kh_get(mt, mrb, h, mid);
     if (k != kh_end(h)) {
-      kh_del(mt, h, k);
+      kh_del(mt, mrb, h, k);
       return;
     }
   }

data/modules/mruby/src/codegen.c

@@ -657,23 +657,24 @@ lambda_body(codegen_scope *s, node *tree, int blk)
 }
 
 static int
-scope_body(codegen_scope *s, node *tree)
+scope_body(codegen_scope *s, node *tree, int val)
 {
   codegen_scope *scope = scope_new(s->mrb, s, tree->car);
 
-  codegen(scope, tree->cdr, VAL);
+  codegen(scope, tree->cdr, val);
   if (!s->iseq) {
     genop(scope, MKOP_A(OP_STOP, 0));
   }
+  else if (!val) {
+    genop(scope, MKOP_AB(OP_RETURN, 0, OP_R_NORMAL));
+  }
   else {
     if (scope->nregs == 0) {
       genop(scope, MKOP_A(OP_LOADNIL, 0));
       genop(scope, MKOP_AB(OP_RETURN, 0, OP_R_NORMAL));
     }
     else {
-      pop();
-      genop_peep(scope, MKOP_AB(OP_RETURN, cursp(), OP_R_NORMAL), NOVAL);
-      push();
+      genop_peep(scope, MKOP_AB(OP_RETURN, scope->sp-1, OP_R_NORMAL), NOVAL);
     }
   }
   scope_finish(scope);
@@ -1235,7 +1236,7 @@ codegen(codegen_scope *s, node *tree, int val)
       genop(s, MKOP_Bx(OP_EPUSH, 0));
       s->ensure_level++;
       codegen(s, tree->car, val);
-      idx = scope_body(s, tree->cdr);
+      idx = scope_body(s, tree->cdr, NOVAL);
       s->iseq[epush] = MKOP_Bx(OP_EPUSH, idx);
       s->ensure_level--;
       genop_peep(s, MKOP_A(OP_EPOP, 1), NOVAL);
@@ -1409,15 +1410,21 @@ codegen(codegen_scope *s, node *tree, int val)
         tree = tree->cdr;
       }
       if (val) {
+        int pos = cursp();
         genop(s, MKOP_A(OP_LOADNIL, cursp()));
+        if (pos3) dispatch_linked(s, pos3);
+        pop();
+        genop(s, MKOP_AB(OP_MOVE, cursp(), pos));
         push();
       }
-      if (pos3) dispatch_linked(s, pos3);
+      else if (pos3) {
+        dispatch_linked(s, pos3);
+      }
     }
     break;
 
   case NODE_SCOPE:
-    scope_body(s, tree);
+    scope_body(s, tree, NOVAL);
     break;
 
   case NODE_FCALL:
@@ -2277,7 +2284,7 @@ codegen(codegen_scope *s, node *tree, int val)
       pop(); pop();
       idx = new_msym(s, sym(tree->car->cdr));
       genop(s, MKOP_AB(OP_CLASS, cursp(), idx));
-      idx = scope_body(s, tree->cdr->cdr->car);
+      idx = scope_body(s, tree->cdr->cdr->car, val);
       genop(s, MKOP_ABx(OP_EXEC, cursp(), idx));
       if (val) {
         push();
@@ -2303,7 +2310,7 @@ codegen(codegen_scope *s, node *tree, int val)
       pop();
       idx = new_msym(s, sym(tree->car->cdr));
       genop(s, MKOP_AB(OP_MODULE, cursp(), idx));
-      idx = scope_body(s, tree->cdr->car);
+      idx = scope_body(s, tree->cdr->car, val);
       genop(s, MKOP_ABx(OP_EXEC, cursp(), idx));
       if (val) {
         push();
@@ -2318,7 +2325,7 @@ codegen(codegen_scope *s, node *tree, int val)
       codegen(s, tree->car, VAL);
       pop();
       genop(s, MKOP_AB(OP_SCLASS, cursp(), cursp()));
-      idx = scope_body(s, tree->cdr->car);
+      idx = scope_body(s, tree->cdr->car, val);
       genop(s, MKOP_ABx(OP_EXEC, cursp(), idx));
       if (val) {
         push();

data/modules/mruby/src/hash.c

@@ -73,7 +73,7 @@ mrb_gc_mark_hash_size(mrb_state *mrb, struct RHash *hash)
 void
 mrb_gc_free_hash(mrb_state *mrb, struct RHash *hash)
 {
-  if (hash->ht) kh_destroy(ht, hash->ht);
+  if (hash->ht) kh_destroy(ht, mrb, hash->ht);
 }
 
 
@@ -85,7 +85,7 @@ mrb_hash_new_capa(mrb_state *mrb, int capa)
   h = (struct RHash*)mrb_obj_alloc(mrb, MRB_TT_HASH, mrb->hash_class);
   h->ht = kh_init(ht, mrb);
   if (capa > 0) {
-    kh_resize(ht, h->ht, capa);
+    kh_resize(ht, mrb, h->ht, capa);
   }
   h->iv = 0;
   return mrb_obj_value(h);
@@ -104,7 +104,7 @@ mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key)
   khiter_t k;
 
   if (h) {
-    k = kh_get(ht, h, key);
+    k = kh_get(ht, mrb, h, key);
     if (k != kh_end(h))
       return kh_value(h, k);
   }
@@ -123,7 +123,7 @@ mrb_hash_fetch(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value def)
   khiter_t k;
 
   if (h) {
-    k = kh_get(ht, h, key);
+    k = kh_get(ht, mrb, h, key);
     if (k != kh_end(h))
       return kh_value(h, k);
   }
@@ -142,11 +142,11 @@ mrb_hash_set(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value val) /* mr
   h = RHASH_TBL(hash);
 
   if (!h) h = RHASH_TBL(hash) = kh_init(ht, mrb);
-  k = kh_get(ht, h, key);
+  k = kh_get(ht, mrb, h, key);
   if (k == kh_end(h)) {
     /* expand */
     int ai = mrb_gc_arena_save(mrb);
-    k = kh_put(ht, h, KEY(key));
+    k = kh_put(ht, mrb, h, KEY(key));
     mrb_gc_arena_restore(mrb, ai);
   }
 
@@ -172,7 +172,7 @@ mrb_hash_dup(mrb_state *mrb, mrb_value hash)
     for (k = kh_begin(h); k != kh_end(h); k++) {
       if (kh_exist(h,k)) {
         int ai = mrb_gc_arena_save(mrb);
-        ret_k = kh_put(ht, ret_h, KEY(kh_key(h,k)));
+        ret_k = kh_put(ht, mrb, ret_h, KEY(kh_key(h,k)));
         mrb_gc_arena_restore(mrb, ai);
         kh_val(ret_h, ret_k) = kh_val(h,k);
       }
@@ -490,10 +490,10 @@ mrb_hash_delete_key(mrb_state *mrb, mrb_value hash, mrb_value key)
   mrb_value delVal;
 
   if (h) {
-    k = kh_get(ht, h, key);
+    k = kh_get(ht, mrb, h, key);
     if (k != kh_end(h)) {
       delVal = kh_value(h, k);
-      kh_del(ht, h, k);
+      kh_del(ht, mrb, h, k);
       return delVal;
     }
   }
@@ -660,7 +660,7 @@ mrb_hash_clear(mrb_state *mrb, mrb_value hash)
 {
   khash_t(ht) *h = RHASH_TBL(hash);
 
-  if (h) kh_clear(ht, h);
+  if (h) kh_clear(ht, mrb, h);
   return hash;
 }
 
@@ -920,7 +920,7 @@ mrb_hash_has_keyWithKey(mrb_state *mrb, mrb_value hash, mrb_value key)
   khiter_t k;
 
   if (h) {
-    k = kh_get(ht, h, key);
+    k = kh_get(ht, mrb, h, key);
     return mrb_bool_value(k != kh_end(h));
   }
   return mrb_false_value();
@@ -1026,7 +1026,7 @@ hash_equal(mrb_state *mrb, mrb_value hash1, mrb_value hash2, int eql)
     for (k1 = kh_begin(h1); k1 != kh_end(h1); k1++) {
       if (!kh_exist(h1, k1)) continue;
       key = kh_key(h1,k1);
-      k2 = kh_get(ht, h2, key);
+      k2 = kh_get(ht, mrb, h2, key);
       if (k2 != kh_end(h2)) {
         if (mrb_equal(mrb, kh_value(h1,k1), kh_value(h2,k2))) {
           continue; /* next key */

data/modules/mruby/src/kernel.c

@@ -733,7 +733,7 @@ method_entry_loop(mrb_state *mrb, struct RClass* klass, khash_t(st)* set)
   if (!h) return;
   for (i=0;i<kh_end(h);i++) {
     if (kh_exist(h, i)) {
-      kh_put(st, set, kh_key(h,i));
+      kh_put(st, mrb, set, kh_key(h,i));
     }
   }
 }
@@ -765,7 +765,7 @@ class_instance_method_list(mrb_state *mrb, mrb_bool recur, struct RClass* klass,
       mrb_ary_push(mrb, ary, mrb_symbol_value(kh_key(set,i)));
     }
   }
-  kh_destroy(st, set);
+  kh_destroy(st, mrb, set);
 
   return ary;
 }
@@ -797,7 +797,7 @@ mrb_obj_singleton_methods(mrb_state *mrb, mrb_bool recur, mrb_value obj)
       mrb_ary_push(mrb, ary, mrb_symbol_value(kh_key(set,i)));
     }
   }
-  kh_destroy(st, set);
+  kh_destroy(st, mrb, set);
 
   return ary;
 }

data/modules/mruby/src/load.c

@@ -38,7 +38,7 @@ offset_crc_body(void)
 }
 
 static mrb_irep*
-read_irep_record_1(mrb_state *mrb, const uint8_t *bin, uint32_t *len)
+read_irep_record_1(mrb_state *mrb, const uint8_t *bin, uint32_t *len, mrb_bool alloc)
 {
   size_t i;
   const uint8_t *src = bin;
@@ -98,7 +98,12 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, uint32_t *len)
       tt = *src++; //pool TT
       pool_data_len = bin_to_uint16(src); //pool data length
       src += sizeof(uint16_t);
-      s = mrb_str_new(mrb, (char *)src, pool_data_len);
+      if (alloc) {
+        s = mrb_str_new(mrb, (char *)src, pool_data_len);
+      }
+      else {
+        s = mrb_str_new_static(mrb, (char *)src, pool_data_len);
+      }
       src += pool_data_len;
       switch (tt) { //pool data
       case IREP_TT_FIXNUM:
@@ -144,7 +149,12 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, uint32_t *len)
         continue;
       }
 
-      irep->syms[i] = mrb_intern(mrb, (char *)src, snl);
+      if (alloc) {
+        irep->syms[i] = mrb_intern(mrb, (char *)src, snl);
+      }
+      else {
+        irep->syms[i] = mrb_intern_static(mrb, (char *)src, snl);
+      }
       src += snl + 1;
 
       mrb_gc_arena_restore(mrb, ai);
@@ -158,16 +168,16 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, uint32_t *len)
 }
 
 static mrb_irep*
-read_irep_record(mrb_state *mrb, const uint8_t *bin, uint32_t *len)
+read_irep_record(mrb_state *mrb, const uint8_t *bin, uint32_t *len, mrb_bool alloc)
 {
-  mrb_irep *irep = read_irep_record_1(mrb, bin, len);
+  mrb_irep *irep = read_irep_record_1(mrb, bin, len, alloc);
   size_t i;
 
   bin += *len;
   for (i=0; i<irep->rlen; i++) {
     uint32_t rlen;
 
-    irep->reps[i] = read_irep_record(mrb, bin, &rlen);
+    irep->reps[i] = read_irep_record(mrb, bin, &rlen, alloc);
     bin += rlen;
     *len += rlen;
   }
@@ -175,12 +185,12 @@ read_irep_record(mrb_state *mrb, const uint8_t *bin, uint32_t *len)
 }
 
 static mrb_irep*
-read_section_irep(mrb_state *mrb, const uint8_t *bin)
+read_section_irep(mrb_state *mrb, const uint8_t *bin, mrb_bool alloc)
 {
   uint32_t len;
 
   bin += sizeof(struct rite_section_irep_header);
-  return read_irep_record(mrb, bin, &len);
+  return read_irep_record(mrb, bin, &len, alloc);
 }
 
 static int
@@ -344,7 +354,7 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, uint32_t
 }
 
 static int
-read_section_debug(mrb_state *mrb, const uint8_t *start, mrb_irep *irep)
+read_section_debug(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, mrb_bool alloc)
 {
   const uint8_t *bin;
   struct rite_section_debug_header *header;
@@ -364,7 +374,12 @@ read_section_debug(mrb_state *mrb, const uint8_t *start, mrb_irep *irep)
   for(i = 0; i < filenames_len; ++i) {
     uint16_t f_len = bin_to_uint16(bin);
     bin += sizeof(uint16_t);
-    filenames[i] = mrb_intern(mrb, (const char *)bin, f_len);
+    if (alloc) {
+      filenames[i] = mrb_intern(mrb, (const char *)bin, f_len);
+    }
+    else {
+      filenames[i] = mrb_intern_static(mrb, (const char *)bin, f_len);
+    }
     bin += f_len;
   }
 
@@ -430,7 +445,7 @@ mrb_read_irep(mrb_state *mrb, const uint8_t *bin)
   do {
     section_header = (const struct rite_section_header *)bin;
     if (memcmp(section_header->section_identify, RITE_SECTION_IREP_IDENTIFIER, sizeof(section_header->section_identify)) == 0) {
-      irep = read_section_irep(mrb, bin);
+      irep = read_section_irep(mrb, bin, FALSE);
       if (!irep) return NULL;
     }
     else if (memcmp(section_header->section_identify, RITE_SECTION_LINENO_IDENTIFIER, sizeof(section_header->section_identify)) == 0) {
@@ -442,7 +457,7 @@ mrb_read_irep(mrb_state *mrb, const uint8_t *bin)
     }
     else if (memcmp(section_header->section_identify, RITE_SECTION_DEBUG_IDENTIFIER, sizeof(section_header->section_identify)) == 0) {
       if (!irep) return NULL;   /* corrupted data */
-      result = read_section_debug(mrb, bin, irep);
+      result = read_section_debug(mrb, bin, irep, FALSE);
       if (result < MRB_DUMP_OK) {
         return NULL;
       }
@@ -561,7 +576,7 @@ read_irep_record_file(mrb_state *mrb, FILE *fp)
   if (fread(&buf[record_header_size], buf_size - record_header_size, 1, fp) == 0) {
     return NULL;
   }
-  irep = read_irep_record_1(mrb, buf, &len);
+  irep = read_irep_record_1(mrb, buf, &len, TRUE);
   mrb_free(mrb, ptr);
   if (!irep) return NULL;
   for (i=0; i<irep->rlen; i++) {
@@ -669,7 +684,7 @@ mrb_read_irep_file(mrb_state *mrb, FILE* fp)
           mrb_free(mrb, bin);
           return NULL;
         }
-        result = read_section_debug(mrb, bin, irep);
+        result = read_section_debug(mrb, bin, irep, TRUE);
         mrb_free(mrb, bin);
       }
       if (result < MRB_DUMP_OK) return NULL;

data/modules/mruby/src/numeric.c

@@ -193,7 +193,7 @@ mrb_flo_to_str(mrb_state *mrb, mrb_value flo, int max_digit)
       }
 
       if (exp >= 100) {
-        mrb_raise(mrb, E_RANGE_ERROR, "Too large expornent.");
+        mrb_raise(mrb, E_RANGE_ERROR, "Too large exponent.");
       }
 
       *(c++) = '0' + exp / 10;