void
mrb_mruby_json_gem_init(mrb_state* mrb) {
struct RClass *_class_json = mrb_define_module(mrb, "JSON");
mrb_define_class_method(mrb, _class_json, "parse", mrb_json_parse, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, _class_json, "stringify", mrb_json_stringify, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, _class_json, "generate", mrb_json_stringify, MRB_ARGS_REQ(1));
}
void
mrb_mruby_objectspace_gem_init(mrb_state *mrb)
{
struct RClass *os = mrb_define_module(mrb, "ObjectSpace");
mrb_define_class_method(mrb, os, "count_objects", os_count_objects, MRB_ARGS_OPT(1));
mrb_define_class_method(mrb, os, "each_object", os_each_object, MRB_ARGS_OPT(1));
}
void mrb_mruby_base58_gem_init(mrb_state *mrb)
{
base58 = mrb_define_module(mrb, "Base58");
mrb_define_module_function(mrb, base58, "encode", mrb_base58_encode, MRB_ARGS_REQ(1) | MRB_ARGS_OPT(1));
mrb_define_module_function(mrb, base58, "decode", mrb_base58_decode, MRB_ARGS_REQ(1) | MRB_ARGS_OPT(1));
DONE;
}
static void
grn_ctx_impl_mrb_init_bindings(grn_ctx *ctx)
{
mrb_state *mrb = ctx->impl->mrb.state;
mrb->ud = ctx;
ctx->impl->mrb.module = mrb_define_module(mrb, "Groonga");
grn_mrb_load(ctx, "backtrace_entry.rb");
grn_mrb_id_init(ctx);
grn_mrb_operator_init(ctx);
grn_mrb_ctx_init(ctx);
grn_mrb_logger_init(ctx);
grn_mrb_void_init(ctx);
grn_mrb_bulk_init(ctx);
grn_mrb_obj_init(ctx);
grn_mrb_column_init(ctx);
grn_mrb_fixed_size_column_init(ctx);
grn_mrb_variable_size_column_init(ctx);
grn_mrb_index_column_init(ctx);
grn_mrb_expr_init(ctx);
grn_mrb_accessor_init(ctx);
grn_mrb_procedure_init(ctx);
}
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 EXPORT
mrb_mruby_require_example_gem_init(mrb_state* mrb) {
int ai = mrb_gc_arena_save(mrb);
_class_example = mrb_define_module(mrb, "Example");
mrb_define_class_method(mrb, _class_example, "helloworld", mrb_example_helloworld, ARGS_NONE());
mrb_gc_arena_restore(mrb, ai);
}
void
mrb_mruby_mrmagick_gem_init(mrb_state *mrb)
{
struct RClass *mrmagick_module;
struct RClass *mrmagick;
myInitializeMagick();
mrmagick_module = mrb_define_module(mrb, "Mrmagick");
mrb_define_module_function(mrb, mrmagick_module, "capi_formats", mrb_mrmagick_formats, MRB_ARGS_NONE());
mrmagick = mrb_define_class_under(mrb, mrmagick_module, "Capi", mrb->object_class);
/*mrb_define_method(mrb, mrmagick, "initialize", mrb_mrmagick_init, MRB_ARGS_REQ(1));*/
mrb_define_class_method(mrb, mrmagick, "scale", mrb_mrmagick_scale, MRB_ARGS_REQ(3));
mrb_define_class_method(mrb, mrmagick, "blur", mrb_mrmagick_blur, MRB_ARGS_REQ(4));
mrb_define_class_method(mrb, mrmagick, "rm", mrb_mrmagick_rm, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, mrmagick, "write", mrb_mrmagick_write, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, mrmagick, "write_gif", mrb_mrmagick_write_gif, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, mrmagick, "to_blob", mrb_mrmagick_to_blob, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, mrmagick, "get_exif_by_entry", mrb_mrmagick_get_exif_by_entry,
MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, mrmagick, "get_columns", mrb_mrmagick_get_columns, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, mrmagick, "get_rows", mrb_mrmagick_get_rows, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, mrmagick, "get_format", mrb_mrmagick_get_format, MRB_ARGS_REQ(1));
DONE;
}
void
mrb_mruby_sqlite3_gem_init(mrb_state* mrb) {
struct RClass *_class_sqlite3;
struct RClass *_class_sqlite3_database;
struct RClass* _class_sqlite3_resultset;
ARENA_SAVE;
_class_sqlite3 = mrb_define_module(mrb, "SQLite3");
_class_sqlite3_database = mrb_define_class_under(mrb, _class_sqlite3, "Database", mrb->object_class);
mrb_define_method(mrb, _class_sqlite3_database, "initialize", mrb_sqlite3_database_init, ARGS_OPT(1));
mrb_define_method(mrb, _class_sqlite3_database, "execute", mrb_sqlite3_database_execute, ARGS_ANY());
mrb_define_method(mrb, _class_sqlite3_database, "execute_batch", mrb_sqlite3_database_execute_batch, ARGS_ANY());
mrb_define_method(mrb, _class_sqlite3_database, "close", mrb_sqlite3_database_close, ARGS_NONE());
mrb_define_method(mrb, _class_sqlite3_database, "last_insert_rowid", mrb_sqlite3_database_last_insert_rowid, ARGS_NONE());
mrb_define_method(mrb, _class_sqlite3_database, "changes", mrb_sqlite3_database_changes, ARGS_NONE());
mrb_define_method(mrb, _class_sqlite3_database, "transaction", mrb_sqlite3_database_transaction, ARGS_NONE());
mrb_define_method(mrb, _class_sqlite3_database, "commit", mrb_sqlite3_database_commit, ARGS_NONE());
mrb_define_method(mrb, _class_sqlite3_database, "rollback", mrb_sqlite3_database_rollback, ARGS_NONE());
ARENA_RESTORE;
_class_sqlite3_resultset = mrb_define_class_under(mrb, _class_sqlite3, "ResultSet", mrb->object_class);
mrb_define_method(mrb, _class_sqlite3_resultset, "next", mrb_sqlite3_resultset_next, ARGS_NONE());
mrb_define_method(mrb, _class_sqlite3_resultset, "close", mrb_sqlite3_resultset_close, ARGS_NONE());
mrb_define_method(mrb, _class_sqlite3_resultset, "fields", mrb_sqlite3_resultset_fields, ARGS_NONE());
mrb_define_method(mrb, _class_sqlite3_resultset, "eof?", mrb_sqlite3_resultset_eof, ARGS_NONE());
ARENA_RESTORE;
}
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 kernel_Init(mrb_state *mrb)
{
mrb_define_method(mrb, mrb->kernel_module, "pinMode", mrb_kernel_pinMode, MRB_ARGS_REQ(2));
mrb_define_method(mrb, mrb->kernel_module, "digitalWrite", mrb_kernel_digitalWrite, MRB_ARGS_REQ(2));
mrb_define_method(mrb, mrb->kernel_module, "pwm", mrb_kernel_pwm, MRB_ARGS_REQ(2));
mrb_define_method(mrb, mrb->kernel_module, "digitalRead", mrb_kernel_digitalRead, MRB_ARGS_REQ(1));
mrb_define_method(mrb, mrb->kernel_module, "analogReference", mrb_kernel_analogReference, MRB_ARGS_REQ(1));
mrb_define_method(mrb, mrb->kernel_module, "analogRead", mrb_kernel_analogRead, MRB_ARGS_REQ(1));
mrb_define_method(mrb, mrb->kernel_module, "tone", mrb_kernel_tone, MRB_ARGS_REQ(2)|MRB_ARGS_OPT(1));
mrb_define_method(mrb, mrb->kernel_module, "noTone", mrb_kernel_noTone, MRB_ARGS_REQ(1));
//mrb_define_method(mrb, mrb->kernel_module, "pwmHz", mrb_kernel_pwmHz, MRB_ARGS_REQ(1));
mrb_define_method(mrb, mrb->kernel_module, "initDac", mrb_kernel_initDac, MRB_ARGS_NONE());
mrb_define_method(mrb, mrb->kernel_module, "analogDac", mrb_kernel_analogDac, MRB_ARGS_REQ(1));
mrb_define_method(mrb, mrb->kernel_module, "delay", mrb_kernel_delay, MRB_ARGS_REQ(1));
mrb_define_method(mrb, mrb->kernel_module, "millis", mrb_kernel_millis, MRB_ARGS_NONE());
mrb_define_method(mrb, mrb->kernel_module, "micros", mrb_kernel_micros, MRB_ARGS_NONE());
mrb_define_method(mrb, mrb->kernel_module, "led", mrb_kernel_led, MRB_ARGS_REQ(1));
mrb_define_method(mrb, mrb->kernel_module, "randomSeed", mrb_kernel_randomSeed, MRB_ARGS_REQ(1));
mrb_define_method(mrb, mrb->kernel_module, "random", mrb_kernel_random, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
struct RClass *El_PsyModule = mrb_define_module(mrb, "El_Psy");
mrb_define_module_function(mrb, El_PsyModule, "Congroo", mrb_El_Psy_congroo, MRB_ARGS_NONE());
}
void
mrb_init_kernel(mrb_state *mrb)
{
struct RClass *krn;
krn = mrb->kernel_module = mrb_define_module(mrb, "Kernel");
mrb_define_class_method(mrb, krn, "block_given?", mrb_f_block_given_p_m, ARGS_NONE()); /* 15.3.1.2.2 */
mrb_define_class_method(mrb, krn, "global_variables", mrb_f_global_variables, ARGS_NONE()); /* 15.3.1.2.4 */
mrb_define_class_method(mrb, krn, "iterator?", mrb_f_block_given_p_m, ARGS_NONE()); /* 15.3.1.2.5 */
; /* 15.3.1.2.11 */
mrb_define_class_method(mrb, krn, "raise", mrb_f_raise, ARGS_ANY()); /* 15.3.1.2.12 */
mrb_define_method(mrb, krn, "singleton_class", mrb_singleton_class, ARGS_NONE());
mrb_define_method(mrb, krn, "==", mrb_obj_equal_m, ARGS_REQ(1)); /* 15.3.1.3.1 */
mrb_define_method(mrb, krn, "!=", mrb_obj_not_equal_m, ARGS_REQ(1));
mrb_define_method(mrb, krn, "===", mrb_equal_m, ARGS_REQ(1)); /* 15.3.1.3.2 */
mrb_define_method(mrb, krn, "__id__", mrb_obj_id_m, ARGS_NONE()); /* 15.3.1.3.3 */
mrb_define_method(mrb, krn, "__send__", mrb_f_send, ARGS_ANY()); /* 15.3.1.3.4 */
mrb_define_method(mrb, krn, "block_given?", mrb_f_block_given_p_m, ARGS_NONE()); /* 15.3.1.3.6 */
mrb_define_method(mrb, krn, "class", mrb_obj_class_m, ARGS_NONE()); /* 15.3.1.3.7 */
mrb_define_method(mrb, krn, "clone", mrb_obj_clone, ARGS_NONE()); /* 15.3.1.3.8 */
mrb_define_method(mrb, krn, "dup", mrb_obj_dup, ARGS_NONE()); /* 15.3.1.3.9 */
mrb_define_method(mrb, krn, "eql?", mrb_obj_equal_m, ARGS_REQ(1)); /* 15.3.1.3.10 */
mrb_define_method(mrb, krn, "equal?", mrb_obj_equal_m, ARGS_REQ(1)); /* 15.3.1.3.11 */
mrb_define_method(mrb, krn, "extend", mrb_obj_extend_m, ARGS_ANY()); /* 15.3.1.3.13 */
mrb_define_method(mrb, krn, "global_variables", mrb_f_global_variables, ARGS_NONE()); /* 15.3.1.3.14 */
mrb_define_method(mrb, krn, "hash", mrb_obj_hash, ARGS_NONE()); /* 15.3.1.3.15 */
mrb_define_method(mrb, krn, "initialize_copy", mrb_obj_init_copy, ARGS_REQ(1)); /* 15.3.1.3.16 */
mrb_define_method(mrb, krn, "inspect", mrb_obj_inspect, ARGS_NONE()); /* 15.3.1.3.17 */
mrb_define_method(mrb, krn, "instance_eval", mrb_obj_instance_eval, ARGS_ANY()); /* 15.3.1.3.18 */
mrb_define_method(mrb, krn, "instance_of?", obj_is_instance_of, ARGS_REQ(1)); /* 15.3.1.3.19 */
mrb_define_method(mrb, krn, "instance_variable_defined?", mrb_obj_ivar_defined, ARGS_REQ(1)); /* 15.3.1.3.20 */
mrb_define_method(mrb, krn, "instance_variable_get", mrb_obj_ivar_get, ARGS_REQ(1)); /* 15.3.1.3.21 */
mrb_define_method(mrb, krn, "instance_variable_set", mrb_obj_ivar_set, ARGS_REQ(2)); /* 15.3.1.3.22 */
mrb_define_method(mrb, krn, "instance_variables", mrb_obj_instance_variables, ARGS_NONE()); /* 15.3.1.3.23 */
mrb_define_method(mrb, krn, "is_a?", mrb_obj_is_kind_of_m, ARGS_REQ(1)); /* 15.3.1.3.24 */
mrb_define_method(mrb, krn, "iterator?", mrb_f_block_given_p_m, ARGS_NONE()); /* 15.3.1.3.25 */
mrb_define_method(mrb, krn, "kind_of?", mrb_obj_is_kind_of_m, ARGS_REQ(1)); /* 15.3.1.3.26 */
mrb_define_method(mrb, krn, "methods", mrb_obj_methods_m, ARGS_ANY()); /* 15.3.1.3.31 */
mrb_define_method(mrb, krn, "nil?", mrb_false, ARGS_NONE()); /* 15.3.1.3.32 */
mrb_define_method(mrb, krn, "object_id", mrb_obj_id_m, ARGS_NONE()); /* 15.3.1.3.33 */
mrb_define_method(mrb, krn, "private_methods", mrb_obj_private_methods, ARGS_ANY()); /* 15.3.1.3.36 */
mrb_define_method(mrb, krn, "protected_methods", mrb_obj_protected_methods, ARGS_ANY()); /* 15.3.1.3.37 */
mrb_define_method(mrb, krn, "public_methods", mrb_obj_public_methods, ARGS_ANY()); /* 15.3.1.3.38 */
mrb_define_method(mrb, krn, "raise", mrb_f_raise, ARGS_ANY()); /* 15.3.1.3.40 */
mrb_define_method(mrb, krn, "remove_instance_variable", mrb_obj_remove_instance_variable,ARGS_REQ(1)); /* 15.3.1.3.41 */
mrb_define_method(mrb, krn, "respond_to?", obj_respond_to, ARGS_ANY()); /* 15.3.1.3.43 */
mrb_define_method(mrb, krn, "send", mrb_f_send, ARGS_ANY()); /* 15.3.1.3.44 */
mrb_define_method(mrb, krn, "__send__", mrb_f_send, ARGS_ANY()); /* 15.3.1.3.4 */
mrb_define_method(mrb, krn, "singleton_methods", mrb_obj_singleton_methods_m, ARGS_ANY()); /* 15.3.1.3.45 */
mrb_define_method(mrb, krn, "to_s", mrb_any_to_s, ARGS_NONE()); /* 15.3.1.3.46 */
#ifdef ENABLE_SPRINTF
mrb_define_method(mrb, krn, "sprintf", mrb_f_sprintf, ARGS_ANY()); /* in sprintf.c */
mrb_define_method(mrb, krn, "format", mrb_f_sprintf, ARGS_ANY()); /* in sprintf.c */
#endif
mrb_include_module(mrb, mrb->object_class, mrb->kernel_module);
}
void
mrb_mruby_signal_gem_init(mrb_state* mrb) {
struct RClass *signal = mrb_define_module(mrb, "Signal");
mrb_obj_iv_set(mrb, (struct RObject *)signal, mrb_intern_lit(mrb, "trap_list"), mrb_ary_new_capa(mrb, NSIG));
mrb_define_class_method(mrb, signal, "trap", signal_trap, MRB_ARGS_ANY());
mrb_define_class_method(mrb, signal, "list", signal_list, MRB_ARGS_NONE());
mrb_define_class_method(mrb, signal, "signame", signal_signame, MRB_ARGS_REQ(1));
mrb_define_method(mrb, mrb->kernel_module, "trap", signal_trap, MRB_ARGS_ANY());
install_sighandler(mrb, SIGINT, sighandler);
#ifdef SIGHUP
install_sighandler(mrb, SIGHUP, sighandler);
#endif
#ifdef SIGQUIT
install_sighandler(mrb, SIGQUIT, sighandler);
#endif
#ifdef SIGTERM
install_sighandler(mrb, SIGTERM, sighandler);
#endif
#ifdef SIGALRM
install_sighandler(mrb, SIGALRM, sighandler);
#endif
#ifdef SIGUSR1
install_sighandler(mrb, SIGUSR1, sighandler);
#endif
#ifdef SIGUSR2
install_sighandler(mrb, SIGUSR2, sighandler);
#endif
}
void
mrb_mruby_tls_openssl_gem_test(mrb_state *mrb)
{
struct RClass *c = mrb_define_module(mrb, "OpenSSLTest");
mrb_define_class_method(mrb, c, "match_dns_id", mrb_tls_openssl_test_match_dns_id, MRB_ARGS_REQ(2));
}
void
mrb_mruby_dir_gem_init(mrb_state* mrb) {
mrb_dir_class = mrb_define_module(mrb, "Dir");
mrb_define_module_function(mrb, mrb_dir_class, "entries", mrb_dir_entries, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_dir_class, "exists?", mrb_dir_exists, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_dir_class, "exist?", mrb_dir_exists, MRB_ARGS_REQ(1));
}
void mrb_mruby_sleep_gem_init(mrb_state *mrb)
{
struct RClass *sleep;
sleep = mrb_define_module(mrb, "Sleep");
mrb_define_class_method(mrb, sleep, "sleep", mrb_f_sleep, ARGS_ANY());
}
void register_all_cocos2dx_experimental_video(mrb_state* mrb)
{
struct RClass* rmodule = mrb_define_module(mrb, "CCExp");
ruby_register_cocos2dx_experimental_video_VideoPlayer(mrb, rmodule);
register_all_cocos2dx_experimental_video_enums(mrb);
}
void mrb_haconiwa_gem_init(mrb_state *mrb)
{
struct RClass *haconiwa;
haconiwa = mrb_define_module(mrb, "Haconiwa");
mrb_define_class_method(mrb, haconiwa, "mrbgem_revisions", mrb_haconiwa_mrgbem_revisions, MRB_ARGS_NONE());
DONE;
}
void
mrb_plt_init(plt_state * plt)
{
plt->plotter_module = mrb_define_module(plt->mrb, "Plotter");
mrb_plt_vector_init(plt);
}
void
mrb_mruby_digest_gem_init(mrb_state *mrb)
{
struct RClass *b, *d, *h;
lib_init();
d = mrb_define_module(mrb, "Digest");
b = mrb_define_class_under(mrb, d, "Base", mrb->object_class);
mrb_define_method(mrb, b, "block_length", mrb_digest_block_length, MRB_ARGS_NONE());
mrb_define_method(mrb, b, "digest", mrb_digest_digest, MRB_ARGS_NONE());
mrb_define_method(mrb, b, "digest!", mrb_digest_digest_bang, MRB_ARGS_NONE()); /* XXX: can be defined in mrblib... */
mrb_define_method(mrb, b, "digest_length", mrb_digest_digest_length, MRB_ARGS_NONE());
//mrb_define_method(mrb, b, "file", mrb_digest_file, MRB_ARGS_REQ(1));
mrb_define_method(mrb, b, "hexdigest", mrb_digest_hexdigest, MRB_ARGS_NONE());
//mrb_define_method(mrb, b, "hexdigest!", mrb_digest_hexdigest_bang, MRB_ARGS_NONE()); /* XXX: can be defined in mrblib... */
mrb_define_method(mrb, b, "initialize", mrb_digest_init, MRB_ARGS_NONE());
mrb_define_method(mrb, b, "initialize_copy", mrb_digest_init_copy, MRB_ARGS_REQ(1));
mrb_define_method(mrb, b, "reset", mrb_digest_reset, MRB_ARGS_NONE());
mrb_define_method(mrb, b, "update", mrb_digest_update, MRB_ARGS_REQ(1));
#define DEFCLASS(n) \
do { \
struct RClass *a = mrb_define_class_under(mrb, d, #n, b); \
MRB_SET_INSTANCE_TT(a, MRB_TT_DATA); \
mrb_define_const(mrb, a, TYPESYM, mrb_fixnum_value(MD_TYPE_##n)); \
} while (0)
#ifdef HAVE_MD5
DEFCLASS(MD5);
#endif
#ifdef HAVE_RMD160
DEFCLASS(RMD160);
#endif
#ifdef HAVE_SHA1
DEFCLASS(SHA1);
#endif
#ifdef HAVE_SHA256
DEFCLASS(SHA256);
#endif
#ifdef HAVE_SHA384
DEFCLASS(SHA384);
#endif
#ifdef HAVE_SHA512
DEFCLASS(SHA512);
#endif
h = mrb_define_class_under(mrb, d, "HMAC", mrb->object_class);
MRB_SET_INSTANCE_TT(h, MRB_TT_DATA);
mrb_define_method(mrb, h, "block_length", mrb_hmac_block_length, MRB_ARGS_NONE());
mrb_define_method(mrb, h, "digest", mrb_hmac_digest, MRB_ARGS_NONE());
mrb_define_method(mrb, h, "digest_length", mrb_hmac_digest_length, MRB_ARGS_NONE());
mrb_define_method(mrb, h, "hexdigest", mrb_hmac_hexdigest, MRB_ARGS_NONE());
mrb_define_method(mrb, h, "initialize", mrb_hmac_init, MRB_ARGS_REQ(2));
mrb_define_method(mrb, h, "initialize_copy", mrb_hmac_init_copy, MRB_ARGS_REQ(1));
mrb_define_method(mrb, h, "update", mrb_hmac_update, MRB_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
#ifdef MRB_USE_FLOAT
mrb_define_const(mrb, mrb_math, "TOLERANCE", mrb_float_value(mrb, 1e-5));
#else
mrb_define_const(mrb, mrb_math, "TOLERANCE", mrb_float_value(mrb, 1e-12));
#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_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_lz4_gem_init(mrb_state* mrb) {
struct RClass *LZ4_mod;
LZ4_mod = mrb_define_module(mrb, "LZ4");
mrb_define_class_under(mrb, LZ4_mod, "Error", E_RUNTIME_ERROR);
mrb_define_module_function(mrb, LZ4_mod, "compress_default", mrb_LZ4_compress_default, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, LZ4_mod, "decompress_safe", mrb_LZ4_decompress_safe, MRB_ARGS_REQ(2));
}
void mrb_mruby_random_gem_init(mrb_state *mrb)
{
struct RClass *random;
random = mrb_define_module(mrb, "Random");
mrb_define_class_method(mrb, random, "rand", mrb_random_rand, ARGS_ANY());
mrb_define_class_method(mrb, random, "srand", mrb_random_srand, ARGS_ANY());
}
/* ------------------------------------------------------------------------*/
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));
}
static void
grn_ctx_impl_mrb_init_bindings(grn_ctx *ctx)
{
mrb_state *mrb = ctx->impl->mrb.state;
mrb->ud = ctx;
ctx->impl->mrb.module = mrb_define_module(mrb, "Groonga");
mrb_define_class_method(mrb, ctx->impl->mrb.module,
"init", mrb_groonga_init, MRB_ARGS_NONE());
mrb_funcall(mrb, mrb_obj_value(ctx->impl->mrb.module), "init", 0);
}
void
mrb_mruby_io_gem_test(mrb_state* mrb)
{
struct RClass *io_test = mrb_define_module(mrb, "MRubyIOTestUtil");
mrb_define_class_method(mrb, io_test, "io_test_setup", mrb_io_test_io_setup, MRB_ARGS_NONE());
mrb_define_class_method(mrb, io_test, "io_test_cleanup", mrb_io_test_io_cleanup, MRB_ARGS_NONE());
mrb_define_class_method(mrb, io_test, "file_test_setup", mrb_io_test_file_setup, MRB_ARGS_NONE());
mrb_define_class_method(mrb, io_test, "file_test_cleanup", mrb_io_test_file_cleanup, MRB_ARGS_NONE());
}
void mrb_mruby_sleep_gem_init(mrb_state *mrb)
{
struct RClass *sleep;
sleep = mrb_define_module(mrb, "Sleep");
mrb_define_class_method(mrb, sleep, "sleep", mrb_f_sleep_sleep, ARGS_REQ(1));
mrb_define_class_method(mrb, sleep, "usleep", mrb_f_usleep_usleep, ARGS_REQ(1));
mrb_define_method(mrb, mrb->kernel_module, "sleep", mrb_f_sleep_sleep, ARGS_REQ(1));
mrb_define_method(mrb, mrb->kernel_module, "usleep", mrb_f_usleep_usleep, ARGS_REQ(1));
}
void
mrb_init_gc(mrb_state *mrb)
{
struct RClass *gc;
gc = mrb_define_module(mrb, "GC");
mrb_define_class_method(mrb, gc, "start", gc_start, ARGS_NONE());
mrb_define_class_method(mrb, gc, "interval_ratio", gc_interval_ratio_get, ARGS_NONE());
mrb_define_class_method(mrb, gc, "interval_ratio=", gc_interval_ratio_set, ARGS_REQ(1));
mrb_define_class_method(mrb, gc, "step_ratio", gc_step_ratio_get, ARGS_NONE());
mrb_define_class_method(mrb, gc, "step_ratio=", gc_step_ratio_set, ARGS_REQ(1));
}
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
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));
}
