script_core 0.2.1 → 0.2.6

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
@@ -29,7 +30,7 @@
 #ifdef _WIN32
     #include <windows.h>
     #define sleep(x) Sleep(x * 1000)
-    #define usleep(x) Sleep((DWORD)((x)<1000) ? 1 : ((x)/1000))
+    #define usleep(x) Sleep((DWORD)(((x)<1000) ? 1 : ((x)/1000)))
 #else
     #include <unistd.h>
     #include <sys/time.h>

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,13 +1,13 @@
 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"
   #spec.cc.defines << "HAVE_SA_LEN=0"
 
   # If Windows, use winsock
-  if ( /mswin|mingw|win32/ =~ RUBY_PLATFORM ) then
+  if for_windows?
     spec.linker.libraries << "wsock32"
     spec.linker.libraries << "ws2_32"
   end

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-socket/test/sockettest.c

@@ -1,4 +1,3 @@
-#include <stdio.h>
 #include <stdlib.h>
 
 #include "mruby.h"
@@ -8,7 +7,9 @@
 
 #include <io.h>
 
-#ifdef _MSC_VER
+#if defined(_MSC_VER) || \
+    (defined(MRB_MINGW32_VERSION) && MRB_MINGW32_VERSION < 3021) || \
+    (defined(MRB_MINGW64_VERSION) && MRB_MINGW64_VERSION < 4000)
 
 #include <fcntl.h>
 #include <sys/stat.h>

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

@@ -5,9 +5,7 @@
 */
 
 #include <mruby.h>
-
 #include <limits.h>
-#include <stdio.h>
 #include <string.h>
 #include <mruby/string.h>
 #include <mruby/hash.h>
@@ -518,6 +516,50 @@ mrb_f_sprintf(mrb_state *mrb, mrb_value obj)
   }
 }
 
+static int
+mrb_int2str(char *buf, size_t len, mrb_int n)
+{
+#ifdef MRB_DISABLE_STDIO
+  char *bufend = buf + len;
+  char *p = bufend - 1;
+
+  if (len < 1) return -1;
+
+  *p -- = '\0';
+  len --;
+
+  if (n < 0) {
+    if (len < 1) return -1;
+
+    *p -- = '-';
+    len --;
+    n = -n;
+  }
+
+  if (n > 0) {
+    for (; n > 0; len --, n /= 10) {
+      if (len < 1) return -1;
+
+      *p -- = '0' + (n % 10);
+    }
+    p ++;
+  }
+  else if (len > 0) {
+    *p = '0';
+    len --;
+  }
+  else {
+    return -1;
+  }
+
+  memmove(buf, p, bufend - p);
+
+  return bufend - p - 1;
+#else
+  return snprintf(buf, len, "%" MRB_PRId, n);
+#endif /* MRB_DISABLE_STDIO */
+}
+
 mrb_value
 mrb_str_format(mrb_state *mrb, mrb_int argc, const mrb_value *argv, mrb_value fmt)
 {
@@ -708,7 +750,12 @@ retry:
         }
         else if (mrb_fixnum_p(val)) {
           mrb_int n = mrb_fixnum(val);
+#ifndef MRB_UTF8_STRING
+          char buf[1];
 
+          buf[0] = (char)n&0xff;
+          tmp = mrb_str_new(mrb, buf, 1);
+#else
           if (n < 0x80) {
             char buf[1];
 
@@ -719,6 +766,7 @@ retry:
             tmp = mrb_funcall(mrb, val, "chr", 0);
             mrb_check_type(mrb, tmp, MRB_TT_STRING);
           }
+#endif
         }
         else {
           mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid character");
@@ -866,7 +914,7 @@ retry:
             width--;
           }
           mrb_assert(base == 10);
-          snprintf(nbuf, sizeof(nbuf), "%" MRB_PRId, v);
+          mrb_int2str(nbuf, sizeof(nbuf), v);
           s = nbuf;
           if (v < 0) s++;       /* skip minus sign */
         }
@@ -874,24 +922,12 @@ retry:
           s = nbuf;
           if (v < 0) {
             dots = 1;
+            val = mrb_fix2binstr(mrb, mrb_fixnum_value(v), base);
           }
