webruby 0.2.2 → 0.2.4

data/modules/mruby/src/error.c

@@ -25,7 +25,7 @@ mrb_exc_new(mrb_state *mrb, struct RClass *c, const char *ptr, long len)
 }
 
 mrb_value
-mrb_exc_new3(mrb_state *mrb, struct RClass* c, mrb_value str)
+mrb_exc_new_str(mrb_state *mrb, struct RClass* c, mrb_value str)
 {
   str = mrb_str_to_str(mrb, str);
   return mrb_funcall(mrb, mrb_obj_value(c), "new", 1, str);
@@ -45,7 +45,7 @@ exc_initialize(mrb_state *mrb, mrb_value exc)
   mrb_value mesg;
 
   if (mrb_get_args(mrb, "|o", &mesg) == 1) {
-    mrb_iv_set(mrb, exc, mrb_intern2(mrb, "mesg", 4), mesg);
+    mrb_iv_set(mrb, exc, mrb_intern_lit(mrb, "mesg"), mesg);
   }
   return exc;
 }
@@ -74,7 +74,7 @@ exc_exception(mrb_state *mrb, mrb_value self)
   if (argc == 0) return self;
   if (mrb_obj_equal(mrb, self, a)) return self;
   exc = mrb_obj_clone(mrb, self);
-  mrb_iv_set(mrb, exc, mrb_intern2(mrb, "mesg", 4), a);
+  mrb_iv_set(mrb, exc, mrb_intern_lit(mrb, "mesg"), a);
 
   return exc;
 }
