script_core 0.2.1 → 0.2.2

data/ext/enterprise_script_service/mruby/mrbgems/mruby-math/test/math.rb

@@ -1,6 +1,14 @@
 ##
 # Math Test
 
+def assert_float_and_int(exp_ary, act_ary)
+  assert('assert_float_and_int') do
+    flo_exp, int_exp, flo_act, int_act = *exp_ary, *act_ary
+    assert_float(flo_exp, flo_act)
+    assert_operator(int_exp, :eql?, int_act)
+  end
+end
+
 assert('Math.sin 0') do
   assert_float(0, Math.sin(0))
 end
@@ -109,12 +117,6 @@
   assert_float(5.0, Math.hypot(3, 4))
 end
 
-assert('Math.frexp 1234') do
-  n = 1234
-  fraction, exponent = Math.frexp(n)
-  assert_float(n, Math.ldexp(fraction, exponent))
-end
-
 assert('Math.erf 1') do
   assert_float(0.842700792949715, Math.erf(1))
 end
@@ -130,3 +132,108 @@
 assert('Math.erfc -1') do
   assert_float(1.8427007929497148, Math.erfc(-1))
 end
+
+assert('Math.acos') do
+  assert_float(0 * Math::PI / 4, Math.acos( 1.0))
+  assert_float(1 * Math::PI / 4, Math.acos( 1.0 / Math.sqrt(2)))
+  assert_float(2 * Math::PI / 4, Math.acos( 0.0))
+  assert_float(4 * Math::PI / 4, Math.acos(-1.0))
+  assert_raise(Math::DomainError) { Math.acos(+1.1) }
+  assert_raise(Math::DomainError) { Math.acos(-1.1) }
+end
+
+assert('Math.asin') do
+  assert_float( 0 * Math::PI / 4, Math.asin( 0.0))
+  assert_float( 1 * Math::PI / 4, Math.asin( 1.0 / Math.sqrt(2)))
+  assert_float( 2 * Math::PI / 4, Math.asin( 1.0))
+  assert_float(-2 * Math::PI / 4, Math.asin(-1.0))
+  assert_raise(Math::DomainError) { Math.asin(+1.1) }
+  assert_raise(Math::DomainError) { Math.asin(-1.1) }
+  assert_raise(Math::DomainError) { Math.asin(2.0) }
+end
+
+assert('Math.atan') do
+  assert_float( 0 * Math::PI / 4, Math.atan( 0.0))
+  assert_float( 1 * Math::PI / 4, Math.atan( 1.0))
+  assert_float( 2 * Math::PI / 4, Math.atan(1.0 / 0.0))
+  assert_float(-1 * Math::PI / 4, Math.atan(-1.0))
+end
+
+assert('Math.cosh') do
+  assert_float(1, Math.cosh(0))
+  assert_float((Math::E ** 1 + Math::E ** -1) / 2, Math.cosh(1))
+  assert_float((Math::E ** 2 + Math::E ** -2) / 2, Math.cosh(2))
+end
+
+assert('Math.sinh') do
+  assert_float(0, Math.sinh(0))
+  assert_float((Math::E ** 1 - Math::E ** -1) / 2, Math.sinh(1))
+  assert_float((Math::E ** 2 - Math::E ** -2) / 2, Math.sinh(2))
+end
+
+assert('Math.tanh') do
+  assert_float(Math.sinh(0) / Math.cosh(0), Math.tanh(0))
+  assert_float(Math.sinh(1) / Math.cosh(1), Math.tanh(1))
+  assert_float(Math.sinh(2) / Math.cosh(2), Math.tanh(2))
+  assert_float(+1.0, Math.tanh(+1000.0))
+  assert_float(-1.0, Math.tanh(-1000.0))
+end
+
+assert('Math.acosh') do
+  assert_float(0, Math.acosh(1))
+  assert_float(1, Math.acosh((Math::E ** 1 + Math::E ** -1) / 2))
+  assert_float(2, Math.acosh((Math::E ** 2 + Math::E ** -2) / 2))
+  assert_raise(Math::DomainError) { Math.acosh(0.9) }
+  assert_raise(Math::DomainError) { Math.acosh(0) }
+end
+
+assert('Math.asinh') do
+  assert_float(0, Math.asinh(0))
+  assert_float(1, Math.asinh((Math::E ** 1 - Math::E ** -1) / 2))
+  assert_float(2, Math.asinh((Math::E ** 2 - Math::E ** -2) / 2))
+end
+
+assert('Math.atanh') do
+  assert_float(0, Math.atanh(Math.sinh(0) / Math.cosh(0)))
+  assert_float(1, Math.atanh(Math.sinh(1) / Math.cosh(1)))
+  assert_float(2, Math.atanh(Math.sinh(2) / Math.cosh(2)))
+  assert_float(Float::INFINITY, Math.atanh(1))
+  assert_float(-Float::INFINITY, Math.atanh(-1))
+  assert_raise(Math::DomainError) { Math.atanh(+1.1) }
+  assert_raise(Math::DomainError) { Math.atanh(-1.1) }
+end
+
+assert('Math.atan2') do
+  assert_float(+0.0, Math.atan2(+0.0, +0.0))
+  assert_float(-0.0, Math.atan2(-0.0, +0.0))
+  assert_float(+Math::PI, Math.atan2(+0.0, -0.0))
+  assert_float(-Math::PI, Math.atan2(-0.0, -0.0))
+
+  inf = Float::INFINITY
+  expected = 3.0 * Math::PI / 4.0
+  assert_float(+expected, Math.atan2(+inf, -inf))
+  assert_float(-expected, Math.atan2(-inf, -inf))
+  expected = Math::PI / 4.0
+  assert_float(+expected, Math.atan2(+inf, +inf))
+  assert_float(-expected, Math.atan2(-inf, +inf))
+
+  assert_float(0, Math.atan2(0, 1))
+  assert_float(Math::PI / 4, Math.atan2(1, 1))
+  assert_float(Math::PI / 2, Math.atan2(1, 0))
+end
+
+assert('Math.ldexp') do
+  assert_float(0.0, Math.ldexp(0.0, 0.0))
+  assert_float(0.5, Math.ldexp(0.5, 0.0))
+  assert_float(1.0, Math.ldexp(0.5, 1.0))
+  assert_float(2.0, Math.ldexp(0.5, 2.0))
+  assert_float(3.0, Math.ldexp(0.75, 2.0))
+end
+
+assert('Math.frexp') do
+  assert_float_and_int([0.0,  0], Math.frexp(0.0))
+  assert_float_and_int([0.5,  0], Math.frexp(0.5))
+  assert_float_and_int([0.5,  1], Math.frexp(1.0))
+  assert_float_and_int([0.5,  2], Math.frexp(2.0))
+  assert_float_and_int([0.75, 2], Math.frexp(3.0))
+end

