void
mrb_mruby_pcap_gem_init(mrb_state *mrb)
{
struct RClass *pcap, *capt;
pcap = mrb_define_module(mrb, "Pcap");
mrb_define_module_function(mrb, pcap, "lookupdev", mrb_pcap_s_lookupdev, ARGS_NONE());
mrb_define_module_function(mrb, pcap, "lookupnet", pcap_s_lookupnet,
ARGS_REQ(1));
mrb_define_const(mrb, pcap, "DLT_NULL", mrb_fixnum_value(DLT_NULL));
mrb_define_const(mrb, pcap, "DLT_EN10MB", mrb_fixnum_value(DLT_EN10MB));
mrb_define_const(mrb, pcap, "DLT_PPP", mrb_fixnum_value(DLT_PPP));
#ifdef DLT_RAW
mrb_define_const(mrb, pcap, "DLT_RAW", mrb_fixnum_value(DLT_RAW));
#endif
capt = mrb_define_class_under(mrb, pcap, "Capture", mrb->object_class);
mrb_define_singleton_method(mrb, (struct RObject*)capt, "open_live", mrb_capture_open_live, MRB_ARGS_ARG(1, 3));
mrb_define_method(mrb, capt, "capture", capture, ARGS_NONE());
mrb_define_method(mrb, capt, "close", capture_close, ARGS_NONE());
mrb_define_method(mrb, capt, "datalink", capture_datalink, ARGS_NONE());
mrb_define_method(mrb, capt, "inject", mrb_capture_inject, MRB_ARGS_REQ(1));
mrb_define_method(mrb, capt, "setfilter", capture_setfilter, ARGS_ANY());
}
void
mrb_mruby_regexp_pcre_gem_init(mrb_state *mrb)
{
struct RClass *re, *md;
re = mrb_define_class(mrb, "Regexp", mrb->object_class);
MRB_SET_INSTANCE_TT(re, MRB_TT_DATA);
mrb_define_method(mrb, re, "initialize", regexp_pcre_initialize, MRB_ARGS_REQ(1) | MRB_ARGS_OPT(2));
mrb_define_method(mrb, re, "match", regexp_pcre_match, MRB_ARGS_REQ(1));
mrb_define_method(mrb, re, "==", regexp_equal, MRB_ARGS_REQ(1));
mrb_define_const(mrb, re, "IGNORECASE", mrb_fixnum_value(MRUBY_REGEXP_IGNORECASE));
mrb_define_const(mrb, re, "EXTENDED", mrb_fixnum_value(MRUBY_REGEXP_EXTENDED));
mrb_define_const(mrb, re, "MULTILINE", mrb_fixnum_value(MRUBY_REGEXP_MULTILINE));
md = mrb_define_class(mrb, "MatchData", mrb->object_class);
MRB_SET_INSTANCE_TT(md, MRB_TT_DATA);
mrb_define_method(mrb, md, "initialize", mrb_matchdata_init, MRB_ARGS_REQ(1));
mrb_define_method(mrb, md, "initialize_copy", mrb_matchdata_init_copy, MRB_ARGS_REQ(1));
mrb_define_method(mrb, md, "begin", mrb_matchdata_begin, MRB_ARGS_REQ(1));
mrb_define_method(mrb, md, "end", mrb_matchdata_end, MRB_ARGS_REQ(1));
mrb_define_method(mrb, md, "length", mrb_matchdata_length, MRB_ARGS_NONE());
}
int main(void)
{
/* new interpreter instance */
mrb_state *mrb;
mrb = mrb_open();
/* modify interpreter state */
// FakeLED class
struct RClass *fake_led_class = mrb_define_class(mrb, "FakeLED", mrb->object_class);
// Instance methods in FakeLED
mrb_define_method(mrb, fake_led_class, "initialize", fake_led_init, MRB_ARGS_REQ(1));
mrb_define_method(mrb, fake_led_class, "illuminate!", fake_led_illuminate, MRB_ARGS_REQ(1));
// Constants nested in FakeLED, eg FakeLED::RED
// They define the available colors of LED (maybe these would be pin numbers IRL)
mrb_define_const(mrb, fake_led_class, "RED", mrb_str_new(mrb, KRED, 4));
mrb_define_const(mrb, fake_led_class, "BLUE", mrb_str_new(mrb, KBLU, 4));
mrb_define_const(mrb, fake_led_class, "GREEN", mrb_str_new(mrb, KGRN, 4));
/* read and execute compiled symbols */
mrb_load_irep(mrb, hello_embedded_ruby);
mrb_close(mrb);
return 0;
}
void
mrb_init_file(mrb_state *mrb)
{
struct RClass *io, *file, *cnst;
io = mrb_class_get(mrb, "IO");
file = mrb_define_class(mrb, "File", io);
MRB_SET_INSTANCE_TT(file, MRB_TT_DATA);
mrb_define_class_method(mrb, file, "umask", mrb_file_s_umask, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, file, "delete", mrb_file_s_unlink, MRB_ARGS_ANY());
mrb_define_class_method(mrb, file, "unlink", mrb_file_s_unlink, MRB_ARGS_ANY());
mrb_define_class_method(mrb, file, "rename", mrb_file_s_rename, MRB_ARGS_REQ(2));
mrb_define_class_method(mrb, file, "dirname", mrb_file_dirname, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, file, "basename", mrb_file_basename, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, file, "realpath", mrb_file_realpath, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
mrb_define_class_method(mrb, file, "size", mrb_file_size, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, file, "_getwd", mrb_file__getwd, MRB_ARGS_NONE());
mrb_define_class_method(mrb, file, "_gethome", mrb_file__gethome, MRB_ARGS_OPT(1));
#ifndef _WIN32
mrb_define_method(mrb, file, "flock", mrb_file_flock, MRB_ARGS_REQ(1));
#endif
cnst = mrb_define_module_under(mrb, file, "Constants");
mrb_define_const(mrb, cnst, "LOCK_SH", mrb_fixnum_value(LOCK_SH));
mrb_define_const(mrb, cnst, "LOCK_EX", mrb_fixnum_value(LOCK_EX));
mrb_define_const(mrb, cnst, "LOCK_UN", mrb_fixnum_value(LOCK_UN));
mrb_define_const(mrb, cnst, "LOCK_NB", mrb_fixnum_value(LOCK_NB));
mrb_define_const(mrb, cnst, "SEPARATOR", mrb_str_new_cstr(mrb, FILE_SEPARATOR));
}
void mrb_mruby_polarssl_gem_init(mrb_state *mrb) {
struct RClass *p, *e, *c, *s, *pkey, *ecdsa, *cipher, *des, *des3;
p = mrb_define_module(mrb, "PolarSSL");
pkey = mrb_define_module_under(mrb, p, "PKey");
e = mrb_define_class_under(mrb, p, "Entropy", mrb->object_class);
MRB_SET_INSTANCE_TT(e, MRB_TT_DATA);
mrb_define_method(mrb, e, "initialize", mrb_entropy_initialize, MRB_ARGS_NONE());
mrb_define_method(mrb, e, "gather", mrb_entropy_gather, MRB_ARGS_NONE());
c = mrb_define_class_under(mrb, p, "CtrDrbg", mrb->object_class);
MRB_SET_INSTANCE_TT(c, MRB_TT_DATA);
mrb_define_method(mrb, c, "initialize", mrb_ctrdrbg_initialize, MRB_ARGS_REQ(1) | MRB_ARGS_OPT(1));
mrb_define_singleton_method(mrb, (struct RObject*)c, "self_test", mrb_ctrdrbg_self_test, MRB_ARGS_NONE());
s = mrb_define_class_under(mrb, p, "SSL", mrb->object_class);
MRB_SET_INSTANCE_TT(s, MRB_TT_DATA);
mrb_define_method(mrb, s, "initialize", mrb_ssl_initialize, MRB_ARGS_NONE());
// 0: Endpoint mode for acting as a client.
mrb_define_const(mrb, s, "SSL_IS_CLIENT", mrb_fixnum_value(SSL_IS_CLIENT));
// 0: Certificate verification mode for doing no verification.
mrb_define_const(mrb, s, "SSL_VERIFY_NONE", mrb_fixnum_value(SSL_VERIFY_NONE));
// 1: Certificate verification mode for optional verification.
mrb_define_const(mrb, s, "SSL_VERIFY_OPTIONAL", mrb_fixnum_value(SSL_VERIFY_OPTIONAL));
// 2: Certificate verification mode for having required verification.
mrb_define_const(mrb, s, "SSL_VERIFY_REQUIRED", mrb_fixnum_value(SSL_VERIFY_REQUIRED));
mrb_define_method(mrb, s, "set_endpoint", mrb_ssl_set_endpoint, MRB_ARGS_REQ(1));
mrb_define_method(mrb, s, "set_authmode", mrb_ssl_set_authmode, MRB_ARGS_REQ(1));
mrb_define_method(mrb, s, "set_rng", mrb_ssl_set_rng, MRB_ARGS_REQ(1));
mrb_define_method(mrb, s, "set_socket", mrb_ssl_set_socket, MRB_ARGS_REQ(1));
mrb_define_method(mrb, s, "handshake", mrb_ssl_handshake, MRB_ARGS_NONE());
mrb_define_method(mrb, s, "write", mrb_ssl_write, MRB_ARGS_REQ(1));
mrb_define_method(mrb, s, "read", mrb_ssl_read, MRB_ARGS_REQ(1));
mrb_define_method(mrb, s, "bytes_available", mrb_ssl_bytes_available, MRB_ARGS_NONE());
mrb_define_method(mrb, s, "fileno", mrb_ssl_fileno, MRB_ARGS_NONE());
mrb_define_method(mrb, s, "close_notify", mrb_ssl_close_notify, MRB_ARGS_NONE());
mrb_define_method(mrb, s, "close", mrb_ssl_close, MRB_ARGS_NONE());
ecdsa = mrb_define_class_under(mrb, pkey, "EC", mrb->object_class);
MRB_SET_INSTANCE_TT(ecdsa, MRB_TT_DATA);
mrb_define_method(mrb, ecdsa, "alloc", mrb_ecdsa_alloc, MRB_ARGS_NONE());
mrb_define_method(mrb, ecdsa, "generate_key", mrb_ecdsa_generate_key, MRB_ARGS_NONE());
mrb_define_method(mrb, ecdsa, "load_pem", mrb_ecdsa_load_pem, MRB_ARGS_REQ(1));
mrb_define_method(mrb, ecdsa, "public_key", mrb_ecdsa_public_key, MRB_ARGS_NONE());
mrb_define_method(mrb, ecdsa, "private_key", mrb_ecdsa_private_key, MRB_ARGS_NONE());
mrb_define_method(mrb, ecdsa, "sign", mrb_ecdsa_sign, MRB_ARGS_REQ(1));
cipher = mrb_define_class_under(mrb, p, "Cipher", mrb->object_class);
des = mrb_define_class_under(mrb, cipher, "DES", cipher);
mrb_define_class_method(mrb, des, "encrypt", mrb_des_encrypt, MRB_ARGS_REQ(4));
mrb_define_class_method(mrb, des, "decrypt", mrb_des_decrypt, MRB_ARGS_REQ(4));
des3 = mrb_define_class_under(mrb, cipher, "DES3", cipher);
mrb_define_class_method(mrb, des3, "encrypt", mrb_des3_encrypt, MRB_ARGS_REQ(4));
mrb_define_class_method(mrb, des3, "decrypt", mrb_des3_decrypt, MRB_ARGS_REQ(4));
}
void EasyRPG::register_text(mrb_state* M) {
static method_info const methods[] = {
{ "draw", &draw, MRB_ARGS_REQ(4) | MRB_ARGS_OPT(2) },
method_info_end };
RClass* const mod = define_module(M, "Text", methods);
mrb_define_const(M, mod, "AlignLeft", mrb_fixnum_value(Text::AlignLeft));
mrb_define_const(M, mod, "AlignCenter", mrb_fixnum_value(Text::AlignCenter));
mrb_define_const(M, mod, "AlignRight", mrb_fixnum_value(Text::AlignRight));
}
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_math_gem_init(mrb_state* mrb)
{
struct RClass *mrb_math;
mrb_math = mrb_define_module(mrb, "Math");
mrb_define_class_under(mrb, mrb_math, "DomainError", mrb->eStandardError_class);
#ifdef M_PI
mrb_define_const(mrb, mrb_math, "PI", mrb_float_value(mrb, M_PI));
#else
mrb_define_const(mrb, mrb_math, "PI", mrb_float_value(mrb, atan(1.0)*4.0));
#endif
#ifdef M_E
mrb_define_const(mrb, mrb_math, "E", mrb_float_value(mrb, M_E));
#else
mrb_define_const(mrb, mrb_math, "E", mrb_float_value(mrb, exp(1.0)));
#endif
mrb_define_module_function(mrb, mrb_math, "sin", math_sin, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "cos", math_cos, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "tan", math_tan, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "asin", math_asin, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "acos", math_acos, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "atan", math_atan, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "atan2", math_atan2, MRB_ARGS_REQ(2));
mrb_define_module_function(mrb, mrb_math, "sinh", math_sinh, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "cosh", math_cosh, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "tanh", math_tanh, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "asinh", math_asinh, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "acosh", math_acosh, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "atanh", math_atanh, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "exp", math_exp, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "log", math_log, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
mrb_define_module_function(mrb, mrb_math, "log2", math_log2, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "log10", math_log10, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "sqrt", math_sqrt, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "cbrt", math_cbrt, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "frexp", math_frexp, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "ldexp", math_ldexp, MRB_ARGS_REQ(2));
mrb_define_module_function(mrb, mrb_math, "hypot", math_hypot, MRB_ARGS_REQ(2));
mrb_define_module_function(mrb, mrb_math, "erf", math_erf, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "erfc", math_erfc, MRB_ARGS_REQ(1));
}
void
mrb_mruby_rs_gyro_gem_init(mrb_state* mrb) {
struct RClass *gyro;
gyro = mrb_define_class(mrb, "Gyro", mrb->object_class);
mrb_define_const(mrb, gyro, "X", mrb_fixnum_value(0));
mrb_define_const(mrb, gyro, "Y", mrb_fixnum_value(1));
mrb_define_const(mrb, gyro, "Z", mrb_fixnum_value(2));
// methods
mrb_define_method(mrb, gyro, "initialize", mrb_rs_gyro_initialize, MRB_ARGS_REQ(1));
mrb_define_method(mrb, gyro, "read", mrb_rs_gyro_read, MRB_ARGS_REQ(1));
}
void
mrb_mruby_opencv_core_init(mrb_state* mrb, struct RClass *cv_class) {
//---------
//cv::Mat
//---------
struct RClass *mat_class = mrb_define_class_under(mrb, cv_class, "Mat", mrb->object_class);
MRB_SET_INSTANCE_TT(mat_class, MRB_TT_DATA);
mrb_define_method(mrb, mat_class, "initialize", mrb_mruby_opencv_initialize, MRB_ARGS_OPT(3));
//method
mrb_define_method(mrb, mat_class, "copyTo", mrb_mruby_opencv_copyTo, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
//array access
mrb_define_method(mrb, mat_class, "[]", mrb_mruby_opencv_aget, MRB_ARGS_ANY());
mrb_define_method(mrb, mat_class, "[]=", mrb_mruby_opencv_aset, MRB_ARGS_ANY());
//properties
mrb_define_method(mrb, mat_class, "rows", mrb_mruby_opencv_rows, MRB_ARGS_NONE());
mrb_define_method(mrb, mat_class, "cols", mrb_mruby_opencv_cols, MRB_ARGS_NONE());
mrb_define_method(mrb, mat_class, "type", mrb_mruby_opencv_type, MRB_ARGS_NONE());
//constants
mrb_define_const(mrb, cv_class, "CV_8UC1", mrb_fixnum_value(CV_8UC1));
mrb_define_const(mrb, cv_class, "CV_8UC2", mrb_fixnum_value(CV_8UC2));
mrb_define_const(mrb, cv_class, "CV_8UC3", mrb_fixnum_value(CV_8UC3));
mrb_define_const(mrb, cv_class, "CV_8UC4", mrb_fixnum_value(CV_8UC4));
mrb_define_const(mrb, cv_class, "CV_32FC1", mrb_fixnum_value(CV_32FC1));
mrb_define_const(mrb, cv_class, "CV_32FC2", mrb_fixnum_value(CV_32FC2));
mrb_define_const(mrb, cv_class, "CV_32FC3", mrb_fixnum_value(CV_32FC3));
mrb_define_const(mrb, cv_class, "CV_32FC4", mrb_fixnum_value(CV_32FC4));
}
void
mrb_mruby_pcre_regexp_gem_init(mrb_state* mrb) {
struct RClass *clazz;
clazz = mrb_define_class(mrb, "PcreRegexp", mrb->object_class);
mrb_define_const(mrb, clazz, "IGNORECASE", mrb_fixnum_value(1));
mrb_define_const(mrb, clazz, "EXTENDED", mrb_fixnum_value(2));
mrb_define_const(mrb, clazz, "MULTILINE", mrb_fixnum_value(4));
mrb_define_method(mrb, clazz, "initialize", pcre_regexp_initialize, MRB_ARGS_REQ(1) | MRB_ARGS_OPT(2));
mrb_define_method(mrb, clazz, "initialize_copy", pcre_regexp_initialize_copy, MRB_ARGS_REQ(1));
mrb_define_method(mrb, clazz, "==", pcre_regexp_equal, MRB_ARGS_REQ(1));
mrb_define_method(mrb, clazz, "match", pcre_regexp_match, MRB_ARGS_REQ(1));
mrb_define_method(mrb, clazz, "casefold?", pcre_regexp_casefold_p, MRB_ARGS_NONE());
}
void
mruby_sdl2_joystick_init(mrb_state *mrb)
{
int arena_size;
struct RClass *mod_Joystick = mrb_define_module_under(mrb, mod_SDL2, "Joysticks");
class_Joystick = mrb_define_class_under(mrb, mod_Joystick, "Joystick", mrb->object_class);
MRB_SET_INSTANCE_TT(class_Joystick, MRB_TT_DATA);
mrb_define_module_function(mrb, mod_Joystick, "num", mrb_sdl2_joystick_num, MRB_ARGS_NONE());
mrb_define_module_function(mrb, mod_Joystick, "name_from_index", mrb_sdl2_joystick_get_name, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, mod_Joystick, "get_guid_from_index", mrb_sdl2_joystick_get_guid, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, mod_Joystick, "get_guid_as_string", mrb_sdl2_joystick_get_guid_as_string, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, mod_Joystick, "get_guid_from_string", mrb_sdl2_joystick_get_guid_from_string, MRB_ARGS_REQ(1));
mrb_define_method(mrb, class_Joystick, "initialize", mrb_sdl2_joystick_joystick_initialize, MRB_ARGS_REQ(1));
mrb_define_method(mrb, class_Joystick, "destroy", mrb_sdl2_joystick_joystick_free, MRB_ARGS_NONE());
mrb_define_method(mrb, class_Joystick, "free", mrb_sdl2_joystick_joystick_free, MRB_ARGS_NONE());
mrb_define_method(mrb, class_Joystick, "get_name", mrb_sdl2_joystick_joystick_get_name, MRB_ARGS_NONE());
mrb_define_method(mrb, class_Joystick, "get_guid", mrb_sdl2_joystick_joystick_get_guid, MRB_ARGS_NONE());
mrb_define_method(mrb, class_Joystick, "get_guid_as_string", mrb_sdl2_joystick_joystick_get_guid_as_string, MRB_ARGS_NONE());
mrb_define_method(mrb, class_Joystick, "is_attached?", mrb_sdl2_joystick_joystick_is_attached, MRB_ARGS_NONE());
mrb_define_method(mrb, class_Joystick, "get_id", mrb_sdl2_joystick_joystick_get_id, MRB_ARGS_NONE());
mrb_define_method(mrb, class_Joystick, "get_general_num_axes", mrb_sdl2_joystick_joystick_get_num_axes, MRB_ARGS_NONE());
mrb_define_method(mrb, class_Joystick, "get_general_num_balls", mrb_sdl2_joystick_joystick_get_num_balls, MRB_ARGS_NONE());
mrb_define_method(mrb, class_Joystick, "get_general_num_hats", mrb_sdl2_joystick_joystick_get_num_hats, MRB_ARGS_NONE());
mrb_define_method(mrb, class_Joystick, "get_general_num_buttons", mrb_sdl2_joystick_joystick_get_num_buttons, MRB_ARGS_NONE());
mrb_define_method(mrb, class_Joystick, "update", mrb_sdl2_joystick_joystick_update, MRB_ARGS_NONE());
mrb_define_method(mrb, class_Joystick, "event_state", mrb_sdl2_joystick_joystick_event_state, MRB_ARGS_REQ(1));
mrb_define_method(mrb, class_Joystick, "get_axis", mrb_sdl2_joystick_joystick_get_axis, MRB_ARGS_REQ(1));
mrb_define_method(mrb, class_Joystick, "get_axis_x", mrb_sdl2_joystick_joystick_get_axis_x, MRB_ARGS_NONE());
mrb_define_method(mrb, class_Joystick, "get_axis_y", mrb_sdl2_joystick_joystick_get_axis_y, MRB_ARGS_NONE());
mrb_define_method(mrb, class_Joystick, "get_hat", mrb_sdl2_joystick_joystick_get_hat, MRB_ARGS_REQ(1));
mrb_define_method(mrb, class_Joystick, "get_ball", mrb_sdl2_joystick_joystick_get_ball, MRB_ARGS_REQ(1));
mrb_define_method(mrb, class_Joystick, "get_button", mrb_sdl2_joystick_joystick_get_button, MRB_ARGS_REQ(1));
arena_size = mrb_gc_arena_save(mrb);
mrb_define_const(mrb, mod_Joystick, "SDL_HAT_CENTERED", mrb_fixnum_value(SDL_HAT_CENTERED));
mrb_define_const(mrb, mod_Joystick, "SDL_HAT_UP", mrb_fixnum_value(SDL_HAT_UP));
mrb_define_const(mrb, mod_Joystick, "SDL_HAT_RIGHT", mrb_fixnum_value(SDL_HAT_RIGHT));
mrb_define_const(mrb, mod_Joystick, "SDL_HAT_DOWN", mrb_fixnum_value(SDL_HAT_DOWN));
mrb_define_const(mrb, mod_Joystick, "SDL_HAT_LEFT", mrb_fixnum_value(SDL_HAT_LEFT));
mrb_define_const(mrb, mod_Joystick, "SDL_HAT_RIGHTUP", mrb_fixnum_value(SDL_HAT_RIGHTUP));
mrb_define_const(mrb, mod_Joystick, "SDL_HAT_RIGHTDOWN", mrb_fixnum_value(SDL_HAT_RIGHTDOWN));
mrb_define_const(mrb, mod_Joystick, "SDL_HAT_LEFTUP", mrb_fixnum_value(SDL_HAT_LEFTUP));
mrb_define_const(mrb, mod_Joystick, "SDL_HAT_LEFTDOWN", mrb_fixnum_value(SDL_HAT_LEFTDOWN));
mrb_gc_arena_restore(mrb, arena_size);
}
void mrb_olinuxino_gem_init(mrb_state* mrb)
{
mrb_define_method(mrb,mrb->object_class,"msleep",mrb_msleep,MRB_ARGS_REQ(1));
mrb_define_method(mrb,mrb->object_class,"loggo",mrb_loggo,MRB_ARGS_REQ(1));
mrb_define_method(mrb,mrb->object_class,"readline",mrb_readline,MRB_ARGS_NONE());
struct RClass *c=mrb_define_class(mrb,"Mainloop",mrb->object_class);
MRB_SET_INSTANCE_TT(c,MRB_TT_DATA);
mrb_define_method(mrb,c,"initialize",mrb_mainloop_initialize,MRB_ARGS_REQ(1));
mrb_define_method(mrb,c,"add_unit",mrb_mainloop_add_unit,MRB_ARGS_REQ(3));
c=mrb_define_class(mrb,"Spi",mrb->object_class);
MRB_SET_INSTANCE_TT(c,MRB_TT_DATA);
mrb_define_method(mrb,c,"initialize",mrb_spi_initialize,MRB_ARGS_REQ(2));
c=mrb_define_class(mrb,"Mrf89",mrb->object_class);
MRB_SET_INSTANCE_TT(c,MRB_TT_DATA);
mrb_define_const(mrb,c,"N_CHANNELS",mrb_fixnum_value(CHANNEL_NUM));
mrb_define_method(mrb,c,"initialize",mrb_mrf89_initialize,MRB_ARGS_REQ(1));
mrb_define_method(mrb,c,"set_para",mrb_mrf89_set_para,MRB_ARGS_REQ(2));
mrb_define_method(mrb,c,"set_channel",mrb_mrf89_set_channel,MRB_ARGS_REQ(1));
mrb_define_method(mrb,c,"transmit",mrb_mrf89_transmit,MRB_ARGS_REQ(1));
mrb_define_method(mrb,c,"receive",mrb_mrf89_receive,MRB_ARGS_NONE());
mrb_define_method(mrb,c,"read",mrb_mrf89_read,MRB_ARGS_REQ(2));
mrb_define_method(mrb,c,"req_para",mrb_mrf89_req_para,MRB_ARGS_REQ(1));
mrb_define_method(mrb,c,"get_irqs",mrb_mrf89_get_irqs,MRB_ARGS_NONE());
c=mrb_define_class(mrb,"Led",mrb->object_class);
MRB_SET_INSTANCE_TT(c,MRB_TT_DATA);
mrb_define_method(mrb,c,"initialize",mrb_led_initialize,MRB_ARGS_REQ(1));
mrb_define_method(mrb,c,"on",mrb_led_on,MRB_ARGS_NONE());
mrb_define_method(mrb,c,"off",mrb_led_off,MRB_ARGS_NONE());
c=mrb_define_class(mrb,"Fb",mrb->object_class);
MRB_SET_INSTANCE_TT(c,MRB_TT_DATA);
mrb_define_method(mrb,c,"initialize",mrb_fb_initialize,MRB_ARGS_REQ(2));
mrb_define_method(mrb,c,"size",mrb_fb_size,MRB_ARGS_NONE());
mrb_define_method(mrb,c,"status",mrb_fb_status,MRB_ARGS_REQ(1));
mrb_define_method(mrb,c,"fill",mrb_fb_fill,MRB_ARGS_REQ(1));
mrb_define_method(mrb,c,"line",mrb_fb_line,MRB_ARGS_REQ(5));
mrb_define_method(mrb,c,"rect",mrb_fb_rect,MRB_ARGS_REQ(5));
mrb_define_method(mrb,c,"save_calibdata",mrb_fb_save_calibdata,MRB_ARGS_REQ(4));
mrb_define_method(mrb,c,"calibdata",mrb_fb_calibdata,MRB_ARGS_NONE());
c=mrb_define_class(mrb,"Osock",mrb->object_class);
MRB_SET_INSTANCE_TT(c,MRB_TT_DATA);
mrb_define_method(mrb,c,"initialize",mrb_osock_initialize,MRB_ARGS_REQ(1));
mrb_define_method(mrb,c,"unit",mrb_osock_unit,MRB_ARGS_NONE());
}
/* ------------------------------------------------------------------------*/
void
mrb_init_math(mrb_state *mrb)
{
struct RClass *mrb_math;
mrb_math = mrb_define_module(mrb, "Math");
#ifdef M_PI
mrb_define_const(mrb, mrb_math, "PI", mrb_float_value(M_PI));
#else
mrb_define_const(mrb, mrb_math, "PI", mrb_float_value(atan(1.0)*4.0));
#endif
#ifdef M_E
mrb_define_const(mrb, mrb_math, "E", mrb_float_value(M_E));
#else
mrb_define_const(mrb, mrb_math, "E", mrb_float_value(exp(1.0)));
#endif
mrb_define_class_method(mrb, mrb_math, "sin", math_sin, 1);
mrb_define_class_method(mrb, mrb_math, "cos", math_cos, 1);
mrb_define_class_method(mrb, mrb_math, "tan", math_tan, 1);
mrb_define_class_method(mrb, mrb_math, "asin", math_asin, 1);
mrb_define_class_method(mrb, mrb_math, "acos", math_acos, 1);
mrb_define_class_method(mrb, mrb_math, "atan", math_atan, 1);
mrb_define_class_method(mrb, mrb_math, "atan2", math_atan2, 2);
mrb_define_class_method(mrb, mrb_math, "sinh", math_sinh, 1);
mrb_define_class_method(mrb, mrb_math, "cosh", math_cosh, 1);
mrb_define_class_method(mrb, mrb_math, "tanh", math_tanh, 1);
mrb_define_class_method(mrb, mrb_math, "exp", math_exp, 1);
mrb_define_class_method(mrb, mrb_math, "log", math_log, -1);
mrb_define_class_method(mrb, mrb_math, "log2", math_log2, 1);
mrb_define_class_method(mrb, mrb_math, "log10", math_log10, 1);
mrb_define_class_method(mrb, mrb_math, "frexp", math_frexp, 1);
mrb_define_class_method(mrb, mrb_math, "ldexp", math_ldexp, 2);
mrb_define_class_method(mrb, mrb_math, "hypot", math_hypot, 2);
}
void
mrb_mruby_errno_gem_init(mrb_state *mrb)
{
struct RClass *e, *eno, *sce, *ste;
mrb_value h, noerror;
ste = mrb_class_get(mrb, "StandardError");
sce = mrb_define_class(mrb, "SystemCallError", ste);
mrb_define_class_method(mrb, sce, "_sys_fail", mrb_sce_sys_fail, MRB_ARGS_REQ(1));
mrb_define_method(mrb, sce, "errno", mrb_sce_errno, MRB_ARGS_NONE());
mrb_define_method(mrb, sce, "to_s", mrb_sce_to_s, MRB_ARGS_NONE());
mrb_define_method(mrb, sce, "initialize", mrb_sce_init, MRB_ARGS_ARG(1, 1));
eno = mrb_define_module(mrb, "Errno");
h = mrb_hash_new(mrb);
mrb_define_const(mrb, eno, "Errno2class", h);
e = mrb_define_class_under(mrb, eno, "NOERROR", sce);
mrb_define_const(mrb, e, "Errno", mrb_fixnum_value(0));
mrb_define_method(mrb, e, "initialize", mrb_exxx_init, MRB_ARGS_OPT(1));
//mrb_define_method(mrb, e, "===", mrb_exxx_cmp, MRB_ARGS_REQ(1));
noerror = mrb_obj_value(e);
#define itsdefined(SYM) \
do { \
int ai = mrb_gc_arena_save(mrb); \
e = mrb_define_class_under(mrb, eno, #SYM, sce); \
mrb_define_const(mrb, e, "Errno", mrb_fixnum_value(SYM)); \
mrb_define_method(mrb, e, "initialize", mrb_exxx_init, MRB_ARGS_OPT(1)); \
mrb_hash_set(mrb, h, mrb_fixnum_value(SYM), mrb_obj_value(e)); \
mrb_gc_arena_restore(mrb, ai); \
} while (0)
#define itsnotdefined(SYM) \
do { \
mrb_define_const(mrb, eno, #SYM, noerror); \
} while (0)
#include "known_errors_def.cstub"
}
void
mrb_mruby_hs_regexp_gem_init(mrb_state* mrb)
{
struct RClass *r;
r = mrb_define_class(mrb, "HsRegexp", mrb->object_class);
MRB_SET_INSTANCE_TT(r, MRB_TT_DATA);
mrb_define_const(mrb, r, "IGNORECASE", mrb_fixnum_value(REGEXP_FLAG_IGNORECASE));
mrb_define_const(mrb, r, "MULTILINE", mrb_fixnum_value(REGEXP_FLAG_MULTILINE));
mrb_define_method(mrb, r, "initialize", hs_regexp_initialize, MRB_ARGS_ANY());
mrb_define_method(mrb, r, "initialize_copy", hs_regexp_initialize_copy, MRB_ARGS_REQ(1));
mrb_define_method(mrb, r, "match", hs_regexp_match, MRB_ARGS_REQ(1));
mrb_define_method(mrb, r, "==", hs_regexp_equal, MRB_ARGS_REQ(1));
mrb_define_method(mrb, r, "casefold?", hs_regexp_casefold_p, MRB_ARGS_NONE());
#ifdef HS_REGEXP_ENABLE_BUILT_IN_REGEXP
mrb_define_global_const(mrb, "Regexp", mrb_obj_value(r));
#endif
}
void
mrb_mruby_curl_gem_init(mrb_state* mrb)
{
struct RClass* _class_curl;
int ai = mrb_gc_arena_save(mrb); \
_class_curl = mrb_define_module(mrb, "Curl");
mrb_define_class_method(mrb, _class_curl, "get", mrb_curl_get, ARGS_REQ(1) | ARGS_OPT(1));
mrb_define_class_method(mrb, _class_curl, "post", mrb_curl_post, ARGS_REQ(2) | ARGS_OPT(1));
mrb_define_class_method(mrb, _class_curl, "send", mrb_curl_send, ARGS_REQ(2));
mrb_define_const(mrb, _class_curl, "SSL_VERIFYPEER", mrb_fixnum_value(1));
mrb_gc_arena_restore(mrb, ai);
}
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_init_math(mrb_state *mrb)
{
struct RClass *mrb_math;
mrb_math = mrb_define_module(mrb, "Math");
#ifdef M_PI
mrb_define_const(mrb, mrb_math, "PI", mrb_float_value(M_PI));
#else
mrb_define_const(mrb, mrb_math, "PI", mrb_float_value(atan(1.0)*4.0));
#endif
#ifdef M_E
mrb_define_const(mrb, mrb_math, "E", mrb_float_value(M_E));
#else
mrb_define_const(mrb, mrb_math, "E", mrb_float_value(exp(1.0)));
#endif
#ifdef MRB_USE_FLOAT
mrb_define_const(mrb, mrb_math, "TOLERANCE", mrb_float_value(1e-5));
#else
mrb_define_const(mrb, mrb_math, "TOLERANCE", mrb_float_value(1e-12));
#endif
mrb_define_module_function(mrb, mrb_math, "sin", math_sin, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "cos", math_cos, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "tan", math_tan, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "asin", math_asin, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "acos", math_acos, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "atan", math_atan, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "atan2", math_atan2, ARGS_REQ(2));
mrb_define_module_function(mrb, mrb_math, "sinh", math_sinh, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "cosh", math_cosh, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "tanh", math_tanh, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "asinh", math_asinh, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "acosh", math_acosh, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "atanh", math_atanh, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "exp", math_exp, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "log", math_log, ARGS_REQ(1)|ARGS_OPT(1));
mrb_define_module_function(mrb, mrb_math, "log2", math_log2, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "log10", math_log10, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "sqrt", math_sqrt, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "cbrt", math_cbrt, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "frexp", math_frexp, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "ldexp", math_ldexp, ARGS_REQ(2));
mrb_define_module_function(mrb, mrb_math, "hypot", math_hypot, ARGS_REQ(2));
mrb_define_module_function(mrb, mrb_math, "erf", math_erf, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "erfc", math_erfc, ARGS_REQ(1));
}
void
mrb_init_file(mrb_state *mrb)
{
struct RClass *io, *file, *cnst;
io = mrb_class_get(mrb, "IO");
file = mrb_define_class(mrb, "File", io);
MRB_SET_INSTANCE_TT(file, MRB_TT_DATA);
mrb_define_class_method(mrb, file, "umask", mrb_file_s_umask, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, file, "delete", mrb_file_s_unlink, MRB_ARGS_ANY());
mrb_define_class_method(mrb, file, "unlink", mrb_file_s_unlink, MRB_ARGS_ANY());
mrb_define_class_method(mrb, file, "rename", mrb_file_s_rename, MRB_ARGS_REQ(2));
mrb_define_class_method(mrb, file, "symlink", mrb_file_s_symlink, MRB_ARGS_REQ(2));
mrb_define_class_method(mrb, file, "chmod", mrb_file_s_chmod, MRB_ARGS_REQ(1) | MRB_ARGS_REST());
mrb_define_class_method(mrb, file, "readlink", mrb_file_s_readlink, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, file, "dirname", mrb_file_dirname, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, file, "basename", mrb_file_basename, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, file, "realpath", mrb_file_realpath, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
mrb_define_class_method(mrb, file, "_getwd", mrb_file__getwd, MRB_ARGS_NONE());
mrb_define_class_method(mrb, file, "_gethome", mrb_file__gethome, MRB_ARGS_OPT(1));
mrb_define_method(mrb, file, "flock", mrb_file_flock, MRB_ARGS_REQ(1));
mrb_define_method(mrb, file, "mtime", mrb_file_mtime, MRB_ARGS_NONE());
cnst = mrb_define_module_under(mrb, file, "Constants");
mrb_define_const(mrb, cnst, "LOCK_SH", mrb_fixnum_value(LOCK_SH));
mrb_define_const(mrb, cnst, "LOCK_EX", mrb_fixnum_value(LOCK_EX));
mrb_define_const(mrb, cnst, "LOCK_UN", mrb_fixnum_value(LOCK_UN));
mrb_define_const(mrb, cnst, "LOCK_NB", mrb_fixnum_value(LOCK_NB));
mrb_define_const(mrb, cnst, "SEPARATOR", mrb_str_new_cstr(mrb, FILE_SEPARATOR));
mrb_define_const(mrb, cnst, "PATH_SEPARATOR", mrb_str_new_cstr(mrb, PATH_SEPARATOR));
#if defined(_WIN32) || defined(_WIN64)
mrb_define_const(mrb, cnst, "ALT_SEPARATOR", mrb_str_new_cstr(mrb, FILE_ALT_SEPARATOR));
#else
mrb_define_const(mrb, cnst, "ALT_SEPARATOR", mrb_nil_value());
#endif
mrb_define_const(mrb, cnst, "NULL", mrb_str_new_cstr(mrb, NULL_FILE));
}
void
mrb_mruby_yaml_gem_init(mrb_state *mrb)
{
struct RClass *klass = mrb_define_module(mrb, "YAML");
mrb_define_class_method(mrb, klass, "load", mrb_yaml_load, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, klass, "dump", mrb_yaml_dump, MRB_ARGS_REQ(1));
mrb_define_const(mrb, klass, "SUPPORT_NULL", mrb_bool_value(MRUBY_YAML_NULL));
mrb_define_const(mrb, klass, "SUPPORT_BOOLEAN_ON", mrb_bool_value(MRUBY_YAML_BOOLEAN_ON));
mrb_define_const(mrb, klass, "SUPPORT_BOOLEAN_YES", mrb_bool_value(MRUBY_YAML_BOOLEAN_YES));
mrb_define_const(mrb, klass, "SUPPORT_BOOLEAN_SHORTHAND_YES", mrb_bool_value(MRUBY_YAML_BOOLEAN_SHORTHAND_YES));
mrb_define_const(mrb, klass, "SUPPORT_BOOLEAN_OFF", mrb_bool_value(MRUBY_YAML_BOOLEAN_OFF));
mrb_define_const(mrb, klass, "SUPPORT_BOOLEAN_NO", mrb_bool_value(MRUBY_YAML_BOOLEAN_NO));
mrb_define_const(mrb, klass, "SUPPORT_BOOLEAN_SHORTHAND_NO", mrb_bool_value(MRUBY_YAML_BOOLEAN_SHORTHAND_NO));
}
void mrb_mruby_curses_gem_init(mrb_state *mrb)
{
struct RClass *curses;
curses = mrb_define_class(mrb, "Curses", mrb->object_class);
MRB_SET_INSTANCE_TT(curses, MRB_TT_DATA);
mrb_define_method(mrb, curses, "initialize", mrb_curses_init, MRB_ARGS_NONE());
mrb_define_class_method(mrb, curses, "initscr", mrb_curses_initscr, MRB_ARGS_NONE());
mrb_define_class_method(mrb, curses, "cbreak", mrb_curses_cbreak, MRB_ARGS_NONE());
mrb_define_class_method(mrb, curses, "nocbreak", mrb_curses_cbreak, MRB_ARGS_NONE());
mrb_define_class_method(mrb, curses, "echo", mrb_curses_noecho, MRB_ARGS_NONE());
mrb_define_class_method(mrb, curses, "noecho", mrb_curses_noecho, MRB_ARGS_NONE());
mrb_define_class_method(mrb, curses, "keypad", mrb_curses_keypad, MRB_ARGS_ANY());
mrb_define_class_method(mrb, curses, "clear", mrb_curses_clear, MRB_ARGS_NONE());
mrb_define_class_method(mrb, curses, "addstr", mrb_curses_addstr, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, curses, "move", mrb_curses_move, MRB_ARGS_ANY());
mrb_define_class_method(mrb, curses, "endwin", mrb_curses_endwin, MRB_ARGS_NONE());
mrb_define_class_method(mrb, curses, "start_color", mrb_curses_start_color, MRB_ARGS_NONE());
mrb_define_class_method(mrb, curses, "init_pair", mrb_curses_init_pair, MRB_ARGS_ANY());
mrb_define_class_method(mrb, curses, "coloron", mrb_curses_coloron, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, curses, "coloroff", mrb_curses_coloroff, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, curses, "wbkgd", mrb_curses_wbkgd, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, curses, "echoline", mrb_curses_echoline, MRB_ARGS_ANY());
mrb_define_class_method(mrb, curses, "ewaddstr", mrb_curses_ewaddstr, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, curses, "ewmove", mrb_curses_ewmove, MRB_ARGS_ANY());
mrb_define_class_method(mrb, curses, "refresh", mrb_curses_refresh, MRB_ARGS_NONE());
mrb_define_class_method(mrb, curses, "ewgetstr", mrb_curses_ewgetstr, MRB_ARGS_NONE());
mrb_define_class_method(mrb, curses, "screen_rows", mrb_curses_screen_rows, MRB_ARGS_NONE());
mrb_define_class_method(mrb, curses, "screen_cols", mrb_curses_screen_cols, MRB_ARGS_NONE());
mrb_define_const(mrb, curses, "COLOR_BLACK", mrb_fixnum_value(COLOR_BLACK));
mrb_define_const(mrb, curses, "COLOR_RED", mrb_fixnum_value(COLOR_RED));
mrb_define_const(mrb, curses, "COLOR_GREEN", mrb_fixnum_value(COLOR_GREEN));
mrb_define_const(mrb, curses, "COLOR_YELLOW", mrb_fixnum_value(COLOR_YELLOW));
mrb_define_const(mrb, curses, "COLOR_BLUE", mrb_fixnum_value(COLOR_BLUE));
mrb_define_const(mrb, curses, "COLOR_MAGENTA", mrb_fixnum_value(COLOR_MAGENTA));
mrb_define_const(mrb, curses, "COLOR_CYAN", mrb_fixnum_value(COLOR_CYAN));
mrb_define_const(mrb, curses, "COLOR_WHITE", mrb_fixnum_value(COLOR_WHITE));
DONE;
}
void
mrb_mjruby_gem_init(mrb_state *mrb)
{
struct RClass *java_support;
mrb_define_method(mrb, mrb->kernel_module, "exec_java", mrb_java_support_exec, MRB_ARGS_ANY());
java_support = mrb_define_class(mrb, "JavaSupport", mrb->object_class);
mrb_define_const(mrb, java_support, "JAVA_EXE", mrb_str_new_cstr(mrb, JAVA_EXE));
mrb_define_const(mrb, java_support, "JAVA_SERVER_DL", mrb_str_new_cstr(mrb, JAVA_SERVER_DL));
mrb_define_const(mrb, java_support, "JAVA_CLIENT_DL", mrb_str_new_cstr(mrb, JAVA_CLIENT_DL));
mrb_define_const(mrb, java_support, "JLI_DL", mrb_str_new_cstr(mrb, JLI_DL));
mrb_define_const(mrb, java_support, "SYSTEM_SHELL", mrb_str_new_cstr(mrb, SYSTEM_SHELL));
mrb_define_const(mrb, java_support, "DEFAULT_JAVA_OPTS", mrb_str_new_cstr(mrb, DEFAULT_JAVA_OPTS));
mrb_define_method(mrb, java_support, "find_native_java", mrb_find_native_java, MRB_ARGS_ANY());
}
void mrb_mruby_uv_gem_test(mrb_state* mrb) {
mrb_define_method(mrb, mrb->object_class, "raise_signal", raise_signal, MRB_ARGS_REQ(1));
mrb_define_method(mrb, mrb->kernel_module, "get_work_result", get_work_result, MRB_ARGS_NONE());
mrb_define_const(mrb, mrb->object_class, "WorkCFunc", mrb_obj_value(mrb_proc_new_cfunc(mrb, work_cfunc)));
}
void
mrb_define_global_const(mrb_state *mrb, const char *name, mrb_value val)
{
mrb_define_const(mrb, mrb->object_class, name, val);
}
void
grn_mrb_expr_init(grn_ctx *ctx)
{
mrb_state *mrb = ctx->impl->mrb.state;
struct RClass *module = ctx->impl->mrb.module;
struct RClass *object_class = ctx->impl->mrb.object_class;
struct RClass *klass;
klass = mrb_define_class_under(mrb, module, "ScanInfo", mrb->object_class);
MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA);
mrb_define_method(mrb, klass, "initialize",
mrb_grn_scan_info_initialize, MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "put_index",
mrb_grn_scan_info_put_index, MRB_ARGS_REQ(6));
mrb_define_method(mrb, klass, "op",
mrb_grn_scan_info_get_op, MRB_ARGS_NONE());
mrb_define_method(mrb, klass, "op=",
mrb_grn_scan_info_set_op, MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "end=",
mrb_grn_scan_info_set_end, MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "query=",
mrb_grn_scan_info_set_query, MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "flags",
mrb_grn_scan_info_get_flags, MRB_ARGS_NONE());
mrb_define_method(mrb, klass, "flags=",
mrb_grn_scan_info_set_flags, MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "logical_op",
mrb_grn_scan_info_get_logical_op, MRB_ARGS_NONE());
mrb_define_method(mrb, klass, "logical_op=",
mrb_grn_scan_info_set_logical_op, MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "max_interval",
mrb_grn_scan_info_get_max_interval, MRB_ARGS_NONE());
mrb_define_method(mrb, klass, "max_interval=",
mrb_grn_scan_info_set_max_interval, MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "similarity_threshold",
mrb_grn_scan_info_get_similarity_threshold, MRB_ARGS_NONE());
mrb_define_method(mrb, klass, "similarity_threshold=",
mrb_grn_scan_info_set_similarity_threshold, MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "get_arg",
mrb_grn_scan_info_get_arg, MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "push_arg",
mrb_grn_scan_info_push_arg, MRB_ARGS_REQ(1));
klass = mrb_define_class_under(mrb, module,
"ExpressionCode", mrb->object_class);
MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA);
mrb_define_method(mrb, klass, "initialize",
mrb_grn_expr_code_initialize, MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "inspect",
mrb_grn_expr_code_inspect, MRB_ARGS_NONE());
mrb_define_method(mrb, klass, "weight",
mrb_grn_expr_code_get_weight, MRB_ARGS_NONE());
mrb_define_method(mrb, klass, "value",
mrb_grn_expr_code_get_value, MRB_ARGS_NONE());
mrb_define_method(mrb, klass, "op",
mrb_grn_expr_code_get_op, MRB_ARGS_NONE());
mrb_define_method(mrb, klass, "flags",
mrb_grn_expr_code_get_flags, MRB_ARGS_NONE());
{
struct RClass *expression_code_class = klass;
struct RClass *flags_module;
flags_module = mrb_define_module_under(mrb, expression_code_class, "Flags");
mrb_define_const(mrb, flags_module, "RELATIONAL_EXPRESSION",
mrb_fixnum_value(GRN_EXPR_CODE_RELATIONAL_EXPRESSION));
}
klass = mrb_define_class_under(mrb, module, "Expression", object_class);
MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA);
mrb_define_singleton_method(mrb, (struct RObject *)klass, "create",
mrb_grn_expression_singleton_create,
MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "initialize",
mrb_grn_expression_initialize, MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "codes",
mrb_grn_expression_codes, MRB_ARGS_NONE());
mrb_define_method(mrb, klass, "get_var_by_offset",
mrb_grn_expression_get_var_by_offset, MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "take_object",
mrb_grn_expression_take_object, MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "allocate_constant",
mrb_grn_expression_allocate_constant, MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "parse",
mrb_grn_expression_parse, MRB_ARGS_ARG(1, 1));
mrb_define_method(mrb, klass, "append_object",
mrb_grn_expression_append_object, MRB_ARGS_REQ(2));
mrb_define_method(mrb, klass, "append_constant",
mrb_grn_expression_append_constant, MRB_ARGS_REQ(3));
mrb_define_method(mrb, klass, "append_operator",
mrb_grn_expression_append_operator, MRB_ARGS_REQ(2));
}
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
grn_mrb_id_init(grn_ctx *ctx)
{
mrb_state *mrb = ctx->impl->mrb.state;
struct RClass *module = ctx->impl->mrb.module;
struct RClass *id_module;
id_module = mrb_define_module_under(mrb, module, "ID");
mrb_define_const(mrb, id_module, "VOID",
mrb_fixnum_value(GRN_DB_VOID));
mrb_define_const(mrb, id_module, "DB",
mrb_fixnum_value(GRN_DB_DB));
mrb_define_const(mrb, id_module, "OBJECT",
mrb_fixnum_value(GRN_DB_OBJECT));
mrb_define_const(mrb, id_module, "BOOL",
mrb_fixnum_value(GRN_DB_BOOL));
mrb_define_const(mrb, id_module, "INT8",
mrb_fixnum_value(GRN_DB_INT8));
mrb_define_const(mrb, id_module, "UINT8",
mrb_fixnum_value(GRN_DB_UINT8));
mrb_define_const(mrb, id_module, "INT16",
mrb_fixnum_value(GRN_DB_INT16));
mrb_define_const(mrb, id_module, "UINT16",
mrb_fixnum_value(GRN_DB_UINT16));
mrb_define_const(mrb, id_module, "INT32",
mrb_fixnum_value(GRN_DB_INT32));
mrb_define_const(mrb, id_module, "UINT32",
mrb_fixnum_value(GRN_DB_UINT32));
mrb_define_const(mrb, id_module, "INT64",
mrb_fixnum_value(GRN_DB_INT64));
mrb_define_const(mrb, id_module, "UINT64",
mrb_fixnum_value(GRN_DB_UINT64));
mrb_define_const(mrb, id_module, "FLOAT",
mrb_fixnum_value(GRN_DB_FLOAT));
mrb_define_const(mrb, id_module, "TIME",
mrb_fixnum_value(GRN_DB_TIME));
mrb_define_const(mrb, id_module, "SHORT_TEXT",
mrb_fixnum_value(GRN_DB_SHORT_TEXT));
mrb_define_const(mrb, id_module, "TEXT",
mrb_fixnum_value(GRN_DB_TEXT));
mrb_define_const(mrb, id_module, "LONG_TEXT",
mrb_fixnum_value(GRN_DB_LONG_TEXT));
mrb_define_const(mrb, id_module, "TOKYO_GEO_POINT",
mrb_fixnum_value(GRN_DB_TOKYO_GEO_POINT));
mrb_define_const(mrb, id_module, "WGS84_GEO_POINT",
mrb_fixnum_value(GRN_DB_WGS84_GEO_POINT));
}
void
mruby_sdl2_events_init(mrb_state *mrb)
{
mod_Input = mrb_define_module_under(mrb, mod_SDL2, "Input");
class_Event = mrb_define_class_under(mrb, mod_Input, "Event", mrb->object_class);
class_ControllerAxisEvent = mrb_define_class_under(mrb, mod_Input, "ControllerAxisEvent", class_Event);
class_ControllerButtonEvent = mrb_define_class_under(mrb, mod_Input, "ControllerButtonEvent", class_Event);
class_ControllerDeviceEvent = mrb_define_class_under(mrb, mod_Input, "ControllerDeviceEvent", class_Event);
class_DollarGestureEvent = mrb_define_class_under(mrb, mod_Input, "DollarGestureEvent", class_Event);
class_DropEvent = mrb_define_class_under(mrb, mod_Input, "DropEvent", class_Event);
class_JoyAxisEvent = mrb_define_class_under(mrb, mod_Input, "JoyAxisEvent", class_Event);
class_JoyBallEvent = mrb_define_class_under(mrb, mod_Input, "JoyBallEvent", class_Event);
class_JoyButtonEvent = mrb_define_class_under(mrb, mod_Input, "JoyButtonEvent", class_Event);
class_JoyHatEvent = mrb_define_class_under(mrb, mod_Input, "JoyHatEvent", class_Event);
class_JoyDeviceEvent = mrb_define_class_under(mrb, mod_Input, "JoyDeviceEvent", class_Event);
class_KeyboardEvent = mrb_define_class_under(mrb, mod_Input, "KeyboardEvent", class_Event);
class_MouseButtonEvent = mrb_define_class_under(mrb, mod_Input, "MouseButtonEvent", class_Event);
class_MouseMotionEvent = mrb_define_class_under(mrb, mod_Input, "MouseMotionEvent", class_Event);
class_MouseWheelEvent = mrb_define_class_under(mrb, mod_Input, "MouseWheelEvent", class_Event);
class_MultiGestureEvent = mrb_define_class_under(mrb, mod_Input, "MultiGestureEvent", class_Event);
class_OsEvent = mrb_define_class_under(mrb, mod_Input, "OsEvent", class_Event);
class_QuitEvent = mrb_define_class_under(mrb, mod_Input, "QuitEvent", class_Event);
class_SysWMEvent = mrb_define_class_under(mrb, mod_Input, "SysWMEvent", class_Event);
class_TextEditingEvent = mrb_define_class_under(mrb, mod_Input, "TextEditingEvent", class_Event);
class_TextInputEvent = mrb_define_class_under(mrb, mod_Input, "TextInputEvent", class_Event);
class_TouchFingerEvent = mrb_define_class_under(mrb, mod_Input, "TouchFingerEvent", class_Event);
class_UserEvent = mrb_define_class_under(mrb, mod_Input, "UserEvent", class_Event);
class_WindowEvent = mrb_define_class_under(mrb, mod_Input, "WindowEvent", class_Event);
MRB_SET_INSTANCE_TT(class_Event, MRB_TT_DATA);
MRB_SET_INSTANCE_TT(class_ControllerAxisEvent, MRB_TT_DATA);
MRB_SET_INSTANCE_TT(class_ControllerButtonEvent, MRB_TT_DATA);
MRB_SET_INSTANCE_TT(class_ControllerDeviceEvent, MRB_TT_DATA);
MRB_SET_INSTANCE_TT(class_DollarGestureEvent, MRB_TT_DATA);
MRB_SET_INSTANCE_TT(class_DropEvent, MRB_TT_DATA);
MRB_SET_INSTANCE_TT(class_JoyAxisEvent, MRB_TT_DATA);
MRB_SET_INSTANCE_TT(class_JoyBallEvent, MRB_TT_DATA);
MRB_SET_INSTANCE_TT(class_JoyButtonEvent, MRB_TT_DATA);
MRB_SET_INSTANCE_TT(class_JoyHatEvent, MRB_TT_DATA);
MRB_SET_INSTANCE_TT(class_JoyDeviceEvent, MRB_TT_DATA);
MRB_SET_INSTANCE_TT(class_KeyboardEvent, MRB_TT_DATA);
MRB_SET_INSTANCE_TT(class_MouseButtonEvent, MRB_TT_DATA);
MRB_SET_INSTANCE_TT(class_MouseMotionEvent, MRB_TT_DATA);
MRB_SET_INSTANCE_TT(class_MouseWheelEvent, MRB_TT_DATA);
MRB_SET_INSTANCE_TT(class_MultiGestureEvent, MRB_TT_DATA);
MRB_SET_INSTANCE_TT(class_OsEvent, MRB_TT_DATA);
MRB_SET_INSTANCE_TT(class_QuitEvent, MRB_TT_DATA);
MRB_SET_INSTANCE_TT(class_SysWMEvent, MRB_TT_DATA);
MRB_SET_INSTANCE_TT(class_TextEditingEvent, MRB_TT_DATA);
MRB_SET_INSTANCE_TT(class_TextInputEvent, MRB_TT_DATA);
MRB_SET_INSTANCE_TT(class_TouchFingerEvent, MRB_TT_DATA);
MRB_SET_INSTANCE_TT(class_UserEvent, MRB_TT_DATA);
MRB_SET_INSTANCE_TT(class_WindowEvent, MRB_TT_DATA);
mrb_define_module_function(mrb, mod_Input, "poll", mrb_sdl2_input_poll, MRB_ARGS_NONE());
mrb_define_module_function(mrb, mod_Input, "wait", mrb_sdl2_input_wait, MRB_ARGS_NONE());
mrb_define_module_function(mrb, mod_Input, "wait_timeout", mrb_sdl2_input_wait_timeout, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, mod_Input, "event_state", mrb_sdl2_input_event_state, MRB_ARGS_REQ(2));
mrb_define_module_function(mrb, mod_Input, "flush", mrb_sdl2_input_flush_event, MRB_ARGS_REQ(1) | MRB_ARGS_OPT(1));
mrb_define_module_function(mrb, mod_Input, "has_events?", mrb_sdl2_input_has_events, MRB_ARGS_REQ(1) | MRB_ARGS_OPT(1));
mrb_define_module_function(mrb, mod_Input, "quit_requested?", mrb_sdl2_input_is_quit_requested, MRB_ARGS_NONE());
mrb_define_module_function(mrb, mod_Input, "register", mrb_sdl2_input_register, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, mod_Input, "push", mrb_sdl2_input_push, MRB_ARGS_REQ(1));
mrb_define_method(mrb, class_Event, "type", mrb_sdl2_input_event_get_type, MRB_ARGS_NONE());
mrb_define_method(mrb, class_KeyboardEvent, "timestamp", mrb_sdl2_input_keyboardevent_get_timestamp, MRB_ARGS_NONE());
mrb_define_method(mrb, class_KeyboardEvent, "window_id", mrb_sdl2_input_keyboardevent_get_window_id, MRB_ARGS_NONE());
mrb_define_method(mrb, class_KeyboardEvent, "state", mrb_sdl2_input_keyboardevent_get_state, MRB_ARGS_NONE());
mrb_define_method(mrb, class_KeyboardEvent, "repeat", mrb_sdl2_input_keyboardevent_get_repeat, MRB_ARGS_NONE());
mrb_define_method(mrb, class_KeyboardEvent, "keysym", mrb_sdl2_input_keyboardevent_get_keysym, MRB_ARGS_NONE());
mrb_define_method(mrb, class_MouseButtonEvent, "timestamp", mrb_sdl2_input_mousebuttonevent_get_timestamp, MRB_ARGS_NONE());
mrb_define_method(mrb, class_MouseButtonEvent, "window_id", mrb_sdl2_input_mousebuttonevent_get_window_id, MRB_ARGS_NONE());
mrb_define_method(mrb, class_MouseButtonEvent, "which", mrb_sdl2_input_mousebuttonevent_get_which, MRB_ARGS_NONE());
mrb_define_method(mrb, class_MouseButtonEvent, "button", mrb_sdl2_input_mousebuttonevent_get_button, MRB_ARGS_NONE());
mrb_define_method(mrb, class_MouseButtonEvent, "state", mrb_sdl2_input_mousebuttonevent_get_state, MRB_ARGS_NONE());
mrb_define_method(mrb, class_MouseButtonEvent, "x", mrb_sdl2_input_mousebuttonevent_get_x, MRB_ARGS_NONE());
mrb_define_method(mrb, class_MouseButtonEvent, "y", mrb_sdl2_input_mousebuttonevent_get_y, MRB_ARGS_NONE());
mrb_define_method(mrb, class_MouseMotionEvent, "timestamp", mrb_sdl2_input_mousemotionevent_get_timestamp, MRB_ARGS_NONE());
mrb_define_method(mrb, class_MouseMotionEvent, "window_id", mrb_sdl2_input_mousemotionevent_get_window_id, MRB_ARGS_NONE());
mrb_define_method(mrb, class_MouseMotionEvent, "which", mrb_sdl2_input_mousemotionevent_get_which, MRB_ARGS_NONE());
mrb_define_method(mrb, class_MouseMotionEvent, "state", mrb_sdl2_input_mousemotionevent_get_state, MRB_ARGS_NONE());
mrb_define_method(mrb, class_MouseMotionEvent, "x", mrb_sdl2_input_mousemotionevent_get_x, MRB_ARGS_NONE());
mrb_define_method(mrb, class_MouseMotionEvent, "y", mrb_sdl2_input_mousemotionevent_get_y, MRB_ARGS_NONE());
mrb_define_method(mrb, class_MouseMotionEvent, "xrel", mrb_sdl2_input_mousemotionevent_get_xrel, MRB_ARGS_NONE());
mrb_define_method(mrb, class_MouseMotionEvent, "yrel", mrb_sdl2_input_mousemotionevent_get_yrel, MRB_ARGS_NONE());
mrb_define_method(mrb, class_MouseWheelEvent, "timestamp", mrb_sdl2_input_mousewheelevent_get_timestamp, MRB_ARGS_NONE());
mrb_define_method(mrb, class_MouseWheelEvent, "window_id", mrb_sdl2_input_mousewheelevent_get_window_id, MRB_ARGS_NONE());
mrb_define_method(mrb, class_MouseWheelEvent, "which", mrb_sdl2_input_mousewheelevent_get_which, MRB_ARGS_NONE());
mrb_define_method(mrb, class_MouseWheelEvent, "x", mrb_sdl2_input_mousewheelevent_get_x, MRB_ARGS_NONE());
mrb_define_method(mrb, class_MouseWheelEvent, "y", mrb_sdl2_input_mousewheelevent_get_y, MRB_ARGS_NONE());
mrb_define_method(mrb, class_QuitEvent, "timestamp", mrb_sdl2_input_quitevent_timestamp, MRB_ARGS_NONE());
mrb_define_method(mrb, class_UserEvent, "initialize", mrb_sdl2_input_userevent_initialize, MRB_ARGS_REQ(2) | MRB_ARGS_OPT(2));
mrb_define_method(mrb, class_UserEvent, "type=", mrb_sdl2_input_userevent_set_type, MRB_ARGS_REQ(1));
mrb_define_method(mrb, class_UserEvent, "timestamp", mrb_sdl2_input_userevent_get_timestamp, MRB_ARGS_NONE());
mrb_define_method(mrb, class_UserEvent, "timestamp=", mrb_sdl2_input_userevent_set_timestamp, MRB_ARGS_REQ(1));
mrb_define_method(mrb, class_UserEvent, "window_id", mrb_sdl2_input_userevent_get_window_id, MRB_ARGS_NONE());
mrb_define_method(mrb, class_UserEvent, "window_id=", mrb_sdl2_input_userevent_set_window_id, MRB_ARGS_REQ(1));
mrb_define_method(mrb, class_UserEvent, "code", mrb_sdl2_input_userevent_get_code, MRB_ARGS_NONE());
mrb_define_method(mrb, class_UserEvent, "code=", mrb_sdl2_input_userevent_set_code, MRB_ARGS_REQ(1));
mrb_define_method(mrb, class_UserEvent, "data1", mrb_sdl2_input_userevent_get_data1, MRB_ARGS_NONE());
mrb_define_method(mrb, class_UserEvent, "data1=", mrb_sdl2_input_userevent_set_data1, MRB_ARGS_REQ(1));
mrb_define_method(mrb, class_UserEvent, "data2", mrb_sdl2_input_userevent_get_data2, MRB_ARGS_NONE());
mrb_define_method(mrb, class_UserEvent, "data2=", mrb_sdl2_input_userevent_set_data2, MRB_ARGS_REQ(1));
mrb_define_method(mrb, class_WindowEvent, "timestamp", mrb_sdl2_input_windowevent_get_timestamp, MRB_ARGS_NONE());
mrb_define_method(mrb, class_WindowEvent, "window_id", mrb_sdl2_input_windowevent_get_window_id, MRB_ARGS_NONE());
mrb_define_method(mrb, class_WindowEvent, "event", mrb_sdl2_input_windowevent_get_event, MRB_ARGS_NONE());
mrb_define_method(mrb, class_WindowEvent, "data1", mrb_sdl2_input_windowevent_get_data1, MRB_ARGS_NONE());
mrb_define_method(mrb, class_WindowEvent, "data2", mrb_sdl2_input_windowevent_get_data2, MRB_ARGS_NONE());
int arena_size = mrb_gc_arena_save(mrb);
/* SDL_EventType */
mrb_define_const(mrb, mod_Input, "SDL_FIRSTEVENT", mrb_fixnum_value(SDL_FIRSTEVENT));
mrb_define_const(mrb, mod_Input, "SDL_QUIT", mrb_fixnum_value(SDL_QUIT));
mrb_define_const(mrb, mod_Input, "SDL_APP_TERMINATING", mrb_fixnum_value(SDL_APP_TERMINATING));
mrb_define_const(mrb, mod_Input, "SDL_APP_LOWMEMORY", mrb_fixnum_value(SDL_APP_LOWMEMORY));
mrb_define_const(mrb, mod_Input, "SDL_APP_WILLENTERBACKGROUND", mrb_fixnum_value(SDL_APP_WILLENTERBACKGROUND));
mrb_define_const(mrb, mod_Input, "SDL_APP_DIDENTERBACKGROUND", mrb_fixnum_value(SDL_APP_DIDENTERBACKGROUND));
mrb_define_const(mrb, mod_Input, "SDL_APP_WILLENTERFOREGROUND", mrb_fixnum_value(SDL_APP_WILLENTERFOREGROUND));
mrb_define_const(mrb, mod_Input, "SDL_APP_DIDENTERFOREGROUND", mrb_fixnum_value(SDL_APP_DIDENTERFOREGROUND));
mrb_define_const(mrb, mod_Input, "SDL_WINDOWEVENT", mrb_fixnum_value(SDL_WINDOWEVENT));
mrb_define_const(mrb, mod_Input, "SDL_SYSWMEVENT", mrb_fixnum_value(SDL_SYSWMEVENT));
mrb_define_const(mrb, mod_Input, "SDL_KEYDOWN", mrb_fixnum_value(SDL_KEYDOWN));
mrb_define_const(mrb, mod_Input, "SDL_KEYUP", mrb_fixnum_value(SDL_KEYUP));
mrb_define_const(mrb, mod_Input, "SDL_TEXTEDITING", mrb_fixnum_value(SDL_TEXTEDITING));
mrb_define_const(mrb, mod_Input, "SDL_TEXTINPUT", mrb_fixnum_value(SDL_TEXTINPUT));
mrb_define_const(mrb, mod_Input, "SDL_MOUSEMOTION", mrb_fixnum_value(SDL_MOUSEMOTION));
mrb_define_const(mrb, mod_Input, "SDL_MOUSEBUTTONDOWN", mrb_fixnum_value(SDL_MOUSEBUTTONDOWN));
mrb_define_const(mrb, mod_Input, "SDL_MOUSEBUTTONUP", mrb_fixnum_value(SDL_MOUSEBUTTONUP));
mrb_define_const(mrb, mod_Input, "SDL_MOUSEWHEEL", mrb_fixnum_value(SDL_MOUSEWHEEL));
mrb_define_const(mrb, mod_Input, "SDL_JOYAXISMOTION", mrb_fixnum_value(SDL_JOYAXISMOTION));
mrb_define_const(mrb, mod_Input, "SDL_JOYBALLMOTION", mrb_fixnum_value(SDL_JOYBALLMOTION));
mrb_define_const(mrb, mod_Input, "SDL_JOYHATMOTION", mrb_fixnum_value(SDL_JOYHATMOTION));
mrb_define_const(mrb, mod_Input, "SDL_JOYBUTTONDOWN", mrb_fixnum_value(SDL_JOYBUTTONDOWN));
mrb_define_const(mrb, mod_Input, "SDL_JOYBUTTONUP", mrb_fixnum_value(SDL_JOYBUTTONUP));
mrb_define_const(mrb, mod_Input, "SDL_JOYDEVICEADDED", mrb_fixnum_value(SDL_JOYDEVICEADDED));
mrb_define_const(mrb, mod_Input, "SDL_JOYDEVICEREMOVED", mrb_fixnum_value(SDL_JOYDEVICEREMOVED));
mrb_define_const(mrb, mod_Input, "SDL_CONTROLLERAXISMOTION", mrb_fixnum_value(SDL_CONTROLLERAXISMOTION));
mrb_define_const(mrb, mod_Input, "SDL_CONTROLLERBUTTONDOWN", mrb_fixnum_value(SDL_CONTROLLERBUTTONDOWN));
mrb_define_const(mrb, mod_Input, "SDL_CONTROLLERBUTTONUP", mrb_fixnum_value(SDL_CONTROLLERBUTTONUP));
mrb_define_const(mrb, mod_Input, "SDL_CONTROLLERDEVICEADDED", mrb_fixnum_value(SDL_CONTROLLERDEVICEADDED));
mrb_define_const(mrb, mod_Input, "SDL_CONTROLLERDEVICEREMOVED", mrb_fixnum_value(SDL_CONTROLLERDEVICEREMOVED));
mrb_define_const(mrb, mod_Input, "SDL_CONTROLLERDEVICEREMAPPED", mrb_fixnum_value(SDL_CONTROLLERDEVICEREMAPPED));
mrb_define_const(mrb, mod_Input, "SDL_FINGERDOWN", mrb_fixnum_value(SDL_FINGERDOWN));
mrb_define_const(mrb, mod_Input, "SDL_FINGERUP", mrb_fixnum_value(SDL_FINGERUP));
mrb_define_const(mrb, mod_Input, "SDL_FINGERMOTION", mrb_fixnum_value(SDL_FINGERMOTION));
mrb_define_const(mrb, mod_Input, "SDL_DOLLARGESTURE", mrb_fixnum_value(SDL_DOLLARGESTURE));
mrb_define_const(mrb, mod_Input, "SDL_DOLLARRECORD", mrb_fixnum_value(SDL_DOLLARRECORD));
mrb_define_const(mrb, mod_Input, "SDL_MULTIGESTURE", mrb_fixnum_value(SDL_MULTIGESTURE));
mrb_define_const(mrb, mod_Input, "SDL_CLIPBOARDUPDATE", mrb_fixnum_value(SDL_CLIPBOARDUPDATE));
mrb_define_const(mrb, mod_Input, "SDL_DROPFILE", mrb_fixnum_value(SDL_DROPFILE));
mrb_define_const(mrb, mod_Input, "SDL_USEREVENT", mrb_fixnum_value(SDL_USEREVENT));
mrb_define_const(mrb, mod_Input, "SDL_LASTEVENT", mrb_fixnum_value(SDL_LASTEVENT));
mrb_gc_arena_restore(mrb, arena_size);
arena_size = mrb_gc_arena_save(mrb);
/* SDL_WindowEventID */
mrb_define_const(mrb, mod_Input, "SDL_WINDOWEVENT_NONE", mrb_fixnum_value(SDL_WINDOWEVENT_NONE));
mrb_define_const(mrb, mod_Input, "SDL_WINDOWEVENT_SHOWN", mrb_fixnum_value(SDL_WINDOWEVENT_SHOWN));
mrb_define_const(mrb, mod_Input, "SDL_WINDOWEVENT_HIDDEN", mrb_fixnum_value(SDL_WINDOWEVENT_HIDDEN));
mrb_define_const(mrb, mod_Input, "SDL_WINDOWEVENT_EXPOSED", mrb_fixnum_value(SDL_WINDOWEVENT_EXPOSED));
mrb_define_const(mrb, mod_Input, "SDL_WINDOWEVENT_MOVED", mrb_fixnum_value(SDL_WINDOWEVENT_MOVED));
mrb_define_const(mrb, mod_Input, "SDL_WINDOWEVENT_RESIZED", mrb_fixnum_value(SDL_WINDOWEVENT_RESIZED));
mrb_define_const(mrb, mod_Input, "SDL_WINDOWEVENT_SIZE_CHANGED", mrb_fixnum_value(SDL_WINDOWEVENT_SIZE_CHANGED));
mrb_define_const(mrb, mod_Input, "SDL_WINDOWEVENT_MINIMIZED", mrb_fixnum_value(SDL_WINDOWEVENT_MINIMIZED));
mrb_define_const(mrb, mod_Input, "SDL_WINDOWEVENT_MAXIMIZED", mrb_fixnum_value(SDL_WINDOWEVENT_MAXIMIZED));
mrb_define_const(mrb, mod_Input, "SDL_WINDOWEVENT_RESTORED", mrb_fixnum_value(SDL_WINDOWEVENT_RESTORED));
mrb_define_const(mrb, mod_Input, "SDL_WINDOWEVENT_ENTER", mrb_fixnum_value(SDL_WINDOWEVENT_ENTER));
mrb_define_const(mrb, mod_Input, "SDL_WINDOWEVENT_LEAVE", mrb_fixnum_value(SDL_WINDOWEVENT_LEAVE));
mrb_define_const(mrb, mod_Input, "SDL_WINDOWEVENT_FOCUS_GAINED", mrb_fixnum_value(SDL_WINDOWEVENT_FOCUS_GAINED));
mrb_define_const(mrb, mod_Input, "SDL_WINDOWEVENT_FOCUS_LOST", mrb_fixnum_value(SDL_WINDOWEVENT_FOCUS_LOST));
mrb_define_const(mrb, mod_Input, "SDL_WINDOWEVENT_CLOSE", mrb_fixnum_value(SDL_WINDOWEVENT_CLOSE));
/* Event state */
mrb_define_const(mrb, mod_Input, "SDL_QUERY", mrb_fixnum_value(SDL_QUERY));
mrb_define_const(mrb, mod_Input, "SDL_IGNORE", mrb_fixnum_value(SDL_IGNORE));
mrb_define_const(mrb, mod_Input, "SDL_DISABLE", mrb_fixnum_value(SDL_DISABLE));
mrb_define_const(mrb, mod_Input, "SDL_ENABLE", mrb_fixnum_value(SDL_ENABLE));
mrb_gc_arena_restore(mrb, arena_size);
}
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, bob, "BasicObject", mrb_obj_value(bob));
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, MRB_ARGS_NONE());
mrb_define_method(mrb, bob, "!", mrb_bob_not, MRB_ARGS_NONE());
mrb_define_method(mrb, bob, "method_missing", mrb_bob_missing, MRB_ARGS_ANY()); /* 15.3.1.3.30 */
mrb_define_class_method(mrb, cls, "new", mrb_class_new_class, MRB_ARGS_ANY());
mrb_define_method(mrb, cls, "superclass", mrb_class_superclass, MRB_ARGS_NONE()); /* 15.2.3.3.4 */
mrb_define_method(mrb, cls, "new", mrb_instance_new, MRB_ARGS_ANY()); /* 15.2.3.3.3 */
mrb_define_method(mrb, cls, "inherited", mrb_bob_init, MRB_ARGS_REQ(1));
MRB_SET_INSTANCE_TT(mod, MRB_TT_MODULE);
mrb_define_method(mrb, mod, "class_variable_defined?", mrb_mod_cvar_defined, MRB_ARGS_REQ(1)); /* 15.2.2.4.16 */
mrb_define_method(mrb, mod, "class_variable_get", mrb_mod_cvar_get, MRB_ARGS_REQ(1)); /* 15.2.2.4.17 */
mrb_define_method(mrb, mod, "class_variable_set", mrb_mod_cvar_set, MRB_ARGS_REQ(2)); /* 15.2.2.4.18 */
mrb_define_method(mrb, mod, "extend_object", mrb_mod_extend_object, MRB_ARGS_REQ(1)); /* 15.2.2.4.25 */
mrb_define_method(mrb, mod, "extended", mrb_bob_init, MRB_ARGS_REQ(1)); /* 15.2.2.4.26 */
mrb_define_method(mrb, mod, "include", mrb_mod_include, MRB_ARGS_ANY()); /* 15.2.2.4.27 */
mrb_define_method(mrb, mod, "include?", mrb_mod_include_p, MRB_ARGS_REQ(1)); /* 15.2.2.4.28 */
mrb_define_method(mrb, mod, "append_features", mrb_mod_append_features, MRB_ARGS_REQ(1)); /* 15.2.2.4.10 */
mrb_define_method(mrb, mod, "class_eval", mrb_mod_module_eval, MRB_ARGS_ANY()); /* 15.2.2.4.15 */
mrb_define_method(mrb, mod, "included", mrb_bob_init, MRB_ARGS_REQ(1)); /* 15.2.2.4.29 */
mrb_define_method(mrb, mod, "included_modules", mrb_mod_included_modules, MRB_ARGS_NONE()); /* 15.2.2.4.30 */
mrb_define_method(mrb, mod, "instance_methods", mrb_mod_instance_methods, MRB_ARGS_ANY()); /* 15.2.2.4.33 */
mrb_define_method(mrb, mod, "method_defined?", mrb_mod_method_defined, MRB_ARGS_REQ(1)); /* 15.2.2.4.34 */
mrb_define_method(mrb, mod, "module_eval", mrb_mod_module_eval, MRB_ARGS_ANY()); /* 15.2.2.4.35 */
mrb_define_method(mrb, mod, "remove_class_variable", mrb_mod_remove_cvar, MRB_ARGS_REQ(1)); /* 15.2.2.4.39 */
mrb_define_method(mrb, mod, "remove_method", mrb_mod_remove_method, MRB_ARGS_ANY()); /* 15.2.2.4.41 */
mrb_define_method(mrb, mod, "to_s", mrb_mod_to_s, MRB_ARGS_NONE());
mrb_define_method(mrb, mod, "inspect", mrb_mod_to_s, MRB_ARGS_NONE());
mrb_define_method(mrb, mod, "alias_method", mrb_mod_alias, MRB_ARGS_ANY()); /* 15.2.2.4.8 */
mrb_define_method(mrb, mod, "ancestors", mrb_mod_ancestors, MRB_ARGS_NONE()); /* 15.2.2.4.9 */
mrb_define_method(mrb, mod, "undef_method", mrb_mod_undef, MRB_ARGS_ANY()); /* 15.2.2.4.41 */
mrb_define_method(mrb, mod, "const_defined?", mrb_mod_const_defined, MRB_ARGS_REQ(1)); /* 15.2.2.4.20 */
mrb_define_method(mrb, mod, "const_get", mrb_mod_const_get, MRB_ARGS_REQ(1)); /* 15.2.2.4.21 */
mrb_define_method(mrb, mod, "const_set", mrb_mod_const_set, MRB_ARGS_REQ(2)); /* 15.2.2.4.23 */
mrb_define_method(mrb, mod, "constants", mrb_mod_constants, MRB_ARGS_NONE()); /* 15.2.2.4.24 */
mrb_define_method(mrb, mod, "remove_const", mrb_mod_remove_const, MRB_ARGS_REQ(1)); /* 15.2.2.4.40 */
mrb_define_method(mrb, mod, "define_method", mod_define_method, MRB_ARGS_REQ(1));
mrb_define_method(mrb, mod, "class_variables", mrb_mod_class_variables, MRB_ARGS_NONE()); /* 15.2.2.4.19 */
mrb_define_method(mrb, mod, "===", mrb_mod_eqq, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, mod, "constants", mrb_mod_s_constants, MRB_ARGS_ANY()); /* 15.2.2.3.1 */
mrb_undef_method(mrb, cls, "append_features");
mrb_undef_method(mrb, cls, "extend_object");
}