@@ -90,7 +90,7 @@ exc_exception(mrb_state *mrb, mrb_value self)
 static mrb_value
 exc_to_s(mrb_state *mrb, mrb_value exc)
 {
-  mrb_value mesg = mrb_attr_get(mrb, exc, mrb_intern2(mrb, "mesg", 4));
+  mrb_value mesg = mrb_attr_get(mrb, exc, mrb_intern_lit(mrb, "mesg"));
 
   if (mrb_nil_p(mesg)) return mrb_str_new_cstr(mrb, mrb_obj_classname(mrb, exc));
   return mesg;
@@ -124,9 +124,9 @@ exc_inspect(mrb_state *mrb, mrb_value exc)
 {
   mrb_value str, mesg, file, line;
 
-  mesg = mrb_attr_get(mrb, exc, mrb_intern2(mrb, "mesg", 4));
-  file = mrb_attr_get(mrb, exc, mrb_intern2(mrb, "file", 4));
-  line = mrb_attr_get(mrb, exc, mrb_intern2(mrb, "line", 4));
+  mesg = mrb_attr_get(mrb, exc, mrb_intern_lit(mrb, "mesg"));
+  file = mrb_attr_get(mrb, exc, mrb_intern_lit(mrb, "file"));
+  line = mrb_attr_get(mrb, exc, mrb_intern_lit(mrb, "line"));
 
   if (!mrb_nil_p(file) && !mrb_nil_p(line)) {
     str = file;
@@ -163,7 +163,7 @@ exc_equal(mrb_state *mrb, mrb_value exc)
   mrb_value obj;
   mrb_value mesg;
   mrb_bool equal_p;
-  mrb_sym id_mesg = mrb_intern2(mrb, "mesg", 4);
+  mrb_sym id_mesg = mrb_intern_lit(mrb, "mesg");
 
   mrb_get_args(mrb, "o", &obj);
   if (mrb_obj_equal(mrb, exc, obj)) {
@@ -171,7 +171,7 @@ exc_equal(mrb_state *mrb, mrb_value exc)
   }
   else {
     if (mrb_obj_class(mrb, exc) != mrb_obj_class(mrb, obj)) {
-      if (mrb_respond_to(mrb, obj, mrb_intern2(mrb, "message", 7))) {
+      if (mrb_respond_to(mrb, obj, mrb_intern_lit(mrb, "message"))) {
         mesg = mrb_funcall(mrb, obj, "message", 0);
       }
       else
@@ -193,7 +193,7 @@ exc_debug_info(mrb_state *mrb, struct RObject *exc)
   mrb_callinfo *ci = mrb->c->ci;
   mrb_code *pc = ci->pc;
 
-  mrb_obj_iv_set(mrb, exc, mrb_intern2(mrb, "ciidx", 5), mrb_fixnum_value(ci - mrb->c->cibase));
+  mrb_obj_iv_set(mrb, exc, mrb_intern_lit(mrb, "ciidx"), mrb_fixnum_value(ci - mrb->c->cibase));
   while (ci >= mrb->c->cibase) {
     mrb_code *err = ci->err;
 
@@ -204,8 +204,8 @@ exc_debug_info(mrb_state *mrb, struct RObject *exc)
       int32_t const line = mrb_debug_get_line(irep, err - irep->iseq);
       char const* file = mrb_debug_get_filename(irep, err - irep->iseq);
       if (line != -1 && file) {
-        mrb_obj_iv_set(mrb, exc, mrb_intern2(mrb, "file", 4), mrb_str_new_cstr(mrb, file));
-        mrb_obj_iv_set(mrb, exc, mrb_intern2(mrb, "line", 4), mrb_fixnum_value(line));
+        mrb_obj_iv_set(mrb, exc, mrb_intern_lit(mrb, "file"), mrb_str_new_cstr(mrb, file));
+        mrb_obj_iv_set(mrb, exc, mrb_intern_lit(mrb, "line"), mrb_fixnum_value(line));
         return;
       }
     }
@@ -231,7 +231,7 @@ mrb_raise(mrb_state *mrb, struct RClass *c, const char *msg)
 {
   mrb_value mesg;
   mesg = mrb_str_new_cstr(mrb, msg);
-  mrb_exc_raise(mrb, mrb_exc_new3(mrb, c, mesg));
+  mrb_exc_raise(mrb, mrb_exc_new_str(mrb, c, mesg));
 }
 
 mrb_value
@@ -297,7 +297,7 @@ mrb_raisef(mrb_state *mrb, struct RClass *c, const char *fmt, ...)
   va_start(args, fmt);
   mesg = mrb_vformat(mrb, fmt, args);
   va_end(args);
-  mrb_exc_raise(mrb, mrb_exc_new3(mrb, c, mesg));
+  mrb_exc_raise(mrb, mrb_exc_new_str(mrb, c, mesg));
 }
 
 void
@@ -350,7 +350,7 @@ mrb_bug(mrb_state *mrb, const char *fmt, ...)
 int
 sysexit_status(mrb_state *mrb, mrb_value err)
 {
-  mrb_value st = mrb_iv_get(mrb, err, mrb_intern2(mrb, "status", 6));
+  mrb_value st = mrb_iv_get(mrb, err, mrb_intern_lit(mrb, "status"));
   return mrb_fixnum(st);
 }
 
@@ -376,7 +376,7 @@ make_exception(mrb_state *mrb, int argc, mrb_value *argv, int isstr)
       if (isstr) {
         mesg = mrb_check_string_type(mrb, argv[0]);
         if (!mrb_nil_p(mesg)) {
-          mesg = mrb_exc_new3(mrb, E_RUNTIME_ERROR, mesg);
+          mesg = mrb_exc_new_str(mrb, E_RUNTIME_ERROR, mesg);
           break;
         }
       }
@@ -388,7 +388,7 @@ make_exception(mrb_state *mrb, int argc, mrb_value *argv, int isstr)
       n = 1;
 exception_call:
       {
-        mrb_sym exc = mrb_intern2(mrb, "exception", 9);
+        mrb_sym exc = mrb_intern_lit(mrb, "exception");
         if (mrb_respond_to(mrb, argv[0], exc)) {
           mesg = mrb_funcall_argv(mrb, argv[0], exc, n, argv+1);
         }

data/modules/mruby/src/error.h

@@ -9,7 +9,7 @@
 
 void mrb_sys_fail(mrb_state *mrb, const char *mesg);
 int sysexit_status(mrb_state *mrb, mrb_value err);
-mrb_value mrb_exc_new3(mrb_state *mrb, struct RClass* c, mrb_value str);
+mrb_value mrb_exc_new_str(mrb_state *mrb, struct RClass* c, mrb_value str);
 mrb_value make_exception(mrb_state *mrb, int argc, mrb_value *argv, int isstr);
 mrb_value mrb_make_exception(mrb_state *mrb, int argc, mrb_value *argv);
 mrb_value mrb_format(mrb_state *mrb, const char *format, ...);

data/modules/mruby/src/etc.c

@@ -198,6 +198,16 @@ mrb_float_value(mrb_state *mrb, mrb_float f)
   return v;
 }
 
+mrb_value
+mrb_float_pool(mrb_state *mrb, mrb_float f)
+{
+  struct RFloat *nf = (struct RFloat *)mrb_malloc(mrb, sizeof(struct RFloat));
+  nf->tt = MRB_TT_FLOAT;
+  nf->c = mrb->float_class;
+  nf->f = f;
+  return mrb_obj_value(nf);
+}
+
 mrb_value
 mrb_cptr_value(mrb_state *mrb, void *p)
 {

data/modules/mruby/src/gc.c

@@ -370,10 +370,16 @@ mrb_free_heap(mrb_state *mrb)
 static void
 gc_protect(mrb_state *mrb, struct RBasic *p)
 {
-  if (mrb->arena_idx >= MRB_ARENA_SIZE) {
+  if (mrb->arena_idx >= MRB_GC_ARENA_SIZE) {
+#ifdef MRB_GC_FIXED_ARENA
     /* arena overflow error */
-    mrb->arena_idx = MRB_ARENA_SIZE - 4; /* force room in arena */
+    mrb->arena_idx = MRB_GC_ARENA_SIZE - 4; /* force room in arena */
     mrb_raise(mrb, E_RUNTIME_ERROR, "arena overflow error");
+#else
+    /* extend arena */
+    mrb->arena_capa *= 1.5;
+    mrb->arena = (struct RBasic**)mrb_realloc(mrb, mrb->arena, sizeof(struct RBasic*)*mrb->arena_capa);
+#endif
   }
   mrb->arena[mrb->arena_idx++] = p;
 }
@@ -619,7 +625,8 @@ obj_free(mrb_state *mrb, struct RBasic *obj)
     {
       struct mrb_context *c = ((struct RFiber*)obj)->cxt;
 
-      mrb_free_context(mrb, c);
+      if (c != mrb->root_c)
+        mrb_free_context(mrb, c);
     }
     break;
 
@@ -639,6 +646,16 @@ obj_free(mrb_state *mrb, struct RBasic *obj)
     mrb_gc_free_str(mrb, (struct RString*)obj);
     break;
 
+  case MRB_TT_PROC:
+    {
+      struct RProc *p = (struct RProc*)obj;
+
+      if (!MRB_PROC_CFUNC_P(p) && p->body.irep) {
+        mrb_irep_decref(mrb, p->body.irep);
+      }
+    }
+    break;
+
   case MRB_TT_RANGE:
     mrb_free(mrb, ((struct RRange*)obj)->edges);
     break;
@@ -662,7 +679,7 @@ obj_free(mrb_state *mrb, struct RBasic *obj)
 static void
 root_scan_phase(mrb_state *mrb)
 {
-  size_t i, e, j;
+  size_t i, e;
 
   if (!is_minor_gc(mrb)) {
     mrb->gray_list = NULL;
@@ -685,19 +702,6 @@ root_scan_phase(mrb_state *mrb)
   if (mrb->root_c != mrb->c) {
     mark_context(mrb, mrb->c);
   }
-
-  /* mark irep pool */
-  if (mrb->irep) {
-    size_t len = mrb->irep_len;
-    if (len > mrb->irep_capa) len = mrb->irep_capa;
-    for (i=0; i<len; i++) {
-      mrb_irep *irep = mrb->irep[i];
-      if (!irep) continue;
-      for (j=0; j<irep->plen; j++) {
-        mrb_gc_mark_value(mrb, irep->pool[j]);
-      }
-    }
-  }
 }
 
 static size_t
@@ -1043,6 +1047,20 @@ mrb_gc_arena_save(mrb_state *mrb)
 void
 mrb_gc_arena_restore(mrb_state *mrb, int idx)
 {
+#ifndef MRB_GC_FIXED_ARENA
+  int capa = mrb->arena_capa;
+
+  if (idx < capa / 2) {
+    capa *= 0.66;
+    if (capa < MRB_GC_ARENA_SIZE) {
+      capa = MRB_GC_ARENA_SIZE;
+    }
+    if (capa != mrb->arena_capa) {
+      mrb->arena = (struct RBasic**)mrb_realloc(mrb, mrb->arena, sizeof(struct RBasic*)*capa);
+      mrb->arena_capa = capa;
+    }
+  }
+#endif
   mrb->arena_idx = idx;
 }
 

data/modules/mruby/src/hash.c

@@ -266,7 +266,7 @@ mrb_hash_init_core(mrb_state *mrb, mrb_value hash)
     RHASH(hash)->flags |= MRB_HASH_PROC_DEFAULT;
     ifnone = block;
   }
-  mrb_iv_set(mrb, hash, mrb_intern2(mrb, "ifnone", 6), ifnone);
+  mrb_iv_set(mrb, hash, mrb_intern_lit(mrb, "ifnone"), ifnone);
   return hash;
 }
 
@@ -425,7 +425,7 @@ mrb_hash_set_default(mrb_state *mrb, mrb_value hash)
 
   mrb_get_args(mrb, "o", &ifnone);
   mrb_hash_modify(mrb, hash);
-  mrb_iv_set(mrb, hash, mrb_intern2(mrb, "ifnone", 6), ifnone);
+  mrb_iv_set(mrb, hash, mrb_intern_lit(mrb, "ifnone"), ifnone);
   RHASH(hash)->flags &= ~(MRB_HASH_PROC_DEFAULT);
 
   return ifnone;
@@ -476,7 +476,7 @@ mrb_hash_set_default_proc(mrb_state *mrb, mrb_value hash)
 
   mrb_get_args(mrb, "o", &ifnone);
   mrb_hash_modify(mrb, hash);
-  mrb_iv_set(mrb, hash, mrb_intern2(mrb, "ifnone", 6), ifnone);
+  mrb_iv_set(mrb, hash, mrb_intern_lit(mrb, "ifnone"), ifnone);
   RHASH(hash)->flags |= MRB_HASH_PROC_DEFAULT;
 
   return ifnone;
@@ -734,7 +734,7 @@ mrb_hash_replace(mrb_state *mrb, mrb_value hash)
   else {
     ifnone = RHASH_IFNONE(hash2);
   }
-  mrb_iv_set(mrb, hash, mrb_intern2(mrb, "ifnone", 6), ifnone);
+  mrb_iv_set(mrb, hash, mrb_intern_lit(mrb, "ifnone"), ifnone);
 
   return hash;
 }
@@ -1004,7 +1004,7 @@ hash_equal(mrb_state *mrb, mrb_value hash1, mrb_value hash2, int eql)
 
   if (mrb_obj_equal(mrb, hash1, hash2)) return mrb_true_value();
   if (!mrb_hash_p(hash2)) {
-      if (!mrb_respond_to(mrb, hash2, mrb_intern2(mrb, "to_hash", 7))) {
+      if (!mrb_respond_to(mrb, hash2, mrb_intern_lit(mrb, "to_hash"))) {
           return mrb_false_value();
       }
       if (eql)

data/modules/mruby/src/kernel.c

@@ -29,7 +29,7 @@ typedef enum {
 mrb_bool
 mrb_obj_basic_to_s_p(mrb_state *mrb, mrb_value obj)
 {
-    struct RProc *me = mrb_method_search(mrb, mrb_class(mrb, obj), mrb_intern2(mrb, "to_s", 4));
+    struct RProc *me = mrb_method_search(mrb, mrb_class(mrb, obj), mrb_intern_lit(mrb, "to_s"));
     if (me && MRB_PROC_CFUNC_P(me) && (me->body.func == mrb_any_to_s))
       return TRUE;
     return FALSE;
@@ -280,7 +280,7 @@ mrb_singleton_class_clone(mrb_state *mrb, mrb_value obj)
     clone->super = klass->super;
     if (klass->iv) {
       mrb_iv_copy(mrb, mrb_obj_value(clone), mrb_obj_value(klass));
-      mrb_obj_iv_set(mrb, (struct RObject*)clone, mrb_intern2(mrb, "__attached__", 12), obj);
+      mrb_obj_iv_set(mrb, (struct RObject*)clone, mrb_intern_lit(mrb, "__attached__"), obj);
     }
     if (klass->mt) {
       clone->mt = kh_copy(mt, mrb, klass->mt);
@@ -542,7 +542,7 @@ obj_is_instance_of(mrb_state *mrb, mrb_value self)
   mrb_value arg;
   mrb_bool instance_of_p;
 
-  mrb_get_args(mrb, "o", &arg);
+  mrb_get_args(mrb, "C", &arg);
   instance_of_p = mrb_obj_is_instance_of(mrb, self, mrb_class_ptr(arg));
 
   return mrb_bool_value(instance_of_p);
@@ -715,14 +715,17 @@ mrb_obj_is_kind_of_m(mrb_state *mrb, mrb_value self)
   mrb_value arg;
   mrb_bool kind_of_p;
 
-  mrb_get_args(mrb, "o", &arg);
+  mrb_get_args(mrb, "C", &arg);
   kind_of_p = mrb_obj_is_kind_of(mrb, self, mrb_class_ptr(arg));
 
   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)
+
 static void
-method_entry_loop(mrb_state *mrb, struct RClass* klass, mrb_value ary)
+method_entry_loop(mrb_state *mrb, struct RClass* klass, khash_t(st)* set)
 {
   khint_t i;
 
@@ -730,7 +733,7 @@ method_entry_loop(mrb_state *mrb, struct RClass* klass, mrb_value ary)
   if (!h) return;
   for (i=0;i<kh_end(h);i++) {
     if (kh_exist(h, i)) {
-      mrb_ary_push(mrb, ary, mrb_symbol_value(kh_key(h,i)));
+      kh_put(st, set, kh_key(h,i));
     }
   }
 }
@@ -738,13 +741,14 @@ method_entry_loop(mrb_state *mrb, struct RClass* klass, mrb_value ary)
 mrb_value
 class_instance_method_list(mrb_state *mrb, mrb_bool recur, struct RClass* klass, int obj)
 {
+  khint_t i;
   mrb_value ary;
   struct RClass* oldklass;
+  khash_t(st)* set = kh_init(st, mrb);
 
-  ary = mrb_ary_new(mrb);
   oldklass = 0;
   while (klass && (klass != oldklass)) {
-    method_entry_loop(mrb, klass, ary);
+    method_entry_loop(mrb, klass, set);
     if ((klass->tt == MRB_TT_ICLASS) ||
         (klass->tt == MRB_TT_SCLASS)) {
     }
@@ -755,28 +759,46 @@ class_instance_method_list(mrb_state *mrb, mrb_bool recur, struct RClass* klass,
     klass = klass->super;
   }
 
+  ary = mrb_ary_new(mrb);
+  for (i=0;i<kh_end(set);i++) {
+    if (kh_exist(set, i)) {
+      mrb_ary_push(mrb, ary, mrb_symbol_value(kh_key(set,i)));
+    }
+  }
+  kh_destroy(st, set);
+
   return ary;
 }
 
 mrb_value
 mrb_obj_singleton_methods(mrb_state *mrb, mrb_bool recur, mrb_value obj)
 {
+  khint_t i;
   mrb_value ary;
   struct RClass* klass;
+  khash_t(st)* set = kh_init(st, mrb);
 
   klass = mrb_class(mrb, obj);
-  ary = mrb_ary_new(mrb);
+
   if (klass && (klass->tt == MRB_TT_SCLASS)) {
-      method_entry_loop(mrb, klass, ary);
+      method_entry_loop(mrb, klass, set);
       klass = klass->super;
   }
   if (recur) {
       while (klass && ((klass->tt == MRB_TT_SCLASS) || (klass->tt == MRB_TT_ICLASS))) {
-        method_entry_loop(mrb, klass, ary);
+        method_entry_loop(mrb, klass, set);
         klass = klass->super;
       }
   }
 
+  ary = mrb_ary_new(mrb);
+  for (i=0;i<kh_end(set);i++) {
+    if (kh_exist(set, i)) {
+      mrb_ary_push(mrb, ary, mrb_symbol_value(kh_key(set,i)));
+    }
+  }
+  kh_destroy(st, set);
+
   return ary;
 }
 
@@ -922,7 +944,7 @@ mrb_f_raise(mrb_state *mrb, mrb_value self)
     /* fall through */
   default:
     exc = mrb_make_exception(mrb, argc, a);
-    mrb_obj_iv_set(mrb, mrb_obj_ptr(exc), mrb_intern2(mrb, "lastpc", 6), mrb_cptr_value(mrb, mrb->c->ci->pc));
+    mrb_obj_iv_set(mrb, mrb_obj_ptr(exc), mrb_intern_lit(mrb, "lastpc"), mrb_cptr_value(mrb, mrb->c->ci->pc));
     mrb_exc_raise(mrb, exc);
     break;
   }
@@ -1027,7 +1049,7 @@ obj_respond_to(mrb_state *mrb, mrb_value self)
   }
 
   if (!respond_to_p) {
-    rtm_id = mrb_intern2(mrb, "respond_to_missing?", 19);
+    rtm_id = mrb_intern_lit(mrb, "respond_to_missing?");
     if (basic_obj_respond_to(mrb, self, rtm_id, !mrb_test(priv))) {
       return mrb_funcall_argv(mrb, self, rtm_id, argc, argv);
     }
@@ -1129,5 +1151,5 @@ mrb_init_kernel(mrb_state *mrb)
   mrb_define_method(mrb, krn, "to_s",                       mrb_any_to_s,                    MRB_ARGS_NONE());    /* 15.3.1.3.46 */
 
   mrb_include_module(mrb, mrb->object_class, mrb->kernel_module);
-  mrb_alias_method(mrb, mrb->module_class, mrb_intern2(mrb, "dup", 3), mrb_intern2(mrb, "clone", 5));
+  mrb_alias_method(mrb, mrb->module_class, mrb_intern_lit(mrb, "dup"), mrb_intern_lit(mrb, "clone"));
 }