data/ext/enterprise_script_service/mruby/mrbgems/mruby-metaprog/src/metaprog.c

@@ -172,7 +172,7 @@ mrb_local_variables(mrb_state *mrb, mrb_value self)
 KHASH_DECLARE(st, mrb_sym, char, FALSE)
 
 static void
-method_entry_loop(mrb_state *mrb, struct RClass* klass, khash_t(st)* set)
+method_entry_loop(mrb_state *mrb, struct RClass *klass, khash_t(st) *set, khash_t(st) *undef)
 {
   khint_t i;
 
@@ -181,20 +181,28 @@ method_entry_loop(mrb_state *mrb, struct RClass* klass, khash_t(st)* set)
   for (i=0;i<kh_end(h);i++) {
     if (kh_exist(h, i)) {
       mrb_method_t m = kh_value(h, i);
-      if (MRB_METHOD_UNDEF_P(m)) continue;
-      kh_put(st, mrb, set, kh_key(h, i));
+      if (MRB_METHOD_UNDEF_P(m)) {
+        if (undef) {
+          kh_put(st, mrb, undef, kh_key(h, i));
+        }
+      }
+      else if (undef == NULL ||
+               kh_get(st, mrb, undef, kh_key(h, i)) == kh_end(undef)) {
+        kh_put(st, mrb, set, kh_key(h, i));
+      }
     }
   }
 }
 
 static mrb_value
