From b8f4e47676785c04c45c2b2fe01bddfc5e98f46d Mon Sep 17 00:00:00 2001
From: Jun Hiroe <Jun.Hiroe@gmail.com>
Date: Fri, 12 Jul 2013 01:27:42 +0900
Subject: 2.Replace mrb_intern() func with mrb_intern2() func or
 mrb_intern_cstr() func.

---
 src/kernel.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/kernel.c')

diff --git a/src/kernel.c b/src/kernel.c
index 0fe374e73..965b80b95 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -1101,5 +1101,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_intern(mrb, "dup"), mrb_intern(mrb, "clone"));
+  mrb_alias_method(mrb, mrb->module_class, mrb_intern2(mrb, "dup", 3), mrb_intern2(mrb, "clone", 5));
 }
-- 
cgit v1.2.3


From 8e42868600e7adcdc5665ff9b0244150296960d6 Mon Sep 17 00:00:00 2001
From: Jun Hiroe <Jun.Hiroe@gmail.com>
Date: Mon, 15 Jul 2013 23:00:54 +0900
Subject: Repalace int with mrb_bool because a return value is boolean.

---
 include/mruby.h                          | 18 +++++++++---------
 include/mruby/string.h                   |  2 +-
 mrbgems/mruby-bin-mirb/tools/mirb/mirb.c |  2 +-
 mrbgems/mruby-range-ext/src/range.c      |  4 ++--
 src/class.c                              |  6 +++---
 src/codegen.c                            |  2 +-
 src/kernel.c                             |  6 +++---
 src/object.c                             | 10 +++++-----
 src/range.c                              |  6 +++---
 src/string.c                             |  4 ++--
 src/symbol.c                             |  4 ++--
 11 files changed, 32 insertions(+), 32 deletions(-)

(limited to 'src/kernel.c')

diff --git a/include/mruby.h b/include/mruby.h
index a7f2a49c4..85b464b8e 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -176,13 +176,13 @@ void mrb_undef_class_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);
-int mrb_class_defined(mrb_state *mrb, const char *name);
+mrb_bool mrb_class_defined(mrb_state *mrb, const char *name);
 struct RClass * mrb_class_get(mrb_state *mrb, const char *name);
 struct RClass * mrb_class_get_under(mrb_state *mrb, struct RClass *outer, const char *name);
 
 mrb_value mrb_obj_dup(mrb_state *mrb, mrb_value obj);
 mrb_value mrb_check_to_integer(mrb_state *mrb, mrb_value val, const char *method);
-int mrb_obj_respond_to(struct RClass* c, mrb_sym mid);
+mrb_bool mrb_obj_respond_to(struct RClass* c, mrb_sym mid);
 struct RClass * mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, struct RClass *super);
 struct RClass * mrb_define_module_under(mrb_state *mrb, struct RClass *outer, const char *name);
 
@@ -264,13 +264,13 @@ void mrb_p(mrb_state*, mrb_value);
 mrb_int mrb_obj_id(mrb_value obj);
 mrb_sym mrb_obj_to_sym(mrb_state *mrb, mrb_value name);
 
-int mrb_obj_eq(mrb_state*, mrb_value, mrb_value);
-int mrb_obj_equal(mrb_state*, mrb_value, mrb_value);
-int mrb_equal(mrb_state *mrb, mrb_value obj1, mrb_value obj2);
+mrb_bool mrb_obj_eq(mrb_state*, mrb_value, mrb_value);
+mrb_bool mrb_obj_equal(mrb_state*, mrb_value, mrb_value);
+mrb_bool mrb_equal(mrb_state *mrb, mrb_value obj1, mrb_value obj2);
 mrb_value mrb_Integer(mrb_state *mrb, mrb_value val);
 mrb_value mrb_Float(mrb_state *mrb, mrb_value val);
 mrb_value mrb_inspect(mrb_state *mrb, mrb_value obj);
-int mrb_eql(mrb_state *mrb, mrb_value obj1, mrb_value obj2);
+mrb_bool mrb_eql(mrb_state *mrb, mrb_value obj1, mrb_value obj2);
 
 void mrb_garbage_collect(mrb_state*);
 void mrb_incremental_gc(mrb_state *);
@@ -292,7 +292,7 @@ const char * mrb_obj_classname(mrb_state *mrb, mrb_value obj);
 struct RClass* mrb_obj_class(mrb_state *mrb, mrb_value obj);
 mrb_value mrb_class_path(mrb_state *mrb, struct RClass *c);
 mrb_value mrb_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, const char *tname, const char *method);
-int mrb_obj_is_kind_of(mrb_state *mrb, mrb_value obj, struct RClass *c);
+mrb_bool mrb_obj_is_kind_of(mrb_state *mrb, mrb_value obj, struct RClass *c);
 mrb_value mrb_obj_inspect(mrb_state *mrb, mrb_value self);
 mrb_value mrb_obj_clone(mrb_state *mrb, mrb_value self);
 
@@ -369,8 +369,8 @@ void mrb_define_global_const(mrb_state *mrb, const char *name, mrb_value val);
 mrb_value mrb_block_proc(void);
 mrb_value mrb_attr_get(mrb_state *mrb, mrb_value obj, mrb_sym id);
 
-int mrb_respond_to(mrb_state *mrb, mrb_value obj, mrb_sym mid);
-int mrb_obj_is_instance_of(mrb_state *mrb, mrb_value obj, struct RClass* c);
+mrb_bool mrb_respond_to(mrb_state *mrb, mrb_value obj, mrb_sym mid);
+mrb_bool mrb_obj_is_instance_of(mrb_state *mrb, mrb_value obj, struct RClass* c);
 
 /* memory pool implementation */
 typedef struct mrb_pool mrb_pool;