-          switch (base) {
-          case 2:
-            if (v < 0) {
-              val = mrb_fix2binstr(mrb, mrb_fixnum_value(v), base);
-            }
-            else {
-              val = mrb_fixnum_to_str(mrb, mrb_fixnum_value(v), base);
-            }
-            strncpy(++s, RSTRING_PTR(val), sizeof(nbuf)-1);
-            break;
-          case 8:
-            snprintf(++s, sizeof(nbuf)-1, "%" MRB_PRIo, v);
-            break;
-          case 16:
-            snprintf(++s, sizeof(nbuf)-1, "%" MRB_PRIx, v);
-            break;
+          else {
+            val = mrb_fixnum_to_str(mrb, mrb_fixnum_value(v), base);
           }
+          strncpy(++s, RSTRING_PTR(val), sizeof(nbuf)-1);
           if (v < 0) {
             char d;
 
@@ -1005,7 +1041,7 @@ retry:
         mrb_value val = GETARG();
         double fval;
         mrb_int need = 6;
-        char fbuf[32];
+        char fbuf[64];
 
         fval = mrb_float(mrb_Float(mrb, val));
         if (!isfinite(fval)) {
@@ -1046,7 +1082,6 @@ retry:
           break;
         }
 
-        fmt_setup(fbuf, sizeof(fbuf), *p, flags, width, prec);
         need = 0;
         if (*p != 'e' && *p != 'E') {
           int i;
@@ -1068,7 +1103,8 @@ retry:
         need += 20;
 
         CHECK(need);
-        n = snprintf(&buf[blen], need, fbuf, fval);
+        fmt_setup(fbuf, sizeof(fbuf), *p, flags, width, prec);
+        n = mrb_float_to_cstr(mrb, &buf[blen], need, fbuf, fval);
         if (n < 0 || n >= need) {
           mrb_raise(mrb, E_RUNTIME_ERROR, "formatting error");
         }
@@ -1110,12 +1146,13 @@ fmt_setup(char *buf, size_t size, int c, int flags, mrb_int width, mrb_int prec)
   if (flags & FSPACE) *buf++ = ' ';
 
   if (flags & FWIDTH) {
-    n = snprintf(buf, end - buf, "%d", (int)width);
+    n = mrb_int2str(buf, end - buf, width);
     buf += n;
   }
 
   if (flags & FPREC) {
-    n = snprintf(buf, end - buf, ".%d", (int)prec);
+    *buf ++ = '.';
+    n = mrb_int2str(buf, end - buf, prec);
     buf += n;
   }
 

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

@@ -8,6 +8,11 @@
   assert_equal 15, ("%b" % (1<<14)).size
   skip unless Object.const_defined?(:Float)
   assert_equal "1.0", "%3.1f" % 1.01
+  assert_equal " 123456789.12", "% 4.2f" % 123456789.123456789
+  assert_equal "123456789.12", "%-4.2f" % 123456789.123456789
+  assert_equal "+123456789.12", "%+4.2f" % 123456789.123456789
+  assert_equal "123456789.12", "%04.2f" % 123456789.123456789
+  assert_equal "00000000123456789.12", "%020.2f" % 123456789.123456789
 end
 
 assert('String#% with inf') do
@@ -68,29 +73,6 @@
   assert_equal "  NaN", "% 5f" % nan
 end
 
-assert("String#% with invalid chr") do
-  begin
-    class Fixnum
-      alias_method :chr_, :chr if method_defined?(:chr)
-
-      def chr
-        nil
-      end
-    end
-
-    assert_raise TypeError do
-      "%c" % 0x80
-    end
-  ensure
-    class Fixnum
-      if method_defined?(:chr_)
-        alias_method :chr, :chr_
-        remove_method :chr_
-      end
-    end
-  end
-end
-
 assert("String#% %b") do
   assert_equal("..10115", "%0b5" % -5)
 end

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

@@ -335,7 +335,7 @@ tr_parse_pattern(mrb_state *mrb, struct tr_pattern *ret, const mrb_value v_patte
 
       len = i - start_pos;
       if (len > UINT16_MAX) {
-        mrb_raise(mrb, E_ARGUMENT_ERROR, "tr pattern too long (max 65536)");
+        mrb_raise(mrb, E_ARGUMENT_ERROR, "tr pattern too long (max 65535)");
       }
       if (pat1 == NULL && ret) {
         goto nomem;
@@ -343,9 +343,9 @@ tr_parse_pattern(mrb_state *mrb, struct tr_pattern *ret, const mrb_value v_patte
       pat1->type = TR_IN_ORDER;
       pat1->flag_reverse = flag_reverse;
       pat1->flag_on_heap = !ret_uninit;
-      pat1->n = len;
+      pat1->n = (uint16_t)len;
       pat1->next = NULL;
-      pat1->val.start_pos = start_pos;
+      pat1->val.start_pos = (uint16_t)start_pos;
     }
 
     if (ret == NULL || ret_uninit) {

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-symbol-ext/src/symbol.c

@@ -47,7 +47,7 @@ mrb_sym_length(mrb_state *mrb, mrb_value self)
 #ifdef MRB_UTF8_STRING
   mrb_int byte_len;
   const char *name = mrb_sym_name_len(mrb, mrb_symbol(self), &byte_len);
-  len = mrb_utf8_len(name, byte_len);
+  len = mrb_utf8_strlen(name, byte_len);
 #else
   mrb_sym_name_len(mrb, mrb_symbol(self), &len);
 #endif

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

@@ -26,6 +26,7 @@
 
   file assert_lib => assert_c
   file assert_c => [assert_rb, build.mrbcfile] do |t|
+    mkdir_p File.dirname(t.name)
     open(t.name, 'w') do |f|
       mrbc.run f, assert_rb, 'mrbtest_assert_irep'
     end
@@ -40,7 +41,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 +150,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 +161,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);
 }