Merge remote-tracking branch 'upstream/master'

8 files changed, 144 insertions, 20 deletions

diff --git a/mrbgems/default.gembox b/mrbgems/default.gembox
index 1c6732d48..b2cdac93d 100644
--- a/mrbgems/default.gembox
+++ b/mrbgems/default.gembox
@@ -41,6 +41,9 @@ MRuby::GemBox.new do |conf|
   # Use Random class
   conf.gem :core => "mruby-random"
 
+  # Use extensional Object class
+  conf.gem :core => "mruby-object-ext"
+
   # Use ObjectSpace class
   conf.gem :core => "mruby-objectspace"
 
diff --git a/mrbgems/mruby-math/src/math.c b/mrbgems/mruby-math/src/math.c
index bf3c007b4..bdc7767f7 100644
--- a/mrbgems/mruby-math/src/math.c
+++ b/mrbgems/mruby-math/src/math.c
@@ -12,8 +12,8 @@
 #define domain_error(msg) \
     mrb_raise(mrb, E_RANGE_ERROR, "Numerical argument is out of domain - " #msg)
 
-/* math functions not provided under Microsoft Visual C++ */
-#ifdef _MSC_VER
+/* math functions not provided by Microsoft Visual C++ 2012 or older */
+#if defined _MSC_VER && _MSC_VER < 1800
 
 #define MATH_TOLERANCE 1E-12
 
@@ -87,6 +87,12 @@ erfc(double x)
   return one_sqrtpi*exp(-x*x)*q2;
 }
 
