Merge branch 'master' of git://github.com/mruby/mruby into XCode

.travis.yml

@@ -0,0 +1,3 @@
+# no installation...
+
+script: "make all test"

include/mruby.h

@@ -294,6 +294,7 @@ void mrb_define_class_method(mrb_state *, struct RClass *, const char *, mrb_fun
 void mrb_define_singleton_method(mrb_state*, struct RObject*, const char*, mrb_func_t,int);
 void mrb_define_module_function(mrb_state*, struct RClass*, const char*, mrb_func_t,int);
 void mrb_define_const(mrb_state*, struct RClass*, const char *name, mrb_value);
+void mrb_undef_method(mrb_state*, struct RClass*, const char*);
 mrb_value mrb_instance_new(mrb_state *mrb, mrb_value cv);
 struct RClass * mrb_class_new(mrb_state *mrb, struct RClass *super);
 struct RClass * mrb_module_new(mrb_state *mrb);

include/mruby/string.h

@@ -24,9 +24,8 @@ extern "C" {
 #define mrb_str_new4 mrb_str_new_frozen
 
 #define STR_BUF_MIN_SIZE 128
-//#define RSTRING_EMBED_LEN_MAX STR_BUF_MIN_SIZE
 
-extern const char ruby_digitmap[];
+extern const char mrb_digitmap[];
 
 struct RString {
   MRUBY_OBJECT_HEADER;

src/class.c

@@ -398,10 +398,16 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
     sp = a->buf;
   }
   while ((c = *format++)) {
-    if (argc < i) {
-      if (opt) continue;
-      mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments");
+    switch (c) {
+    case '|': case '*': case '&':
+      break;
+    default:
+      if (argc <= i) {
+	if (opt) continue;
+	mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments");
+      }
     }
+
     switch (c) {
     case 'o':
       {
@@ -556,6 +562,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
     case '|':
       opt = 1;
       break;
+
     case '*':
       {
         mrb_value **var;
@@ -569,6 +576,8 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
 	    *var = sp;
             i = argc;
           }
+	  i = argc;
+	  sp += *pl;
         }
         else {
           *pl = 0;
@@ -582,7 +591,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
     mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments");
   }
   va_end(ap);
-  return 0;
+  return i;
 }
 
 static struct RClass*
@@ -1100,8 +1109,8 @@ mrb_mod_alias(mrb_state *mrb, mrb_value mod)
 }
 
 
-void
-mrb_undef_method(mrb_state *mrb, struct RClass *c, mrb_sym a)
+static void
+undef_method(mrb_state *mrb, struct RClass *c, mrb_sym a)
 {
   mrb_value m;
 
@@ -1110,6 +1119,12 @@ mrb_undef_method(mrb_state *mrb, struct RClass *c, mrb_sym a)
   mrb_define_method_vm(mrb, c, a, m);
 }
 
+void
+mrb_undef_method(mrb_state *mrb, struct RClass *c, const char *name)
+{
+  undef_method(mrb, c, mrb_intern(mrb, name));
+}
+
 mrb_value
 mrb_mod_undef(mrb_state *mrb, mrb_value mod)
 {
@@ -1119,7 +1134,7 @@ mrb_mod_undef(mrb_state *mrb, mrb_value mod)
 
   mrb_get_args(mrb, "*", &argv, &argc);
   while (argc--) {
-    mrb_undef_method(mrb, c, mrb_symbol(*argv));
+    undef_method(mrb, c, mrb_symbol(*argv));
     argv++;
   }
   return mrb_nil_value();
@@ -1170,7 +1185,7 @@ mrb_init_class(mrb_state *mrb)
   mrb_name_class(mrb, mod, mrb_intern(mrb, "Module"));
   mrb_name_class(mrb, cls, mrb_intern(mrb, "Class"));
 
-  mrb_undef_method(mrb, mod, mrb_intern(mrb, "new"));
+  mrb_undef_method(mrb, mod, "new");
   MRB_SET_INSTANCE_TT(cls, MRB_TT_CLASS);
   mrb_define_method(mrb, bob, "initialize", mrb_bob_init, ARGS_NONE());
   mrb_define_method(mrb, bob, "!", mrb_bob_not, ARGS_NONE());

src/error.c

@@ -56,9 +56,9 @@ exc_initialize(mrb_state *mrb, mrb_value exc)
 {
   mrb_value mesg;
 
-  mrb_get_args(mrb, "o", &mesg);
-  mrb_iv_set(mrb, exc, mrb_intern(mrb, "mesg"), mesg);
-
+  if (mrb_get_args(mrb, "|o", &mesg) == 1) {
+    mrb_iv_set(mrb, exc, mrb_intern(mrb, "mesg"), mesg);
+  }
   return exc;
 }
 

src/gc.c

@@ -247,6 +247,9 @@ mrb_obj_alloc(mrb_state *mrb, enum mrb_vtype ttype, struct RClass *cls)
 {
   struct RBasic *p;
 
+#ifdef MRB_GC_STRESS
+  mrb_garbage_collect(mrb);
+#endif
   if (mrb->gc_threshold < mrb->live) {
     mrb_incremental_gc(mrb);
   }
@@ -277,6 +280,11 @@ mrb_obj_alloc(mrb_state *mrb, enum mrb_vtype ttype, struct RClass *cls)
 static inline void
 add_gray_list(mrb_state *mrb, struct RBasic *obj)
 {
+#ifdef MRB_GC_STRESS
+  if (obj->tt > MRB_TT_MAXDEFINE) {
+    abort();
+  }
+#endif
   paint_gray(obj);
   obj->gcnext = mrb->gray_list;
   mrb->gray_list = obj;
@@ -499,14 +507,18 @@ root_scan_phase(mrb_state *mrb)
   /* mark closure */
   for (ci = mrb->cibase; ci <= mrb->ci; ci++) {
     if (!ci) continue;
-    mrb_gc_mark( mrb, (struct RBasic*)ci->env);
+    mrb_gc_mark(mrb, (struct RBasic*)ci->env);
+    mrb_gc_mark(mrb, (struct RBasic*)ci->proc);
+    mrb_gc_mark(mrb, (struct RBasic*)ci->target_class);
   }
   /* mark irep pool */
   for (i=0; i<mrb->irep_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]);
+    if (mrb->irep) {
+      mrb_irep *irep = mrb->irep[i];
+      if (!irep) continue;
+      for (j=0; j<irep->plen; j++) {
+	mrb_gc_mark_value(mrb, irep->pool[j]);
+      }
     }
   }
 }

src/hash.c

@@ -1037,14 +1037,12 @@ mrb_hash_values(mrb_state *mrb, mrb_value hash)
 {
   khash_t(ht) *h = RHASH_TBL(hash);
   khiter_t k;
-  mrb_value ary = mrb_ary_new(mrb);
+  mrb_value ary = mrb_ary_new_capa(mrb, kh_size(h));
 
   if (!h) return ary;
   for (k = kh_begin(h); k != kh_end(h); k++) {
     if (kh_exist(h, k)){
       mrb_value v = kh_value(h,k);
-      if ( !mrb_special_const_p(v) )
-        v = mrb_obj_dup(mrb, v);
       mrb_ary_push(mrb, ary, v);
     }
   }

src/load.c

@@ -531,14 +531,13 @@ mrb_read_irep(mrb_state *mrb, const char *bin)
     src += MRB_DUMP_SIZE_OF_LONG;                      //record ren
     if ((ret = read_rite_irep_record(mrb, src, mrb->irep[i], &len)) != MRB_DUMP_OK)
       goto error_exit;
-    mrb->irep[i]->idx = i;
+    mrb->irep[mrb->irep_len++]->idx = i;
     src += len;
   }
   if (0 != bin_to_uint32(src)) {              //dummy record len
     ret = MRB_DUMP_GENERAL_FAILURE;
   }
 
-  mrb->irep_len += nirep;
 error_exit:
   if (ret != MRB_DUMP_OK) {
     for (n=0,i=sirep; n<nirep; n++,i++) {

src/numeric.c

@@ -1140,7 +1140,7 @@ mrb_fix2str(mrb_state *mrb, mrb_value x, int base)
   }
   *--b = '\0';
   do {
-    *--b = ruby_digitmap[(int)(val % base)];
+    *--b = mrb_digitmap[(int)(val % base)];
   } while (val /= base);
   if (neg) {
     *--b = '-';
@@ -1266,6 +1266,7 @@ mrb_init_numeric(mrb_state *mrb)
   integer = mrb_define_class(mrb, "Integer",  numeric);
   fixnum = mrb->fixnum_class = mrb_define_class(mrb, "Fixnum", integer);
 
+  mrb_undef_method(mrb,  fixnum, "new");
   mrb_define_method(mrb, fixnum,  "+",        mrb_fixnum_plus,   ARGS_REQ(1)); /* 15.2.8.3.1  */
   mrb_define_method(mrb, fixnum,  "-",        mrb_fixnum_minus,  ARGS_REQ(1)); /* 15.2.8.3.2  */
   mrb_define_method(mrb, fixnum,  "-@",       fix_uminus,        ARGS_REQ(1)); /* 15.2.7.4.2  */
@@ -1293,6 +1294,7 @@ mrb_init_numeric(mrb_state *mrb)
 
   /* Float Class */
   fl = mrb->float_class = mrb_define_class(mrb, "Float", numeric);
+  mrb_undef_method(mrb,  fl, "new");
   mrb_define_method(mrb, fl,      "+",         mrb_float_plus,   ARGS_REQ(1)); /* 15.2.9.3.1  */
   mrb_define_method(mrb, fl,      "-",         flo_minus,        ARGS_REQ(1)); /* 15.2.9.3.2  */
   mrb_define_method(mrb, fl,      "*",         flo_mul,          ARGS_REQ(1)); /* 15.2.9.3.3  */

src/object.c

@@ -290,6 +290,7 @@ mrb_init_object(mrb_state *mrb)
   struct RClass *f;
 
   n = mrb->nil_class   = mrb_define_class(mrb, "NilClass",   mrb->object_class);
+  mrb_undef_method(mrb,  n, "new");
   mrb_define_method(mrb, n, "&",    false_and,      ARGS_REQ(1));  /* 15.2.4.3.1  */
   mrb_define_method(mrb, n, "^",    false_xor,      ARGS_REQ(1));  /* 15.2.4.3.2  */
   mrb_define_method(mrb, n, "|",    false_or,       ARGS_REQ(1));  /* 15.2.4.3.3  */
@@ -297,12 +298,14 @@ mrb_init_object(mrb_state *mrb)
   mrb_define_method(mrb, n, "to_s", nil_to_s,       ARGS_NONE());  /* 15.2.4.3.5  */
 
   t = mrb->true_class  = mrb_define_class(mrb, "TrueClass",  mrb->object_class);
+  mrb_undef_method(mrb,  n, "new");
   mrb_define_method(mrb, t, "&",    true_and,       ARGS_REQ(1));  /* 15.2.5.3.1  */
   mrb_define_method(mrb, t, "^",    true_xor,       ARGS_REQ(1));  /* 15.2.5.3.2  */
   mrb_define_method(mrb, t, "to_s", true_to_s,      ARGS_NONE());  /* 15.2.5.3.3  */
   mrb_define_method(mrb, t, "|",    true_or,        ARGS_REQ(1));  /* 15.2.5.3.4  */
 
   f = mrb->false_class = mrb_define_class(mrb, "FalseClass", mrb->object_class);
+  mrb_undef_method(mrb,  n, "new");
   mrb_define_method(mrb, f, "&",    false_and,      ARGS_REQ(1));  /* 15.2.6.3.1  */
   mrb_define_method(mrb, f, "^",    false_xor,      ARGS_REQ(1));  /* 15.2.6.3.2  */
   mrb_define_method(mrb, f, "to_s", false_to_s,     ARGS_NONE());  /* 15.2.6.3.3  */

src/sprintf.c

@@ -90,7 +90,7 @@ mrb_fix2binstr(mrb_state *mrb, mrb_value x, int base)
   }
   *--b = '\0';
   do {
-    *--b = ruby_digitmap[(int)(val % base)];
+    *--b = mrb_digitmap[(int)(val % base)];
   } while (val /= base);
 
   if (mrb_fixnum(x) < 0) {

src/string.c

@@ -33,7 +33,7 @@
 #define TRUE    1
 #endif
 
-const char ruby_digitmap[] = "0123456789abcdefghijklmnopqrstuvwxyz";
+const char mrb_digitmap[] = "0123456789abcdefghijklmnopqrstuvwxyz";
 
 #ifdef INCLUDE_REGEXP
 static mrb_value get_pat(mrb_state *mrb, mrb_value pat, mrb_int quote);

test/t/nil.rb

@@ -6,21 +6,21 @@ assert('NilClass', '15.2.4') do
 end
 
 assert('NilClass#&', '15.2.4.3.1') do
-  not NilClass.new.& and not NilClass.new.&(nil)
+  not nil.&(true) and not nil.&(nil)
 end
 
 assert('NilClass#^', '15.2.4.3.2') do
-  NilClass.new.^(true) and not NilClass.new.^(false)
+  nil.^(true) and not nil.^(false)
 end
 
 assert('NilClass#|', '15.2.4.3.3') do
-  NilClass.new.|(true) and not NilClass.new.|(false)
+  nil.|(true) and not nil.|(false)
 end
 
 assert('NilClass#nil?', '15.2.4.3.4') do
-  NilClass.new.nil?
+  nil.nil?
 end
 
 assert('NilClass#to_s', '15.2.4.3.5') do
-  NilClass.new.to_s == ''
+  nil.to_s == ''
 end