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()); }
void mruby_sdl2_mutex_init(mrb_state *mrb) { class_Mutex = mrb_define_class_under(mrb, mod_SDL2, "Mutex", mrb->object_class); class_Semaphore = mrb_define_class_under(mrb, mod_SDL2, "Semaphore", mrb->object_class); class_Cond = mrb_define_class_under(mrb, mod_SDL2, "Cond", mrb->object_class); MRB_SET_INSTANCE_TT(class_Mutex, MRB_TT_DATA); MRB_SET_INSTANCE_TT(class_Semaphore, MRB_TT_DATA); MRB_SET_INSTANCE_TT(class_Cond, MRB_TT_DATA); mrb_define_method(mrb, class_Mutex, "initialize", mrb_sdl2_mutex_initialize, MRB_ARGS_NONE()); mrb_define_method(mrb, class_Mutex, "destroy", mrb_sdl2_mutex_destroy, MRB_ARGS_NONE()); mrb_define_method(mrb, class_Mutex, "lock", mrb_sdl2_mutex_lock, MRB_ARGS_NONE()); mrb_define_method(mrb, class_Mutex, "try_lock", mrb_sdl2_mutex_try_lock, MRB_ARGS_NONE()); mrb_define_method(mrb, class_Mutex, "unlock", mrb_sdl2_mutex_unlock, MRB_ARGS_NONE()); mrb_define_method(mrb, class_Semaphore, "initialize", mrb_sdl2_semaphore_initialize, MRB_ARGS_REQ(1)); mrb_define_method(mrb, class_Semaphore, "destroy", mrb_sdl2_semaphore_destroy, MRB_ARGS_NONE()); mrb_define_method(mrb, class_Semaphore, "post", mrb_sdl2_semaphore_post, MRB_ARGS_NONE()); mrb_define_method(mrb, class_Semaphore, "wait", mrb_sdl2_semaphore_wait, MRB_ARGS_NONE()); mrb_define_method(mrb, class_Semaphore, "try_wait", mrb_sdl2_semaphore_try_wait, MRB_ARGS_NONE()); mrb_define_method(mrb, class_Semaphore, "wait_timeout", mrb_sdl2_semaphore_wait_timeout, MRB_ARGS_REQ(1)); mrb_define_method(mrb, class_Semaphore, "value", mrb_sdl2_semaphore_get_value, MRB_ARGS_NONE()); mrb_define_method(mrb, class_Cond, "initialize", mrb_sdl2_cond_initialize, MRB_ARGS_NONE()); mrb_define_method(mrb, class_Cond, "destroy", mrb_sdl2_cond_destroy, MRB_ARGS_NONE()); mrb_define_method(mrb, class_Cond, "broadcast", mrb_sdl2_cond_broadcast, MRB_ARGS_NONE()); mrb_define_method(mrb, class_Cond, "signal", mrb_sdl2_cond_signal, MRB_ARGS_NONE()); mrb_define_method(mrb, class_Cond, "wait", mrb_sdl2_cond_wait, MRB_ARGS_REQ(1)); mrb_define_method(mrb, class_Cond, "wait_timeout", mrb_sdl2_cond_wait_timeout, MRB_ARGS_REQ(2)); }
void mrb_cp_contact_point_init(mrb_state *mrb, struct RClass *cp_module) { mrb_cp_contact_point_class = mrb_define_class_under(mrb, cp_module, "ContactPoint", mrb->object_class); mrb_cp_contact_point_set_class = mrb_define_class_under(mrb, cp_module, "ContactPointSet", mrb->object_class); /* */ MRB_SET_INSTANCE_TT(mrb_cp_contact_point_class, MRB_TT_OBJECT); MRB_SET_INSTANCE_TT(mrb_cp_contact_point_set_class, MRB_TT_OBJECT); /* */ mrb_define_method(mrb, mrb_cp_contact_point_class, "initialize", contact_point_initialize, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb_cp_contact_point_class, "point_a", contact_point_get_point_a, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb_cp_contact_point_class, "point_a=", contact_point_set_point_a, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mrb_cp_contact_point_class, "point_b", contact_point_get_point_b, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb_cp_contact_point_class, "point_b=", contact_point_set_point_b, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mrb_cp_contact_point_class, "distance", contact_point_get_distance, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb_cp_contact_point_class, "distance=", contact_point_set_distance, MRB_ARGS_REQ(1)); /* */ mrb_define_method(mrb, mrb_cp_contact_point_set_class, "initialize", contact_point_set_initialize, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb_cp_contact_point_set_class, "count", contact_point_set_get_count, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb_cp_contact_point_set_class, "count=", contact_point_set_set_count, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mrb_cp_contact_point_set_class, "normal", contact_point_set_get_normal, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb_cp_contact_point_set_class, "normal=", contact_point_set_set_normal, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mrb_cp_contact_point_set_class, "points", contact_point_set_get_points, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb_cp_contact_point_set_class, "points=", contact_point_set_set_points, MRB_ARGS_REQ(1)); }
void mruby_sdl2_misc_init(mrb_state *mrb) { class_Buffer = mrb_define_class_under(mrb, mod_SDL2, "Buffer", mrb->object_class); class_FloatBuffer = mrb_define_class_under(mrb, mod_SDL2, "FloatBuffer", class_Buffer); class_ByteBuffer = mrb_define_class_under(mrb, mod_SDL2, "ByteBuffer", class_Buffer); MRB_SET_INSTANCE_TT(class_Buffer, MRB_TT_DATA); MRB_SET_INSTANCE_TT(class_FloatBuffer, MRB_TT_DATA); MRB_SET_INSTANCE_TT(class_ByteBuffer, MRB_TT_DATA); mrb_define_method(mrb, class_Buffer, "initialize", mrb_sdl2_misc_buffer_initialize, MRB_ARGS_REQ(1)); mrb_define_method(mrb, class_Buffer, "address", mrb_sdl2_misc_buffer_get_address, MRB_ARGS_NONE()); mrb_define_method(mrb, class_Buffer, "size", mrb_sdl2_misc_buffer_get_size, MRB_ARGS_NONE()); mrb_define_method(mrb, class_Buffer, "cptr", mrb_sdl2_misc_buffer_get_cptr, MRB_ARGS_NONE()); mrb_define_method(mrb, class_FloatBuffer, "initialize", mrb_sdl2_misc_floatbuffer_initialize, MRB_ARGS_REQ(1)); mrb_define_method(mrb, class_FloatBuffer, "size", mrb_sdl2_misc_floatbuffer_get_size, MRB_ARGS_NONE()); mrb_define_method(mrb, class_FloatBuffer, "[]", mrb_sdl2_misc_floatbuffer_get_at, MRB_ARGS_REQ(1)); mrb_define_method(mrb, class_FloatBuffer, "[]=", mrb_sdl2_misc_floatbuffer_set_at, MRB_ARGS_REQ(2)); mrb_define_method(mrb, class_ByteBuffer, "initialize", mrb_sdl2_misc_bytebuffer_initialize, MRB_ARGS_REQ(1)); mrb_define_method(mrb, class_ByteBuffer, "[]", mrb_sdl2_misc_bytebuffer_get_at, MRB_ARGS_REQ(1)); mrb_define_method(mrb, class_ByteBuffer, "[]=", mrb_sdl2_misc_bytebuffer_set_at, MRB_ARGS_REQ(2)); }
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 mrb_mruby_sha2_gem_init(mrb_state* mrb) { digest_module = mrb_define_module(mrb, "Digest"); base_class = mrb_define_class_under(mrb, digest_module, "Base", mrb->object_class); sha256_class = mrb_define_class_under(mrb, digest_module, "SHA256", base_class); sha384_class = mrb_define_class_under(mrb, digest_module, "SHA384", base_class); sha512_class = mrb_define_class_under(mrb, digest_module, "SHA512", base_class); MRB_SET_INSTANCE_TT(sha256_class, MRB_TT_DATA); MRB_SET_INSTANCE_TT(sha384_class, MRB_TT_DATA); MRB_SET_INSTANCE_TT(sha512_class, MRB_TT_DATA); mrb_define_method(mrb, sha256_class, "initialize", sha256_initialize, MRB_ARGS_NONE()); mrb_define_method(mrb, sha256_class, "update", sha256_update, MRB_ARGS_REQ(1)); mrb_define_method(mrb, sha256_class, "<<", sha256_update, MRB_ARGS_REQ(1)); mrb_define_method(mrb, sha256_class, "reset", sha256_reset, MRB_ARGS_NONE()); mrb_define_method(mrb, sha256_class, "clone", sha256_clone, MRB_ARGS_NONE()); mrb_define_method(mrb, sha256_class, "dup", sha256_clone, MRB_ARGS_NONE()); mrb_define_method(mrb, sha256_class, "digest", sha256_digest, MRB_ARGS_NONE()); mrb_define_method(mrb, sha256_class, "hexdigest", sha256_hexdigest, MRB_ARGS_NONE()); mrb_define_method(mrb, sha256_class, "to_s", sha256_hexdigest, MRB_ARGS_NONE()); mrb_define_method(mrb, sha256_class, "digest_length", sha256_digest_length, MRB_ARGS_NONE()); mrb_define_method(mrb, sha256_class, "block_length", sha256_block_length, MRB_ARGS_NONE()); mrb_define_method(mrb, sha256_class, "file", sha256_file, MRB_ARGS_REQ(1)); mrb_define_method(mrb, sha384_class, "initialize", sha384_initialize, MRB_ARGS_NONE()); mrb_define_method(mrb, sha384_class, "update", sha384_update, MRB_ARGS_REQ(1)); mrb_define_method(mrb, sha384_class, "<<", sha384_update, MRB_ARGS_REQ(1)); mrb_define_method(mrb, sha384_class, "reset", sha384_reset, MRB_ARGS_NONE()); mrb_define_method(mrb, sha384_class, "clone", sha384_clone, MRB_ARGS_NONE()); mrb_define_method(mrb, sha384_class, "dup", sha384_clone, MRB_ARGS_NONE()); mrb_define_method(mrb, sha384_class, "digest", sha384_digest, MRB_ARGS_NONE()); mrb_define_method(mrb, sha384_class, "hexdigest", sha384_hexdigest, MRB_ARGS_NONE()); mrb_define_method(mrb, sha384_class, "to_s", sha384_hexdigest, MRB_ARGS_NONE()); mrb_define_method(mrb, sha384_class, "digest_length", sha384_digest_length, MRB_ARGS_NONE()); mrb_define_method(mrb, sha384_class, "block_length", sha384_block_length, MRB_ARGS_NONE()); mrb_define_method(mrb, sha384_class, "file", sha384_file, MRB_ARGS_REQ(1)); mrb_define_method(mrb, sha512_class, "initialize", sha512_initialize, MRB_ARGS_NONE()); mrb_define_method(mrb, sha512_class, "update", sha512_update, MRB_ARGS_REQ(1)); mrb_define_method(mrb, sha512_class, "<<", sha512_update, MRB_ARGS_REQ(1)); mrb_define_method(mrb, sha512_class, "reset", sha512_reset, MRB_ARGS_NONE()); mrb_define_method(mrb, sha512_class, "clone", sha512_clone, MRB_ARGS_NONE()); mrb_define_method(mrb, sha512_class, "dup", sha512_clone, MRB_ARGS_NONE()); mrb_define_method(mrb, sha512_class, "digest", sha512_digest, MRB_ARGS_NONE()); mrb_define_method(mrb, sha512_class, "hexdigest", sha512_hexdigest, MRB_ARGS_NONE()); mrb_define_method(mrb, sha512_class, "to_s", sha512_hexdigest, MRB_ARGS_NONE()); mrb_define_method(mrb, sha512_class, "digest_length", sha512_digest_length, MRB_ARGS_NONE()); mrb_define_method(mrb, sha512_class, "block_length", sha512_block_length, MRB_ARGS_NONE()); mrb_define_method(mrb, sha512_class, "file", sha512_file, MRB_ARGS_REQ(1)); }
void mrb_mruby_digest_ffi_gem_init(mrb_state* mrb) { struct RClass *digest; struct RClass *base; struct RClass *md5; struct RClass *rmd160; struct RClass *sha1; struct RClass *sha256; struct RClass *sha384; struct RClass *sha512; struct RClass *hmac; digest = mrb_define_module(mrb, "Digest"); base = mrb_define_class_under(mrb, digest, "Base", mrb->object_class); md5 = mrb_define_class_under(mrb, digest, "MD5", base); rmd160 = mrb_define_class_under(mrb, digest, "RMD160", base); sha1 = mrb_define_class_under(mrb, digest, "SHA1", base); sha256 = mrb_define_class_under(mrb, digest, "SHA256", base); sha384 = mrb_define_class_under(mrb, digest, "SHA384", base); sha512 = mrb_define_class_under(mrb, digest, "SHA512", base); MRB_SET_INSTANCE_TT(base, MRB_TT_DATA); mrb_define_method(mrb, base, "initialize", mrb_base_init, MRB_ARGS_NONE()); mrb_define_method(mrb, base, "block_length", mrb_digest_block_length, MRB_ARGS_NONE()); mrb_define_method(mrb, base, "reset", mrb_digest_reset, MRB_ARGS_NONE()); mrb_define_method(mrb, base, "update", mrb_digest_update, MRB_ARGS_REQ(1)); mrb_define_method(mrb, base, "digest", mrb_digest_digest, MRB_ARGS_NONE()); mrb_define_method(mrb, base, "digest!", mrb_digest_digest_bang, MRB_ARGS_NONE()); mrb_define_method(mrb, base, "digest_length", mrb_digest_digest_length, MRB_ARGS_NONE()); mrb_define_method(mrb, base, "hexdigest", mrb_digest_hexdigest, MRB_ARGS_NONE()); MRB_SET_INSTANCE_TT(md5, MRB_TT_DATA); mrb_define_method(mrb, md5, "initialize", mrb_md5_init, MRB_ARGS_NONE()); MRB_SET_INSTANCE_TT(rmd160, MRB_TT_DATA); mrb_define_method(mrb, rmd160, "initialize", mrb_rmd160_init, MRB_ARGS_NONE()); MRB_SET_INSTANCE_TT(sha1, MRB_TT_DATA); mrb_define_method(mrb, sha1, "initialize", mrb_sha1_init, MRB_ARGS_NONE()); MRB_SET_INSTANCE_TT(sha256, MRB_TT_DATA); mrb_define_method(mrb, sha256, "initialize", mrb_sha256_init, MRB_ARGS_NONE()); MRB_SET_INSTANCE_TT(sha384, MRB_TT_DATA); mrb_define_method(mrb, sha384, "initialize", mrb_sha384_init, MRB_ARGS_NONE()); MRB_SET_INSTANCE_TT(sha512, MRB_TT_DATA); mrb_define_method(mrb, sha512, "initialize", mrb_sha512_init, MRB_ARGS_NONE()); hmac = mrb_define_class_under(mrb, digest, "HMAC", mrb->object_class); MRB_SET_INSTANCE_TT(hmac, MRB_TT_DATA); mrb_define_method(mrb, hmac, "initialize", mrb_hmac_init, MRB_ARGS_REQ(2)); mrb_define_method(mrb, hmac, "block_length", mrb_digest_hmac_block_length, MRB_ARGS_NONE()); mrb_define_method(mrb, hmac, "update", mrb_digest_hmac_update, MRB_ARGS_REQ(1)); mrb_define_method(mrb, hmac, "digest", mrb_digest_hmac_digest, MRB_ARGS_NONE()); mrb_define_method(mrb, hmac, "digest_length", mrb_digest_hmac_digest_length, MRB_ARGS_NONE()); mrb_define_method(mrb, hmac, "hexdigest", mrb_digest_hmac_hexdigest, MRB_ARGS_NONE()); }
void ruby_register_cocos2dx_experimental_video_VideoPlayer(mrb_state* mrb, struct RClass* rmodule) { std::string typeName = typeid(cocos2d::experimental::ui::VideoPlayer).name(); g_rubyType[typeName] = "CCExp::VideoPlayer"; g_rubyDataType[typeName] = &ruby_cocos2dx_Ref_type; struct RClass* p_rmodule = mrb->object_class; p_rmodule = mrb_module_get_under(mrb, p_rmodule, "CCUI"); struct RClass* p_rclass = mrb_class_get_under(mrb, p_rmodule, "Widget"); struct RClass *rclass = mrb_define_class_under(mrb, rmodule, "VideoPlayer", p_rclass); MRB_SET_INSTANCE_TT(rclass, MRB_TT_DATA); mrb_define_method(mrb, rclass, "get_file_name", ruby_cocos2dx_experimental_video_VideoPlayer_getFileName, ARGS_NONE()); mrb_define_method(mrb, rclass, "get_url", ruby_cocos2dx_experimental_video_VideoPlayer_getURL, ARGS_NONE()); mrb_define_method(mrb, rclass, "play", ruby_cocos2dx_experimental_video_VideoPlayer_play, ARGS_NONE()); mrb_define_method(mrb, rclass, "pause", ruby_cocos2dx_experimental_video_VideoPlayer_pause, ARGS_NONE()); mrb_define_method(mrb, rclass, "set_keep_aspect_ratio_enabled", ruby_cocos2dx_experimental_video_VideoPlayer_setKeepAspectRatioEnabled, ARGS_REQ(1)); mrb_define_method(mrb, rclass, "resume", ruby_cocos2dx_experimental_video_VideoPlayer_resume, ARGS_NONE()); mrb_define_method(mrb, rclass, "stop", ruby_cocos2dx_experimental_video_VideoPlayer_stop, ARGS_NONE()); mrb_define_method(mrb, rclass, "set_full_screen_enabled", ruby_cocos2dx_experimental_video_VideoPlayer_setFullScreenEnabled, ARGS_REQ(1)); mrb_define_method(mrb, rclass, "set_file_name", ruby_cocos2dx_experimental_video_VideoPlayer_setFileName, ARGS_REQ(1)); mrb_define_method(mrb, rclass, "set_url", ruby_cocos2dx_experimental_video_VideoPlayer_setURL, ARGS_REQ(1)); mrb_define_method(mrb, rclass, "keep_aspect_ratio_enabled?", ruby_cocos2dx_experimental_video_VideoPlayer_isKeepAspectRatioEnabled, ARGS_NONE()); mrb_define_method(mrb, rclass, "on_play_event", ruby_cocos2dx_experimental_video_VideoPlayer_onPlayEvent, ARGS_REQ(1)); mrb_define_method(mrb, rclass, "full_screen_enabled?", ruby_cocos2dx_experimental_video_VideoPlayer_isFullScreenEnabled, ARGS_NONE()); mrb_define_method(mrb, rclass, "playing?", ruby_cocos2dx_experimental_video_VideoPlayer_isPlaying, ARGS_NONE()); mrb_define_method(mrb, rclass, "seek_to", ruby_cocos2dx_experimental_video_VideoPlayer_seekTo, ARGS_REQ(1)); mrb_define_class_method(mrb, rclass, "create", ruby_cocos2dx_experimental_video_VideoPlayer_create_static, ARGS_NONE()); struct RClass* renum_EventType = mrb_define_module_under(mrb, rclass, "EventType"); ruby_cocos2dx_experimental_video_VideoPlayer_EventType_enum_init(mrb, renum_EventType); mrb_define_class_method(mrb, renum_EventType, "PLAYING", ruby_cocos2dx_experimental_video_constant_get, ARGS_NONE()); mrb_define_class_method(mrb, renum_EventType, "PAUSED", ruby_cocos2dx_experimental_video_constant_get, ARGS_NONE()); mrb_define_class_method(mrb, renum_EventType, "STOPPED", ruby_cocos2dx_experimental_video_constant_get, ARGS_NONE()); mrb_define_class_method(mrb, renum_EventType, "COMPLETED", ruby_cocos2dx_experimental_video_constant_get, ARGS_NONE()); }
/* * Document-class: Cache * * <code>Cache</code> provides for a Hashtable of strings in shared * memory (via a memory mapped file), which thus can be shared between * processes on a computer. Here is an example of its usage: * * $lm = Cache.new :namespace => "viewcounters" * $lm[:foo] = 1 * $lm[:foo] # -> "1" * $lm.delete(:foo) * * <code>Cache</code> can also be used as a persistent key value * database, just use the :filename instead of the :namespace parameter. * * $lm = Cache.new :filename => "my-database.lmc" * $lm[:foo] = 1 * $lm[:foo] # -> "1" * $lm.delete(:foo) * * == Default sizes of memory pools * * The default size for memory pools is 1024 (MB). It cannot be changed later, * so choose a size that will provide enough space for all your data. You * might consider setting this size to the maximum filesize of your * filesystem. Also note that while these memory pools may look large on your * disk, they really aren't, because with sparse files only those parts of the * file which contain non-null data actually use disk space. * * == Automatic recovery from crashes * * In case a process is terminated while accessing a memory pool, other * processes will wait for the lock up to 2 seconds, and will then try to * resume the aborted operation. This can also be done explicitly by using * Cache.check(options). * * == Clearing memory pools * * Removing memory pools can be done with Cache.drop(options). * * == Environment * * If you use the :namespace parameter, the .lmc file for your namespace will * reside in /var/tmp/Cache. This can be overriden by setting the * LMC_NAMESPACES_ROOT_PATH variable in the environment. * * == Storing Ruby Objects * * If you want to store Ruby objects instead of just strings, consider * using Cache::SharedObjectStorage. * */ void mrb_mruby_cache_gem_init(mrb_state *mrb) { struct RClass *Cache; lmc_init(); Cache = mrb_define_class(mrb, "Cache", mrb->object_class); MRB_SET_INSTANCE_TT(Cache, MRB_TT_DATA); mrb_define_method(mrb, Cache, "initialize", Cache_init, MRB_ARGS_REQ(1)); mrb_define_singleton_method(mrb, (struct RObject *)Cache, "drop", Cache__drop, MRB_ARGS_REQ(1)); mrb_define_singleton_method(mrb, (struct RObject *)Cache, "disable_test_crash", Cache__disable_test_crash, MRB_ARGS_NONE()); mrb_define_singleton_method(mrb, (struct RObject *)Cache, "enable_test_crash", Cache__enable_test_crash, MRB_ARGS_NONE()); mrb_define_method(mrb, Cache, "get", Cache__get, MRB_ARGS_REQ(1)); mrb_define_method(mrb, Cache, "[]", Cache__get, MRB_ARGS_REQ(1)); mrb_define_method(mrb, Cache, "delete", Cache__delete, MRB_ARGS_REQ(1)); mrb_define_method(mrb, Cache, "set", Cache__set, MRB_ARGS_REQ(2)); mrb_define_method(mrb, Cache, "clear", Cache__clear, MRB_ARGS_NONE()); mrb_define_method(mrb, Cache, "[]=", Cache__set, MRB_ARGS_REQ(2)); mrb_define_method(mrb, Cache, "close", Cache__close, MRB_ARGS_NONE()); mrb_define_method(mrb, Cache, "size", Cache__size, MRB_ARGS_NONE()); mrb_define_method(mrb, Cache, "shm_status", Cache__shm_status, MRB_ARGS_NONE()); mrb_define_method(mrb, Cache, "check_consistency", Cache__check_consistency, MRB_ARGS_NONE()); // mrb_define_method(mrb, Cache, "keys", Cache__keys, MRB_ARGS_NONE()); DONE; }
void mruby_sdl2_video_surface_init(mrb_state *mrb, struct RClass *mod_Video) { class_Surface = mrb_define_class_under(mrb, mod_Video, "Surface", mrb->object_class); MRB_SET_INSTANCE_TT(class_Surface, MRB_TT_DATA); mrb_define_method(mrb, class_Surface, "initialize", mrb_sdl2_video_surface_initialize, MRB_ARGS_REQ(8)); mrb_define_method(mrb, class_Surface, "free", mrb_sdl2_video_surface_free, MRB_ARGS_NONE()); mrb_define_method(mrb, class_Surface, "destroy", mrb_sdl2_video_surface_free, MRB_ARGS_NONE()); mrb_define_method(mrb, class_Surface, "blit_scaled", mrb_sdl2_video_surface_blit_scaled, MRB_ARGS_REQ(2) | MRB_ARGS_OPT(1)); mrb_define_method(mrb, class_Surface, "blit_surface", mrb_sdl2_video_surface_blit_surface, MRB_ARGS_REQ(3)); mrb_define_method(mrb, class_Surface, "blit_from_string",mrb_sdl2_video_surface_blit_from_string,MRB_ARGS_REQ(5)); mrb_define_method(mrb, class_Surface, "convert_format", mrb_sdl2_video_surface_convert_format, MRB_ARGS_REQ(2)); mrb_define_method(mrb, class_Surface, "fill_rect", mrb_sdl2_video_surface_fill_rect, MRB_ARGS_REQ(1) | MRB_ARGS_OPT(1)); mrb_define_method(mrb, class_Surface, "fill_rects", mrb_sdl2_video_surface_fill_rects, MRB_ARGS_REQ(2)); mrb_define_method(mrb, class_Surface, "clip_rect", mrb_sdl2_video_surface_get_clip_rect, MRB_ARGS_NONE()); mrb_define_method(mrb, class_Surface, "clip_rect=", mrb_sdl2_video_surface_set_clip_rect, MRB_ARGS_REQ(1)); mrb_define_method(mrb, class_Surface, "color_key_get", mrb_sdl2_video_surface_get_color_key, MRB_ARGS_NONE()); mrb_define_method(mrb, class_Surface, "color_key_set", mrb_sdl2_video_surface_get_solor_key, MRB_ARGS_REQ(2)); mrb_define_method(mrb, class_Surface, "alpha_mod", mrb_sdl2_video_surface_get_alpha_mod, MRB_ARGS_NONE()); mrb_define_method(mrb, class_Surface, "alpha_mod=", mrb_sdl2_video_surface_set_alpha_mod, MRB_ARGS_REQ(1)); mrb_define_method(mrb, class_Surface, "blend_mode", mrb_sdl2_video_surface_get_blend_mode, MRB_ARGS_NONE()); mrb_define_method(mrb, class_Surface, "blend_mode=", mrb_sdl2_video_surface_set_blend_mode, MRB_ARGS_REQ(1)); mrb_define_method(mrb, class_Surface, "color_mod", mrb_sdl2_video_surface_get_color_mod, MRB_ARGS_NONE()); mrb_define_method(mrb, class_Surface, "color_mod=", mrb_sdl2_video_surface_set_color_mod, MRB_ARGS_REQ(1)); mrb_define_method(mrb, class_Surface, "palette", mrb_sdl2_video_surface_set_palette, MRB_ARGS_REQ(1)); mrb_define_method(mrb, class_Surface, "rle", mrb_sdl2_video_surface_set_rle, MRB_ARGS_REQ(1)); mrb_define_method(mrb, class_Surface, "lock", mrb_sdl2_video_surface_lock, MRB_ARGS_NONE()); mrb_define_method(mrb, class_Surface, "unlock", mrb_sdl2_video_surface_unlock, MRB_ARGS_NONE()); mrb_define_class_method(mrb, class_Surface, "load_bmp", mrb_sdl2_video_surface_load_bmp, MRB_ARGS_REQ(1)); mrb_define_class_method(mrb, class_Surface, "save_bmp", mrb_sdl2_video_surface_save_bmp, MRB_ARGS_REQ(2)); }
static void copy_class(mrb_state *mrb, mrb_value dst, mrb_value src) { struct RClass *dc = mrb_class_ptr(dst); struct RClass *sc = mrb_class_ptr(src); /* if the origin is not the same as the class, then the origin and the current class need to be copied */ if (sc->flags & MRB_FL_CLASS_IS_PREPENDED) { struct RClass *c0 = sc->super; struct RClass *c1 = dc; /* copy prepended iclasses */ while (!(c0->flags & MRB_FL_CLASS_IS_ORIGIN)) { c1->super = mrb_class_ptr(mrb_obj_dup(mrb, mrb_obj_value(c0))); c1 = c1->super; c0 = c0->super; } c1->super = mrb_class_ptr(mrb_obj_dup(mrb, mrb_obj_value(c0))); c1->super->flags |= MRB_FL_CLASS_IS_ORIGIN; } if (sc->mt) { dc->mt = kh_copy(mt, mrb, sc->mt); } else { dc->mt = kh_init(mt, mrb); } dc->super = sc->super; MRB_SET_INSTANCE_TT(dc, MRB_INSTANCE_TT(sc)); }
static mrb_value make_struct(mrb_state *mrb, mrb_value name, mrb_value members, struct RClass * klass) { mrb_value nstr; mrb_sym id; struct RClass *c; if (mrb_nil_p(name)) { c = mrb_class_new(mrb, klass); } else { /* old style: should we warn? */ name = mrb_str_to_str(mrb, name); id = mrb_obj_to_sym(mrb, name); if (!is_const_id(mrb, mrb_sym2name_len(mrb, id, NULL))) { mrb_name_error(mrb, id, "identifier %S needs to be constant", name); } if (mrb_const_defined_at(mrb, mrb_obj_value(klass), id)) { mrb_warn(mrb, "redefining constant Struct::%S", 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_ARRAY); nstr = mrb_obj_value(c); mrb_iv_set(mrb, nstr, mrb_intern_lit(mrb, "__members__"), members); mrb_define_class_method(mrb, c, "new", mrb_instance_new, MRB_ARGS_ANY()); mrb_define_class_method(mrb, c, "[]", mrb_instance_new, MRB_ARGS_ANY()); mrb_define_class_method(mrb, c, "members", mrb_struct_s_members_m, MRB_ARGS_NONE()); /* RSTRUCT(nstr)->basic.c->super = c->c; */ make_struct_define_accessors(mrb, members, c); return nstr; }
void mrb_init_io(mrb_state *mrb) { struct RClass *io; io = mrb_define_class(mrb, "IO", mrb->object_class); MRB_SET_INSTANCE_TT(io, MRB_TT_DATA); mrb_include_module(mrb, io, mrb_module_get(mrb, "Enumerable")); /* 15.2.20.3 */ #ifndef _WIN32 mrb_define_class_method(mrb, io, "_popen", mrb_io_s_popen, MRB_ARGS_ANY()); mrb_define_class_method(mrb, io, "_sysclose", mrb_io_s_sysclose, MRB_ARGS_REQ(1)); #endif mrb_define_class_method(mrb, io, "select", mrb_io_s_select, MRB_ARGS_ANY()); mrb_define_class_method(mrb, io, "sysopen", mrb_io_s_sysopen, MRB_ARGS_ANY()); mrb_define_method(mrb, io, "initialize", mrb_io_initialize, MRB_ARGS_ANY()); /* 15.2.20.5.21 (x)*/ mrb_define_method(mrb, io, "sync", mrb_io_sync, MRB_ARGS_NONE()); mrb_define_method(mrb, io, "sync=", mrb_io_set_sync, MRB_ARGS_REQ(1)); mrb_define_method(mrb, io, "sysread", mrb_io_sysread, MRB_ARGS_ANY()); mrb_define_method(mrb, io, "sysseek", mrb_io_sysseek, MRB_ARGS_REQ(1)); mrb_define_method(mrb, io, "syswrite", mrb_io_syswrite, MRB_ARGS_REQ(1)); mrb_define_method(mrb, io, "close", mrb_io_close, MRB_ARGS_NONE()); /* 15.2.20.5.1 */ mrb_define_method(mrb, io, "close_on_exec=", mrb_io_set_close_on_exec, MRB_ARGS_REQ(1)); mrb_define_method(mrb, io, "close_on_exec?", mrb_io_close_on_exec_p, MRB_ARGS_NONE()); mrb_define_method(mrb, io, "closed?", mrb_io_closed, MRB_ARGS_NONE()); /* 15.2.20.5.2 */ mrb_define_method(mrb, io, "pid", mrb_io_pid, MRB_ARGS_NONE()); /* 15.2.20.5.2 */ mrb_define_method(mrb, io, "fileno", mrb_io_fileno, MRB_ARGS_NONE()); mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$/"), mrb_str_new_cstr(mrb, "\n")); }
void mrb_SQLite_Sqlite3Context_init(mrb_state* mrb) { static int initialized = 0; if (initialized) return; else initialized = 1; /* MRUBY_BINDING: pre_class_definition */ /* sha: user_defined */ /* MRUBY_BINDING_END */ /* MRUBY_BINDING: Sqlite3Context::class_definition */ /* sha: 928b5f23e2bf714e656d6a536c89099098e41c7f5dd167e3acee29e7eb920d7b */ struct RClass* Sqlite3Context_class = mrb_define_class_under(mrb, SQLite_module(mrb), "Sqlite3Context", mrb->object_class); MRB_SET_INSTANCE_TT(Sqlite3Context_class, MRB_TT_DATA); /* MRUBY_BINDING_END */ /* MRUBY_BINDING: Sqlite3Context::pre_class_method_definitions */ /* sha: user_defined */ /* MRUBY_BINDING_END */ /* MRUBY_BINDING: Sqlite3Context::class_method_definitions */ /* sha: 4f9b865727d5035d391d88ededfb875cdae800908485348884b36a262239cd77 */ #if BIND_Sqlite3Context_INITIALIZE mrb_define_method(mrb, Sqlite3Context_class, "initialize", mrb_SQLite_Sqlite3Context_initialize, MRB_ARGS_NONE()); #endif /* MRUBY_BINDING_END */ /* MRUBY_BINDING: Sqlite3Context::post_class_definition */ /* sha: user_defined */ /* MRUBY_BINDING_END */ }
MRB_CP_EXTERN void mrb_cp_arbiter_init(mrb_state* mrb, struct RClass* cp_module) { struct RClass* mrb_cp_arbiter_class = mrb_define_class_under(mrb, cp_module, "Arbiter", mrb->object_class); MRB_SET_INSTANCE_TT(mrb_cp_arbiter_class, MRB_TT_DATA); mrb_define_method(mrb, mrb_cp_arbiter_class, "restitution", arbiter_get_restitution, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb_cp_arbiter_class, "restitution=", arbiter_set_restitution, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mrb_cp_arbiter_class, "friction", arbiter_get_friction, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb_cp_arbiter_class, "friction=", arbiter_set_friction, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mrb_cp_arbiter_class, "surface_velocity", arbiter_get_surface_velocity, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb_cp_arbiter_class, "surface_velocity=", arbiter_set_surface_velocity, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mrb_cp_arbiter_class, "total_impulse", arbiter_total_impulse, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb_cp_arbiter_class, "total_ke", arbiter_total_ke, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb_cp_arbiter_class, "ignore", arbiter_ignore, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb_cp_arbiter_class, "shapes", arbiter_shapes, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb_cp_arbiter_class, "bodies", arbiter_bodies, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb_cp_arbiter_class, "contact_point_set", arbiter_get_contact_point_set, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb_cp_arbiter_class, "contact_point_set=", arbiter_set_contact_point_set, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mrb_cp_arbiter_class, "first_contact?", arbiter_is_first_contact, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb_cp_arbiter_class, "removal?", arbiter_is_removal, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb_cp_arbiter_class, "normal", arbiter_get_normal, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb_cp_arbiter_class, "point_a", arbiter_get_point_a, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mrb_cp_arbiter_class, "point_b", arbiter_get_point_b, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mrb_cp_arbiter_class, "depth", arbiter_get_depth, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mrb_cp_arbiter_class, "call_wildcard_begin_a", arbiter_call_wildcard_begin_a, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mrb_cp_arbiter_class, "call_wildcard_begin_b", arbiter_call_wildcard_begin_b, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mrb_cp_arbiter_class, "call_wildcard_pre_solve_a", arbiter_call_wildcard_pre_solve_a, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mrb_cp_arbiter_class, "call_wildcard_pre_solve_b", arbiter_call_wildcard_pre_solve_b, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mrb_cp_arbiter_class, "call_wildcard_post_solve_a", arbiter_call_wildcard_post_solve_a, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mrb_cp_arbiter_class, "call_wildcard_post_solve_b", arbiter_call_wildcard_post_solve_b, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mrb_cp_arbiter_class, "call_wildcard_separate_a", arbiter_call_wildcard_separate_a, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mrb_cp_arbiter_class, "call_wildcard_separate_b", arbiter_call_wildcard_separate_b, MRB_ARGS_REQ(1)); }
void grn_mrb_table_cursor_init(grn_ctx *ctx) { grn_mrb_data *data = &(ctx->impl->mrb); mrb_state *mrb = data->state; struct RClass *module = data->module; struct RClass *klass; klass = mrb_define_class_under(mrb, module, "TableCursor", mrb->object_class); MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); mrb_define_class_method(mrb, klass, "open_raw", mrb_grn_table_cursor_class_open_raw, MRB_ARGS_ARG(1, 1)); mrb_define_method(mrb, klass, "initialize", mrb_grn_table_cursor_initialize, MRB_ARGS_REQ(1)); mrb_define_method(mrb, klass, "close", mrb_grn_table_cursor_close, MRB_ARGS_NONE()); mrb_define_method(mrb, klass, "next", mrb_grn_table_cursor_next, MRB_ARGS_NONE()); mrb_define_method(mrb, klass, "count", mrb_grn_table_cursor_count, MRB_ARGS_NONE()); mrb_define_method(mrb, klass, "key", mrb_grn_table_cursor_get_key, MRB_ARGS_NONE()); }
void mrb_ipvs_service_class_init(mrb_state *mrb, struct RClass *_class_ipvs) { struct RClass *_class_ipvs_service; _class_ipvs_service = mrb_define_class_under(mrb, _class_ipvs, "Service", mrb->object_class); MRB_SET_INSTANCE_TT(_class_ipvs_service, MRB_TT_DATA); mrb_define_method(mrb, _class_ipvs_service, "initialize", mrb_ipvs_service_init, MRB_ARGS_REQ(1)); mrb_define_method(mrb, _class_ipvs_service, "initialize_copy", mrb_ipvs_service_init_copy, MRB_ARGS_REQ(1) | MRB_ARGS_OPT(6)); mrb_define_method(mrb, _class_ipvs_service, "add_service", mrb_ipvs_service_add, MRB_ARGS_NONE()); mrb_define_method(mrb, _class_ipvs_service, "del_service", mrb_ipvs_service_del, MRB_ARGS_NONE()); mrb_define_method(mrb, _class_ipvs_service, "add_dest", mrb_ipvs_service_add_dest, MRB_ARGS_REQ(1)); mrb_define_method(mrb, _class_ipvs_service, "del_dest", mrb_ipvs_service_del_dest, MRB_ARGS_REQ(1)); mrb_define_method(mrb, _class_ipvs_service, "addr", mrb_ipvs_service_get_addr, MRB_ARGS_NONE()); mrb_define_method(mrb, _class_ipvs_service, "port", mrb_ipvs_service_get_port, MRB_ARGS_NONE()); mrb_define_method(mrb, _class_ipvs_service, "proto", mrb_ipvs_service_get_proto, MRB_ARGS_NONE()); mrb_define_method(mrb, _class_ipvs_service, "sched_name", mrb_ipvs_service_get_sched_name, MRB_ARGS_NONE()); // mrb_define_method(mrb, _class_ipvs_service, "timeout", // mrb_ipvs_service_get_timeout, MRB_ARGS_NONE()); // mrb_define_method(mrb, _class_ipvs_service, "netmask", // mrb_ipvs_service_get_netmask, MRB_ARGS_NONE()); // mrb_define_method(mrb, _class_ipvs_service, "ops", // mrb_ipvs_service_get_ops, MRB_ARGS_NONE()); }
void mrb_SDL_SDLHapticDirection_init(mrb_state* mrb) { RClass* SDLHapticDirection_class = mrb_define_class_under(mrb, SDL_module(mrb), "HapticDirection", mrb->object_class); MRB_SET_INSTANCE_TT(SDLHapticDirection_class, MRB_TT_DATA); #if BIND_SDLHapticDirection_INITIALIZE mrb_define_method(mrb, SDLHapticDirection_class, "initialize", mrb_SDL_SDLHapticDirection_initialize, MRB_ARGS_NONE()); #endif mrb_define_class_method(mrb, SDLHapticDirection_class, "disown", mrb_SDL_SDLHapticDirection_disown, MRB_ARGS_ARG(1, 0)); mrb_define_class_method(mrb, SDLHapticDirection_class, "belongs_to_ruby?", mrb_SDL_SDLHapticDirection_belongs_to_ruby, MRB_ARGS_ARG(1, 0)); /* * Fields */ #if BIND_SDLHapticDirection_type_FIELD_READER mrb_define_method(mrb, SDLHapticDirection_class, "type", mrb_SDL_SDLHapticDirection_get_type, MRB_ARGS_ARG(0, 0)); #endif #if BIND_SDLHapticDirection_type_FIELD_WRITER mrb_define_method(mrb, SDLHapticDirection_class, "type=", mrb_SDL_SDLHapticDirection_set_type, MRB_ARGS_ARG(1, 0)); #endif #if BIND_SDLHapticDirection_dir_FIELD_READER mrb_define_method(mrb, SDLHapticDirection_class, "dir", mrb_SDL_SDLHapticDirection_get_dir, MRB_ARGS_ARG(0, 0)); #endif #if BIND_SDLHapticDirection_dir_FIELD_WRITER mrb_define_method(mrb, SDLHapticDirection_class, "dir=", mrb_SDL_SDLHapticDirection_set_dir, MRB_ARGS_ARG(1, 0)); #endif }
void mrb_SQLite_Sqlite3Mutex_init(mrb_state* mrb) { static int initialized = 0; if (initialized) return; else initialized = 1; /* MRUBY_BINDING: pre_class_definition */ /* sha: user_defined */ /* MRUBY_BINDING_END */ /* MRUBY_BINDING: Sqlite3Mutex::class_definition */ /* sha: 2490c1d7468f2cec0f603085127a504ecec7f2925024e2f033bc71ae281ab8c1 */ struct RClass* Sqlite3Mutex_class = mrb_define_class_under(mrb, SQLite_module(mrb), "Sqlite3Mutex", mrb->object_class); MRB_SET_INSTANCE_TT(Sqlite3Mutex_class, MRB_TT_DATA); /* MRUBY_BINDING_END */ /* MRUBY_BINDING: Sqlite3Mutex::pre_class_method_definitions */ /* sha: user_defined */ /* MRUBY_BINDING_END */ /* MRUBY_BINDING: Sqlite3Mutex::class_method_definitions */ /* sha: 5a60b52fd9627ad898a5e9cafc9edf67abd88cb73cc3dd2fb95cc1deca99c4e0 */ #if BIND_Sqlite3Mutex_INITIALIZE mrb_define_method(mrb, Sqlite3Mutex_class, "initialize", mrb_SQLite_Sqlite3Mutex_initialize, MRB_ARGS_NONE()); #endif /* MRUBY_BINDING_END */ /* MRUBY_BINDING: Sqlite3Mutex::post_class_definition */ /* sha: user_defined */ /* MRUBY_BINDING_END */ }
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 grn_mrb_table_init(grn_ctx *ctx) { grn_mrb_data *data = &(ctx->impl->mrb); mrb_state *mrb = data->state; struct RClass *module = data->module; struct RClass *object_class = data->object_class; struct RClass *klass; klass = mrb_define_class_under(mrb, module, "Table", object_class); MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); mrb_define_method(mrb, klass, "[]", mrb_grn_table_array_reference, MRB_ARGS_REQ(1)); mrb_define_method(mrb, klass, "locked?", mrb_grn_table_is_locked, MRB_ARGS_NONE()); mrb_define_method(mrb, klass, "size", mrb_grn_table_get_size, MRB_ARGS_NONE()); mrb_define_method(mrb, klass, "empty?", mrb_grn_table_is_empty, MRB_ARGS_NONE()); mrb_define_method(mrb, klass, "select", mrb_grn_table_select, MRB_ARGS_ARG(1, 1)); mrb_define_method(mrb, klass, "sort", mrb_grn_table_sort, MRB_ARGS_ARG(1, 1)); }
void mrb_init_exception(mrb_state *mrb) { struct RClass *exception, *runtime_error, *script_error; mrb->eException_class = exception = mrb_define_class(mrb, "Exception", mrb->object_class); /* 15.2.22 */ MRB_SET_INSTANCE_TT(exception, MRB_TT_EXCEPTION); mrb_define_class_method(mrb, exception, "exception", mrb_instance_new, MRB_ARGS_ANY()); mrb_define_method(mrb, exception, "exception", exc_exception, MRB_ARGS_ANY()); mrb_define_method(mrb, exception, "initialize", exc_initialize, MRB_ARGS_ANY()); mrb_define_method(mrb, exception, "to_s", exc_to_s, MRB_ARGS_NONE()); mrb_define_method(mrb, exception, "message", exc_message, MRB_ARGS_NONE()); mrb_define_method(mrb, exception, "inspect", exc_inspect, MRB_ARGS_NONE()); mrb_define_method(mrb, exception, "backtrace", exc_get_backtrace, MRB_ARGS_NONE()); mrb_define_method(mrb, exception, "set_backtrace", exc_set_backtrace, MRB_ARGS_REQ(1)); mrb->eStandardError_class = mrb_define_class(mrb, "StandardError", mrb->eException_class); /* 15.2.23 */ runtime_error = mrb_define_class(mrb, "RuntimeError", mrb->eStandardError_class); /* 15.2.28 */ mrb->nomem_err = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, runtime_error, "Out of memory")); #ifdef MRB_GC_FIXED_ARENA mrb->arena_err = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, runtime_error, "arena overflow error")); #endif script_error = mrb_define_class(mrb, "ScriptError", mrb->eException_class); /* 15.2.37 */ mrb_define_class(mrb, "SyntaxError", script_error); /* 15.2.38 */ mrb_define_class(mrb, "SystemStackError", exception); }
void mrb_init_proc(mrb_state *mrb) { struct RProc *m; mrb_irep *call_irep = (mrb_irep *)mrb_malloc(mrb, sizeof(mrb_irep)); static const mrb_irep mrb_irep_zero = { 0 }; if (call_irep == NULL) return; *call_irep = mrb_irep_zero; call_irep->flags = MRB_ISEQ_NO_FREE; call_irep->iseq = call_iseq; call_irep->ilen = 1; mrb->proc_class = mrb_define_class(mrb, "Proc", mrb->object_class); MRB_SET_INSTANCE_TT(mrb->proc_class, MRB_TT_PROC); mrb_define_method(mrb, mrb->proc_class, "initialize", mrb_proc_initialize, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb->proc_class, "initialize_copy", mrb_proc_init_copy, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mrb->proc_class, "arity", mrb_proc_arity, MRB_ARGS_NONE()); m = mrb_proc_new(mrb, call_irep); mrb_define_method_raw(mrb, mrb->proc_class, mrb_intern_lit(mrb, "call"), m); mrb_define_method_raw(mrb, mrb->proc_class, mrb_intern_lit(mrb, "[]"), m); mrb_define_class_method(mrb, mrb->kernel_module, "lambda", proc_lambda, MRB_ARGS_NONE()); /* 15.3.1.2.6 */ mrb_define_method(mrb, mrb->kernel_module, "lambda", proc_lambda, MRB_ARGS_NONE()); /* 15.3.1.3.27 */ }
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_init_io(mrb_state *mrb) { struct RClass *io; io = mrb_define_class(mrb, "IO", mrb->object_class); MRB_SET_INSTANCE_TT(io, MRB_TT_DATA); mrb_include_module(mrb, io, mrb_class_get(mrb, "Enumerable")); /* 15.2.20.3 */ mrb_define_class_method(mrb, io, "_popen", mrb_io_s_popen, ARGS_ANY()); mrb_define_class_method(mrb, io, "for_fd", mrb_io_s_for_fd, ARGS_REQ(1)|ARGS_OPT(2)); mrb_define_class_method(mrb, io, "sysopen", mrb_io_s_sysopen, ARGS_ANY()); mrb_define_method(mrb, io, "_bless", mrb_io_bless, ARGS_NONE()); mrb_define_method(mrb, io, "initialize", mrb_io_initialize, ARGS_ANY()); /* 15.2.20.5.21 (x)*/ mrb_define_method(mrb, io, "sysread", mrb_io_sysread, ARGS_ANY()); mrb_define_method(mrb, io, "sysseek", mrb_io_sysseek, ARGS_REQ(1)); mrb_define_method(mrb, io, "syswrite", mrb_io_syswrite, ARGS_REQ(1)); mrb_define_method(mrb, io, "close", mrb_io_close, ARGS_NONE()); /* 15.2.20.5.1 */ mrb_define_method(mrb, io, "closed?", mrb_io_closed, ARGS_NONE()); /* 15.2.20.5.2 */ mrb_define_method(mrb, io, "pid", mrb_io_pid, ARGS_NONE()); /* 15.2.20.5.2 */ mrb_define_method(mrb, io, "fileno", mrb_io_fileno, ARGS_NONE()); mrb_gv_set(mrb, mrb_intern(mrb, "$/"), mrb_str_new_cstr(mrb, "\n")); }
void mrb_init_hash(mrb_state *mrb) { struct RClass *h; mrb->hash_class = h = mrb_define_class(mrb, "Hash", mrb->object_class); /* 15.2.13 */ MRB_SET_INSTANCE_TT(h, MRB_TT_HASH); mrb_define_method(mrb, h, "[]", mrb_hash_aget, MRB_ARGS_REQ(1)); /* 15.2.13.4.2 */ mrb_define_method(mrb, h, "[]=", mrb_hash_aset, MRB_ARGS_REQ(2)); /* 15.2.13.4.3 */ mrb_define_method(mrb, h, "clear", mrb_hash_clear, MRB_ARGS_NONE()); /* 15.2.13.4.4 */ mrb_define_method(mrb, h, "default", mrb_hash_default, MRB_ARGS_ANY()); /* 15.2.13.4.5 */ mrb_define_method(mrb, h, "default=", mrb_hash_set_default, MRB_ARGS_REQ(1)); /* 15.2.13.4.6 */ mrb_define_method(mrb, h, "default_proc", mrb_hash_default_proc,MRB_ARGS_NONE()); /* 15.2.13.4.7 */ mrb_define_method(mrb, h, "default_proc=", mrb_hash_set_default_proc,MRB_ARGS_REQ(1)); /* 15.2.13.4.7 */ mrb_define_method(mrb, h, "__delete", mrb_hash_delete, MRB_ARGS_REQ(1)); /* core of 15.2.13.4.8 */ mrb_define_method(mrb, h, "empty?", mrb_hash_empty_p, MRB_ARGS_NONE()); /* 15.2.13.4.12 */ mrb_define_method(mrb, h, "has_key?", mrb_hash_has_key, MRB_ARGS_REQ(1)); /* 15.2.13.4.13 */ mrb_define_method(mrb, h, "has_value?", mrb_hash_has_value, MRB_ARGS_REQ(1)); /* 15.2.13.4.14 */ mrb_define_method(mrb, h, "include?", mrb_hash_has_key, MRB_ARGS_REQ(1)); /* 15.2.13.4.15 */ mrb_define_method(mrb, h, "initialize", mrb_hash_init, MRB_ARGS_OPT(1)); /* 15.2.13.4.16 */ mrb_define_method(mrb, h, "key?", mrb_hash_has_key, MRB_ARGS_REQ(1)); /* 15.2.13.4.18 */ mrb_define_method(mrb, h, "keys", mrb_hash_keys, MRB_ARGS_NONE()); /* 15.2.13.4.19 */ mrb_define_method(mrb, h, "length", mrb_hash_size_m, MRB_ARGS_NONE()); /* 15.2.13.4.20 */ mrb_define_method(mrb, h, "member?", mrb_hash_has_key, MRB_ARGS_REQ(1)); /* 15.2.13.4.21 */ mrb_define_method(mrb, h, "shift", mrb_hash_shift, MRB_ARGS_NONE()); /* 15.2.13.4.24 */ mrb_define_method(mrb, h, "dup", mrb_hash_dup, MRB_ARGS_NONE()); mrb_define_method(mrb, h, "size", mrb_hash_size_m, MRB_ARGS_NONE()); /* 15.2.13.4.25 */ mrb_define_method(mrb, h, "store", mrb_hash_aset, MRB_ARGS_REQ(2)); /* 15.2.13.4.26 */ mrb_define_method(mrb, h, "value?", mrb_hash_has_value, MRB_ARGS_REQ(1)); /* 15.2.13.4.27 */ mrb_define_method(mrb, h, "values", mrb_hash_values, MRB_ARGS_NONE()); /* 15.2.13.4.28 */ mrb_define_method(mrb, h, "to_hash", mrb_hash_to_hash, MRB_ARGS_NONE()); /* 15.2.13.4.29 (x)*/ }
void mrb_SDL_SDLSysWMEvent_init(mrb_state* mrb) { RClass* SDLSysWMEvent_class = mrb_define_class_under(mrb, SDL_module(mrb), "SysWMEvent", mrb->object_class); MRB_SET_INSTANCE_TT(SDLSysWMEvent_class, MRB_TT_DATA); #if BIND_SDLSysWMEvent_INITIALIZE mrb_define_method(mrb, SDLSysWMEvent_class, "initialize", mrb_SDL_SDLSysWMEvent_initialize, MRB_ARGS_NONE()); #endif mrb_define_class_method(mrb, SDLSysWMEvent_class, "disown", mrb_SDL_SDLSysWMEvent_disown, MRB_ARGS_ARG(1, 0)); mrb_define_class_method(mrb, SDLSysWMEvent_class, "belongs_to_ruby?", mrb_SDL_SDLSysWMEvent_belongs_to_ruby, MRB_ARGS_ARG(1, 0)); /* * Fields */ #if BIND_SDLSysWMEvent_type_FIELD_READER mrb_define_method(mrb, SDLSysWMEvent_class, "type", mrb_SDL_SDLSysWMEvent_get_type, MRB_ARGS_ARG(0, 0)); #endif #if BIND_SDLSysWMEvent_type_FIELD_WRITER mrb_define_method(mrb, SDLSysWMEvent_class, "type=", mrb_SDL_SDLSysWMEvent_set_type, MRB_ARGS_ARG(1, 0)); #endif #if BIND_SDLSysWMEvent_timestamp_FIELD_READER mrb_define_method(mrb, SDLSysWMEvent_class, "timestamp", mrb_SDL_SDLSysWMEvent_get_timestamp, MRB_ARGS_ARG(0, 0)); #endif #if BIND_SDLSysWMEvent_timestamp_FIELD_WRITER mrb_define_method(mrb, SDLSysWMEvent_class, "timestamp=", mrb_SDL_SDLSysWMEvent_set_timestamp, MRB_ARGS_ARG(1, 0)); #endif #if BIND_SDLSysWMEvent_msg_FIELD_READER mrb_define_method(mrb, SDLSysWMEvent_class, "msg", mrb_SDL_SDLSysWMEvent_get_msg, MRB_ARGS_ARG(0, 0)); #endif #if BIND_SDLSysWMEvent_msg_FIELD_WRITER mrb_define_method(mrb, SDLSysWMEvent_class, "msg=", mrb_SDL_SDLSysWMEvent_set_msg, MRB_ARGS_ARG(1, 0)); #endif }
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, "_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)); mrb_define_const(mrb, cnst, "NULL", mrb_str_new_cstr(mrb, NULL_FILE)); }
void mrb_UV_TTY_init(mrb_state* mrb) { static int initialized = 0; if (initialized) return; else initialized = 1; /* MRUBY_BINDING: pre_class_definition */ /* sha: user_defined */ /* MRUBY_BINDING_END */ /* MRUBY_BINDING: TTY::class_definition */ /* sha: e179da3abd4f03f12eb8b7d868d587bb3ddf2485c29e4e08a635241323afd6a0 */ struct RClass* TTY_class = mrb_define_class_under(mrb, UV_module(mrb), "TTY", Handle_class(mrb)); MRB_SET_INSTANCE_TT(TTY_class, MRB_TT_DATA); /* MRUBY_BINDING_END */ /* MRUBY_BINDING: TTY::pre_class_method_definitions */ /* sha: user_defined */ /* MRUBY_BINDING_END */ /* MRUBY_BINDING: TTY::class_method_definitions */ /* sha: ff1583ca3b265e832da93ae99d874530b632bfbe02f4ebdf5a02113ad3e689b7 */ #if BIND_TTY_INITIALIZE mrb_define_method(mrb, TTY_class, "initialize", mrb_UV_TTY_initialize, MRB_ARGS_NONE()); #endif /* MRUBY_BINDING_END */ /* MRUBY_BINDING: TTY::post_class_definition */ /* sha: user_defined */ /* MRUBY_BINDING_END */ }
void grn_mrb_table_sort_key_init(grn_ctx *ctx) { grn_mrb_data *data = &(ctx->impl->mrb); mrb_state *mrb = data->state; struct RClass *module = data->module; struct RClass *klass; klass = mrb_define_class_under(mrb, module, "TableSortKey", mrb->object_class); MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); mrb_define_method(mrb, klass, "initialize", mrb_grn_table_sort_key_initialize, MRB_ARGS_NONE()); mrb_define_method(mrb, klass, "close", mrb_grn_table_sort_key_close, MRB_ARGS_NONE()); mrb_define_method(mrb, klass, "key=", mrb_grn_table_sort_key_set_key, MRB_ARGS_REQ(1)); mrb_define_method(mrb, klass, "flags=", mrb_grn_table_sort_key_set_flags, MRB_ARGS_REQ(1)); mrb_define_method(mrb, klass, "offset=", mrb_grn_table_sort_key_set_offset, MRB_ARGS_REQ(1)); }