webruby 0.2.7 → 0.9.1

data/modules/mruby/src/variable.c

@@ -46,11 +46,10 @@ iv_new(mrb_state *mrb)
   iv_tbl *t;
 
   t = mrb_malloc(mrb, sizeof(iv_tbl));
-  if (t) {
-    t->size = 0;
-    t->rootseg =  NULL;
-    t->last_len = 0;
-  }
+  t->size = 0;
+  t->rootseg =  NULL;
+  t->last_len = 0;
+
   return t;
 }
 
@@ -119,16 +118,16 @@ iv_put(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value val)
 }
 
 /*
- * Get a value for a symbol from the instance the variable table.
+ * Get a value for a symbol from the instance variable table.
  *
  * Parameters
  *   mrb
  *   t     the variable table to be searched.
  *   sym   the symbol to be used as the key.
- *   vp    the value pointer. Recieves the value if the specified symbol contains
- *         in the instance variable table.
+ *   vp    the value pointer. Receives the value if the specified symbol is
+ *         contained in the instance variable table.
  * Returns
- *   true if the specfiyed symbol contains in the instance variable table.
+ *   true if the specified symbol is contained in the instance variable table.
  */
 static mrb_bool
 iv_get(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value *vp)
@@ -160,10 +159,10 @@ iv_get(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value *vp)
  * Parameters
  *   t    the variable table to be searched.
  *   sym  the symbol to be used as the key.
- *   vp   the value pointer. Recieve the deleted value if the symbol contans
- *        in the instance varible table.
+ *   vp   the value pointer. Receive the deleted value if the symbol is
+ *        contained in the instance variable table.
  * Returns
- *   true if the specfied symbol contains in the instance variable table.
+ *   true if the specified symbol is contained in the instance variable table.
  */
 static mrb_bool
 iv_del(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value *vp)