diff --git a/include/mruby/string.h b/include/mruby/string.h
index 26d1344d8..000c80b09 100644
--- a/include/mruby/string.h
+++ b/include/mruby/string.h
@@ -57,7 +57,7 @@ mrb_value mrb_str_to_str(mrb_state *mrb, mrb_value str);
 mrb_int mrb_str_hash(mrb_state *mrb, mrb_value str);
 mrb_value mrb_str_buf_append(mrb_state *mrb, mrb_value str, mrb_value str2);
 mrb_value mrb_str_inspect(mrb_state *mrb, mrb_value str);
-int mrb_str_equal(mrb_state *mrb, mrb_value str1, mrb_value str2);
+mrb_bool mrb_str_equal(mrb_state *mrb, mrb_value str1, mrb_value str2);
 mrb_value mrb_str_dump(mrb_state *mrb, mrb_value str);
 mrb_value mrb_str_cat(mrb_state *mrb, mrb_value str, const char *ptr, size_t len);
 mrb_value mrb_str_append(mrb_state *mrb, mrb_value str, mrb_value str2);
diff --git a/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c b/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c
index 7f2fcf282..eb7194f30 100644
--- a/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c
+++ b/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c
@@ -38,7 +38,7 @@ p(mrb_state *mrb, mrb_value obj, int prompt)
 
 /* Guess if the user might want to enter more
  * or if he wants an evaluation of his code now */
