#include #include #include #include #include #ifdef MRB_WITHOUT_FLOAT typedef mrb_int mrb_float; #define mrb_float(o) mrb_fixnum(o) #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) { VFNative *native = (VFNative*)data; if (native->type == ARG_s) mrb_free(mrb, native->s); mrb_free(mrb, native); } static const struct mrb_data_type native_data_type = { "TestVFormat::Native", native_free }; static mrb_value native_initialize(mrb_state *mrb, mrb_value self) { 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; } 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) { 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; } #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) static mrb_value vf_s_format(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 */ } } void mrb_init_test_vformat(mrb_state *mrb) { struct RClass *vf, *n; 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)); }