webruby 0.2.2 → 0.2.4

data/modules/mruby/src/state.c

@@ -11,6 +11,7 @@
 #include "mruby/irep.h"
 #include "mruby/variable.h"
 #include "mruby/debug.h"
+#include "mruby/string.h"
 
 void mrb_init_heap(mrb_state*);
 void mrb_init_core(mrb_state*);
@@ -41,6 +42,11 @@ mrb_open_allocf(mrb_allocf f, void *ud)
   mrb->allocf = f;
   mrb->current_white_part = MRB_GC_WHITE_A;
 
+#ifndef MRB_GC_FIXED_ARENA
+  mrb->arena = (struct RBasic**)mrb_malloc(mrb, sizeof(struct RBasic*)*MRB_GC_ARENA_SIZE);
+  mrb->arena_capa = MRB_GC_ARENA_SIZE;
+#endif
+
   mrb_init_heap(mrb);
   mrb->c = (struct mrb_context*)mrb_malloc(mrb, sizeof(struct mrb_context));
   *mrb->c = mrb_context_zero;
@@ -107,18 +113,72 @@ void mrb_free_symtbl(mrb_state *mrb);
 void mrb_free_heap(mrb_state *mrb);
 
 void
-mrb_irep_free(mrb_state *mrb, struct mrb_irep *irep)
+mrb_irep_incref(mrb_state *mrb, mrb_irep *irep)
 {
+  irep->refcnt++;
+}
+
+void
+mrb_irep_decref(mrb_state *mrb, mrb_irep *irep)
+{
+  irep->refcnt--;
+  if (irep->refcnt == 0) {
+    mrb_irep_free(mrb, irep);
+  }
+}
+
+void
+mrb_irep_free(mrb_state *mrb, mrb_irep *irep)
+{
+  size_t i;
+
   if (!(irep->flags & MRB_ISEQ_NO_FREE))
     mrb_free(mrb, irep->iseq);
+  for (i=0; i<irep->plen; i++) {
+    if (mrb_type(irep->pool[i]) == MRB_TT_STRING) {
+      mrb_free(mrb, mrb_str_ptr(irep->pool[i])->ptr);
+      mrb_free(mrb, mrb_obj_ptr(irep->pool[i]));
+    }
+#ifdef MRB_WORD_BOXING
+    else if (mrb_type(irep->pool[i]) == MRB_TT_FLOAT) {
+      mrb_free(mrb, mrb_obj_ptr(irep->pool[i]));
+    }
+#endif
+  }
   mrb_free(mrb, irep->pool);
   mrb_free(mrb, irep->syms);
+  for (i=0; i<irep->rlen; i++) {
+    mrb_irep_decref(mrb, irep->reps[i]);
+  }
+  mrb_free(mrb, irep->reps);
   mrb_free(mrb, (void *)irep->filename);
   mrb_free(mrb, irep->lines);
   mrb_debug_info_free(mrb, irep->debug_info);
   mrb_free(mrb, irep);
 }
 