-mrb_class_instance_method_list(mrb_state *mrb, mrb_bool recur, struct RClass* klass, int obj)
+mrb_class_instance_method_list(mrb_state *mrb, mrb_bool recur, struct RClass *klass, int obj)
 {
   khint_t i;
   mrb_value ary;
   mrb_bool prepended = FALSE;
-  struct RClass* oldklass;
-  khash_t(st)* set = kh_init(st, mrb);
+  struct RClass *oldklass;
+  khash_t(st) *set = kh_init(st, mrb);
+  khash_t(st) *undef = (recur ? kh_init(st, mrb) : NULL);
 
   if (!recur && (klass->flags & MRB_FL_CLASS_IS_PREPENDED)) {
     MRB_CLASS_ORIGIN(klass);
@@ -203,7 +211,7 @@ mrb_class_instance_method_list(mrb_state *mrb, mrb_bool recur, struct RClass* kl
 
   oldklass = 0;
   while (klass && (klass != oldklass)) {
-    method_entry_loop(mrb, klass, set);
+    method_entry_loop(mrb, klass, set, undef);
     if ((klass->tt == MRB_TT_ICLASS && !prepended) ||
         (klass->tt == MRB_TT_SCLASS)) {
     }
@@ -221,6 +229,7 @@ mrb_class_instance_method_list(mrb_state *mrb, mrb_bool recur, struct RClass* kl
     }
   }
   kh_destroy(st, mrb, set);
+  if (undef) kh_destroy(st, mrb, undef);
 
   return ary;
 }
@@ -313,18 +322,19 @@ mrb_obj_singleton_methods(mrb_state *mrb, mrb_bool recur, mrb_value obj)
 {
   khint_t i;
   mrb_value ary;
-  struct RClass* klass;
-  khash_t(st)* set = kh_init(st, mrb);
+  struct RClass *klass;
+  khash_t(st) *set = kh_init(st, mrb);
+  khash_t(st) *undef = (recur ? kh_init(st, mrb) : NULL);
 
   klass = mrb_class(mrb, obj);
 
   if (klass && (klass->tt == MRB_TT_SCLASS)) {
-      method_entry_loop(mrb, klass, set);
+      method_entry_loop(mrb, klass, set, undef);
       klass = klass->super;
   }
   if (recur) {
       while (klass && ((klass->tt == MRB_TT_SCLASS) || (klass->tt == MRB_TT_ICLASS))) {
-        method_entry_loop(mrb, klass, set);
+        method_entry_loop(mrb, klass, set, undef);
         klass = klass->super;
       }
   }
@@ -336,6 +346,7 @@ mrb_obj_singleton_methods(mrb_state *mrb, mrb_bool recur, mrb_value obj)
     }
   }
   kh_destroy(st, mrb, set);
+  if (undef) kh_destroy(st, mrb, undef);
 
   return ary;
 }

data/ext/enterprise_script_service/mruby/mrbgems/mruby-pack/README.md

@@ -49,6 +49,7 @@ There is no dependency on other mrbgems.
 ## License
 
 Copyright (c) 2012 Internet Initiative Japan Inc.
+Copyright (c) 2017 mruby developers
 
 Permission is hereby granted, free of charge, to any person obtaining a 
 copy of this software and associated documentation files (the "Software"), 

data/ext/enterprise_script_service/mruby/mrbgems/mruby-pack/mrbgem.rake

@@ -1,6 +1,6 @@
 MRuby::Gem::Specification.new('mruby-pack') do |spec|
   spec.license = 'MIT'
-  spec.authors = 'Internet Initiative Japan Inc.'
+  spec.authors = ['Internet Initiative Japan Inc.', 'mruby developers']
   spec.summary = 'Array#pack and String#unpack method'
 
   spec.cc.include_paths << "#{build.root}/src"

data/ext/enterprise_script_service/mruby/mrbgems/mruby-sleep/mrbgem.rake