@@ -290,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;
@@ -354,7 +353,7 @@ iv_foreach(mrb_state *mrb, iv_tbl *t, iv_foreach_func *func, void *p)
 
   if (h) {
     for (k = kh_begin(h); k != kh_end(h); k++) {
-      if (kh_exist(h, k)){
+      if (kh_exist(h, k)) {
         n = (*func)(mrb, kh_key(h, k), kh_value(h, k), p);
         if (n > 0) return FALSE;
         if (n < 0) {
@@ -369,10 +368,12 @@ iv_foreach(mrb_state *mrb, iv_tbl *t, iv_foreach_func *func, void *p)
 static size_t
 iv_size(mrb_state *mrb, iv_tbl *t)
 {
-  khash_t(iv) *h = &t->h;
+  khash_t(iv) *h;
 
-  if (!h) return 0;
-  return kh_size(h);
+  if (t && (h = &t->h)) {
+    return kh_size(h);
+  }
+  return 0;
 }
 
 static iv_tbl*
@@ -458,13 +459,14 @@ obj_iv_p(mrb_value obj)
     case MRB_TT_SCLASS:
     case MRB_TT_HASH:
     case MRB_TT_DATA:
+    case MRB_TT_EXCEPTION:
       return TRUE;
     default:
       return FALSE;
   }
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_obj_iv_get(mrb_state *mrb, struct RObject *obj, mrb_sym sym)
 {
   mrb_value v;
@@ -474,7 +476,7 @@ mrb_obj_iv_get(mrb_state *mrb, struct RObject *obj, mrb_sym sym)
   return mrb_nil_value();
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_iv_get(mrb_state *mrb, mrb_value obj, mrb_sym sym)
 {
   if (obj_iv_p(obj)) {
@@ -483,7 +485,7 @@ mrb_iv_get(mrb_state *mrb, mrb_value obj, mrb_sym sym)
   return mrb_nil_value();
 }
 
-void
+MRB_API void
 mrb_obj_iv_set(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
 {
   iv_tbl *t = obj->iv;
@@ -495,7 +497,7 @@ mrb_obj_iv_set(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
   iv_put(mrb, t, sym, v);
 }
 
-void
+MRB_API void
 mrb_obj_iv_ifnone(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
 {
   iv_tbl *t = obj->iv;
@@ -510,7 +512,7 @@ mrb_obj_iv_ifnone(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
   iv_put(mrb, t, sym, v);
 }
 
-void
+MRB_API void
 mrb_iv_set(mrb_state *mrb, mrb_value obj, mrb_sym sym, mrb_value v)
 {
   if (obj_iv_p(obj)) {
@@ -521,7 +523,7 @@ mrb_iv_set(mrb_state *mrb, mrb_value obj, mrb_sym sym, mrb_value v)
   }
 }
 
-mrb_bool
+MRB_API mrb_bool
 mrb_obj_iv_defined(mrb_state *mrb, struct RObject *obj, mrb_sym sym)
 {
   iv_tbl *t;
@@ -533,14 +535,40 @@ mrb_obj_iv_defined(mrb_state *mrb, struct RObject *obj, mrb_sym sym)
   return FALSE;
 }
 
-mrb_bool
+MRB_API mrb_bool
 mrb_iv_defined(mrb_state *mrb, mrb_value obj, mrb_sym sym)
 {
   if (!obj_iv_p(obj)) return FALSE;
   return mrb_obj_iv_defined(mrb, mrb_obj_ptr(obj), sym);
 }
 
-void
+#define identchar(c) (ISALNUM(c) || (c) == '_' || !ISASCII(c))
+
+MRB_API mrb_bool
+mrb_iv_p(mrb_state *mrb, mrb_sym iv_name)
+{
+  const char *s;
+  mrb_int i, len;
+
+  s = mrb_sym2name_len(mrb, iv_name, &len);
+  if (len < 2) return FALSE;
+  if (s[0] != '@') return FALSE;
+  if (s[1] == '@') return FALSE;
+  for (i=1; i<len; i++) {
+    if (!identchar(s[i])) return FALSE;
+  }
+  return TRUE;
+}
+
+MRB_API void
+mrb_iv_check(mrb_state *mrb, mrb_sym iv_name)
+{
+  if (!mrb_iv_p(mrb, iv_name)) {
+    mrb_name_error(mrb, iv_name, "`%S' is not allowed as an instance variable name", mrb_sym2str(mrb, iv_name));
+  }
+}
+
+MRB_API void
 mrb_iv_copy(mrb_state *mrb, mrb_value dest, mrb_value src)
 {
   struct RObject *d = mrb_obj_ptr(dest);
@@ -551,6 +579,7 @@ mrb_iv_copy(mrb_state *mrb, mrb_value dest, mrb_value src)
     d->iv = 0;
   }
   if (s->iv) {
+    mrb_write_barrier(mrb, (struct RBasic*)d);
     d->iv = iv_copy(mrb, s->iv);
   }
 }
@@ -560,20 +589,21 @@ 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_int len;
   mrb_value ins;
+  char *sp = RSTRING_PTR(str);
 
   /* need not to show internal data */
-  if (RSTRING_PTR(str)[0] == '-') { /* first element */
-    RSTRING_PTR(str)[0] = '#';
-    mrb_str_cat(mrb, str, " ", 1);
+  if (sp[0] == '-') { /* first element */
+    sp[0] = '#';
+    mrb_str_cat_lit(mrb, str, " ");
   }
   else {
-    mrb_str_cat(mrb, str, ", ", 2);
+    mrb_str_cat_lit(mrb, str, ", ");
   }
   s = mrb_sym2name_len(mrb, sym, &len);
   mrb_str_cat(mrb, str, s, len);
-  mrb_str_cat(mrb, str, "=", 1);
+  mrb_str_cat_lit(mrb, str, "=");
   if (mrb_type(v) == MRB_TT_OBJECT) {
     ins = mrb_any_to_s(mrb, v);
   }
@@ -594,19 +624,19 @@ mrb_obj_iv_inspect(mrb_state *mrb, struct RObject *obj)
     const char *cn = mrb_obj_classname(mrb, mrb_obj_value(obj));
     mrb_value str = mrb_str_buf_new(mrb, 30);
 
-    mrb_str_buf_cat(mrb, str, "-<", 2);
-    mrb_str_cat2(mrb, str, cn);
-    mrb_str_cat(mrb, str, ":", 1);
+    mrb_str_cat_lit(mrb, str, "-<");
+    mrb_str_cat_cstr(mrb, str, cn);
+    mrb_str_cat_lit(mrb, str, ":");
     mrb_str_concat(mrb, str, mrb_ptr_to_str(mrb, obj));
 
     iv_foreach(mrb, t, inspect_i, &str);
-    mrb_str_cat(mrb, str, ">", 1);
+    mrb_str_cat_lit(mrb, str, ">");
     return str;
   }
   return mrb_any_to_s(mrb, mrb_obj_value(obj));
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_iv_remove(mrb_state *mrb, mrb_value obj, mrb_sym sym)
 {
   if (obj_iv_p(obj)) {
@@ -639,7 +669,7 @@ iv_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p)
 {
   mrb_value ary;
   const char* s;
-  size_t len;
+  mrb_int len;
 
   ary = *(mrb_value*)p;
   s = mrb_sym2name_len(mrb, sym, &len);
@@ -683,7 +713,7 @@ cv_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p)
 {
   mrb_value ary;
   const char* s;
-  size_t len;
+  mrb_int len;
 
   ary = *(mrb_value*)p;
   s = mrb_sym2name_len(mrb, sym, &len);
@@ -726,7 +756,7 @@ mrb_mod_class_variables(mrb_state *mrb, mrb_value mod)
   return ary;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_mod_cv_get(mrb_state *mrb, struct RClass * c, mrb_sym sym)
 {
   struct RClass * cls = c;
@@ -747,13 +777,13 @@ mrb_mod_cv_get(mrb_state *mrb, struct RClass * c, mrb_sym sym)
   return mrb_nil_value();
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_cv_get(mrb_state *mrb, mrb_value mod, mrb_sym sym)
 {
   return mrb_mod_cv_get(mrb, mrb_class_ptr(mod), sym);
 }
 
-void
+MRB_API void
 mrb_mod_cv_set(mrb_state *mrb, struct RClass *c, mrb_sym sym, mrb_value v)
 {
   struct RClass * cls = c;
@@ -779,13 +809,13 @@ mrb_mod_cv_set(mrb_state *mrb, struct RClass *c, mrb_sym sym, mrb_value v)
   iv_put(mrb, cls->iv, sym, v);
 }
 
-void
+MRB_API void
 mrb_cv_set(mrb_state *mrb, mrb_value mod, mrb_sym sym, mrb_value v)
 {
   mrb_mod_cv_set(mrb, mrb_class_ptr(mod), sym, v);
 }
 
-mrb_bool
+MRB_API mrb_bool
 mrb_mod_cv_defined(mrb_state *mrb, struct RClass * c, mrb_sym sym)
 {
   while (c) {
@@ -799,7 +829,7 @@ mrb_mod_cv_defined(mrb_state *mrb, struct RClass * c, mrb_sym sym)
   return FALSE;
 }
 
-mrb_bool
+MRB_API mrb_bool
 mrb_cv_defined(mrb_state *mrb, mrb_value mod, mrb_sym sym)
 {
   return mrb_mod_cv_defined(mrb, mrb_class_ptr(mod), sym);
@@ -824,16 +854,6 @@ mrb_vm_cv_set(mrb_state *mrb, mrb_sym sym, mrb_value v)
   mrb_mod_cv_set(mrb, c, sym, v);
 }
 
-mrb_bool
-mrb_const_defined(mrb_state *mrb, mrb_value mod, mrb_sym sym)
-{
-  struct RClass *m = mrb_class_ptr(mod);
-  iv_tbl *t = m->iv;
-
-  if (!t) return FALSE;
-  return iv_get(mrb, t, sym, NULL);
-}
-
 static void
 mod_const_check(mrb_state *mrb, mrb_value mod)
 {
@@ -854,7 +874,7 @@ const_get(mrb_state *mrb, struct RClass *base, mrb_sym sym)
   struct RClass *c = base;
   mrb_value v;
   iv_tbl *t;
-  mrb_bool retry = 0;
+  mrb_bool retry = FALSE;
   mrb_value name;
 
 L_RETRY:
@@ -868,14 +888,14 @@ L_RETRY:
   }
   if (!retry && base && base->tt == MRB_TT_MODULE) {
     c = mrb->object_class;
-    retry = 1;
+    retry = TRUE;
     goto L_RETRY;
   }
   name = mrb_symbol_value(sym);
   return mrb_funcall_argv(mrb, mrb_obj_value(base), mrb_intern_lit(mrb, "const_missing"), 1, &name);
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_const_get(mrb_state *mrb, mrb_value mod, mrb_sym sym)
 {
   mod_const_check(mrb, mod);
@@ -907,14 +927,14 @@ mrb_vm_const_get(mrb_state *mrb, mrb_sym sym)
   return const_get(mrb, c, sym);
 }
 
-void
+MRB_API void
 mrb_const_set(mrb_state *mrb, mrb_value mod, mrb_sym sym, mrb_value v)
 {
   mod_const_check(mrb, mod);
   mrb_iv_set(mrb, mod, sym, v);
 }
 
- void
+void
 mrb_vm_const_set(mrb_state *mrb, mrb_sym sym, mrb_value v)
 {
   struct RClass *c = mrb->c->ci->proc->target_class;
@@ -923,20 +943,20 @@ mrb_vm_const_set(mrb_state *mrb, mrb_sym sym, mrb_value v)
   mrb_obj_iv_set(mrb, (struct RObject*)c, sym, v);
 }
 
-void
+MRB_API void
 mrb_const_remove(mrb_state *mrb, mrb_value mod, mrb_sym sym)
 {
   mod_const_check(mrb, mod);
   mrb_iv_remove(mrb, mod, sym);
 }
 
-void
+MRB_API void
 mrb_define_const(mrb_state *mrb, struct RClass *mod, const char *name, mrb_value v)
 {
   mrb_obj_iv_set(mrb, (struct RObject*)mod, mrb_intern_cstr(mrb, name), v);
 }
 
-void
+MRB_API void
 mrb_define_global_const(mrb_state *mrb, const char *name, mrb_value val)
 {
   mrb_define_const(mrb, mrb->object_class, name, val);
@@ -947,7 +967,7 @@ const_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p)
 {
   mrb_value ary;
   const char* s;
-  size_t len;
+  mrb_int len;
 
   ary = *(mrb_value*)p;
   s = mrb_sym2name_len(mrb, sym, &len);
@@ -968,20 +988,23 @@ mrb_value
 mrb_mod_constants(mrb_state *mrb, mrb_value mod)
 {
   mrb_value ary;
+  mrb_bool inherit = TRUE;
   struct RClass *c = mrb_class_ptr(mod);
 
+  mrb_get_args(mrb, "|b", &inherit);
   ary = mrb_ary_new(mrb);
   while (c) {
     if (c->iv) {
       iv_foreach(mrb, c->iv, const_i, &ary);
     }
+    if (!inherit) break;
     c = c->super;
     if (c == mrb->object_class) break;
   }
   return ary;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_gv_get(mrb_state *mrb, mrb_sym sym)
 {
   mrb_value v;
@@ -994,7 +1017,7 @@ mrb_gv_get(mrb_state *mrb, mrb_sym sym)
   return mrb_nil_value();
 }
 
-void
+MRB_API void
 mrb_gv_set(mrb_state *mrb, mrb_sym sym, mrb_value v)
 {
   iv_tbl *t;
@@ -1008,7 +1031,7 @@ mrb_gv_set(mrb_state *mrb, mrb_sym sym, mrb_value v)
   iv_put(mrb, t, sym, v);
 }
 
-void
+MRB_API void
 mrb_gv_remove(mrb_state *mrb, mrb_sym sym)
 {
   if (!mrb->globals) {
@@ -1052,15 +1075,16 @@ 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_intern_lit(mrb, buf)));
+    mrb_ary_push(mrb, ary, mrb_symbol_value(mrb_intern(mrb, buf, 2)));
   }
   return ary;
 }
 
 static mrb_bool
-mrb_const_defined_0(mrb_state *mrb, struct RClass *klass, mrb_sym id, mrb_bool exclude, mrb_bool recurse)
+mrb_const_defined_0(mrb_state *mrb, mrb_value mod, mrb_sym id, mrb_bool exclude, mrb_bool recurse)
 {
-  struct RClass * tmp;
+  struct RClass *klass = mrb_class_ptr(mod);
+  struct RClass *tmp;
   mrb_bool mod_retry = 0;
 
   tmp = klass;
@@ -1080,13 +1104,19 @@ retry:
   return FALSE;
 }
 
-int
-mrb_const_defined_at(mrb_state *mrb, struct RClass *klass, mrb_sym id)
+MRB_API mrb_bool
+mrb_const_defined(mrb_state *mrb, mrb_value mod, mrb_sym id)
 {
-  return mrb_const_defined_0(mrb, klass, id, TRUE, FALSE);
+  return mrb_const_defined_0(mrb, mod, id, TRUE, TRUE);
 }
 
-mrb_value
+MRB_API mrb_bool
+mrb_const_defined_at(mrb_state *mrb, mrb_value mod, mrb_sym id)
+{
+  return mrb_const_defined_0(mrb, mod, id, TRUE, FALSE);
+}
+
+MRB_API mrb_value
 mrb_attr_get(mrb_state *mrb, mrb_value obj, mrb_sym id)
 {
   return mrb_iv_get(mrb, obj, id);

data/modules/mruby/src/version.c

@@ -0,0 +1,13 @@
+#include "mruby.h"
+#include "mruby/variable.h"
+
+void
+mrb_init_version(mrb_state* mrb)
+{
+  mrb_define_global_const(mrb, "RUBY_VERSION", mrb_str_new_lit(mrb, MRUBY_RUBY_VERSION));
+  mrb_define_global_const(mrb, "RUBY_ENGINE", mrb_str_new_lit(mrb, MRUBY_RUBY_ENGINE));
+  mrb_define_global_const(mrb, "MRUBY_VERSION", mrb_str_new_lit(mrb, MRUBY_VERSION));
+  mrb_define_global_const(mrb, "MRUBY_RELEASE_DATE", mrb_str_new_lit(mrb, MRUBY_RELEASE_DATE));
+  mrb_define_global_const(mrb, "MRUBY_DESCRIPTION", mrb_str_new_lit(mrb, MRUBY_DESCRIPTION));
+  mrb_define_global_const(mrb, "MRUBY_COPYRIGHT", mrb_str_new_lit(mrb, MRUBY_COPYRIGHT));
+}