+mrb_value
+mrb_str_pool(mrb_state *mrb, mrb_value str)
+{
+  struct RString *s = mrb_str_ptr(str);
+  struct RString *ns;
+  mrb_int len;
+
+  ns = (struct RString *)mrb_malloc(mrb, sizeof(struct RString));
+  ns->tt = MRB_TT_STRING;
+  ns->c = mrb->string_class;
+
+  len = s->len;
+  ns->len = len;
+  ns->ptr = (char *)mrb_malloc(mrb, (size_t)len+1);
+  if (s->ptr) {
+    memcpy(ns->ptr, s->ptr, len);
+  }
+  ns->ptr[len] = '\0';
+
+  return mrb_obj_value(ns);
+}
+
 void
 mrb_free_context(mrb_state *mrb, struct mrb_context *c)
 {
@@ -133,20 +193,17 @@ mrb_free_context(mrb_state *mrb, struct mrb_context *c)
 void
 mrb_close(mrb_state *mrb)
 {
-  size_t i;
-
   mrb_final_core(mrb);
 
   /* free */
   mrb_gc_free_gv(mrb);
-  for (i=0; i<mrb->irep_len; i++) {
-    mrb_irep_free(mrb, mrb->irep[i]);
-  }
-  mrb_free(mrb, mrb->irep);
   mrb_free_context(mrb, mrb->root_c);
   mrb_free_symtbl(mrb);
   mrb_free_heap(mrb);
   mrb_alloca_free(mrb);
+#ifndef MRB_GC_FIXED_ARENA
+  mrb_free(mrb, mrb->arena);
+#endif
   mrb_free(mrb, mrb);
 }
 
@@ -160,28 +217,9 @@ mrb_add_irep(mrb_state *mrb)
   static const mrb_irep mrb_irep_zero = { 0 };
   mrb_irep *irep;
 
-  if (!mrb->irep) {
-    size_t max = MRB_IREP_ARRAY_INIT_SIZE;
-
-    if (mrb->irep_len > max) max = mrb->irep_len+1;
-    mrb->irep = (mrb_irep **)mrb_calloc(mrb, max, sizeof(mrb_irep*));
-    mrb->irep_capa = max;
-  }
-  else if (mrb->irep_capa <= mrb->irep_len) {
-    size_t i;
-    size_t old_capa = mrb->irep_capa;
-    while (mrb->irep_capa <= mrb->irep_len) {
-      mrb->irep_capa *= 2;
-    }
-    mrb->irep = (mrb_irep **)mrb_realloc(mrb, mrb->irep, sizeof(mrb_irep*)*mrb->irep_capa);
-    for (i = old_capa; i < mrb->irep_capa; i++) {
-      mrb->irep[i] = NULL;
-    }
-  }
   irep = (mrb_irep *)mrb_malloc(mrb, sizeof(mrb_irep));
   *irep = mrb_irep_zero;
-  mrb->irep[mrb->irep_len] = irep;
-  irep->idx = mrb->irep_len++;
+  irep->refcnt = 1;
 
   return irep;
 }

data/modules/mruby/src/string.c

@@ -331,34 +331,6 @@ str_make_shared(mrb_state *mrb, struct RString *s)
   }
 }
 
-/*
- *  call-seq: (Caution! string literal)
- *     String.new(str="")   => new_str
- *
- *  Returns a new string object containing a copy of <i>str</i>.
- */
-
-mrb_value
-mrb_str_literal(mrb_state *mrb, mrb_value str)
-{
-  struct RString *s, *orig;
-  mrb_shared_string *shared;
-
-  s = mrb_obj_alloc_string(mrb);
-  orig = mrb_str_ptr(str);
-  if (!(orig->flags & MRB_STR_SHARED)) {
-    str_make_shared(mrb, orig);
-  }
-  shared = orig->aux.shared;
-  shared->refcnt++;
-  s->ptr = shared->ptr;
-  s->len = shared->len;
-  s->aux.shared = shared;
-  s->flags |= MRB_STR_SHARED;
-
-  return mrb_obj_value(s);
-}
-
 /*
  *  call-seq:
  *     char* str = String("abcd"), len=strlen("abcd")
@@ -574,10 +546,10 @@ mrb_str_cmp_m(mrb_state *mrb, mrb_value str1)
 
   mrb_get_args(mrb, "o", &str2);
   if (!mrb_string_p(str2)) {
-    if (!mrb_respond_to(mrb, str2, mrb_intern2(mrb, "to_s", 4))) {
+    if (!mrb_respond_to(mrb, str2, mrb_intern_lit(mrb, "to_s"))) {
       return mrb_nil_value();
     }
-    else if (!mrb_respond_to(mrb, str2, mrb_intern2(mrb, "<=>", 3))) {
+    else if (!mrb_respond_to(mrb, str2, mrb_intern_lit(mrb, "<=>"))) {
       return mrb_nil_value();
     }
     else {
@@ -613,7 +585,7 @@ mrb_str_equal(mrb_state *mrb, mrb_value str1, mrb_value str2)
   if (mrb_obj_equal(mrb, str1, str2)) return TRUE;
   if (!mrb_string_p(str2)) {
     if (mrb_nil_p(str2)) return FALSE;
-    if (!mrb_respond_to(mrb, str2, mrb_intern2(mrb, "to_str", 6))) {
+    if (!mrb_respond_to(mrb, str2, mrb_intern_lit(mrb, "to_str"))) {
       return FALSE;
     }
     str2 = mrb_funcall(mrb, str2, "to_str", 0);

data/modules/mruby/src/symbol.c

@@ -35,7 +35,7 @@ KHASH_DECLARE(n2s, symbol_name, mrb_sym, 1)
 KHASH_DEFINE (n2s, symbol_name, mrb_sym, 1, sym_hash_func, sym_hash_equal)
 /* ------------------------------------------------------ */
 mrb_sym