@@ -1,5 +1,5 @@
 MRuby::Gem::Specification.new('mruby-sleep') do |spec|
   spec.license = 'MIT'
-  spec.authors = 'MATSUMOTO Ryosuke'
+  spec.authors = ['MATSUMOTO Ryosuke', 'mruby developers']
   spec.version = '0.0.1'
 end

data/ext/enterprise_script_service/mruby/mrbgems/mruby-sleep/src/mrb_sleep.c

@@ -2,6 +2,7 @@
 ** mrb_sleep - sleep methods for mruby
 **
 ** Copyright (c) mod_mruby developers 2012-
+** Copyright (c) mruby developers 2018
 **
 ** Permission is hereby granted, free of charge, to any person obtaining
 ** a copy of this software and associated documentation files (the

data/ext/enterprise_script_service/mruby/mrbgems/mruby-socket/README.md

@@ -35,6 +35,7 @@ Date: Tue, 21 May 2013 04:31:30 GMT
 ## License
 
 Copyright (c) 2013 Internet Initiative Japan Inc.
+Copyright (c) 2017 mruby developers
 
 Permission is hereby granted, free of charge, to any person obtaining a
 copy of this software and associated documentation files (the "Software"),

data/ext/enterprise_script_service/mruby/mrbgems/mruby-socket/mrbgem.rake

@@ -1,6 +1,6 @@
 MRuby::Gem::Specification.new('mruby-socket') do |spec|
   spec.license = 'MIT'
-  spec.authors = 'Internet Initiative Japan'
+  spec.authors = ['Internet Initiative Japan', 'mruby developers']
   spec.summary = 'standard socket class'
 
   spec.cc.include_paths << "#{build.root}/src"

data/ext/enterprise_script_service/mruby/mrbgems/mruby-socket/src/socket.c

@@ -476,7 +476,7 @@ mrb_basicsocket_setsockopt(mrb_state *mrb, mrb_value self)
     optname = mrb_fixnum(mrb_funcall(mrb, so, "optname", 0));
     optval = mrb_funcall(mrb, so, "data", 0);
   } else {
-    mrb_raisef(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (%i for 3)", argc);
+    mrb_argnum_error(mrb, argc, 3, 3);
   }
 
   s = socket_fd(mrb, self);

data/ext/enterprise_script_service/mruby/mrbgems/mruby-struct/src/struct.c

@@ -274,7 +274,7 @@ mrb_struct_s_def(mrb_state *mrb, mrb_value klass)
   name = mrb_nil_value();
   mrb_get_args(mrb, "*&", &argv, &argc, &b);
   if (argc == 0) { /* special case to avoid crash */
-    mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments");
+    mrb_argnum_error(mrb, argc, 1, -1);
   }
   else {
     pargv = argv;

data/ext/enterprise_script_service/mruby/mrbgems/mruby-test/mrbgem.rake

@@ -40,7 +40,7 @@
 
     file test_rbobj => g.test_rbireps
     file g.test_rbireps => [g.test_rbfiles, build.mrbcfile].flatten do |t|
-      FileUtils.mkdir_p File.dirname(t.name)
+      mkdir_p File.dirname(t.name)
       open(t.name, 'w') do |f|
         g.print_gem_test_header(f)
         test_preload = g.test_preload and [g.dir, MRUBY_ROOT].map {|dir|
@@ -149,15 +149,10 @@
   # of the test gem depending on a change to the gem
   # selection
   active_gems_path = "#{build_dir}/active_gems_path.lst"
-  active_gem_list = if File.exist? active_gems_path
-                      File.read active_gems_path
-                    else
-                      FileUtils.mkdir_p File.dirname(active_gems_path)
-                      nil
-                    end
+  active_gem_list = File.read active_gems_path if File.exist? active_gems_path
   current_gem_list = build.gems.map(&:name).join("\n")
   task active_gems_path do |_t|
-    FileUtils.mkdir_p File.dirname(active_gems_path)
+    mkdir_p File.dirname(active_gems_path)
     File.write active_gems_path, current_gem_list
   end
   file clib => active_gems_path if active_gem_list != current_gem_list
@@ -165,7 +160,7 @@
   file mlib => clib
   file clib => [build.mrbcfile, __FILE__] do |_t|
     _pp "GEN", "*.rb", "#{clib.relative_path}"
-    FileUtils.mkdir_p File.dirname(clib)
+    mkdir_p File.dirname(clib)
     open(clib, 'w') do |f|
       f.puts %Q[/*]
       f.puts %Q[ * This file contains a list of all]

data/ext/enterprise_script_service/mruby/mrbgems/mruby-test/vformat.c

@@ -4,197 +4,176 @@
 #include <mruby/data.h>
 #include <mruby/string.h>
 
-#ifdef MRB_WITHOUT_FLOAT
-typedef mrb_int mrb_float;
-#define mrb_float(o) mrb_fixnum(o)
+/* no argument */
+static mrb_value
+vf_s_format_0(mrb_state *mrb, mrb_value klass)
+{
+  mrb_value fmt_str;
+  const char *fmt;
+
+  mrb_get_args(mrb, "S", &fmt_str);
+  fmt = RSTRING_CSTR(mrb, fmt_str);
+
+  return mrb_format(mrb, fmt);
+}
+
+/* c char */
+static mrb_value
+vf_s_format_c(mrb_state *mrb, mrb_value klass)
+{
+  mrb_value fmt_str, arg_str;
+  const char *fmt;
+  char c;
+  
+  mrb_get_args(mrb, "SS", &fmt_str, &arg_str);
+  fmt = RSTRING_CSTR(mrb, fmt_str);
+  c = RSTRING_CSTR(mrb, arg_str)[0];
+
+  return mrb_format(mrb, fmt, c);
+}
+
+/* d int */
+static mrb_value
+vf_s_format_d(mrb_state *mrb, mrb_value klass)
+{
+  mrb_value fmt_str;
+  const char *fmt;
+  mrb_int i;
+  int d;
+
+  mrb_get_args(mrb, "Si", &fmt_str, &i);
+  fmt = RSTRING_CSTR(mrb, fmt_str);
+  d = (int)i;
+
+  return mrb_format(mrb, fmt, d);
+}
+
+#ifndef MRB_WITHOUT_FLOAT
+/* f float */
+static mrb_value
+vf_s_format_f(mrb_state *mrb, mrb_value klass)
+{
+  mrb_value fmt_str;
+  const char *fmt;
+  mrb_float f;
+
+  mrb_get_args(mrb, "Sf", &fmt_str, &f);
+  fmt = RSTRING_CSTR(mrb, fmt_str);
+
+  return mrb_format(mrb, fmt, f);
+}
 #endif
 
-#define NATIVE_TYPES                                                        \
-  char c;                                                                   \
-  int d;                                                                    \
-  mrb_float f;                                                              \
-  mrb_int i;                                                                \
-/*  size_t l;                                                             */\
-  mrb_sym n;                                                                \
-  char *s;                                                                  \
-  struct RClass *C
-
-#define NATIVE_DEFINE_TYPE_FUNC(t)                                          \
-  static mrb_value                                                          \
-  native_s_##t(mrb_state *mrb, mrb_value klass)                             \
-  {                                                                         \
-    mrb_value obj, type = mrb_fixnum_value(ARG_##t);                        \
-    mrb_get_args(mrb, "o", &obj);                                           \
-    return mrb_funcall(mrb, klass, "new", 2, type, obj);                    \
-  }
-
-#define NATIVE_DEFINE_TYPE_METHOD(t) \
-  mrb_define_class_method(mrb, n, #t, native_s_##t, MRB_ARGS_REQ(1))
-
-typedef enum {
-  ARG_c,
-  ARG_d,
-  ARG_f,
-  ARG_i,
-/*  ARG_l,*/
-  ARG_n,
-  ARG_s,
-  ARG_C,
-  ARG_v,
-} VFArgumentType;
-
-typedef struct {
-  VFArgumentType type;
-  union { NATIVE_TYPES; };
-} VFNative;
-
-typedef struct {
-  VFArgumentType type;
-  union {
-    NATIVE_TYPES;
-    mrb_value v;
-  };
-} VFArgument;
-
-static void
-native_free(mrb_state *mrb, void *data)
+/* i fixnum */
+static mrb_value
+vf_s_format_i(mrb_state *mrb, mrb_value klass)
 {
-  VFNative *native = (VFNative*)data;
-  if (native->type == ARG_s) mrb_free(mrb, native->s);
-  mrb_free(mrb, native);
+  mrb_value fmt_str;
+  const char *fmt;
+  mrb_int i;
+
+  mrb_get_args(mrb, "Si", &fmt_str, &i);
+  fmt = RSTRING_CSTR(mrb, fmt_str);
+
+  return mrb_format(mrb, fmt, i);
 }
 
-static const struct mrb_data_type native_data_type = {
-  "TestVFormat::Native", native_free
-};
+/* l char*, size_t */
+static mrb_value
+vf_s_format_l(mrb_state *mrb, mrb_value klass)
+{
+  mrb_value fmt_str, arg_str;
+  const char *fmt;
+  const char *s;
+  mrb_int i;
+  size_t len;
+
+  mrb_get_args(mrb, "SSi", &fmt_str, &arg_str, &i);
+  fmt = RSTRING_CSTR(mrb, fmt_str);
+  s = RSTRING_PTR(arg_str);
+  len = (size_t)i;
+  if (len > (size_t)RSTRING_LEN(arg_str)) len = (size_t)RSTRING_LEN(arg_str);
+
+  return mrb_format(mrb, fmt, s, len);
+}
 
+/* n symbol */
 static mrb_value
-native_initialize(mrb_state *mrb, mrb_value self)
+vf_s_format_n(mrb_state *mrb, mrb_value klass)
 {
-  VFNative data, *datap;
-  mrb_int type;
-  mrb_value obj;
-
-  mrb_get_args(mrb, "io", &type, &obj);
-  data.type = (VFArgumentType)type;
-  switch (data.type) {
-    case ARG_c: data.c = RSTRING_PTR(obj)[0]; break;
-    case ARG_d: data.d = (int)mrb_fixnum(obj); break;
-    case ARG_f: data.f = mrb_float(obj); break;
-    case ARG_i: data.i = mrb_fixnum(obj); break;
-/*    case ARG_l: data.l = (size_t)mrb_fixnum(obj); break;*/
-    case ARG_n: data.n = mrb_symbol(obj); break;
-    case ARG_s: data.s = (char*)mrb_malloc(mrb, RSTRING_LEN(obj) + 1);
-                memcpy(data.s, RSTRING_PTR(obj), RSTRING_LEN(obj));
-                data.s[RSTRING_LEN(obj)] = '\0'; break;
-    case ARG_C: data.C = mrb_class_ptr(obj); break;
-    default: mrb_raise(mrb, E_ARGUMENT_ERROR, "unknown type");
-  }
-  datap = (VFNative*)mrb_malloc(mrb, sizeof(VFNative));
-  *datap = data;
-  mrb_data_init(self, datap, &native_data_type);
-  return self;
+  mrb_value fmt_str;
+  const char *fmt;
+  mrb_sym sym;
+
+  mrb_get_args(mrb, "Sn", &fmt_str, &sym);
+  fmt = RSTRING_CSTR(mrb, fmt_str);
+
+  return mrb_format(mrb, fmt, sym);
 }
 
-NATIVE_DEFINE_TYPE_FUNC(c)
-NATIVE_DEFINE_TYPE_FUNC(d)
-NATIVE_DEFINE_TYPE_FUNC(f)
-NATIVE_DEFINE_TYPE_FUNC(i)
-/*NATIVE_DEFINE_TYPE_FUNC(l)*/
-NATIVE_DEFINE_TYPE_FUNC(n)
-NATIVE_DEFINE_TYPE_FUNC(s)
-NATIVE_DEFINE_TYPE_FUNC(C)
-
-static VFArgument*
-arg_from_obj(mrb_state *mrb, mrb_value obj, struct RClass *native_class,
-             VFArgument *vf_arg)
+/* s char* */
+static mrb_value
+vf_s_format_s(mrb_state *mrb, mrb_value klass)
 {
-  if (mrb_obj_is_instance_of(mrb, obj, native_class)) {
-    const VFNative *native = (VFNative*)DATA_PTR(obj);
-    *(VFNative*)vf_arg = *native;
-  }
-  else {
-    vf_arg->v = obj;
-    vf_arg->type = ARG_v;
-  }
-  return vf_arg;
+  mrb_value fmt_str, arg_str;
+  const char *fmt;
+  const char *s;
+
+  mrb_get_args(mrb, "SS", &fmt_str, &arg_str);
+  fmt = RSTRING_CSTR(mrb, fmt_str);
+  s = RSTRING_CSTR(mrb, arg_str);
+
+  return mrb_format(mrb, fmt, s);
 }
 
-#define VF_FORMAT_INIT(klass)                                               \
-  struct RClass *vf_native_class =                                          \
-    mrb_class_get_under(mrb, mrb_class_ptr(klass), "Native");               \
-  VFArgument vf_args[2];
-
-#define VF_ARG(args, idx) \
-  arg_from_obj(mrb, args[idx], vf_native_class, &vf_args[idx])
-
-#define VF_FORMAT0(fmt) mrb_format(mrb, fmt);
-#define VF_FORMAT1(fmt, args) \
-  (VF_ARG(args, 0), VF_FORMAT_TYPED(fmt, 1, vf_args, NULL))
-#define VF_FORMAT2(fmt, args) (                                             \
-  VF_ARG(args, 0), VF_ARG(args, 1),                                         \
-  VF_FORMAT2_COND_EXPR(fmt, vf_args, vf_args+1, c) :                        \
-  VF_FORMAT2_COND_EXPR(fmt, vf_args, vf_args+1, d) :                        \
-  VF_FORMAT2_COND_EXPR(fmt, vf_args, vf_args+1, f) :                        \
-  VF_FORMAT2_COND_EXPR(fmt, vf_args, vf_args+1, i) :                        \
-/*  VF_FORMAT2_COND_EXPR(fmt, vf_args, vf_args+1, l) :                    */\
-  VF_FORMAT2_COND_EXPR(fmt, vf_args, vf_args+1, n) :                        \
-  VF_FORMAT2_COND_EXPR(fmt, vf_args, vf_args+1, s) :                        \
-  VF_FORMAT2_COND_EXPR(fmt, vf_args, vf_args+1, C) :                        \
-  VF_FORMAT2_COND_EXPR(fmt, vf_args, vf_args+1, v) :                        \
-  mrb_nil_value()  /* not reached */                                        \
-)
-#define VF_FORMAT2_COND_EXPR(fmt, a1, a2, t) \
-  a1->type == ARG_##t ? VF_FORMAT_TYPED(fmt, 2, a2, (a1)->t)
-#define VF_FORMAT_TYPED(fmt, n_arg, type_a, v1)                             \
-  VF_FORMAT_TYPED_COND_EXPR(fmt, n_arg, type_a, v1, c) :                    \
-  VF_FORMAT_TYPED_COND_EXPR(fmt, n_arg, type_a, v1, d) :                    \
-  VF_FORMAT_TYPED_COND_EXPR(fmt, n_arg, type_a, v1, f) :                    \
-  VF_FORMAT_TYPED_COND_EXPR(fmt, n_arg, type_a, v1, i) :                    \
-/*  VF_FORMAT_TYPED_COND_EXPR(fmt, n_arg, type_a, v1, l) :                */\
-  VF_FORMAT_TYPED_COND_EXPR(fmt, n_arg, type_a, v1, n) :                    \
-  VF_FORMAT_TYPED_COND_EXPR(fmt, n_arg, type_a, v1, s) :                    \
-  VF_FORMAT_TYPED_COND_EXPR(fmt, n_arg, type_a, v1, C) :                    \
-  VF_FORMAT_TYPED_COND_EXPR(fmt, n_arg, type_a, v1, v) :                    \
-  mrb_nil_value()  /* not reached */
-#define VF_FORMAT_TYPED_COND_EXPR(fmt, n_arg, type_a, v1, t)                \
-  (type_a)->type == ARG_##t ? n_arg == 1 ?                                  \
-    mrb_format(mrb, fmt, (type_a)->t) : mrb_format(mrb, fmt, v1, (type_a)->t)
+/* C RClass */
+static mrb_value
+vf_s_format_C(mrb_state *mrb, mrb_value klass)
+{
+  mrb_value fmt_str, arg_cls;
+  const char *fmt;
+  struct RClass *c;
+
+  mrb_get_args(mrb, "SC", &fmt_str, &arg_cls);
+  fmt = RSTRING_CSTR(mrb, fmt_str);
+  c = mrb_class_ptr(arg_cls);
 
+  return mrb_format(mrb, fmt, c);
+}
+
+/* v value */
 static mrb_value
-vf_s_format(mrb_state *mrb, mrb_value klass)
+vf_s_format_v(mrb_state *mrb, mrb_value klass)
 {
-  mrb_value fmt_str, args[2];
-  mrb_int argc = mrb_get_args(mrb, "S|oo", &fmt_str, args, args+1);
-  const char *fmt = RSTRING_CSTR(mrb, fmt_str);
-
-  VF_FORMAT_INIT(klass);
-
-  switch (argc) {
-    case 1: return VF_FORMAT0(fmt);
-    case 2: return VF_FORMAT1(fmt, args);
-    case 3: return VF_FORMAT2(fmt, args);
-    default: return mrb_nil_value();  /* not reached */
-  }
+  mrb_value fmt_str, arg_v;
+  const char *fmt;
+
+  mrb_get_args(mrb, "So", &fmt_str, &arg_v);
+  fmt = RSTRING_CSTR(mrb, fmt_str);
+
+  return mrb_format(mrb, fmt, arg_v);
 }
 
 void
 mrb_init_test_vformat(mrb_state *mrb)
 {
-  struct RClass *vf, *n;
+  struct RClass *vf;
 
   vf = mrb_define_module(mrb, "TestVFormat");
-  mrb_define_class_method(mrb, vf, "format", vf_s_format, MRB_ARGS_ARG(1,2));
-
-  n = mrb_define_class_under(mrb, vf, "Native", mrb->object_class);
-  MRB_SET_INSTANCE_TT(n, MRB_TT_DATA);
-  NATIVE_DEFINE_TYPE_METHOD(c);
-  NATIVE_DEFINE_TYPE_METHOD(d);
-  NATIVE_DEFINE_TYPE_METHOD(f);
-  NATIVE_DEFINE_TYPE_METHOD(i);
-/*  NATIVE_DEFINE_TYPE_METHOD(l);*/
-  NATIVE_DEFINE_TYPE_METHOD(n);
-  NATIVE_DEFINE_TYPE_METHOD(s);
-  NATIVE_DEFINE_TYPE_METHOD(C);
-  mrb_define_method(mrb, n, "initialize", native_initialize, MRB_ARGS_REQ(2));
+  mrb_define_class_method(mrb, vf, "z", vf_s_format_0, MRB_ARGS_REQ(1));
+
+#define VF_DEFINE_FORMAT_METHOD(t) VF_DEFINE_FORMAT_METHOD_n(t,2)
+#define VF_DEFINE_FORMAT_METHOD_n(t,n) mrb_define_class_method(mrb, vf, #t, vf_s_format_##t, MRB_ARGS_REQ(n));
+  
+  VF_DEFINE_FORMAT_METHOD(c);
+  VF_DEFINE_FORMAT_METHOD(d);
+#ifndef MRB_WITHOUT_FLOAT
+  VF_DEFINE_FORMAT_METHOD(f);
+#endif
+  VF_DEFINE_FORMAT_METHOD(i);
+  VF_DEFINE_FORMAT_METHOD_n(l,3);
+  VF_DEFINE_FORMAT_METHOD(n);
+  VF_DEFINE_FORMAT_METHOD(s);
+  VF_DEFINE_FORMAT_METHOD(C);
+  VF_DEFINE_FORMAT_METHOD(v);
 }