+double
+log2(double x)
+{
+    return log10(x)/log10(2.0);
+}
+
 #endif
 
 /*
@@ -358,18 +364,6 @@ math_atanh(mrb_state *mrb, mrb_value obj)
 # define log10(x) ((x) < 0.0 ? nan("") : log10(x))
 #endif
 
-#ifndef log2
-#ifndef HAVE_LOG2
-double
-log2(double x)
-{
-    return log10(x)/log10(2.0);
-}
-#else
-extern double log2(double);
-#endif
-#endif
-
 /*
  *  call-seq:
  *     Math.exp(x)    -> float
diff --git a/mrbgems/mruby-object-ext/mrbgem.rake b/mrbgems/mruby-object-ext/mrbgem.rake
new file mode 100644
index 000000000..1f232949e
--- /dev/null
+++ b/mrbgems/mruby-object-ext/mrbgem.rake
@@ -0,0 +1,4 @@
+MRuby::Gem::Specification.new('mruby-object-ext') do |spec|
+  spec.license = 'MIT'
+  spec.authors = 'mruby developers'
+end
diff --git a/mrbgems/mruby-object-ext/src/object.c b/mrbgems/mruby-object-ext/src/object.c
new file mode 100644
index 000000000..598ebe91d
--- /dev/null
+++ b/mrbgems/mruby-object-ext/src/object.c
@@ -0,0 +1,108 @@
+#include "mruby.h"
+#include "mruby/array.h"
+#include "mruby/class.h"
+
+/*
+ *  call-seq:
+ *     nil.to_a    -> []
+ *
+ *  Always returns an empty array.
+ */
+
+static mrb_value
+nil_to_a(mrb_state *mrb, mrb_value obj)
+{
+    return mrb_ary_new(mrb);
+}
+
+/*
+ *  call-seq:
+ *     nil.to_f    -> 0.0
+ *
+ *  Always returns zero.
+ */
+
+static mrb_value
+nil_to_f(mrb_state *mrb, mrb_value obj)
+{
+    return mrb_float_value(mrb, 0.0);
+}
+
+/*
+ *  call-seq:
+ *     nil.to_i    -> 0
+ *
+ *  Always returns zero.
+ */
+
+static mrb_value
+nil_to_i(mrb_state *mrb, mrb_value obj)
+{
+    return mrb_fixnum_value(0);
+}
+
+/*
+ *  call-seq:
+ *     obj.instance_exec(arg...) {|var...| block }                       -> obj
+ *
+ *  Executes the given block within the context of the receiver
+ *  (_obj_). In order to set the context, the variable +self+ is set
+ *  to _obj_ while the code is executing, giving the code access to
+ *  _obj_'s instance variables.  Arguments are passed as block parameters.
+ *
+ *     class KlassWithSecret
+ *       def initialize
+ *         @secret = 99
+ *       end
+ *     end
+ *     k = KlassWithSecret.new
+ *     k.instance_exec(5) {|x| @secret+x }   #=> 104
+ */
+
+mrb_value 
+mrb_yield_internal(mrb_state *mrb, mrb_value b, int argc, mrb_value *argv, mrb_value self, struct RClass *c);
+
+static mrb_value
+mrb_obj_instance_exec(mrb_state *mrb, mrb_value self)
+{
+  mrb_value *argv;
+  int argc;
+  mrb_value blk;
+  struct RClass *c;
+  
+  mrb_get_args(mrb, "*&", &argv, &argc, &blk);
+
+  if (mrb_nil_p(blk)) {
+    mrb_raise(mrb, E_ARGUMENT_ERROR, "no block given");
+  }
+
+  switch (mrb_type(self)) {
+  case MRB_TT_SYMBOL:
+  case MRB_TT_FIXNUM:
+  case MRB_TT_FLOAT:
+    c = 0;
+    break;
+  default:
+    c = mrb_class_ptr(mrb_singleton_class(mrb, self));
+    break;
+  }
+
+  return mrb_yield_internal(mrb, blk, argc, argv, self, c);
+}
+
+void
+mrb_mruby_object_ext_gem_init(mrb_state* mrb)
+{
+  struct RClass * n = mrb->nil_class;
+
+  mrb_define_method(mrb, n, "to_a", nil_to_a,       MRB_ARGS_NONE());
+  mrb_define_method(mrb, n, "to_f", nil_to_f,       MRB_ARGS_NONE());
+  mrb_define_method(mrb, n, "to_i", nil_to_i,       MRB_ARGS_NONE());
+
+  mrb_define_method(mrb, mrb->object_class, "instance_exec", mrb_obj_instance_exec, MRB_ARGS_ANY() | MRB_ARGS_BLOCK());
+}
+
+void
+mrb_mruby_object_ext_gem_final(mrb_state* mrb)
+{
+}
diff --git a/mrbgems/mruby-object-ext/test/nil.rb b/mrbgems/mruby-object-ext/test/nil.rb
new file mode 100644
index 000000000..e385dec6a
--- /dev/null
+++ b/mrbgems/mruby-object-ext/test/nil.rb
@@ -0,0 +1,11 @@
+assert('NilClass#to_a') do
+  assert_equal nil.to_a, []
+end
+
+assert('NilClass#to_f') do
+  assert_equal nil.to_f, 0.0
+end
+
+assert('NilClass#to_i') do
+  assert_equal nil.to_i, 0
+end
diff --git a/mrbgems/mruby-object-ext/test/object.rb b/mrbgems/mruby-object-ext/test/object.rb
new file mode 100644
index 000000000..1a75622f6
--- /dev/null
+++ b/mrbgems/mruby-object-ext/test/object.rb
@@ -0,0 +1,9 @@
+assert('Object#instance_exec') do
+  class KlassWithSecret
+    def initialize
+      @secret = 99
+    end
+  end
+  k = KlassWithSecret.new
+  assert_equal k.instance_exec(5) {|x| @secret+x }, 104
+end
diff --git a/mrbgems/mruby-sprintf/src/sprintf.c b/mrbgems/mruby-sprintf/src/sprintf.c
index 55698d09f..6479b19bc 100644
--- a/mrbgems/mruby-sprintf/src/sprintf.c
+++ b/mrbgems/mruby-sprintf/src/sprintf.c
@@ -15,10 +15,6 @@
 #include <math.h>
 #include <ctype.h>
 
-#ifdef _MSC_VER
-#include <float.h>
-#endif
-
 #ifdef HAVE_IEEEFP_H
 #include <ieeefp.h>
 #endif
diff --git a/mrbgems/mruby-struct/src/struct.c b/mrbgems/mruby-struct/src/struct.c
index a2731ca54..7a796414d 100644
--- a/mrbgems/mruby-struct/src/struct.c
+++ b/mrbgems/mruby-struct/src/struct.c
@@ -185,8 +185,7 @@ static mrb_value
 mrb_struct_set(mrb_state *mrb, mrb_value obj, mrb_value val)
 {
   const char *name;
-  int i;
-  size_t len;
+  size_t i, len;
   mrb_sym mid;
   mrb_value members, slot, *ptr, *ptr_members;