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)); }