-int
+mrb_bool
 is_code_block_open(struct mrb_parser_state *parser)
 {
   int code_block_open = FALSE;
diff --git a/mrbgems/mruby-range-ext/src/range.c b/mrbgems/mruby-range-ext/src/range.c
index 377677ffb..4e17dac8c 100644
--- a/mrbgems/mruby-range-ext/src/range.c
+++ b/mrbgems/mruby-range-ext/src/range.c
@@ -1,7 +1,7 @@
 #include "mruby.h"
 #include "mruby/range.h"
 
-static int
+static mrb_bool
 r_le(mrb_state *mrb, mrb_value a, mrb_value b)
 {
   mrb_value r = mrb_funcall(mrb, a, "<=>", 1, b); /* compare result */
@@ -15,7 +15,7 @@ r_le(mrb_state *mrb, mrb_value a, mrb_value b)
   return FALSE;
 }
 
-static int
+static mrb_bool
 r_lt(mrb_state *mrb, mrb_value a, mrb_value b)
 {
   mrb_value r = mrb_funcall(mrb, a, "<=>", 1, b);
diff --git a/src/class.c b/src/class.c
index 9868d0080..606a54a7c 100644
--- a/src/class.c
+++ b/src/class.c
@@ -203,7 +203,7 @@ mrb_vm_define_class(mrb_state *mrb, mrb_value outer, mrb_value super, mrb_sym id
   return c;
 }
 
-int
+mrb_bool
 mrb_class_defined(mrb_state *mrb, const char *name)
 {
   mrb_value sym = mrb_check_intern_cstr(mrb, name);
@@ -1172,7 +1172,7 @@ mrb_bob_missing(mrb_state *mrb, mrb_value mod)
   return mrb_nil_value();
 }
 
-int
+mrb_bool
 mrb_obj_respond_to(struct RClass* c, mrb_sym mid)
 {
   khiter_t k;
@@ -1196,7 +1196,7 @@ mrb_obj_respond_to(struct RClass* c, mrb_sym mid)
   return FALSE;         /* no method */
 }
 
-int
+mrb_bool
 mrb_respond_to(mrb_state *mrb, mrb_value obj, mrb_sym mid)
 {
   return mrb_obj_respond_to(mrb_class(mrb, obj), mid);
diff --git a/src/codegen.c b/src/codegen.c
index 8dd5a124d..37176653b 100644
--- a/src/codegen.c
+++ b/src/codegen.c
@@ -683,7 +683,7 @@ scope_body(codegen_scope *s, node *tree)
   return idx - s->idx;
 }
 
-static int
+static mrb_bool
 nosplat(node *t)
 {
   while (t) {
diff --git a/src/kernel.c b/src/kernel.c
index 965b80b95..ae8d24710 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -26,7 +26,7 @@ typedef enum {
     NOEX_RESPONDS  = 0x80
 } mrb_method_flag_t;
 
-int
+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));
@@ -521,7 +521,7 @@ mrb_obj_instance_eval(mrb_state *mrb, mrb_value self)
   return mrb_yield_internal(mrb, b, 0, 0, self, c);
 }
 
-int
+mrb_bool
 mrb_obj_is_instance_of(mrb_state *mrb, mrb_value obj, struct RClass* c)
 {
   if (mrb_obj_class(mrb, obj) == c) return TRUE;
@@ -938,7 +938,7 @@ mrb_obj_remove_instance_variable(mrb_state *mrb, mrb_value self)
   return val;
 }
 
-static inline int
+static inline mrb_bool
 basic_obj_respond_to(mrb_state *mrb, mrb_value obj, mrb_sym id, int pub)
 {
   return mrb_respond_to(mrb, obj, id);
diff --git a/src/object.c b/src/object.c
index 4003452cc..5b2278767 100644
--- a/src/object.c
+++ b/src/object.c
@@ -11,7 +11,7 @@
 #include "mruby/string.h"
 #include "error.h"
 
-int
+mrb_bool
 mrb_obj_eq(mrb_state *mrb, mrb_value v1, mrb_value v2)
 {
   if (mrb_type(v1) != mrb_type(v2)) return FALSE;
@@ -33,14 +33,14 @@ mrb_obj_eq(mrb_state *mrb, mrb_value v1, mrb_value v2)
   }
 }
 
-int
+mrb_bool
 mrb_obj_equal(mrb_state *mrb, mrb_value v1, mrb_value v2)
 {
   /* temporary definition */
   return mrb_obj_eq(mrb, v1, v2);
 }
 
-int
+mrb_bool
 mrb_equal(mrb_state *mrb, mrb_value obj1, mrb_value obj2)
 {
   mrb_value result;
@@ -468,7 +468,7 @@ mrb_any_to_s(mrb_state *mrb, mrb_value obj)
  *     b.kind_of? M       #=> true
  */
 
-int
+mrb_bool
 mrb_obj_is_kind_of(mrb_state *mrb, mrb_value obj, struct RClass *c)
 {
   struct RClass *cl = mrb_class(mrb, obj);
@@ -585,7 +585,7 @@ mrb_inspect(mrb_state *mrb, mrb_value obj)
   return mrb_obj_as_string(mrb, mrb_funcall(mrb, obj, "inspect", 0, 0));
 }
 
-int
+mrb_bool
 mrb_eql(mrb_state *mrb, mrb_value obj1, mrb_value obj2)
 {
   if (mrb_obj_eq(mrb, obj1, obj2)) return TRUE;
diff --git a/src/range.c b/src/range.c
index 92eddfe8c..6e313df51 100644
--- a/src/range.c
+++ b/src/range.c
@@ -170,7 +170,7 @@ mrb_range_eq(mrb_state *mrb, mrb_value range)
   return mrb_true_value();
 }
 
-static int
+static mrb_bool
 r_le(mrb_state *mrb, mrb_value a, mrb_value b)
 {
   mrb_value r = mrb_funcall(mrb, a, "<=>", 1, b); /* compare result */
@@ -184,7 +184,7 @@ r_le(mrb_state *mrb, mrb_value a, mrb_value b)
   return FALSE;
 }
 
-static int
+static mrb_bool
 r_gt(mrb_state *mrb, mrb_value a, mrb_value b)
 {
   mrb_value r = mrb_funcall(mrb, a, "<=>", 1, b);
@@ -197,7 +197,7 @@ r_gt(mrb_state *mrb, mrb_value a, mrb_value b)
   return FALSE;
 }
 
-static int
+static mrb_bool
 r_ge(mrb_state *mrb, mrb_value a, mrb_value b)
 {
   mrb_value r = mrb_funcall(mrb, a, "<=>", 1, b); /* compare result */
diff --git a/src/string.c b/src/string.c
index 59a1df455..975f6cdb9 100644
--- a/src/string.c
+++ b/src/string.c
@@ -595,7 +595,7 @@ mrb_str_cmp_m(mrb_state *mrb, mrb_value str1)
   return mrb_fixnum_value(result);
 }
 
-static int
+static mrb_bool
 str_eql(mrb_state *mrb, const mrb_value str1, const mrb_value str2)
 {
   const mrb_int len = RSTRING_LEN(str1);
@@ -606,7 +606,7 @@ str_eql(mrb_state *mrb, const mrb_value str1, const mrb_value str2)
   return FALSE;
 }
 
-int
+mrb_bool
 mrb_str_equal(mrb_state *mrb, mrb_value str1, mrb_value str2)
 {
   if (mrb_obj_equal(mrb, str1, str2)) return TRUE;
diff --git a/src/symbol.c b/src/symbol.c
index c29f7c6ae..bd8dce7df 100644
--- a/src/symbol.c
+++ b/src/symbol.c
@@ -251,7 +251,7 @@ sym_to_sym(mrb_state *mrb, mrb_value sym)
 #endif
 #define is_identchar(c) (SIGN_EXTEND_CHAR(c)!=-1&&(ISALNUM(c) || (c) == '_'))
 
-static int
+static mrb_bool
 is_special_global_name(const char* m)
 {
   switch (*m) {
@@ -274,7 +274,7 @@ is_special_global_name(const char* m)
   return !*m;
 }
 
-static int
+static mrb_bool
 symname_p(const char *name)
 {
   const char *m = name;
-- 
cgit v1.2.3


From 75f8aab247abf58b61b3700c078d61ccf7e168bf Mon Sep 17 00:00:00 2001
From: Ryan Scott <ryan.scott@tickbox.com.au>
Date: Thu, 18 Jul 2013 07:54:16 +1000
Subject: First round of trying to improve the performance of attr_reader and
 attr_writer. From ~24sec to ~15sec

---
 benchmark/ao-render.rb | 42 +++++++++++++-----------------------------
 mrblib/class.rb        |  6 +++---
 src/kernel.c           | 45 +++++++++++++++++++++++++++++++++++----------
 3 files changed, 51 insertions(+), 42 deletions(-)

(limited to 'src/kernel.c')

diff --git a/benchmark/ao-render.rb b/benchmark/ao-render.rb
index 793804a7b..e7406b26b 100644
--- a/benchmark/ao-render.rb
+++ b/benchmark/ao-render.rb
@@ -6,8 +6,8 @@
 # mruby version by Hideki Miura
 #
 
-IMAGE_WIDTH = 256
-IMAGE_HEIGHT = 256
+IMAGE_WIDTH = 64
+IMAGE_HEIGHT = 64
 NSUBSAMPLES = 2
 NAO_SAMPLES = 8
 
@@ -30,19 +30,14 @@ module Rand
 end
 
 class Vec
+  attr_accessor :x, :y, :z
+
   def initialize(x, y, z)
     @x = x
     @y = y
     @z = z
   end
 
-  def x=(v); @x = v; end
-  def y=(v); @y = v; end
-  def z=(v); @z = v; end
-  def x; @x; end
-  def y; @y; end
-  def z; @z; end
-
   def vadd(b)
     Vec.new(@x + b.x, @y + b.y, @z + b.z)
   end
@@ -80,14 +75,13 @@ end
 
 
 class Sphere
+  attr_reader :center, :radius
+
   def initialize(center, radius)
     @center = center
     @radius = radius
   end
 
-  def center; @center; end
-  def radius; @radius; end
-
   def intersect(ray, isect)
     rs = ray.org.vsub(@center)
     b = rs.vdot(ray.dir)
@@ -140,33 +134,23 @@ class Plane
 end
 
 class Ray
+  attr_accessor :org, :dir
+
   def initialize(org, dir)
     @org = org
     @dir = dir
   end
-
-  def org; @org; end
-  def org=(v); @org = v; end
-  def dir; @dir; end
-  def dir=(v); @dir = v; end
 end
 
 class Isect
+  attr_accessor :t, :hit, :pl, :n
+
   def initialize
     @t = 10000000.0
     @hit = false
     @pl = Vec.new(0.0, 0.0, 0.0)
     @n = Vec.new(0.0, 0.0, 0.0)
   end
-
-  def t; @t; end
-  def t=(v); @t = v; end
-  def hit; @hit; end
-  def hit=(v); @hit = v; end
-  def pl; @pl; end
-  def pl=(v); @pl = v; end
-  def n; @n; end
-  def n=(v); @n = v; end
 end
 
 def clamp(f)
@@ -298,9 +282,9 @@ class Scene
         r = rad.x / (nsf * nsf)
         g = rad.y / (nsf * nsf)
         b = rad.z / (nsf * nsf)
-        printf("%c", clamp(r))
-        printf("%c", clamp(g))
-        printf("%c", clamp(b))
+        # printf("%c", clamp(r))
+        # printf("%c", clamp(g))
+        # printf("%c", clamp(b))
       end
     end
   end
diff --git a/mrblib/class.rb b/mrblib/class.rb
index 4f268b6c8..d6ef34f17 100644
--- a/mrblib/class.rb
+++ b/mrblib/class.rb
@@ -2,15 +2,15 @@ class Module
   # 15.2.2.4.13
   def attr_reader(*names)
     names.each{|name|
-      name2 = ('@'+name.to_s).intern
+      name2 = ('@'+name.to_s)
       define_method(name){self.instance_variable_get(name2)}
     }
   end
   # 15.2.2.4.14
   def attr_writer(*names)
     names.each{|name|
-      name2 = ('@'+name.to_s).intern
-      name = (name.to_s+"=").intern
+      name2 = ('@'+name.to_s)
+      name = (name.to_s+"=")
       define_method(name){|v|self.instance_variable_set(name2,v)}
     }
   end
diff --git a/src/kernel.c b/src/kernel.c
index ae8d24710..068b80f62 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -548,6 +548,14 @@ obj_is_instance_of(mrb_state *mrb, mrb_value self)
   return mrb_bool_value(instance_of_p);
 }
 
+static void
+valid_iv_name(mrb_state *mrb, mrb_sym id, const char* s, size_t len) 
+{
+  if (len < 2 || !(s[0] == '@' && s[1] != '@')) {
+    mrb_name_error(mrb, id, "`%S' is not allowed as an instance variable name", mrb_sym2str(mrb, id));
+  }
+}
+
 static void
 check_iv_name(mrb_state *mrb, mrb_sym id)
 {
@@ -555,9 +563,23 @@ check_iv_name(mrb_state *mrb, mrb_sym id)
   size_t len;
 
   s = mrb_sym2name_len(mrb, id, &len);
-  if (len < 2 || !(s[0] == '@' && s[1] != '@')) {
-    mrb_name_error(mrb, id, "`%S' is not allowed as an instance variable name", mrb_sym2str(mrb, id));
+  valid_iv_name(mrb, id, s, len);
+}
+
+static mrb_sym
+get_valid_iv_sym(mrb_state *mrb, mrb_value val)
+{
+  mrb_sym id;
+
+  if (mrb_string_p(val)) {
+    id = mrb_intern_cstr(mrb, RSTRING_PTR(val));
+    valid_iv_name(mrb, id, RSTRING_PTR(val), RSTRING_LEN(val));
+  } else if(mrb_symbol_p(val)) {
+    id = mrb_symbol(val);
+    check_iv_name(mrb, id);
   }
+
+  return id;
 }
 
 /* 15.3.1.3.20 */
@@ -582,10 +604,11 @@ mrb_value
 mrb_obj_ivar_defined(mrb_state *mrb, mrb_value self)
 {
   mrb_sym mid;
+  mrb_value sym;
   mrb_bool defined_p;
 
-  mrb_get_args(mrb, "n", &mid);
-  check_iv_name(mrb, mid);
+  mrb_get_args(mrb, "o", &sym);
+  mid = get_valid_iv_sym(mrb, sym);
   defined_p = mrb_obj_iv_defined(mrb, mrb_obj_ptr(self), mid);
 
   return mrb_bool_value(defined_p);
@@ -615,10 +638,11 @@ mrb_value
 mrb_obj_ivar_get(mrb_state *mrb, mrb_value self)
 {
   mrb_sym id;
+  mrb_value sym;
+  
+  mrb_get_args(mrb, "o", &sym);
 
-  mrb_get_args(mrb, "n", &id);
-
-  check_iv_name(mrb, id);
+  id = get_valid_iv_sym(mrb, sym);
   return mrb_iv_get(mrb, self, id);
 }
 
@@ -646,10 +670,11 @@ mrb_value
 mrb_obj_ivar_set(mrb_state *mrb, mrb_value self)
 {
   mrb_sym id;
-  mrb_value val;
+  mrb_value sym, val;
 
-  mrb_get_args(mrb, "no", &id, &val);
-  check_iv_name(mrb, id);
+  mrb_get_args(mrb, "oo", &sym, &val);
+  
+  id = get_valid_iv_sym(mrb, sym);
   mrb_iv_set(mrb, self, id, val);
   return val;
 }
-- 
cgit v1.2.3


From 3ebd8167e149c66e7b9a822b196ea610fe07a419 Mon Sep 17 00:00:00 2001
From: Ryan Scott <ryan.scott@tickbox.com.au>
Date: Sun, 21 Jul 2013 18:05:45 +1000
Subject: Slight cleanup of code

---
 src/kernel.c | 50 +++++++++++++++++++++++++-------------------------
 1 file changed, 25 insertions(+), 25 deletions(-)

(limited to 'src/kernel.c')

diff --git a/src/kernel.c b/src/kernel.c
index 068b80f62..f2c7f182f 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -549,37 +549,37 @@ obj_is_instance_of(mrb_state *mrb, mrb_value self)
 }
 
 static void
-valid_iv_name(mrb_state *mrb, mrb_sym id, const char* s, size_t len) 
+valid_iv_name(mrb_state *mrb, mrb_sym iv_name_id, const char* s, size_t len) 
 {
   if (len < 2 || !(s[0] == '@' && s[1] != '@')) {
-    mrb_name_error(mrb, id, "`%S' is not allowed as an instance variable name", mrb_sym2str(mrb, id));
+    mrb_name_error(mrb, iv_name_id, "`%S' is not allowed as an instance variable name", mrb_sym2str(mrb, iv_name_id));
   }
 }
 
 static void
-check_iv_name(mrb_state *mrb, mrb_sym id)
+check_iv_name(mrb_state *mrb, mrb_sym iv_name_id)
 {
   const char *s;
   size_t len;
 
-  s = mrb_sym2name_len(mrb, id, &len);
-  valid_iv_name(mrb, id, s, len);
+  s = mrb_sym2name_len(mrb, iv_name_id, &len);
+  valid_iv_name(mrb, iv_name_id, s, len);
 }
 
 static mrb_sym
-get_valid_iv_sym(mrb_state *mrb, mrb_value val)
+get_valid_iv_sym(mrb_state *mrb, mrb_value iv_name)
 {
-  mrb_sym id;
-
-  if (mrb_string_p(val)) {
-    id = mrb_intern_cstr(mrb, RSTRING_PTR(val));
-    valid_iv_name(mrb, id, RSTRING_PTR(val), RSTRING_LEN(val));
-  } else if(mrb_symbol_p(val)) {
-    id = mrb_symbol(val);
-    check_iv_name(mrb, id);
+  mrb_sym iv_name_id;
+
+  if (mrb_string_p(iv_name)) {
+    iv_name_id = mrb_intern_cstr(mrb, RSTRING_PTR(iv_name));
+    valid_iv_name(mrb, iv_name_id, RSTRING_PTR(iv_name), RSTRING_LEN(iv_name));
+  } else if(mrb_symbol_p(iv_name)) {
+    iv_name_id = mrb_symbol(iv_name);
+    check_iv_name(mrb, iv_name_id);
   }
 
-  return id;
+  return iv_name_id;
 }
 
 /* 15.3.1.3.20 */
@@ -637,13 +637,13 @@ mrb_obj_ivar_defined(mrb_state *mrb, mrb_value self)
 mrb_value
 mrb_obj_ivar_get(mrb_state *mrb, mrb_value self)
 {
-  mrb_sym id;
-  mrb_value sym;
+  mrb_sym iv_name_id;
+  mrb_value iv_name;
   
-  mrb_get_args(mrb, "o", &sym);
+  mrb_get_args(mrb, "o", &iv_name);
 
-  id = get_valid_iv_sym(mrb, sym);
-  return mrb_iv_get(mrb, self, id);
+  iv_name_id = get_valid_iv_sym(mrb, iv_name);
+  return mrb_iv_get(mrb, self, iv_name_id);
 }
 
 /* 15.3.1.3.22 */
@@ -669,13 +669,13 @@ mrb_obj_ivar_get(mrb_state *mrb, mrb_value self)
 mrb_value
 mrb_obj_ivar_set(mrb_state *mrb, mrb_value self)
 {
-  mrb_sym id;
-  mrb_value sym, val;
+  mrb_sym iv_name_id;
+  mrb_value iv_name, val;
 
-  mrb_get_args(mrb, "oo", &sym, &val);
+  mrb_get_args(mrb, "oo", &iv_name, &val);
   
-  id = get_valid_iv_sym(mrb, sym);
-  mrb_iv_set(mrb, self, id, val);
+  iv_name_id = get_valid_iv_sym(mrb, iv_name);
+  mrb_iv_set(mrb, self, iv_name_id, val);
   return val;
 }
 
-- 
cgit v1.2.3


From 2daf39ddc85c7c4d36e18580a6fb60dcf1f0ecf4 Mon Sep 17 00:00:00 2001
From: "Yukihiro \"Matz\" Matsumoto" <matz@ruby-lang.org>
Date: Mon, 22 Jul 2013 09:52:06 +0900
Subject: change else formatting

---
 src/array.c   |  3 ++-
 src/class.c   | 15 ++++++++++-----
 src/error.c   |  9 ++++++---
 src/gc.c      |  3 ++-
 src/kernel.c  |  3 ++-
 src/numeric.c |  9 ++++++---
 6 files changed, 28 insertions(+), 14 deletions(-)

(limited to 'src/kernel.c')

diff --git a/src/array.c b/src/array.c
index b5bbdf0fa..526cf4973 100644
--- a/src/array.c
+++ b/src/array.c
@@ -926,7 +926,8 @@ inspect_ary(mrb_state *mrb, mrb_value ary, mrb_value list)
     }
     if (mrb_array_p(RARRAY_PTR(ary)[i])) {
       s = inspect_ary(mrb, RARRAY_PTR(ary)[i], list);
-    } else {
+    }
+    else {
       s = mrb_inspect(mrb, RARRAY_PTR(ary)[i]);
     }
     mrb_str_buf_cat(mrb, arystr, RSTRING_PTR(s), RSTRING_LEN(s));
diff --git a/src/class.c b/src/class.c
index 606a54a7c..ad4c9eaa2 100644
--- a/src/class.c
+++ b/src/class.c
@@ -1437,7 +1437,8 @@ undef_method(mrb_state *mrb, struct RClass *c, mrb_sym a)
 
   if (!mrb_obj_respond_to(c, a)) {
     mrb_name_error(mrb, a, "undefined method '%S' for class '%S'", mrb_sym2str(mrb, a), mrb_obj_value(c));
-  } else {
+  }
+  else {
     MRB_SET_VALUE(m, MRB_TT_PROC, value.p, 0);
     mrb_define_method_vm(mrb, c, a, m);
   }
@@ -1519,7 +1520,8 @@ get_sym_or_str_arg(mrb_state *mrb)
 
   if (mrb_symbol_p(sym_or_str) || mrb_string_p(sym_or_str)) {
     return sym_or_str;
-  } else {
+  }
+  else {
     mrb_value obj = mrb_funcall(mrb, sym_or_str, "inspect", 0);
     mrb_raisef(mrb, E_TYPE_ERROR, "%S is not a symbol", obj);
     return mrb_nil_value();
@@ -1551,7 +1553,8 @@ mrb_mod_cvar_defined(mrb_state *mrb, mrb_value mod)
   if (mrb_symbol_p(id)) {
     check_cv_name_sym(mrb, mrb_symbol(id));
     defined_p = mrb_cv_defined(mrb, mod, mrb_symbol(id));
-  } else {
+  }
+  else {
     mrb_value sym;
     check_cv_name_str(mrb, id);
     sym = mrb_check_intern_str(mrb, id);
@@ -1703,7 +1706,8 @@ mrb_mod_method_defined(mrb_state *mrb, mrb_value mod)
   id = get_sym_or_str_arg(mrb);
   if (mrb_symbol_p(id)) {
     method_defined_p = mrb_obj_respond_to(mrb_class_ptr(mod), mrb_symbol(id));
-  } else {
+  }
+  else {
     mrb_value sym = mrb_check_intern_str(mrb, id);
     if (mrb_nil_p(sym)) {
       method_defined_p = FALSE;
@@ -1787,7 +1791,8 @@ mrb_mod_const_defined(mrb_state *mrb, mrb_value mod)
   if (mrb_type(id) == MRB_TT_SYMBOL) {
     check_const_name_sym(mrb, mrb_symbol(id));
     const_defined_p = mrb_const_defined(mrb, mod, mrb_symbol(id));
-  } else {
+  }
+  else {
     mrb_value sym;
     check_const_name_str(mrb, id);
     sym = mrb_check_intern_str(mrb, id);
diff --git a/src/error.c b/src/error.c
index bd3afd2e1..9f3a86cc8 100644
--- a/src/error.c
+++ b/src/error.c
@@ -147,7 +147,8 @@ exc_inspect(mrb_state *mrb, mrb_value exc)
     if (!mrb_nil_p(mesg) && RSTRING_LEN(mesg) > 0) {
       mrb_str_cat(mrb, str, ": ", 2);
       mrb_str_append(mrb, str, mesg);
-    } else {
+    }
+    else {
       mrb_str_cat(mrb, str, ": ", 2);
       mrb_str_cat_cstr(mrb, str, mrb_obj_classname(mrb, exc));
     }
@@ -425,10 +426,12 @@ mrb_sys_fail(mrb_state *mrb, const char *mesg)
     sce = mrb_class_get(mrb, "SystemCallError");
     if (mesg != NULL) {
       mrb_funcall(mrb, mrb_obj_value(sce), "_sys_fail", 2, mrb_fixnum_value(no), mrb_str_new_cstr(mrb, mesg));
-    } else {
+    }
+    else {
       mrb_funcall(mrb, mrb_obj_value(sce), "_sys_fail", 1, mrb_fixnum_value(no));
     }
-  } else {
+  }
+  else {
     mrb_raise(mrb, E_RUNTIME_ERROR, mesg);
   }
 }
diff --git a/src/gc.c b/src/gc.c
index a22ef1adf..581a5ff9c 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -212,7 +212,8 @@ mrb_calloc(mrb_state *mrb, size_t nelem, size_t len)
     if (p) {
       memset(p, 0, size);
     }
-  } else {
+  }
+  else {
     p = NULL;
   }
 
diff --git a/src/kernel.c b/src/kernel.c
index f2c7f182f..4914b7285 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -574,7 +574,8 @@ get_valid_iv_sym(mrb_state *mrb, mrb_value iv_name)
   if (mrb_string_p(iv_name)) {
     iv_name_id = mrb_intern_cstr(mrb, RSTRING_PTR(iv_name));
     valid_iv_name(mrb, iv_name_id, RSTRING_PTR(iv_name), RSTRING_LEN(iv_name));
-  } else if(mrb_symbol_p(iv_name)) {
+  }
+  else if(mrb_symbol_p(iv_name)) {
     iv_name_id = mrb_symbol(iv_name);
     check_iv_name(mrb, iv_name_id);
   }
diff --git a/src/numeric.c b/src/numeric.c
index e1543c089..c734a595d 100644
--- a/src/numeric.c
+++ b/src/numeric.c
@@ -240,7 +240,8 @@ mrb_flo_to_str(mrb_state *mrb, mrb_value flo, int max_digit)
       *(c++) = 'e';
       if (exp > 0) {
         *(c++) = '+';
-      } else {
+      }
+      else {
         *(c++) = '-';
         exp = -exp;
       }
@@ -1253,12 +1254,14 @@ mrb_fixnum_to_str(mrb_state *mrb, mrb_value x, int base)
 
   if (val == 0) {
     *--b = '0';
-  } else if (val < 0) {
+  }
+  else if (val < 0) {
     do {
       *--b = mrb_digitmap[-(val % base)];
     } while (val /= base);
     *--b = '-';
-  } else {
+  }
+  else {
     do {
       *--b = mrb_digitmap[(int)(val % base)];
     } while (val /= base);
-- 
cgit v1.2.3


From 4a8e89db2bb586095a43eba46edbce0e58feb55f Mon Sep 17 00:00:00 2001
From: fleuria <me.ssword@gmail.com>
Date: Wed, 24 Jul 2013 19:10:10 +0800
Subject: suppress the warnings from get_valid_iv_sym()

The parameter iv_name SHOULD be string or symbol, but there is no
garantee on it.
---
 src/kernel.c | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

(limited to 'src/kernel.c')

diff --git a/src/kernel.c b/src/kernel.c
index 4914b7285..eb123b51e 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -4,6 +4,8 @@
 ** See Copyright Notice in mruby.h
 */
 
+#include <assert.h>
+
 #include "mruby.h"
 #include "mruby/array.h"
 #include "mruby/class.h"
@@ -549,7 +551,7 @@ obj_is_instance_of(mrb_state *mrb, mrb_value self)
 }
 
 static void
-valid_iv_name(mrb_state *mrb, mrb_sym iv_name_id, const char* s, size_t len) 
+valid_iv_name(mrb_state *mrb, mrb_sym iv_name_id, const char* s, size_t len)
 {
   if (len < 2 || !(s[0] == '@' && s[1] != '@')) {
     mrb_name_error(mrb, iv_name_id, "`%S' is not allowed as an instance variable name", mrb_sym2str(mrb, iv_name_id));
@@ -575,7 +577,8 @@ get_valid_iv_sym(mrb_state *mrb, mrb_value iv_name)
     iv_name_id = mrb_intern_cstr(mrb, RSTRING_PTR(iv_name));
     valid_iv_name(mrb, iv_name_id, RSTRING_PTR(iv_name), RSTRING_LEN(iv_name));
   }
-  else if(mrb_symbol_p(iv_name)) {
+  else {
+    assert(mrb_symbol_p(iv_name));
     iv_name_id = mrb_symbol(iv_name);
     check_iv_name(mrb, iv_name_id);
   }
@@ -640,7 +643,7 @@ mrb_obj_ivar_get(mrb_state *mrb, mrb_value self)
 {
   mrb_sym iv_name_id;
   mrb_value iv_name;
-  
+
   mrb_get_args(mrb, "o", &iv_name);
 
   iv_name_id = get_valid_iv_sym(mrb, iv_name);
@@ -674,7 +677,7 @@ mrb_obj_ivar_set(mrb_state *mrb, mrb_value self)
   mrb_value iv_name, val;
 
   mrb_get_args(mrb, "oo", &iv_name, &val);
-  
+
   iv_name_id = get_valid_iv_sym(mrb, iv_name);
   mrb_iv_set(mrb, self, iv_name_id, val);
   return val;
-- 
cgit v1.2.3


From 620e323d156378f776b9914c45d460699ebfc41f Mon Sep 17 00:00:00 2001
From: fleuria <me.ssword@gmail.com>
Date: Thu, 25 Jul 2013 02:51:24 +0800
Subject: replace assert with mrb_assert

---
 src/kernel.c  |  5 ++---
 src/numeric.c |  3 +--
 src/parse.y   | 22 +++++++++++-----------
 src/state.c   |  8 ++------
 src/vm.c      |  6 +++---
 5 files changed, 19 insertions(+), 25 deletions(-)

(limited to 'src/kernel.c')

diff --git a/src/kernel.c b/src/kernel.c
index eb123b51e..ce3aa89f0 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -4,8 +4,6 @@
 ** See Copyright Notice in mruby.h
 */
 
-#include <assert.h>
-
 #include "mruby.h"
 #include "mruby/array.h"
 #include "mruby/class.h"
@@ -573,12 +571,13 @@ get_valid_iv_sym(mrb_state *mrb, mrb_value iv_name)
 {
   mrb_sym iv_name_id;
 
+  mrb_assert(mrb_symbol_p(iv_name) || mrb_string_p(iv_name));
+
   if (mrb_string_p(iv_name)) {
     iv_name_id = mrb_intern_cstr(mrb, RSTRING_PTR(iv_name));
     valid_iv_name(mrb, iv_name_id, RSTRING_PTR(iv_name), RSTRING_LEN(iv_name));
   }
   else {
-    assert(mrb_symbol_p(iv_name));
     iv_name_id = mrb_symbol(iv_name);
     check_iv_name(mrb, iv_name_id);
   }
diff --git a/src/numeric.c b/src/numeric.c
index c734a595d..4d794f8d8 100644
--- a/src/numeric.c
+++ b/src/numeric.c
@@ -4,7 +4,6 @@
 ** See Copyright Notice in mruby.h
 */
 
-#include <assert.h>
 #include <float.h>
 #if defined(__FreeBSD__) && __FreeBSD__ < 4
 # include <floatingpoint.h>
@@ -782,7 +781,7 @@ fixdivmod(mrb_state *mrb, mrb_int x, mrb_int y, mrb_int *divp, mrb_int *modp)
 {
   mrb_int div, mod;
 
-  /* TODO: add assert(y != 0) to make sure */
+  /* TODO: add mrb_assert(y != 0) to make sure */
 
   if (y < 0) {
     if (x < 0)
diff --git a/src/parse.y b/src/parse.y
index fda66e92c..9a83d5cbd 100644
--- a/src/parse.y
+++ b/src/parse.y
@@ -1,6 +1,6 @@
 /*
 ** parse.y - mruby parser
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
@@ -272,7 +272,7 @@ new_scope(parser_state *p, node *body)
 static node*
 new_begin(parser_state *p, node *body)
 {
-  if (body) 
+  if (body)
     return list2((node*)NODE_BEGIN, body);
   return cons((node*)NODE_BEGIN, 0);
 }
@@ -909,7 +909,7 @@ parsing_heredoc_inf(parser_state *p)
   node *nd = p->parsing_heredoc;
   if (nd == NULL)
     return NULL;
-  /* assert(nd->car->car == NODE_HEREDOC); */
+  /* mrb_assert(nd->car->car == NODE_HEREDOC); */
   return (parser_heredoc_info*)nd->car->cdr;
 }
 
@@ -2744,7 +2744,7 @@ var_ref		: variable
 		    {
 		      $$ = var_reference(p, $1);
 		    }
-		| keyword_nil 
+		| keyword_nil
 		    {
 		      $$ = new_nil(p);
 		    }
@@ -3408,7 +3408,7 @@ scan_oct(const int *start, int len, int *retlen)
   const int *s = start;
   int retval = 0;
 
-  /* assert(len <= 3) */
+  /* mrb_assert(len <= 3) */
   while (len-- && *s >= '0' && *s <= '7') {
     retval <<= 3;
     retval |= *s++ - '0';
@@ -3426,7 +3426,7 @@ scan_hex(const int *start, int len, int *retlen)
   register int retval = 0;
   char *tmp;
 
-  /* assert(len <= 2) */
+  /* mrb_assert(len <= 2) */
   while (len-- && *s && (tmp = (char*)strchr(hexdigit, *s))) {
     retval <<= 4;
     retval |= (tmp - hexdigit) & 15;
@@ -3686,7 +3686,7 @@ parse_string(parser_state *p)
 
     tokadd(p, c);
 
-  } 
+  }
 
   tokfix(p);
   p->lstate = EXPR_END;
@@ -3731,7 +3731,7 @@ parse_string(parser_state *p)
   yylval.nd = new_str(p, tok(p), toklen(p));
   return tSTRING;
 }
- 
+
 
 static int
 heredoc_identifier(parser_state *p)
@@ -4813,7 +4813,7 @@ parser_yylex(parser_state *p)
       pushback(p, c);
       if (last_state == EXPR_FNAME) goto gvar;
       tokfix(p);
-      yylval.nd = new_nth_ref(p, atoi(tok(p))); 
+      yylval.nd = new_nth_ref(p, atoi(tok(p)));
       return tNTH_REF;
 
     default:
@@ -5176,7 +5176,7 @@ parser_state*
 mrb_parse_file(mrb_state *mrb, FILE *f, mrbc_context *c)
 {
   parser_state *p;
- 
+
   p = mrb_parser_new(mrb);
   if (!p) return 0;
   p->s = p->send = NULL;
@@ -5561,7 +5561,7 @@ parser_dump(mrb_state *mrb, node *tree, int offset)
     printf("NODE_CALL:\n");
     parser_dump(mrb, tree->car, offset+1);
     dump_prefix(offset+1);
-    printf("method='%s' (%d)\n", 
+    printf("method='%s' (%d)\n",
     mrb_sym2name(mrb, sym(tree->cdr->car)),
     (int)(intptr_t)tree->cdr->car);
     tree = tree->cdr->cdr->car;
diff --git a/src/state.c b/src/state.c
index 34de1e45e..5dcc4a40a 100644
--- a/src/state.c
+++ b/src/state.c
@@ -21,10 +21,6 @@ inspect_main(mrb_state *mrb, mrb_value mod)
   return mrb_str_new(mrb, "main", 4);
 }
 
-#ifdef MRB_NAN_BOXING
-#include <assert.h>
-#endif
-
 mrb_state*
 mrb_open_allocf(mrb_allocf f, void *ud)
 {
@@ -33,7 +29,7 @@ mrb_open_allocf(mrb_allocf f, void *ud)
   mrb_state *mrb;
 
 #ifdef MRB_NAN_BOXING
-  assert(sizeof(void*) == 4);
+  mrb_assert(sizeof(void*) == 4);
 #endif
 
   mrb = (mrb_state *)(f)(NULL, NULL, sizeof(mrb_state), ud);
@@ -192,7 +188,7 @@ mrb_value
 mrb_top_self(mrb_state *mrb)
 {
   if (!mrb->top_self) {
-    mrb->top_self = (struct RObject*)mrb_obj_alloc(mrb, MRB_TT_OBJECT, mrb->object_class);  
+    mrb->top_self = (struct RObject*)mrb_obj_alloc(mrb, MRB_TT_OBJECT, mrb->object_class);
     mrb_define_singleton_method(mrb, mrb->top_self, "inspect", inspect_main, MRB_ARGS_NONE());
     mrb_define_singleton_method(mrb, mrb->top_self, "to_s", inspect_main, MRB_ARGS_NONE());
   }
diff --git a/src/vm.c b/src/vm.c
index c9e80e0ed..f3c659e50 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -92,12 +92,12 @@ stack_init(mrb_state *mrb)
 {
   struct mrb_context *c = mrb->c;
 
-  /* assert(mrb->stack == NULL); */
+  /* mrb_assert(mrb->stack == NULL); */
   c->stbase = (mrb_value *)mrb_calloc(mrb, STACK_INIT_SIZE, sizeof(mrb_value));
   c->stend = c->stbase + STACK_INIT_SIZE;
   c->stack = c->stbase;
 
-  /* assert(ci == NULL); */
+  /* mrb_assert(ci == NULL); */
   c->cibase = (mrb_callinfo *)mrb_calloc(mrb, CALLINFO_INIT_SIZE, sizeof(mrb_callinfo));
   c->ciend = c->cibase + CALLINFO_INIT_SIZE;
   c->ci = c->cibase;
@@ -544,7 +544,7 @@ void mrb_gv_val_set(mrb_state *mrb, mrb_sym sym, mrb_value val);
 mrb_value
 mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
 {
-  /* assert(mrb_proc_cfunc_p(proc)) */
+  /* mrb_assert(mrb_proc_cfunc_p(proc)) */
   mrb_irep *irep = proc->body.irep;
   mrb_code *pc = irep->iseq;
   mrb_value *pool = irep->pool;
-- 
cgit v1.2.3