void
mrb_init_print(mrb_state *mrb)
{
struct RClass *krn;
krn = mrb->kernel_module;
mrb_define_method(mrb, krn, "__printstr__", mrb_printstr, ARGS_REQ(1));
}
static void mrb_init_js_obj(mrb_state *mrb)
{
struct RClass *obj;
obj = MRB_UD_JS_OBJ_CLASS(mrb) = mrb_define_class(mrb, "JsObj", mrb->object_class);
MRB_SET_INSTANCE_TT(obj, MRB_TT_DATA);
mrb_define_class_method(mrb, obj, "get", mrb_js_obj_get, ARGS_REQ(1));
mrb_define_method(mrb, obj, "method_missing", mrb_js_obj_method_missing, ARGS_ANY());
}
void
mrb_mruby_thread_gem_init(mrb_state* mrb) {
struct RClass *_class_thread, *_class_mutex;
_class_thread = mrb_define_class(mrb, "Thread", mrb->object_class);
mrb_define_method(mrb, _class_thread, "initialize", mrb_thread_init, ARGS_OPT(1));
mrb_define_method(mrb, _class_thread, "join", mrb_thread_join, ARGS_NONE());
mrb_define_method(mrb, _class_thread, "kill", mrb_thread_kill, ARGS_NONE());
mrb_define_method(mrb, _class_thread, "terminate", mrb_thread_kill, ARGS_NONE());
mrb_define_method(mrb, _class_thread, "alive?", mrb_thread_alive, ARGS_NONE());
mrb_define_module_function(mrb, _class_thread, "sleep", mrb_thread_sleep, ARGS_REQ(1));
_class_mutex = mrb_define_class(mrb, "Mutex", mrb->object_class);
mrb_define_method(mrb, _class_mutex, "initialize", mrb_mutex_init, ARGS_NONE());
mrb_define_method(mrb, _class_mutex, "lock", mrb_mutex_lock, ARGS_NONE());
mrb_define_method(mrb, _class_mutex, "try_lock", mrb_mutex_try_lock, ARGS_NONE());
mrb_define_method(mrb, _class_mutex, "locked?", mrb_mutex_locked, ARGS_NONE());
mrb_define_method(mrb, _class_mutex, "sleep", mrb_mutex_sleep, ARGS_REQ(1));
mrb_define_method(mrb, _class_mutex, "synchronize", mrb_mutex_synchronize, ARGS_REQ(1));
mrb_define_method(mrb, _class_mutex, "unlock", mrb_mutex_unlock, ARGS_NONE());
}
/*
* A <code>Struct</code> is a convenient way to bundle a number of
* attributes together, using accessor methods, without having to write
* an explicit class.
*
* The <code>Struct</code> class is a generator of specific classes,
* each one of which is defined to hold a set of variables and their
* accessors. In these examples, we'll call the generated class
* ``<i>Customer</i>Class,'' and we'll show an example instance of that
* class as ``<i>Customer</i>Inst.''
*
* In the descriptions that follow, the parameter <i>symbol</i> refers
* to a symbol, which is either a quoted string or a
* <code>Symbol</code> (such as <code>:name</code>).
*/
void
mrb_init_struct(mrb_state *mrb)
{
struct RClass *st;
st = mrb_define_class(mrb, "Struct", mrb->object_class);
mrb_define_class_method(mrb, st, "new", mrb_struct_s_def, ARGS_ANY()); /* 15.2.18.3.1 */
mrb_define_method(mrb, st, "==", mrb_struct_equal, ARGS_REQ(1)); /* 15.2.18.4.1 */
mrb_define_method(mrb, st, "[]", mrb_struct_aref, ARGS_REQ(1)); /* 15.2.18.4.2 */
mrb_define_method(mrb, st, "[]=", mrb_struct_aset, ARGS_REQ(2)); /* 15.2.18.4.3 */
mrb_define_method(mrb, st, "members", mrb_struct_members_m, ARGS_NONE()); /* 15.2.18.4.6 */
mrb_define_method(mrb, st, "initialize", mrb_struct_initialize_m,ARGS_ANY()); /* 15.2.18.4.8 */
mrb_define_method(mrb, st, "initialize_copy", mrb_struct_init_copy, ARGS_REQ(1)); /* 15.2.18.4.9 */
mrb_define_method(mrb, st, "inspect", mrb_struct_inspect, ARGS_NONE()); /* 15.2.18.4.10(x) */
mrb_define_alias(mrb, st, "to_s", "inspect"); /* 15.2.18.4.11(x) */
mrb_define_method(mrb, st, "eql?", mrb_struct_eql, ARGS_REQ(1)); /* 15.2.18.4.12(x) */
}
void
mrb_init_print(mrb_state *mrb)
{
struct RClass *krn;
krn = mrb->kernel_module;
mrb_define_method(mrb, krn, "__printstr__", mrb_printstr, ARGS_REQ(1));
mrb_define_method(mrb, krn, "p", p_m, ARGS_ANY()); /* 15.3.1.3.34 */
}
/* #[<ENTRY_FUNC>]# eInitialize_initializeBridge
* name: eInitialize_initializeBridge
* global_name: nMruby_tSCharPointer_eInitialize_initializeBridge
* oneway: false
* #[</ENTRY_FUNC>]# */
void
eInitialize_initializeBridge(mrb_state* mrb, struct RClass * TECS)
{
struct RClass *c;
/* ここに処理本体を記述します #_TEFB_# */
c=tecs_init_SCharPointer( mrb, TECS );
mrb_define_method(mrb, c, "to_s", CharPointer_to_s, ARGS_NONE());
mrb_define_method(mrb, c, "from_s", CharPointer_from_s, ARGS_REQ(1));
}
void
mrb_init_exception(mrb_state *mrb)
{
struct RClass *e;
struct RClass *eTypeError_class;
struct RClass *eArgumentError_class;
struct RClass *eIndexError_class;
struct RClass *eRangeError_class;
struct RClass *eNameError_class;
struct RClass *eNoMethodError_class;
struct RClass *eScriptError_class;
struct RClass *eSyntaxError_class;
struct RClass *eLoadError_class;
struct RClass *eSystemCallError_class;
struct RClass *eLocalJumpError_class;
struct RClass *eRegexpError_class;
struct RClass *eZeroDivisionError_class;
struct RClass *eEncodingError_class;
struct RClass *eNotImpError_class;
struct RClass *eFloatDomainError_class;
struct RClass *eKeyError_class;
mrb->eException_class = e = mrb_define_class(mrb, "Exception", mrb->object_class); /* 15.2.22 */
mrb_define_class_method(mrb, e, "exception", mrb_instance_new, ARGS_ANY());
mrb_define_method(mrb, e, "exception", exc_exception, ARGS_ANY());
mrb_define_method(mrb, e, "initialize", exc_initialize, ARGS_ANY());
mrb_define_method(mrb, e, "==", exc_equal, ARGS_REQ(1));
mrb_define_method(mrb, e, "to_s", exc_to_s, ARGS_NONE());
mrb_define_method(mrb, e, "message", exc_message, ARGS_NONE());
mrb_define_method(mrb, e, "inspect", exc_inspect, ARGS_NONE());
mrb->eStandardError_class = mrb_define_class(mrb, "StandardError", mrb->eException_class); /* 15.2.23 */
mrb->eRuntimeError_class = mrb_define_class(mrb, "RuntimeError", mrb->eStandardError_class); /* 15.2.28 */
eTypeError_class = mrb_define_class(mrb, "TypeError", mrb->eStandardError_class); /* 15.2.29 */
eArgumentError_class = mrb_define_class(mrb, "ArgumentError", mrb->eStandardError_class); /* 15.2.24 */
eIndexError_class = mrb_define_class(mrb, "IndexError", mrb->eStandardError_class); /* 15.2.33 */
eRangeError_class = mrb_define_class(mrb, "RangeError", mrb->eStandardError_class); /* 15.2.26 */
eNameError_class = mrb_define_class(mrb, "NameError", mrb->eStandardError_class); /* 15.2.31 */
eNoMethodError_class = mrb_define_class(mrb, "NoMethodError", eNameError_class); /* 15.2.32 */
eScriptError_class = mrb_define_class(mrb, "ScriptError", mrb->eException_class); /* 15.2.37 */
eSyntaxError_class = mrb_define_class(mrb, "SyntaxError", eScriptError_class); /* 15.2.38 */
eLoadError_class = mrb_define_class(mrb, "LoadError", eScriptError_class); /* 15.2.39 */
eSystemCallError_class = mrb_define_class(mrb, "SystemCallError", mrb->eStandardError_class); /* 15.2.36 */
eLocalJumpError_class = mrb_define_class(mrb, "LocalJumpError", mrb->eStandardError_class); /* 15.2.25 */
eRegexpError_class = mrb_define_class(mrb, "RegexpError", mrb->eStandardError_class); /* 15.2.27 */
eZeroDivisionError_class = mrb_define_class(mrb, "ZeroDivisionError", mrb->eStandardError_class); /* 15.2.30 */
eEncodingError_class = mrb_define_class(mrb, "EncodingError", mrb->eStandardError_class);
eNotImpError_class = mrb_define_class(mrb, "NotImplementedError", eScriptError_class);
eFloatDomainError_class = mrb_define_class(mrb, "FloatDomainError", eRangeError_class);
eKeyError_class = mrb_define_class(mrb, "KeyError", eIndexError_class);
}
void mrb_mruby_vedis_gem_init(mrb_state *mrb)
{
struct RClass *vedis;
vedis = mrb_define_class(mrb, "Vedis", mrb->object_class);
mrb_define_method(mrb, vedis, "initialize", mrb_vedis_open, ARGS_OPT(1));
mrb_define_method(mrb, vedis, "set", mrb_vedis_set, ARGS_REQ(2));
mrb_define_method(mrb, vedis, "get", mrb_vedis_get, ARGS_REQ(1));
mrb_define_method(mrb, vedis, "[]=", mrb_vedis_set, ARGS_REQ(2));
mrb_define_method(mrb, vedis, "[]", mrb_vedis_get, ARGS_REQ(1));
mrb_define_method(mrb, vedis, "exec", mrb_vedis_exec, ARGS_REQ(1));
mrb_define_method(mrb, vedis, "del", mrb_vedis_del, ARGS_REQ(1));
mrb_define_method(mrb, vedis, "append", mrb_vedis_append, ARGS_REQ(2));
mrb_define_method(mrb, vedis, "<<", mrb_vedis_append_hash, ARGS_REQ(1));
mrb_define_method(mrb, vedis, "exists?", mrb_vedis_exists, ARGS_REQ(1));
mrb_define_method(mrb, vedis, "strlen", mrb_vedis_strlen, ARGS_REQ(1));
mrb_define_method(mrb, vedis, "close", mrb_vedis_close, ARGS_NONE());
DONE;
}
static mrb_value
make_struct(mrb_state *mrb, mrb_value name, mrb_value members, struct RClass * klass)
{
mrb_value nstr, *ptr_members;
mrb_sym id;
long i, len;
struct RClass *c;
//OBJ_FREEZE(members);
if (mrb_nil_p(name)) {
c = mrb_class_new(mrb, klass);
//mrb_make_metaclass(nstr, RBASIC(klass)->c);
//mrb_class_inherited(klass, nstr);
}
else {
/* old style: should we warn? */
name = mrb_str_to_str(mrb, name);
id = mrb_to_id(mrb, name);
if (!mrb_is_const_id(id)) {
//mrb_name_error(id, "identifier %s needs to be constant", StringValuePtr(name));
mrb_name_error(mrb, id, "identifier %s needs to be constant", mrb_string_value_ptr(mrb, name));
}
if (mrb_const_defined_at(mrb, klass, id)) {
//mrb_warn("redefining constant Struct::%s", StringValuePtr(name));
mrb_warn("redefining constant Struct::%s", mrb_string_value_ptr(mrb, name));
//?rb_mod_remove_const(klass, mrb_sym2name(mrb, id));
}
c = mrb_define_class_under(mrb, klass, RSTRING_PTR(name), klass);
}
MRB_SET_INSTANCE_TT(c, MRB_TT_STRUCT);
nstr = mrb_obj_value(c);
mrb_iv_set(mrb, nstr, mrb_intern(mrb, "__members__"), members);
mrb_define_class_method(mrb, c, "new", mrb_instance_new, ARGS_ANY());
mrb_define_class_method(mrb, c, "[]", mrb_instance_new, ARGS_ANY());
mrb_define_class_method(mrb, c, "members", mrb_struct_s_members_m, ARGS_NONE());
//RSTRUCT(nstr)->basic.c->super = c->c;
ptr_members = RARRAY_PTR(members);
len = RARRAY_LEN(members);
for (i=0; i< len; i++) {
mrb_sym id = SYM2ID(ptr_members[i]);
if (mrb_is_local_id(id) || mrb_is_const_id(id)) {
if (i < N_REF_FUNC) {
mrb_define_method_id(mrb, c, id, ref_func[i], ARGS_NONE());
}
else {
mrb_define_method_id(mrb, c, id, mrb_struct_ref, ARGS_NONE());
}
mrb_define_method_id(mrb, c, mrb_id_attrset(mrb, id), mrb_struct_set_m, ARGS_REQ(1));
}
}
return nstr;
}
void
mrb_init_gc(mrb_state *mrb)
{
struct RClass *gc;
gc = mrb_define_module(mrb, "GC");
mrb_define_class_method(mrb, gc, "start", gc_start, ARGS_NONE());
mrb_define_class_method(mrb, gc, "enable", gc_enable, ARGS_NONE());
mrb_define_class_method(mrb, gc, "disable", gc_disable, ARGS_NONE());
mrb_define_class_method(mrb, gc, "interval_ratio", gc_interval_ratio_get, ARGS_NONE());
mrb_define_class_method(mrb, gc, "interval_ratio=", gc_interval_ratio_set, ARGS_REQ(1));
mrb_define_class_method(mrb, gc, "step_ratio", gc_step_ratio_get, ARGS_NONE());
mrb_define_class_method(mrb, gc, "step_ratio=", gc_step_ratio_set, ARGS_REQ(1));
mrb_define_class_method(mrb, gc, "generational_mode=", gc_generational_mode_set, ARGS_REQ(1));
mrb_define_class_method(mrb, gc, "generational_mode", gc_generational_mode_get, ARGS_NONE());
#ifdef GC_TEST
#ifdef GC_DEBUG
mrb_define_class_method(mrb, gc, "test", gc_test, ARGS_NONE());
#endif
#endif
}
void
mrb_init_range(mrb_state *mrb)
{
struct RClass *r;
r = mrb_define_class(mrb, "Range", mrb->object_class);
MRB_SET_INSTANCE_TT(r, MRB_TT_RANGE);
mrb_include_module(mrb, r, mrb_class_get(mrb, "Enumerable"));
mrb_define_method(mrb, r, "begin", mrb_range_beg, ARGS_NONE()); /* 15.2.14.4.3 */
mrb_define_method(mrb, r, "end", mrb_range_end, ARGS_NONE()); /* 15.2.14.4.5 */
mrb_define_method(mrb, r, "==", mrb_range_eq, ARGS_REQ(1)); /* 15.2.14.4.1 */
mrb_define_method(mrb, r, "===", mrb_range_include, ARGS_REQ(1)); /* 15.2.14.4.2 */
mrb_define_method(mrb, r, "each", mrb_range_each, ARGS_NONE()); /* 15.2.14.4.4 */
mrb_define_method(mrb, r, "exclude_end?", mrb_range_excl, ARGS_NONE()); /* 15.2.14.4.6 */
mrb_define_method(mrb, r, "first", mrb_range_beg, ARGS_NONE()); /* 15.2.14.4.7 */
mrb_define_method(mrb, r, "include?", mrb_range_include, ARGS_REQ(1)); /* 15.2.14.4.8 */
mrb_define_method(mrb, r, "initialize", mrb_range_initialize, ARGS_ANY()); /* 15.2.14.4.9 */
mrb_define_method(mrb, r, "last", mrb_range_end, ARGS_NONE()); /* 15.2.14.4.10 */
mrb_define_method(mrb, r, "member?", mrb_range_include, ARGS_REQ(1)); /* 15.2.14.4.11 */
mrb_define_method(mrb, r, "to_s", range_to_s, ARGS_NONE()); /* 15.2.14.4.12(x) */
mrb_define_method(mrb, r, "inspect", range_inspect, ARGS_NONE()); /* 15.2.14.4.13(x) */
mrb_define_method(mrb, r, "eql?", range_eql, ARGS_REQ(1)); /* 15.2.14.4.14(x) */
mrb_define_method(mrb, r, "initialize_copy", range_initialize_copy, ARGS_REQ(1)); /* 15.2.14.4.15(x) */
}
void
mrb_mruby_rx_gpio_gem_init(mrb_state* mrb) {
struct RClass *gpio;
gpio = mrb_define_class(mrb, "Rx_gpio", mrb->object_class);
mrb_define_const(mrb,gpio, "LED0", mrb_fixnum_value(100));
mrb_define_const(mrb,gpio, "LED1", mrb_fixnum_value(101));
mrb_define_const(mrb,gpio, "LED2", mrb_fixnum_value(102));
mrb_define_const(mrb,gpio, "LED3", mrb_fixnum_value(103));
mrb_define_const(mrb,gpio, "IO2", mrb_fixnum_value(202));
mrb_define_const(mrb,gpio, "IO3", mrb_fixnum_value(203));
mrb_define_const(mrb,gpio, "IO4", mrb_fixnum_value(204));
mrb_define_const(mrb,gpio, "IO5", mrb_fixnum_value(205));
mrb_define_const(mrb,gpio, "IO44", mrb_fixnum_value(210));
mrb_define_const(mrb,gpio, "IO45", mrb_fixnum_value(211));
mrb_define_const(mrb,gpio, "IO46", mrb_fixnum_value(212));
mrb_define_const(mrb,gpio, "IO47", mrb_fixnum_value(213));
mrb_define_const(mrb,gpio, "IO48", mrb_fixnum_value(214));
mrb_define_const(mrb,gpio, "IO49", mrb_fixnum_value(215));
mrb_define_const(mrb,gpio, "IO50", mrb_fixnum_value(216));
mrb_define_const(mrb,gpio, "IO51", mrb_fixnum_value(217));
mrb_define_const(mrb,gpio, "IO11", mrb_fixnum_value(249));
mrb_define_const(mrb,gpio, "IO12", mrb_fixnum_value(250));
mrb_define_const(mrb,gpio, "IO2IN", mrb_fixnum_value(302));
mrb_define_const(mrb,gpio, "IO3IN", mrb_fixnum_value(303));
mrb_define_const(mrb,gpio, "IO4IN", mrb_fixnum_value(304));
mrb_define_const(mrb,gpio, "IO5IN", mrb_fixnum_value(305));
mrb_define_const(mrb,gpio, "IO44IN", mrb_fixnum_value(310));
mrb_define_const(mrb,gpio, "IO45IN", mrb_fixnum_value(311));
mrb_define_const(mrb,gpio, "IO46IN", mrb_fixnum_value(312));
mrb_define_const(mrb,gpio, "IO47IN", mrb_fixnum_value(313));
mrb_define_const(mrb,gpio, "IO48IN", mrb_fixnum_value(314));
mrb_define_const(mrb,gpio, "IO49IN", mrb_fixnum_value(315));
mrb_define_const(mrb,gpio, "IO50IN", mrb_fixnum_value(316));
mrb_define_const(mrb,gpio, "IO51IN", mrb_fixnum_value(317));
mrb_define_const(mrb,gpio, "IO12IN", mrb_fixnum_value(350));
/* methods */
mrb_define_method(mrb, gpio, "initialize", mrb_rx_gpio_initialize, ARGS_REQ(1));
mrb_define_method(mrb, gpio, "on", mrb_rx_gpio_on, ARGS_NONE());
mrb_define_method(mrb, gpio, "off", mrb_rx_gpio_off, ARGS_NONE());
mrb_define_method(mrb, gpio, "in", mrb_rx_gpio_input, ARGS_NONE());
}
void
mrb_mruby_ssp_thread_gem_init(mrb_state* mrb) {
struct RClass *ssp;
ssp = mrb_define_class(mrb, "Ssp_thread", mrb->object_class);
/* methods */
mrb_define_method(mrb, ssp, "initialize", mrb_ssp_thread_initialize, ARGS_REQ(2));
mrb_define_method(mrb, ssp, "act" , mrb_ssp_thread_act, ARGS_NONE());
mrb_define_method(mrb, ssp, "iact", mrb_ssp_thread_iact, ARGS_NONE());
}
void
mrb_init_core(mrb_state *mrb)
{
mrb_init_symtbl(mrb);
mrb_init_class(mrb);
mrb_init_object(mrb);
mrb_init_kernel(mrb);
mrb_init_comparable(mrb);
mrb_init_enumerable(mrb);
mrb_init_symbols(mrb);
mrb_init_proc(mrb);
mrb_init_string(mrb);
Init_version(mrb); /* after init_string */
mrb_init_array(mrb);
mrb_init_hash(mrb);
mrb_init_numeric(mrb);
mrb_init_range(mrb);
mrb_init_struct(mrb);
mrb_init_gc(mrb);
#ifdef INCLUDE_REGEXP
mrb_init_regexp(mrb);
mrb_init_encoding(mrb);
#endif
mrb_init_exception(mrb);
mrb_init_print(mrb);
mrb_init_time(mrb);
#ifdef MANDEL
mrb_define_method(mrb, mrb->kernel_module, "pow", mpow, ARGS_REQ(2));
mrb_define_method(mrb, mrb->kernel_module, "sqrt", msqrt, ARGS_REQ(1));
mrb_define_method(mrb, mrb->kernel_module, "putc", mputc, ARGS_REQ(1));
#endif
mrb_init_mrblib(mrb);
mrb_gc_arena_restore(mrb, 0);
}
void
mrb_init_class(mrb_state *mrb)
{
struct RClass *bob; /* BasicObject */
struct RClass *obj; /* Object */
struct RClass *mod; /* Module */
struct RClass *cls; /* Class */
//struct RClass *krn; /* Kernel */
/* boot class hierarchy */
bob = boot_defclass(mrb, 0);
obj = boot_defclass(mrb, bob); mrb->object_class = obj;
mod = boot_defclass(mrb, obj); mrb->module_class = mod;/* obj -> mod */
cls = boot_defclass(mrb, mod); mrb->class_class = cls; /* obj -> cls */
/* fix-up loose ends */
bob->c = obj->c = mod->c = cls->c = cls;
make_metaclass(mrb, bob);
make_metaclass(mrb, obj);
make_metaclass(mrb, mod);
make_metaclass(mrb, cls);
/* name basic classes */
mrb_define_const(mrb, obj, "BasicObject", mrb_obj_value(bob));
mrb_define_const(mrb, obj, "Object", mrb_obj_value(obj));
mrb_define_const(mrb, obj, "Module", mrb_obj_value(mod));
mrb_define_const(mrb, obj, "Class", mrb_obj_value(cls));
/* name each classes */
mrb_name_class(mrb, bob, mrb_intern(mrb, "BasicObject"));
mrb_name_class(mrb, obj, mrb_intern(mrb, "Object"));
mrb_name_class(mrb, mod, mrb_intern(mrb, "Module"));
mrb_name_class(mrb, cls, mrb_intern(mrb, "Class"));
mrb_undef_method(mrb, mod, "new");
MRB_SET_INSTANCE_TT(cls, MRB_TT_CLASS);
mrb_define_method(mrb, bob, "initialize", mrb_bob_init, ARGS_NONE());
mrb_define_method(mrb, bob, "!", mrb_bob_not, ARGS_NONE());
mrb_define_method(mrb, bob, "method_missing", mrb_bob_missing, ARGS_ANY()); /* 15.3.1.3.30 */
mrb_define_class_method(mrb, cls, "new", mrb_class_new_class, ARGS_ANY());
mrb_define_method(mrb, cls, "superclass", mrb_class_superclass, ARGS_NONE()); /* 15.2.3.3.4 */
mrb_define_method(mrb, cls, "new", mrb_instance_new, ARGS_ANY()); /* 15.2.3.3.3 */
mrb_define_method(mrb, cls, "inherited", mrb_bob_init, ARGS_REQ(1));
mrb_define_method(mrb, mod, "include", mrb_mod_include, ARGS_REQ(1)); /* 15.2.2.4.27 */
mrb_define_method(mrb, mod, "to_s", mrb_mod_to_s, ARGS_NONE());
mrb_define_method(mrb, mod, "alias_method", mrb_mod_alias, ARGS_ANY()); /* 15.2.2.4.8 */
mrb_define_method(mrb, mod, "undef_method", mrb_mod_undef, ARGS_ANY()); /* 15.2.2.4.41 */
mrb_define_method(mrb, mod, "const_defined?", mrb_mod_const_defined, ARGS_REQ(1)); /* 15.2.2.4.20 */
mrb_define_method(mrb, mod, "const_get", mrb_mod_const_get, ARGS_REQ(1)); /* 15.2.2.4.21 */
mrb_define_method(mrb, mod, "const_set", mrb_mod_const_set, ARGS_REQ(2)); /* 15.2.2.4.23 */
mrb_define_method(mrb, mod, "define_method", mod_define_method, ARGS_REQ(1));
mrb_define_method(mrb, mod, "===", mrb_mod_eqq, ARGS_REQ(1));
}
void
mrb_mruby_ssp_cyclic_gem_init(mrb_state* mrb) {
struct RClass *cyc;
cyc = mrb_define_class(mrb, "Ssp_cyclic", mrb->object_class);
/* methods */
mrb_define_method(mrb, cyc, "initialize", mrb_ssp_cyclic_initialize, ARGS_REQ(2));
mrb_define_method(mrb, cyc, "start", mrb_ssp_cyclic_sta, ARGS_NONE());
mrb_define_method(mrb, cyc, "stop" , mrb_ssp_cyclic_stp, ARGS_NONE());
mrb_define_method(mrb, cyc, "istop" , mrb_ssp_cyclic_istp, ARGS_NONE());
}
void
mrb_init_symbols(mrb_state *mrb)
{
struct RClass *sym;
sym = mrb->symbol_class = mrb_define_class(mrb, "Symbol", mrb->object_class);
mrb_define_method(mrb, sym, "===", sym_equal, ARGS_REQ(1)); /* 15.2.11.3.1 */
mrb_define_method(mrb, sym, "id2name", mrb_sym_to_s, ARGS_NONE()); /* 15.2.11.3.2 */
mrb_define_method(mrb, sym, "to_s", mrb_sym_to_s, ARGS_NONE()); /* 15.2.11.3.3 */
mrb_define_method(mrb, sym, "to_sym", sym_to_sym, ARGS_NONE()); /* 15.2.11.3.4 */
mrb_define_method(mrb, sym, "inspect", sym_inspect, ARGS_NONE()); /* 15.2.11.3.5(x) */
}
void
mrb_init_enumerable(mrb_state *mrb)
{
struct RClass *cenum;
//#undef mrb_intern
//#define mrb_intern(str) mrb_intern_const(str)
cenum = mrb_define_module(mrb, "Enumerable");
#if 0
//mrb_define_class_method(mrb, cenum, "all?", enum_all, ARGS_NONE()); /* 15.3.2.2.1 */
//mrb_define_class_method(mrb, cenum, "any?", enum_any, ARGS_NONE()); /* 15.3.2.2.2 */
//mrb_define_class_method(mrb, cenum, "collect", enum_collect, ARGS_NONE()); /* 15.3.2.2.3 */
//mrb_define_class_method(mrb, cenum, "detect", enum_find_m, ARGS_ANY()); /* 15.3.2.2.4 */
//mrb_define_class_method(mrb, cenum, "each_with_index", enum_each_with_index_m, ARGS_ANY()); /* 15.3.2.2.5 */
mrb_define_class_method(mrb, cenum, "entries", enum_to_a_m, ARGS_ANY()); /* 15.3.2.2.6 */
//mrb_define_class_method(mrb, cenum, "find", enum_find_m, ARGS_ANY()); /* 15.3.2.2.7 */
//mrb_define_class_method(mrb, cenum, "find_all", enum_find_all, ARGS_NONE()); /* 15.3.2.2.8 */
//mrb_define_class_method(mrb, cenum, "grep", enum_grep, ARGS_REQ(1)); /* 15.3.2.2.9 */
mrb_define_class_method(mrb, cenum, "include?", enum_member, ARGS_REQ(1)); /* 15.3.2.2.10 */
//mrb_define_class_method(mrb, cenum, "inject", enum_inject_m, ARGS_ANY()); /* 15.3.2.2.11 */
//mrb_define_class_method(mrb, cenum, "map", enum_collect, ARGS_NONE()); /* 15.3.2.2.12 */
//mrb_define_class_method(mrb, cenum, "max", enum_max, ARGS_NONE()); /* 15.3.2.2.13 */
//mrb_define_class_method(mrb, cenum, "min", enum_min, ARGS_NONE()); /* 15.3.2.2.14 */
mrb_define_class_method(mrb, cenum, "member?", enum_member, ARGS_REQ(1)); /* 15.3.2.2.15 */
//mrb_define_class_method(mrb, cenum, "partition", enum_partition, ARGS_NONE()); /* 15.3.2.2.16 */
//mrb_define_class_method(mrb, cenum, "reject", enum_reject, ARGS_NONE()); /* 15.3.2.2.17 */
//mrb_define_class_method(mrb, cenum, "select", enum_find_all, ARGS_NONE()); /* 15.3.2.2.18 */
//mrb_define_class_method(mrb, cenum, "sort", enum_sort, ARGS_NONE()); /* 15.3.2.2.19 */
mrb_define_class_method(mrb, cenum, "to_a", enum_to_a_m, ARGS_ANY()); /* 15.3.2.2.20 */
id_eqq = mrb_intern(mrb, "===");
id_each = mrb_intern(mrb, "each");
id_cmp = mrb_intern(mrb, "<=>");
id_next = mrb_intern(mrb, "next");
id_size = mrb_intern(mrb, "size");
#endif
}
void
mrb_init_uefi_handle(mrb_state *mrb, struct RClass *mrb_uefi)
{
struct RClass *h_cls;
h_cls = mrb_define_class_under(mrb, mrb_uefi, "Handle", mrb->object_class);
MRB_SET_INSTANCE_TT(h_cls, MRB_TT_DATA);
mrb_define_method(mrb, h_cls, "==", mrb_uefi_handle_eq, ARGS_REQ(1));
mrb_define_method(mrb, h_cls, "to_s", mrb_uefi_handle_to_s, ARGS_NONE());
mrb_define_method(mrb, h_cls, "inspect", mrb_uefi_handle_inspect, ARGS_NONE());
mrb_define_method(mrb, h_cls, "value", mrb_uefi_handle_value, ARGS_NONE());
mrb_const_set(mrb, mrb_obj_value(h_cls), mrb_intern(mrb, "NULL"),
mrb_uefi_handle_make_helper(mrb, h_cls, NULL));
}
bool init_mruby()
{
Serial2.println("init_mruby enter");
g_mrb = mrb_open_allocf(myallocfCCM, NULL);
// g_mrb = mrb_open_allocf(myallocf, NULL);
Serial2.print("mrb_open done. total allocated : ");
Serial2.println(total_size, DEC);
mrb_load_irep(g_mrb, blinker);
RClass *freeRTOSModule = mrb_define_module(g_mrb, "FreeRTOS");
mrb_define_module_function(g_mrb, freeRTOSModule, "sleep", mrb_freertos_sleep, ARGS_REQ(1));
Serial2.println("mruby initialized");
return true;
}
void
mrb_init_exception(mrb_state *mrb)
{
struct RClass *e;
mrb->eException_class = e = mrb_define_class(mrb, "Exception", mrb->object_class); /* 15.2.22 */
mrb_define_class_method(mrb, e, "exception", mrb_instance_new, ARGS_ANY());
mrb_define_method(mrb, e, "exception", exc_exception, ARGS_ANY());
mrb_define_method(mrb, e, "initialize", exc_initialize, ARGS_ANY());
mrb_define_method(mrb, e, "==", exc_equal, ARGS_REQ(1));
mrb_define_method(mrb, e, "to_s", exc_to_s, ARGS_NONE());
mrb_define_method(mrb, e, "message", exc_message, ARGS_NONE());
mrb_define_method(mrb, e, "inspect", exc_inspect, ARGS_NONE());
mrb->eStandardError_class = mrb_define_class(mrb, "StandardError", mrb->eException_class); /* 15.2.23 */
mrb_define_class(mrb, "RuntimeError", mrb->eStandardError_class); /* 15.2.28 */
}
void
mrb_mruby_sysfsgpio_gem_init(mrb_state* mrb)
{
struct RClass *tc;
/* define class */
tc = mrb_define_class(mrb,"GPIO",mrb->object_class);
MRB_SET_INSTANCE_TT(tc, MRB_TT_DATA);
mrb_define_method(mrb, tc, "initialize", mrb_c_gpio_initialize, ARGS_REQ(1));
mrb_define_method(mrb, tc, "attach", mrb_c_gpio_attach, ARGS_NONE());
mrb_define_method(mrb, tc, "detach", mrb_c_gpio_detach, ARGS_NONE());
mrb_define_method(mrb, tc, "direction_high", mrb_c_gpio_direction_high, ARGS_NONE());
mrb_define_method(mrb, tc, "direction_low", mrb_c_gpio_direction_low, ARGS_NONE());
mrb_define_method(mrb, tc, "direction_out", mrb_c_gpio_direction_out, ARGS_NONE());
mrb_define_method(mrb, tc, "direction_in", mrb_c_gpio_direction_in, ARGS_NONE());
mrb_define_method(mrb, tc, "read", mrb_c_gpio_read, ARGS_NONE());
}
void
mrb_init_comparable(mrb_state *mrb)
{
struct RClass *comp;
comp = mrb_define_module(mrb, "Comparable");
mrb_define_method(mrb, comp, "<", cmp_lt_m, ARGS_REQ(1)); /* 15.3.3.2.1 */
mrb_define_method(mrb, comp, "<=", cmp_le_m, ARGS_REQ(1)); /* 15.3.3.2.2 */
mrb_define_method(mrb, comp, "==", cmp_equal, ARGS_REQ(1)); /* 15.3.3.2.3 */
mrb_define_method(mrb, comp, ">", cmp_gt_m, ARGS_REQ(1)); /* 15.3.3.2.4 */
mrb_define_method(mrb, comp, ">=", cmp_ge_m, ARGS_REQ(1)); /* 15.3.3.2.5 */
mrb_define_method(mrb, comp, "between?", cmp_between, ARGS_REQ(2)); /* 15.3.3.2.6 */
}
void
mrb_http_init(mrb_state* mrb) {
_class_http = mrb_define_module(mrb, "HTTP");
_class_http_parser = mrb_define_class_under(mrb, _class_http, "Parser", mrb->object_class);
mrb_define_method(mrb, _class_http_parser, "initialize", mrb_http_parser_init, ARGS_OPT(1));
mrb_define_method(mrb, _class_http_parser, "parse", mrb_http_parser_parse, ARGS_OPT(2));
mrb_define_method(mrb, _class_http_parser, "execute", mrb_http_parser_execute, ARGS_REQ(1));
_class_http_request = mrb_define_class_under(mrb, _class_http, "Request", mrb->object_class);
mrb_define_method(mrb, _class_http_request, "schema", mrb_http_request_schema, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "host", mrb_http_request_host, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "port", mrb_http_request_port, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "path", mrb_http_request_path, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "query", mrb_http_request_query, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "fragment", mrb_http_request_fragment, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "headers", mrb_http_request_headers, ARGS_NONE());
_class_http_response = mrb_define_class_under(mrb, _class_http, "Response", mrb->object_class);
}
void
init_cfunc_rubyvm(mrb_state *mrb, struct RClass* module, void (*mrb_state_init)(mrb_state*))
{
cfunc_state(mrb)->mrb_state_init = mrb_state_init;
struct RClass *rubyvm_class = mrb_define_class_under(mrb, module, "RubyVM", mrb->object_class);
cfunc_state(mrb)->rubyvm_class = rubyvm_class;
mrb_define_class_method(mrb, rubyvm_class, "thread", cfunc_rubyvm_class_thread, ARGS_REQ(1));
mrb_define_method(mrb, rubyvm_class, "dispatch", cfunc_rubyvm_dispatch, ARGS_ANY());
struct RClass *rubyvm_task_class = mrb_define_class_under(mrb, cfunc_state(mrb)->rubyvm_class, "Task", mrb->object_class);
cfunc_state(mrb)->rubyvm_task_class = rubyvm_task_class;
mrb_define_method(mrb, rubyvm_task_class, "wait", cfunc_rubyvm_task_wait, ARGS_NONE());
mrb_define_method(mrb, rubyvm_task_class, "result", cfunc_rubyvm_task_result, ARGS_NONE());
mrb_define_method(mrb, rubyvm_task_class, "status", cfunc_rubyvm_task_status, ARGS_NONE());
mrb_define_const(mrb, rubyvm_task_class, "QUEUED", mrb_fixnum_value(queue_task_queued));
mrb_define_const(mrb, rubyvm_task_class, "RUNNING", mrb_fixnum_value(queue_task_running));
mrb_define_const(mrb, rubyvm_task_class, "FINISHED", mrb_fixnum_value(queue_task_finished));
}
void mrb_mruby_redis_gem_init(mrb_state *mrb)
{
struct RClass *redis;
redis = mrb_define_class(mrb, "Redis", mrb->object_class);
mrb_define_method(mrb, redis, "initialize", mrb_redis_connect, ARGS_ANY());
mrb_define_method(mrb, redis, "select", mrb_redis_select, ARGS_REQ(1));
mrb_define_method(mrb, redis, "set", mrb_redis_set, ARGS_ANY());
mrb_define_method(mrb, redis, "get", mrb_redis_get, ARGS_ANY());
mrb_define_method(mrb, redis, "randomkey", mrb_redis_randomkey, ARGS_NONE());
mrb_define_method(mrb, redis, "[]=", mrb_redis_set, ARGS_ANY());
mrb_define_method(mrb, redis, "[]", mrb_redis_get, ARGS_ANY());
mrb_define_method(mrb, redis, "del", mrb_redis_del, ARGS_ANY());
mrb_define_method(mrb, redis, "incr", mrb_redis_incr, ARGS_OPT(1));
mrb_define_method(mrb, redis, "decr", mrb_redis_decr, ARGS_OPT(1));
mrb_define_method(mrb, redis, "rpush", mrb_redis_rpush, ARGS_OPT(2));
mrb_define_method(mrb, redis, "lpush", mrb_redis_lpush, ARGS_OPT(2));
mrb_define_method(mrb, redis, "lrange", mrb_redis_lrange, ARGS_ANY());
mrb_define_method(mrb, redis, "ltrim", mrb_redis_ltrim, ARGS_ANY());
mrb_define_method(mrb, redis, "publish", mrb_redis_pub, ARGS_ANY());
mrb_define_method(mrb, redis, "close", mrb_redis_close, ARGS_NONE());
DONE;
}
void
mrb_mruby_http_gem_init(mrb_state* mrb) {
_class_http = mrb_define_module(mrb, "HTTP");
_class_http_parser = mrb_define_class_under(mrb, _class_http, "Parser", mrb->object_class);
mrb_define_method(mrb, _class_http_parser, "initialize", mrb_http_parser_init, ARGS_OPT(1));
mrb_define_method(mrb, _class_http_parser, "parse_request", mrb_http_parser_parse_request, ARGS_OPT(2));
mrb_define_method(mrb, _class_http_parser, "parse_url", mrb_http_parser_parse_url, ARGS_REQ(1));
mrb_define_method(mrb, _class_http_parser, "execute", mrb_http_parser_execute, ARGS_REQ(1));
mrb_define_method(mrb, _class_http_parser, "data=", mrb_http_data_set, ARGS_REQ(1));
mrb_define_method(mrb, _class_http_parser, "data", mrb_http_data_get, ARGS_NONE());
_class_http_request = mrb_define_class_under(mrb, _class_http, "Request", mrb->object_class);
mrb_define_method(mrb, _class_http_request, "schema", mrb_http_request_schema, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "host", mrb_http_request_host, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "port", mrb_http_request_port, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "path", mrb_http_request_path, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "query", mrb_http_request_query, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "headers", mrb_http_request_headers, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "method", mrb_http_request_method, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "data=", mrb_http_data_set, ARGS_REQ(1));
mrb_define_method(mrb, _class_http_request, "data", mrb_http_data_get, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "body=", mrb_http_request_body_set, ARGS_REQ(1));
mrb_define_method(mrb, _class_http_request, "body", mrb_http_request_body_get, ARGS_NONE());
_class_http_url = mrb_define_class_under(mrb, _class_http, "URL", mrb->object_class);
mrb_define_method(mrb, _class_http_url, "schema", mrb_http_url_schema, ARGS_NONE());
mrb_define_method(mrb, _class_http_url, "host", mrb_http_url_host, ARGS_NONE());
mrb_define_method(mrb, _class_http_url, "port", mrb_http_url_port, ARGS_NONE());
mrb_define_method(mrb, _class_http_url, "path", mrb_http_url_path, ARGS_NONE());
mrb_define_method(mrb, _class_http_url, "query", mrb_http_url_query, ARGS_NONE());
mrb_define_method(mrb, _class_http_url, "fragment", mrb_http_url_fragment, ARGS_NONE());
mrb_define_class_method(mrb, _class_http_url, "encode", mrb_http_url_encode, ARGS_REQ(1));
mrb_define_class_method(mrb, _class_http_url, "decode", mrb_http_url_decode, ARGS_REQ(1));
_class_http_response = mrb_define_class_under(mrb, _class_http, "Response", mrb->object_class);
}
void
mrb_init_array(mrb_state *mrb)
{
struct RClass *a;
a = mrb->array_class = mrb_define_class(mrb, "Array", mrb->object_class);
MRB_SET_INSTANCE_TT(a, MRB_TT_ARRAY);
mrb_include_module(mrb, a, mrb_class_get(mrb, "Enumerable"));
mrb_define_class_method(mrb, a, "[]", mrb_ary_s_create, ARGS_ANY()); /* 15.2.12.4.1 */
mrb_define_method(mrb, a, "*", mrb_ary_times, ARGS_REQ(1)); /* 15.2.12.5.1 */
mrb_define_method(mrb, a, "+", mrb_ary_plus, ARGS_REQ(1)); /* 15.2.12.5.2 */
mrb_define_method(mrb, a, "<<", mrb_ary_push_m, ARGS_REQ(1)); /* 15.2.12.5.3 */
mrb_define_method(mrb, a, "[]", mrb_ary_aget, ARGS_ANY()); /* 15.2.12.5.4 */
mrb_define_method(mrb, a, "[]=", mrb_ary_aset, ARGS_ANY()); /* 15.2.12.5.5 */
mrb_define_method(mrb, a, "clear", mrb_ary_clear, ARGS_NONE()); /* 15.2.12.5.6 */
mrb_define_method(mrb, a, "concat", mrb_ary_concat_m, ARGS_REQ(1)); /* 15.2.12.5.8 */
mrb_define_method(mrb, a, "delete_at", mrb_ary_delete_at, ARGS_REQ(1)); /* 15.2.12.5.9 */
mrb_define_method(mrb, a, "empty?", mrb_ary_empty_p, ARGS_NONE()); /* 15.2.12.5.12 */
mrb_define_method(mrb, a, "first", mrb_ary_first, ARGS_OPT(1)); /* 15.2.12.5.13 */
mrb_define_method(mrb, a, "index", mrb_ary_index_m, ARGS_REQ(1)); /* 15.2.12.5.14 */
mrb_define_method(mrb, a, "initialize_copy", mrb_ary_replace_m, ARGS_REQ(1)); /* 15.2.12.5.16 */
mrb_define_method(mrb, a, "join", mrb_ary_join_m, ARGS_ANY()); /* 15.2.12.5.17 */
mrb_define_method(mrb, a, "last", mrb_ary_last, ARGS_ANY()); /* 15.2.12.5.18 */
mrb_define_method(mrb, a, "length", mrb_ary_size, ARGS_NONE()); /* 15.2.12.5.19 */
mrb_define_method(mrb, a, "pop", mrb_ary_pop, ARGS_NONE()); /* 15.2.12.5.21 */
mrb_define_method(mrb, a, "push", mrb_ary_push_m, ARGS_ANY()); /* 15.2.12.5.22 */
mrb_define_method(mrb, a, "replace", mrb_ary_replace_m, ARGS_REQ(1)); /* 15.2.12.5.23 */
mrb_define_method(mrb, a, "reverse", mrb_ary_reverse, ARGS_NONE()); /* 15.2.12.5.24 */
mrb_define_method(mrb, a, "reverse!", mrb_ary_reverse_bang, ARGS_NONE()); /* 15.2.12.5.25 */
mrb_define_method(mrb, a, "rindex", mrb_ary_rindex_m, ARGS_REQ(1)); /* 15.2.12.5.26 */
mrb_define_method(mrb, a, "shift", mrb_ary_shift, ARGS_NONE()); /* 15.2.12.5.27 */
mrb_define_method(mrb, a, "size", mrb_ary_size, ARGS_NONE()); /* 15.2.12.5.28 */
mrb_define_method(mrb, a, "slice", mrb_ary_aget, ARGS_ANY()); /* 15.2.12.5.29 */
mrb_define_method(mrb, a, "unshift", mrb_ary_unshift_m, ARGS_ANY()); /* 15.2.12.5.30 */
mrb_define_method(mrb, a, "inspect", mrb_ary_inspect, ARGS_NONE()); /* 15.2.12.5.31 (x) */
mrb_define_alias(mrb, a, "to_s", "inspect"); /* 15.2.12.5.32 (x) */
mrb_define_method(mrb, a, "==", mrb_ary_equal, ARGS_REQ(1)); /* 15.2.12.5.33 (x) */
mrb_define_method(mrb, a, "eql?", mrb_ary_eql, ARGS_REQ(1)); /* 15.2.12.5.34 (x) */
mrb_define_method(mrb, a, "<=>", mrb_ary_cmp, ARGS_REQ(1)); /* 15.2.12.5.36 (x) */
}
void init_cfunc_type(mrb_state *mrb, struct RClass* module)
{
struct cfunc_state *state = cfunc_state(mrb, module);
struct RClass *type_class = mrb_define_class_under(mrb, module, "Type", mrb->object_class);
MRB_SET_INSTANCE_TT(type_class, MRB_TT_DATA);
state->type_class = type_class;
set_cfunc_state(mrb, type_class, state);
int ai = mrb_gc_arena_save(mrb);
mrb_define_class_method(mrb, type_class, "refer", cfunc_type_class_refer, ARGS_REQ(1));
mrb_define_class_method(mrb, type_class, "size", cfunc_type_size, ARGS_NONE());
mrb_define_class_method(mrb, type_class, "align", cfunc_type_align, ARGS_NONE());
mrb_define_class_method(mrb, type_class, "get", cfunc_type_class_get, ARGS_REQ(1));
mrb_define_class_method(mrb, type_class, "set", cfunc_type_class_set, ARGS_REQ(2));
mrb_define_method(mrb, type_class, "initialize", cfunc_type_initialize, ARGS_ANY());
mrb_define_method(mrb, type_class, "value", cfunc_type_get_value, ARGS_NONE());
mrb_define_method(mrb, type_class, "value=", cfunc_type_set_value, ARGS_REQ(1));
mrb_define_method(mrb, type_class, "addr", cfunc_type_addr, ARGS_NONE());
mrb_define_method(mrb, type_class, "to_ffi_value", cfunc_type_addr, ARGS_NONE());
DONE;
int map_size = sizeof(types) / sizeof(struct mrb_ffi_type);
int i;
for(i = 0; i < map_size; ++i) {
struct RClass *new_class = mrb_define_class_under(mrb, module, types[i].name, type_class);
mrb_value ffi_type = mrb_obj_value(Data_Wrap_Struct(mrb, mrb->object_class, &cfunc_class_ffi_data_type, &types[i]));
mrb_obj_iv_set(mrb, (struct RObject*)new_class, mrb_intern_cstr(mrb, "@ffi_type"), ffi_type);
}
DONE;
mrb_value mod = mrb_obj_value(module);
state->void_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern_cstr(mrb, "Void")));
state->uint8_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern_cstr(mrb, "UInt8")));
state->sint8_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern_cstr(mrb, "SInt8")));
state->uint16_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern_cstr(mrb, "UInt16")));
state->sint16_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern_cstr(mrb, "SInt16")));
state->uint32_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern_cstr(mrb, "UInt32")));
state->sint32_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern_cstr(mrb, "SInt32")));
state->uint64_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern_cstr(mrb, "UInt64")));
state->sint64_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern_cstr(mrb, "SInt64")));
state->float_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern_cstr(mrb, "Float")));
state->double_class = mrb_class_ptr(mrb_const_get(mrb, mod, mrb_intern_cstr(mrb, "Double")));
DONE;
mrb_define_class_method(mrb, mrb->nil_class, "size", cfunc_nil_size, ARGS_NONE());
mrb_define_class_method(mrb, mrb->nil_class, "align", cfunc_nil_align, ARGS_NONE());
DONE;
// uint64 specific
struct RClass *uint64_class = state->uint64_class;
mrb_define_class_method(mrb, uint64_class, "get", cfunc_uint64_class_get, ARGS_REQ(1));
mrb_define_method(mrb, uint64_class, "value", cfunc_uint64_get_value, ARGS_NONE());
mrb_define_method(mrb, uint64_class, "low", cfunc_uint64_get_low, ARGS_NONE());
mrb_define_method(mrb, uint64_class, "low=", cfunc_uint64_set_low, ARGS_REQ(1));
mrb_define_method(mrb, uint64_class, "high", cfunc_uint64_get_high, ARGS_NONE());
mrb_define_method(mrb, uint64_class, "high=", cfunc_uint64_set_high, ARGS_REQ(1));
mrb_define_method(mrb, uint64_class, "to_s", cfunc_uint64_to_s, ARGS_REQ(1));
mrb_define_method(mrb, uint64_class, "divide", cfunc_uint64_divide, ARGS_REQ(1));
DONE;
// sint64 specific
struct RClass *sint64_class = state->sint64_class;
mrb_define_class_method(mrb, sint64_class, "get", cfunc_sint64_class_get, ARGS_REQ(1));
mrb_define_method(mrb, sint64_class, "value", cfunc_sint64_get_value, ARGS_NONE());
mrb_define_method(mrb, sint64_class, "low", cfunc_uint64_get_low, ARGS_NONE());
mrb_define_method(mrb, sint64_class, "low=", cfunc_uint64_set_low, ARGS_REQ(1));
mrb_define_method(mrb, sint64_class, "high", cfunc_uint64_get_high, ARGS_NONE());
mrb_define_method(mrb, sint64_class, "high=", cfunc_uint64_set_high, ARGS_REQ(1));
mrb_define_method(mrb, sint64_class, "to_s", cfunc_int64_to_s, ARGS_REQ(1));
DONE;
}
void
mrb_init_kernel(mrb_state *mrb)
{
struct RClass *krn;
krn = mrb->kernel_module = mrb_define_module(mrb, "Kernel");
mrb_define_class_method(mrb, krn, "block_given?", mrb_f_block_given_p_m, ARGS_NONE()); /* 15.3.1.2.2 */
mrb_define_class_method(mrb, krn, "global_variables", mrb_f_global_variables, ARGS_NONE()); /* 15.3.1.2.4 */
mrb_define_class_method(mrb, krn, "iterator?", mrb_f_block_given_p_m, ARGS_NONE()); /* 15.3.1.2.5 */
; /* 15.3.1.2.11 */
mrb_define_class_method(mrb, krn, "raise", mrb_f_raise, ARGS_ANY()); /* 15.3.1.2.12 */
mrb_define_method(mrb, krn, "singleton_class", mrb_singleton_class, ARGS_NONE());
mrb_define_method(mrb, krn, "==", mrb_obj_equal_m, ARGS_REQ(1)); /* 15.3.1.3.1 */
mrb_define_method(mrb, krn, "!=", mrb_obj_not_equal_m, ARGS_REQ(1));
mrb_define_method(mrb, krn, "===", mrb_equal_m, ARGS_REQ(1)); /* 15.3.1.3.2 */
mrb_define_method(mrb, krn, "__id__", mrb_obj_id_m, ARGS_NONE()); /* 15.3.1.3.3 */
mrb_define_method(mrb, krn, "__send__", mrb_f_send, ARGS_ANY()); /* 15.3.1.3.4 */
mrb_define_method(mrb, krn, "block_given?", mrb_f_block_given_p_m, ARGS_NONE()); /* 15.3.1.3.6 */
mrb_define_method(mrb, krn, "class", mrb_obj_class_m, ARGS_NONE()); /* 15.3.1.3.7 */
mrb_define_method(mrb, krn, "clone", mrb_obj_clone, ARGS_NONE()); /* 15.3.1.3.8 */
mrb_define_method(mrb, krn, "dup", mrb_obj_dup, ARGS_NONE()); /* 15.3.1.3.9 */
mrb_define_method(mrb, krn, "eql?", mrb_obj_equal_m, ARGS_REQ(1)); /* 15.3.1.3.10 */
mrb_define_method(mrb, krn, "equal?", mrb_obj_equal_m, ARGS_REQ(1)); /* 15.3.1.3.11 */
mrb_define_method(mrb, krn, "extend", mrb_obj_extend_m, ARGS_ANY()); /* 15.3.1.3.13 */
mrb_define_method(mrb, krn, "global_variables", mrb_f_global_variables, ARGS_NONE()); /* 15.3.1.3.14 */
mrb_define_method(mrb, krn, "hash", mrb_obj_hash, ARGS_NONE()); /* 15.3.1.3.15 */
mrb_define_method(mrb, krn, "initialize_copy", mrb_obj_init_copy, ARGS_REQ(1)); /* 15.3.1.3.16 */
mrb_define_method(mrb, krn, "inspect", mrb_obj_inspect, ARGS_NONE()); /* 15.3.1.3.17 */
mrb_define_method(mrb, krn, "instance_eval", mrb_obj_instance_eval, ARGS_ANY()); /* 15.3.1.3.18 */
mrb_define_method(mrb, krn, "instance_of?", obj_is_instance_of, ARGS_REQ(1)); /* 15.3.1.3.19 */
mrb_define_method(mrb, krn, "instance_variable_defined?", mrb_obj_ivar_defined, ARGS_REQ(1)); /* 15.3.1.3.20 */
mrb_define_method(mrb, krn, "instance_variable_get", mrb_obj_ivar_get, ARGS_REQ(1)); /* 15.3.1.3.21 */
mrb_define_method(mrb, krn, "instance_variable_set", mrb_obj_ivar_set, ARGS_REQ(2)); /* 15.3.1.3.22 */
mrb_define_method(mrb, krn, "instance_variables", mrb_obj_instance_variables, ARGS_NONE()); /* 15.3.1.3.23 */
mrb_define_method(mrb, krn, "is_a?", mrb_obj_is_kind_of_m, ARGS_REQ(1)); /* 15.3.1.3.24 */
mrb_define_method(mrb, krn, "iterator?", mrb_f_block_given_p_m, ARGS_NONE()); /* 15.3.1.3.25 */
mrb_define_method(mrb, krn, "kind_of?", mrb_obj_is_kind_of_m, ARGS_REQ(1)); /* 15.3.1.3.26 */
mrb_define_method(mrb, krn, "methods", mrb_obj_methods_m, ARGS_ANY()); /* 15.3.1.3.31 */
mrb_define_method(mrb, krn, "nil?", mrb_false, ARGS_NONE()); /* 15.3.1.3.32 */
mrb_define_method(mrb, krn, "object_id", mrb_obj_id_m, ARGS_NONE()); /* 15.3.1.3.33 */
mrb_define_method(mrb, krn, "private_methods", mrb_obj_private_methods, ARGS_ANY()); /* 15.3.1.3.36 */
mrb_define_method(mrb, krn, "protected_methods", mrb_obj_protected_methods, ARGS_ANY()); /* 15.3.1.3.37 */
mrb_define_method(mrb, krn, "public_methods", mrb_obj_public_methods, ARGS_ANY()); /* 15.3.1.3.38 */
mrb_define_method(mrb, krn, "raise", mrb_f_raise, ARGS_ANY()); /* 15.3.1.3.40 */
mrb_define_method(mrb, krn, "remove_instance_variable", mrb_obj_remove_instance_variable,ARGS_REQ(1)); /* 15.3.1.3.41 */
mrb_define_method(mrb, krn, "respond_to?", obj_respond_to, ARGS_ANY()); /* 15.3.1.3.43 */
mrb_define_method(mrb, krn, "send", mrb_f_send, ARGS_ANY()); /* 15.3.1.3.44 */
mrb_define_method(mrb, krn, "__send__", mrb_f_send, ARGS_ANY()); /* 15.3.1.3.4 */
mrb_define_method(mrb, krn, "singleton_methods", mrb_obj_singleton_methods_m, ARGS_ANY()); /* 15.3.1.3.45 */
mrb_define_method(mrb, krn, "to_s", mrb_any_to_s, ARGS_NONE()); /* 15.3.1.3.46 */
#ifdef ENABLE_SPRINTF
mrb_define_method(mrb, krn, "sprintf", mrb_f_sprintf, ARGS_ANY()); /* in sprintf.c */
mrb_define_method(mrb, krn, "format", mrb_f_sprintf, ARGS_ANY()); /* in sprintf.c */
#endif
mrb_include_module(mrb, mrb->object_class, mrb->kernel_module);
}
