webruby 0.2.2 → 0.2.4

data/modules/mruby/mrbgems/mruby-random/src/random.c

@@ -6,7 +6,9 @@
 
 #include "mruby.h"
 #include "mruby/variable.h"
+#include "mruby/class.h"
 #include "mruby/data.h"
+#include "mruby/array.h"
 #include "mt19937ar.h"
 
 #include <time.h>
@@ -18,23 +20,11 @@
 #define INSTANCE_RAND_SEED_KEY_CSTR_LEN 16
 
 #define MT_STATE_KEY          "$mrb_i_mt_state"
-#define MT_STATE_KEY_CSTR_LEN 15
 
 static const struct mrb_data_type mt_state_type = {
   MT_STATE_KEY, mrb_free,
 };
 
-static mt_state *mrb_mt_get_context(mrb_state *mrb,  mrb_value self)
-{
-  mt_state *t;
-  mrb_value context;
-
-  context = mrb_iv_get(mrb, self, mrb_intern2(mrb, MT_STATE_KEY, MT_STATE_KEY_CSTR_LEN));
-  t = DATA_GET_PTR(mrb, context, &mt_state_type, mt_state);
-
-  return t;
-}
-
 static void mt_g_srand(unsigned long seed)
 {
   init_genrand(seed);
@@ -50,7 +40,8 @@ static double mt_g_rand_real()
   return genrand_real1();
 }
 