-mrb_intern2(mrb_state *mrb, const char *name, size_t len)
+mrb_intern(mrb_state *mrb, const char *name, size_t len)
 {
   khash_t(n2s) *h = mrb->name2sym;
   symbol_name sname;
@@ -63,13 +63,13 @@ mrb_intern2(mrb_state *mrb, const char *name, size_t len)
 mrb_sym
 mrb_intern_cstr(mrb_state *mrb, const char *name)
 {
-  return mrb_intern2(mrb, name, strlen(name));
+  return mrb_intern(mrb, name, strlen(name));
 }
 
 mrb_sym
 mrb_intern_str(mrb_state *mrb, mrb_value str)
 {
-  return mrb_intern2(mrb, RSTRING_PTR(str), RSTRING_LEN(str));
+  return mrb_intern(mrb, RSTRING_PTR(str), RSTRING_LEN(str));
 }
 
 mrb_value

data/modules/mruby/src/variable.c

@@ -563,6 +563,7 @@ inspect_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p)
   mrb_value str = *(mrb_value*)p;
   const char *s;
   size_t len;
+  mrb_value ins;
 
   /* need not to show internal data */
   if (RSTRING_PTR(str)[0] == '-') { /* first element */
@@ -575,7 +576,13 @@ inspect_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p)
   s = mrb_sym2name_len(mrb, sym, &len);
   mrb_str_cat(mrb, str, s, len);
   mrb_str_cat(mrb, str, "=", 1);
-  mrb_str_append(mrb, str, mrb_inspect(mrb, v));
+  if (mrb_type(v) == MRB_TT_OBJECT) {
+    ins = mrb_any_to_s(mrb, v);
+  }
+  else {
+    ins = mrb_inspect(mrb, v);
+  }
+  mrb_str_append(mrb, str, ins);
   return 0;
 }
 
@@ -884,7 +891,7 @@ L_RETRY:
     goto L_RETRY;
   }
   name = mrb_symbol_value(sym);
-  return mrb_funcall_argv(mrb, mrb_obj_value(base), mrb_intern2(mrb, "const_missing", 13), 1, &name);
+  return mrb_funcall_argv(mrb, mrb_obj_value(base), mrb_intern_lit(mrb, "const_missing"), 1, &name);
 }
 
 mrb_value
@@ -963,7 +970,7 @@ const_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p)
 
   ary = *(mrb_value*)p;
   s = mrb_sym2name_len(mrb, sym, &len);
-  if (len > 1 && ISUPPER(s[0])) {
+  if (len >= 1 && ISUPPER(s[0])) {
     mrb_ary_push(mrb, ary, mrb_symbol_value(sym));
   }
   return 0;
@@ -1064,7 +1071,7 @@ mrb_f_global_variables(mrb_state *mrb, mrb_value self)
   buf[2] = 0;
   for (i = 1; i <= 9; ++i) {
     buf[1] = (char)(i + '0');
-    mrb_ary_push(mrb, ary, mrb_symbol_value(mrb_intern2(mrb, buf, 2)));
+    mrb_ary_push(mrb, ary, mrb_symbol_value(mrb_intern_lit(mrb, buf)));
   }
   return ary;
 }
@@ -1127,7 +1134,7 @@ mrb_class_sym(mrb_state *mrb, struct RClass *c, struct RClass *outer)
 {
   mrb_value name;
 
-  name = mrb_obj_iv_get(mrb, (struct RObject*)c, mrb_intern2(mrb, "__classid__", 11));
+  name = mrb_obj_iv_get(mrb, (struct RObject*)c, mrb_intern_lit(mrb, "__classid__"));
   if (mrb_nil_p(name)) {
 
     if (!outer) return 0;