-static mrb_value mrb_random_mt_g_srand(mrb_state *mrb, mrb_value seed)
+static mrb_value 
+mrb_random_mt_g_srand(mrb_state *mrb, mrb_value seed)
 {
   if (mrb_nil_p(seed)) {
     seed = mrb_fixnum_value(time(NULL) + mt_g_rand());
@@ -64,35 +55,41 @@ static mrb_value mrb_random_mt_g_srand(mrb_state *mrb, mrb_value seed)
   return seed;
 }
 
-static mrb_value mrb_random_mt_g_rand(mrb_state *mrb, mrb_value max)
+static mrb_value 
+mrb_random_mt_g_rand(mrb_state *mrb, mrb_value max)
 {
   mrb_value value;
 
   if (mrb_fixnum(max) == 0) {
     value = mrb_float_value(mrb, mt_g_rand_real());
-  } else {
+  }
+  else {
     value = mrb_fixnum_value(mt_g_rand() % mrb_fixnum(max));
   }
 
   return value;
 }
  
-static void mt_srand(mt_state *t, unsigned long seed)
+static void 
+mt_srand(mt_state *t, unsigned long seed)
 {
   mrb_random_init_genrand(t, seed);
 }  
 
-static unsigned long mt_rand(mt_state *t)
+static unsigned long 
+mt_rand(mt_state *t)
 {
   return mrb_random_genrand_int32(t);
 }  
 
-static double mt_rand_real(mt_state *t)
+static double 
+mt_rand_real(mt_state *t)
 {
   return mrb_random_genrand_real1(t);
 }  
 
-static mrb_value mrb_random_mt_srand(mrb_state *mrb, mt_state *t, mrb_value seed)
+static mrb_value 
+mrb_random_mt_srand(mrb_state *mrb, mt_state *t, mrb_value seed)
 { 
   if (mrb_nil_p(seed)) {
     seed = mrb_fixnum_value(time(NULL) + mt_rand(t));
@@ -106,20 +103,23 @@ static mrb_value mrb_random_mt_srand(mrb_state *mrb, mt_state *t, mrb_value seed
   return seed;
 }
 
-static mrb_value mrb_random_mt_rand(mrb_state *mrb, mt_state *t, mrb_value max)
+static mrb_value 
+mrb_random_mt_rand(mrb_state *mrb, mt_state *t, mrb_value max)
 { 
   mrb_value value;
 
   if (mrb_fixnum(max) == 0) {
     value = mrb_float_value(mrb, mt_rand_real(t));
-  } else {
+  }
+  else {
     value = mrb_fixnum_value(mt_rand(t) % mrb_fixnum(max));
   }
 
   return value;
 }
 
-static mrb_value get_opt(mrb_state* mrb)
+static mrb_value 
+get_opt(mrb_state* mrb)
 {
   mrb_value arg;
 
@@ -138,89 +138,186 @@ static mrb_value get_opt(mrb_state* mrb)
   return arg;
 }
 
-static mrb_value mrb_random_g_rand(mrb_state *mrb, mrb_value self)
+static void 
+mrb_random_g_rand_seed(mrb_state *mrb) 
 {
-  mrb_value max;
   mrb_value seed;
-
-  max = get_opt(mrb);
-  seed = mrb_gv_get(mrb, mrb_intern2(mrb, GLOBAL_RAND_SEED_KEY, GLOBAL_RAND_SEED_KEY_CSTR_LEN));
+  
+  seed = mrb_gv_get(mrb, mrb_intern(mrb, GLOBAL_RAND_SEED_KEY, GLOBAL_RAND_SEED_KEY_CSTR_LEN));
   if (mrb_nil_p(seed)) {
     mrb_random_mt_g_srand(mrb, mrb_nil_value());
   }
+}
+
+static mrb_value 
+mrb_random_g_rand(mrb_state *mrb, mrb_value self)
+{
+  mrb_value max;
+
+  max = get_opt(mrb);
+  mrb_random_g_rand_seed(mrb);
   return mrb_random_mt_g_rand(mrb, max);
 }
 
-static mrb_value mrb_random_g_srand(mrb_state *mrb, mrb_value self)
+static mrb_value 
+mrb_random_g_srand(mrb_state *mrb, mrb_value self)
 {
   mrb_value seed;
   mrb_value old_seed;
 
   seed = get_opt(mrb);
   seed = mrb_random_mt_g_srand(mrb, seed);
-  old_seed = mrb_gv_get(mrb, mrb_intern2(mrb, GLOBAL_RAND_SEED_KEY, GLOBAL_RAND_SEED_KEY_CSTR_LEN));
-  mrb_gv_set(mrb, mrb_intern2(mrb, GLOBAL_RAND_SEED_KEY, GLOBAL_RAND_SEED_KEY_CSTR_LEN), seed);
+  old_seed = mrb_gv_get(mrb, mrb_intern(mrb, GLOBAL_RAND_SEED_KEY, GLOBAL_RAND_SEED_KEY_CSTR_LEN));
+  mrb_gv_set(mrb, mrb_intern(mrb, GLOBAL_RAND_SEED_KEY, GLOBAL_RAND_SEED_KEY_CSTR_LEN), seed);
   return old_seed;
 }
 
-static mrb_value mrb_random_init(mrb_state *mrb, mrb_value self)
+static mrb_value 
+mrb_random_init(mrb_state *mrb, mrb_value self)
 {
   mrb_value seed;
-
-
-  mt_state *t = (mt_state *)mrb_malloc(mrb, sizeof(mt_state));
+  mt_state *t;
+  
+  DATA_TYPE(self) = &mt_state_type;
+  DATA_PTR(self) = NULL;
+  
+  /* avoid memory leaks */
+  t = (mt_state*)DATA_PTR(self);
+  if (t) {
+    mrb_free(mrb, t);
+  }  
+
+  t = (mt_state *)mrb_malloc(mrb, sizeof(mt_state));
   t->mti = N + 1;
 
   seed = get_opt(mrb);
   seed = mrb_random_mt_srand(mrb, t, seed);
-  mrb_iv_set(mrb, self, mrb_intern2(mrb, INSTANCE_RAND_SEED_KEY, INSTANCE_RAND_SEED_KEY_CSTR_LEN), seed);
-  mrb_iv_set(mrb, self, mrb_intern2(mrb, MT_STATE_KEY, MT_STATE_KEY_CSTR_LEN),
-    mrb_obj_value(Data_Wrap_Struct(mrb, mrb->object_class, &mt_state_type, (void*) t)));
+  mrb_iv_set(mrb, self, mrb_intern(mrb, INSTANCE_RAND_SEED_KEY, INSTANCE_RAND_SEED_KEY_CSTR_LEN), seed);
+  
+  DATA_PTR(self) = t;
+  
   return self;
 }
 
-static mrb_value mrb_random_rand(mrb_state *mrb, mrb_value self)
+static void 
+mrb_random_rand_seed(mrb_state *mrb, mrb_value self)
 {
-  mrb_value max;
   mrb_value seed;
-  mt_state *t = mrb_mt_get_context(mrb, self);
-
-  max = get_opt(mrb);
-  seed = mrb_iv_get(mrb, self, mrb_intern2(mrb, INSTANCE_RAND_SEED_KEY, INSTANCE_RAND_SEED_KEY_CSTR_LEN));
+  mt_state *t = DATA_PTR(self);
+  
+  seed = mrb_iv_get(mrb, self, mrb_intern(mrb, INSTANCE_RAND_SEED_KEY, INSTANCE_RAND_SEED_KEY_CSTR_LEN));
   if (mrb_nil_p(seed)) {
     mrb_random_mt_srand(mrb, t, mrb_nil_value());
   }
+}
+
+static mrb_value 
+mrb_random_rand(mrb_state *mrb, mrb_value self)
+{
+  mrb_value max;
+  mt_state *t = DATA_PTR(self);
+
+  max = get_opt(mrb);
+  mrb_random_rand_seed(mrb, self);
   return mrb_random_mt_rand(mrb, t, max);
 }
 
-static mrb_value mrb_random_srand(mrb_state *mrb, mrb_value self)
+static mrb_value 
+mrb_random_srand(mrb_state *mrb, mrb_value self)
 {
   mrb_value seed;
   mrb_value old_seed;
-  mt_state *t = mrb_mt_get_context(mrb, self);
+  mt_state *t = DATA_PTR(self);
 
   seed = get_opt(mrb);
   seed = mrb_random_mt_srand(mrb, t, seed);
-  old_seed = mrb_iv_get(mrb, self, mrb_intern2(mrb, INSTANCE_RAND_SEED_KEY, INSTANCE_RAND_SEED_KEY_CSTR_LEN));
-  mrb_iv_set(mrb, self, mrb_intern2(mrb, INSTANCE_RAND_SEED_KEY, INSTANCE_RAND_SEED_KEY_CSTR_LEN), seed);
+  old_seed = mrb_iv_get(mrb, self, mrb_intern(mrb, INSTANCE_RAND_SEED_KEY, INSTANCE_RAND_SEED_KEY_CSTR_LEN));
+  mrb_iv_set(mrb, self, mrb_intern(mrb, INSTANCE_RAND_SEED_KEY, INSTANCE_RAND_SEED_KEY_CSTR_LEN), seed);
 
   return old_seed;
 }
 
+/*
+ *  call-seq:
+ *     ary.shuffle!   ->   ary
+ *
+ *  Shuffles elements in self in place.
+ */
+
+static mrb_value
+mrb_ary_shuffle_bang(mrb_state *mrb, mrb_value ary)
+{
+  mrb_int i;
+  mrb_value random = mrb_nil_value();
+  
+  if (RARRAY_LEN(ary) > 1) {
+    mrb_get_args(mrb, "|o", &random);
+
+    if (mrb_nil_p(random)) {
+      mrb_random_g_rand_seed(mrb);
+    }
+    else {
+      mrb_data_check_type(mrb, random, &mt_state_type);
+      mrb_random_rand_seed(mrb, random);
+    }
+  
+    mrb_ary_modify(mrb, mrb_ary_ptr(ary));
+    
+    for (i = RARRAY_LEN(ary) - 1; i > 0; i--)  {
+      mrb_int j;
+      mrb_value tmp;
+      
+      if (mrb_nil_p(random)) {
+        j = mrb_fixnum(mrb_random_mt_g_rand(mrb, mrb_fixnum_value(RARRAY_LEN(ary))));
+      }
+      else {
+        j = mrb_fixnum(mrb_random_mt_rand(mrb, DATA_PTR(random), mrb_fixnum_value(RARRAY_LEN(ary))));
+      }
+      
+      tmp = RARRAY_PTR(ary)[i];
+      RARRAY_PTR(ary)[i] = RARRAY_PTR(ary)[j];
+      RARRAY_PTR(ary)[j] = tmp;
+    }    
+  }
+  
+  return ary;
+}
+
+/*
+ *  call-seq:
+ *     ary.shuffle   ->   new_ary
+ *
+ *  Returns a new array with elements of self shuffled.
+ */
+
+static mrb_value
+mrb_ary_shuffle(mrb_state *mrb, mrb_value ary)
+{
+  mrb_value new_ary = mrb_ary_new_from_values(mrb, RARRAY_LEN(ary), RARRAY_PTR(ary));
+  mrb_ary_shuffle_bang(mrb, new_ary);
+  
+  return new_ary;
+}
+
 void mrb_mruby_random_gem_init(mrb_state *mrb)
 {
   struct RClass *random;
+  struct RClass *array = mrb->array_class;
 
   mrb_define_method(mrb, mrb->kernel_module, "rand", mrb_random_g_rand, MRB_ARGS_OPT(1));
   mrb_define_method(mrb, mrb->kernel_module, "srand", mrb_random_g_srand, MRB_ARGS_OPT(1));
 
   random = mrb_define_class(mrb, "Random", mrb->object_class);
+  MRB_SET_INSTANCE_TT(random, MRB_TT_DATA);
   mrb_define_class_method(mrb, random, "rand", mrb_random_g_rand, MRB_ARGS_OPT(1));
   mrb_define_class_method(mrb, random, "srand", mrb_random_g_srand, MRB_ARGS_OPT(1));
 
   mrb_define_method(mrb, random, "initialize", mrb_random_init, MRB_ARGS_OPT(1));
   mrb_define_method(mrb, random, "rand", mrb_random_rand, MRB_ARGS_OPT(1));
   mrb_define_method(mrb, random, "srand", mrb_random_srand, MRB_ARGS_OPT(1));
+  
+  mrb_define_method(mrb, array, "shuffle", mrb_ary_shuffle, MRB_ARGS_OPT(1));
+  mrb_define_method(mrb, array, "shuffle!", mrb_ary_shuffle_bang, MRB_ARGS_OPT(1));
 }
 
 void mrb_mruby_random_gem_final(mrb_state *mrb)

data/modules/mruby/mrbgems/mruby-random/test/random.rb

@@ -30,3 +30,47 @@ end
 assert("float") do
   rand.class == Float
 end
+
+assert("Array#shuffle") do 
+  ary = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  shuffled = ary.shuffle
+  
+  ary == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] and shuffled != ary and 10.times { |x| ary.include? x }
+end
+
+assert('Array#shuffle!') do
+  ary = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  ary.shuffle!
+  
+  ary != [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] and 10.times { |x| ary.include? x }
+end
+
+assert("Array#shuffle(random)") do 
+  assert_raise(TypeError) do
+    # this will cause an exception due to the wrong argument
+    [1, 2].shuffle "Not a Random instance"
+  end
+  
+  # verify that the same seed causes the same results
+  ary1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  shuffle1 = ary1.shuffle Random.new 345
+  ary2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  shuffle2 = ary2.shuffle Random.new 345
+  
+  ary1 != shuffle1 and 10.times { |x| shuffle1.include? x } and shuffle1 == shuffle2
+end
+
+assert('Array#shuffle!(random)') do
+  assert_raise(TypeError) do
+    # this will cause an exception due to the wrong argument
+    [1, 2].shuffle! "Not a Random instance"
+  end
+    
+  # verify that the same seed causes the same results
+  ary1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  ary1.shuffle! Random.new 345
+  ary2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  ary2.shuffle! Random.new 345
+  
+  ary1 != [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] and 10.times { |x| ary1.include? x } and ary1 == ary2
+end

data/modules/mruby/mrbgems/mruby-struct/src/struct.c

@@ -49,7 +49,7 @@ mrb_struct_iv_get(mrb_state *mrb, mrb_value c, const char *name)
 mrb_value
 mrb_struct_s_members(mrb_state *mrb, mrb_value klass)
 {
-  mrb_value members = struct_ivar_get(mrb, klass, mrb_intern2(mrb, "__members__", 11));
+  mrb_value members = struct_ivar_get(mrb, klass, mrb_intern_lit(mrb, "__members__"));
 
   if (mrb_nil_p(members)) {
     mrb_raise(mrb, E_TYPE_ERROR, "uninitialized struct");
@@ -176,7 +176,7 @@ mrb_id_attrset(mrb_state *mrb, mrb_sym id)
   buf[len] = '=';
   buf[len+1] = '\0';
 
-  mid = mrb_intern2(mrb, buf, len+1);
+  mid = mrb_intern(mrb, buf, len+1);
   mrb_free(mrb, buf);
   return mid;
 }
@@ -191,7 +191,7 @@ mrb_struct_set(mrb_state *mrb, mrb_value obj, mrb_value val)
 
   /* get base id */
   name = mrb_sym2name_len(mrb, mrb->c->ci->mid, &len);
-  mid = mrb_intern2(mrb, name, len-1); /* omit last "=" */
+  mid = mrb_intern(mrb, name, len-1); /* omit last "=" */
 
   members = mrb_struct_members(mrb, obj);
   ptr_members = RARRAY_PTR(members);
@@ -258,7 +258,7 @@ make_struct(mrb_state *mrb, mrb_value name, mrb_value members, struct RClass * k
   }
   MRB_SET_INSTANCE_TT(c, MRB_TT_ARRAY);
   nstr = mrb_obj_value(c);
-  mrb_iv_set(mrb, nstr, mrb_intern2(mrb, "__members__", 11), members);
+  mrb_iv_set(mrb, nstr, mrb_intern_lit(mrb, "__members__"), members);
 
   mrb_define_class_method(mrb, c, "new", mrb_instance_new, MRB_ARGS_ANY());
   mrb_define_class_method(mrb, c, "[]", mrb_instance_new, MRB_ARGS_ANY());
@@ -393,7 +393,7 @@ num_members(mrb_state *mrb, struct RClass *klass)
 {
   mrb_value members;
 
-  members = struct_ivar_get(mrb, mrb_obj_value(klass), mrb_intern2(mrb, "__members__", 11));
+  members = struct_ivar_get(mrb, mrb_obj_value(klass), mrb_intern_lit(mrb, "__members__"));
   if (!mrb_array_p(members)) {
     mrb_raise(mrb, E_TYPE_ERROR, "broken members");
   }

data/modules/mruby/mrblib/numeric.rb

@@ -1,24 +1,51 @@
 ##
-# Integer
+# Numeric
 #
-# ISO 15.2.8
-class Integer
-
+# ISO 15.2.7
+class Numeric
+  include Comparable
   ##
   # Returns the receiver simply.
   #
-  # ISO 15.2.8.3.14
-  def ceil
+  # ISO 15.2.7.4.1
+  def +@
     self
   end
 
+  ##
+  # Returns the receiver's value, negated.
+  #
+  # ISO 15.2.7.4.2
+  def -@
+    0 - self
+  end
+
+  ##
+  # Returns the absolute value of the receiver.
+  #
+  # ISO 15.2.7.4.3
+  def abs
+    if self < 0
+      -self
+    else
+      self
+    end
+  end
+end
+
+##
+# Integral
+#
+# mruby special - module to share methods between Floats and Integers
+#                 to make them compatible
+module Integral
   ##
   # Calls the given block once for each Integer
   # from +self+ downto +num+.
   #
   # ISO 15.2.8.3.15
   def downto(num, &block)
-    i = self
+    i = self.to_i
     while(i >= num)
       block.call(i)
       i -= 1
@@ -27,12 +54,14 @@ class Integer
   end
 
   ##
-  # Returns the receiver simply.
+  # Returns self + 1
   #
-  # ISO 15.2.8.3.17
-  def floor
-    self
+  # ISO 15.2.8.3.19
+  def next
+    self + 1
   end
+  # ISO 15.2.8.3.21
+  alias succ next
 
   ##
   # Calls the given block +self+ times.
@@ -47,29 +76,13 @@ class Integer
     self
   end
 
-  ##
-  # Returns the receiver simply.
-  #
-  # ISO 15.2.8.3.24
-  def round
-    self
-  end
-
-  ##
-  # Returns the receiver simply.
-  #
-  # ISO 15.2.8.3.26
-  def truncate
-    self
-  end
-
   ##
   # Calls the given block once for each Integer
   # from +self+ upto +num+.
   #
   # ISO 15.2.8.3.27
   def upto(num, &block)
-    i = self
+    i = self.to_i
     while(i <= num)
       block.call(i)
       i += 1
@@ -92,10 +105,63 @@ class Integer
 end
 
 ##
-# Numeric is comparable
+# Integer
 #
-# ISO 15.2.7.3
-module Comparable; end
-class Numeric
-  include Comparable
+# ISO 15.2.8
+class Integer
+  include Integral
+  ##
+  # Returns the receiver simply.
+  #
+  # ISO 15.2.8.3.14
+  def ceil
+    self
+  end
+
+  ##
+  # Returns the receiver simply.
+  #
+  # ISO 15.2.8.3.17
+  def floor
+    self
+  end
+
+  ##
+  # Returns the receiver simply.
+  #
+  # ISO 15.2.8.3.24
+  alias round floor
+
+  ##
+  # Returns the receiver simply.
+  #
+  # ISO 15.2.8.3.26
+  alias truncate floor
+end
+
+##
+# Float
+#
+# ISO 15.2.9
+class Float
+  include Integral
+  # mruby special - since mruby integers may be upgraded to floats,
+  # floats should be compatible to integers.
+  def >> other
+    n = self.to_i
+    other.to_i.times {
+      n /= 2
+    }
+    n
+  end
+  def << other
+    n = self.to_i
+    other.to_i.times {
+      n *= 2
+    }
+    n.to_i
+  end
+
+  def divmod(other)
+  end
 end

data/modules/mruby/src/array.c

@@ -138,6 +138,13 @@ ary_modify(mrb_state *mrb, struct RArray *a)
   }
 }
 
+void
+mrb_ary_modify(mrb_state *mrb, struct RArray* a)
+{
+  mrb_write_barrier(mrb, (struct RBasic*)a);
+  ary_modify(mrb, a);
+}
+
 static void
 ary_make_shared(mrb_state *mrb, struct RArray *a)
 {
@@ -302,7 +309,7 @@ mrb_ary_cmp(mrb_state *mrb, mrb_value ary1)
   a1 = RARRAY(ary1); a2 = RARRAY(ary2);
   if (a1->len == a2->len && a1->ptr == a2->ptr) return mrb_fixnum_value(0);
   else {
-    mrb_sym cmp = mrb_intern2(mrb, "<=>", 3);
+    mrb_sym cmp = mrb_intern_lit(mrb, "<=>");
 
     len = RARRAY_LEN(ary1);
     if (len > RARRAY_LEN(ary2)) {
@@ -1063,7 +1070,7 @@ mrb_ary_equal(mrb_state *mrb, mrb_value ary1)
   if (mrb_obj_equal(mrb, ary1, ary2)) return mrb_true_value();
   if (mrb_special_const_p(ary2)) return mrb_false_value();
   if (!mrb_array_p(ary2)) {
-    if (!mrb_respond_to(mrb, ary2, mrb_intern2(mrb, "to_ary", 6))) {
+    if (!mrb_respond_to(mrb, ary2, mrb_intern_lit(mrb, "to_ary"))) {
       return mrb_false_value();
     }
     else {
@@ -1117,8 +1124,8 @@ mrb_init_array(mrb_state *mrb)
 
   mrb_define_class_method(mrb, a, "[]",        mrb_ary_s_create,     MRB_ARGS_ANY());  /* 15.2.12.4.1 */
 
-  mrb_define_method(mrb, a, "*",               mrb_ary_times,        MRB_ARGS_REQ(1)); /* 15.2.12.5.1  */
-  mrb_define_method(mrb, a, "+",               mrb_ary_plus,         MRB_ARGS_REQ(1)); /* 15.2.12.5.2  */
+  mrb_define_method(mrb, a, "+",               mrb_ary_plus,         MRB_ARGS_REQ(1)); /* 15.2.12.5.1  */
+  mrb_define_method(mrb, a, "*",               mrb_ary_times,        MRB_ARGS_REQ(1)); /* 15.2.12.5.2  */
   mrb_define_method(mrb, a, "<<",              mrb_ary_push_m,       MRB_ARGS_REQ(1)); /* 15.2.12.5.3  */
   mrb_define_method(mrb, a, "[]",              mrb_ary_aget,         MRB_ARGS_ANY());  /* 15.2.12.5.4  */
   mrb_define_method(mrb, a, "[]=",             mrb_ary_aset,         MRB_ARGS_ANY());  /* 15.2.12.5.5  */

data/modules/mruby/src/backtrace.c

@@ -65,7 +65,7 @@ mrb_output_backtrace(mrb_state *mrb, struct RObject *exc, output_stream_func fun
   int i, line;
 
   func(mrb, stream, 1, "trace:\n");
-  ciidx = mrb_fixnum(mrb_obj_iv_get(mrb, exc, mrb_intern2(mrb, "ciidx", 5)));
+  ciidx = mrb_fixnum(mrb_obj_iv_get(mrb, exc, mrb_intern_lit(mrb, "ciidx")));
   if (ciidx >= mrb->c->ciend - mrb->c->cibase)
     ciidx = 10; /* ciidx is broken... */
 
@@ -88,7 +88,7 @@ mrb_output_backtrace(mrb_state *mrb, struct RObject *exc, output_stream_func fun
         pc = mrb->c->cibase[i+1].pc - 1;
       }
       else {
-        pc = (mrb_code*)mrb_cptr(mrb_obj_iv_get(mrb, exc, mrb_intern2(mrb, "lastpc", 6)));
+        pc = (mrb_code*)mrb_cptr(mrb_obj_iv_get(mrb, exc, mrb_intern_lit(mrb, "lastpc")));
       }
       filename = mrb_debug_get_filename(irep, pc - irep->iseq);
       line = mrb_debug_get_line(irep, pc - irep->iseq);