void mrb_SDL_NSWindow_init(mrb_state* mrb) { RClass* NSWindow_class = mrb_define_class_under(mrb, SDL_module(mrb), "NSWindow", mrb->object_class); MRB_SET_INSTANCE_TT(NSWindow_class, MRB_TT_DATA); #if BIND_NSWindow_INITIALIZE mrb_define_method(mrb, NSWindow_class, "initialize", mrb_SDL_NSWindow_initialize, MRB_ARGS_NONE()); #endif mrb_define_class_method(mrb, NSWindow_class, "disown", mrb_SDL_NSWindow_disown, MRB_ARGS_ARG(1, 0)); mrb_define_class_method(mrb, NSWindow_class, "belongs_to_ruby?", mrb_SDL_NSWindow_belongs_to_ruby, MRB_ARGS_ARG(1, 0)); }
void ofRuby3DPrimitive::setup(mrb_state *mrb, RClass *klass) { mrb_define_method(mrb, klass, "initialize", init, MRB_ARGS_NONE()); mrb_define_method(mrb, klass, "draw", draw, MRB_ARGS_OPT(1)); mrb_define_method(mrb, klass, "move", move, MRB_ARGS_REQ(1)); mrb_define_method(mrb, klass, "x", getX, MRB_ARGS_NONE()); mrb_define_method(mrb, klass, "y", getX, MRB_ARGS_NONE()); mrb_define_method(mrb, klass, "z", getX, MRB_ARGS_NONE()); mrb_define_method(mrb, klass, "position=", setPosition, MRB_ARGS_REQ(1)); }
void grn_mrb_procedure_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, "Procedure", object_class); MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); mrb_define_method(mrb, klass, "initialize", mrb_grn_procedure_initialize, MRB_ARGS_REQ(1)); mrb_define_method(mrb, klass, "selector?", mrb_grn_procedure_selector_p, MRB_ARGS_NONE()); mrb_define_method(mrb, klass, "selector_only?", mrb_grn_procedure_selector_only_p, MRB_ARGS_NONE()); mrb_define_method(mrb, klass, "scorer?", mrb_grn_procedure_scorer_p, MRB_ARGS_NONE()); }
void init_cfunc_closure(mrb_state *mrb, struct RClass* module) { struct cfunc_state *state = cfunc_state(mrb, module); struct RClass *closure_class = mrb_define_class_under(mrb, module, "Closure", state->pointer_class); state->closure_class = closure_class; mrb_value ffi_type = mrb_obj_value(Data_Wrap_Struct(mrb, mrb->object_class, &cfunc_closure_ffi_type_data_type, &closure_mrb_ffi_type)); mrb_obj_iv_set(mrb, (struct RObject*)closure_class, mrb_intern_cstr(mrb, "@ffi_type"), ffi_type); mrb_define_method(mrb, closure_class, "initialize", cfunc_closure_initialize, ARGS_ANY()); }
void mrb_mruby_string_ext_gem_init(mrb_state* mrb) { struct RClass * s = mrb->string_class; mrb_define_method(mrb, s, "dump", mrb_str_dump, MRB_ARGS_NONE()); mrb_define_method(mrb, s, "getbyte", mrb_str_getbyte, MRB_ARGS_REQ(1)); mrb_define_method(mrb, s, "swapcase!", mrb_str_swapcase_bang, MRB_ARGS_NONE()); mrb_define_method(mrb, s, "swapcase", mrb_str_swapcase, MRB_ARGS_NONE()); mrb_define_method(mrb, s, "concat", mrb_str_concat2, MRB_ARGS_REQ(1)); mrb_define_method(mrb, s, "<<", mrb_str_concat2, MRB_ARGS_REQ(1)); mrb_define_method(mrb, s, "start_with?", mrb_str_start_with, MRB_ARGS_REST()); mrb_define_method(mrb, s, "end_with?", mrb_str_end_with, MRB_ARGS_REST()); }
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_file(mrb_state *mrb) { struct RClass *io, *file, *cnst; io = mrb_class_get(mrb, "IO"); file = mrb_define_class(mrb, "File", io); MRB_SET_INSTANCE_TT(file, MRB_TT_DATA); mrb_define_class_method(mrb, file, "umask", mrb_file_s_umask, MRB_ARGS_REQ(1)); mrb_define_class_method(mrb, file, "delete", mrb_file_s_unlink, MRB_ARGS_ANY()); mrb_define_class_method(mrb, file, "unlink", mrb_file_s_unlink, MRB_ARGS_ANY()); mrb_define_class_method(mrb, file, "rename", mrb_file_s_rename, MRB_ARGS_REQ(2)); mrb_define_class_method(mrb, file, "symlink", mrb_file_s_symlink, MRB_ARGS_REQ(2)); mrb_define_class_method(mrb, file, "chmod", mrb_file_s_chmod, MRB_ARGS_REQ(1) | MRB_ARGS_REST()); mrb_define_class_method(mrb, file, "readlink", mrb_file_s_readlink, MRB_ARGS_REQ(1)); mrb_define_class_method(mrb, file, "dirname", mrb_file_dirname, MRB_ARGS_REQ(1)); mrb_define_class_method(mrb, file, "basename", mrb_file_basename, MRB_ARGS_REQ(1)); mrb_define_class_method(mrb, file, "realpath", mrb_file_realpath, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1)); mrb_define_class_method(mrb, file, "_getwd", mrb_file__getwd, MRB_ARGS_NONE()); mrb_define_class_method(mrb, file, "_gethome", mrb_file__gethome, MRB_ARGS_OPT(1)); mrb_define_method(mrb, file, "flock", mrb_file_flock, MRB_ARGS_REQ(1)); mrb_define_method(mrb, file, "mtime", mrb_file_mtime, MRB_ARGS_NONE()); cnst = mrb_define_module_under(mrb, file, "Constants"); mrb_define_const(mrb, cnst, "LOCK_SH", mrb_fixnum_value(LOCK_SH)); mrb_define_const(mrb, cnst, "LOCK_EX", mrb_fixnum_value(LOCK_EX)); mrb_define_const(mrb, cnst, "LOCK_UN", mrb_fixnum_value(LOCK_UN)); mrb_define_const(mrb, cnst, "LOCK_NB", mrb_fixnum_value(LOCK_NB)); mrb_define_const(mrb, cnst, "SEPARATOR", mrb_str_new_cstr(mrb, FILE_SEPARATOR)); mrb_define_const(mrb, cnst, "PATH_SEPARATOR", mrb_str_new_cstr(mrb, PATH_SEPARATOR)); #if defined(_WIN32) || defined(_WIN64) mrb_define_const(mrb, cnst, "ALT_SEPARATOR", mrb_str_new_cstr(mrb, FILE_ALT_SEPARATOR)); #else mrb_define_const(mrb, cnst, "ALT_SEPARATOR", mrb_nil_value()); #endif mrb_define_const(mrb, cnst, "NULL", mrb_str_new_cstr(mrb, NULL_FILE)); }
void grn_mrb_cache_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, "Cache", mrb->object_class); MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); mrb_define_class_method(mrb, klass, "current", mrb_grn_cache_class_current, MRB_ARGS_NONE()); mrb_define_method(mrb, klass, "initialize", mrb_grn_cache_initialize, MRB_ARGS_REQ(1)); mrb_define_method(mrb, klass, "fetch", mrb_grn_cache_fetch, MRB_ARGS_REQ(1)); mrb_define_method(mrb, klass, "update", mrb_grn_cache_update, MRB_ARGS_REQ(2)); }
void mrb_vmod_class_define(mrb_state *mrb) { struct RClass *varnish; varnish = mrb_define_class(mrb, "Varnish", mrb->object_class); mrb_define_method(mrb, varnish, "initialize", mrb_vmod_init, MRB_ARGS_NONE() ); mrb_vmod_action_define(mrb); mrb_vmod_fetch_define(mrb); mrb_vmod_recv_define(mrb); mrb_vmod_deliver_define(mrb); mrb_vmod_backend_define(mrb); }
void planeBindingInit(mrb_state *mrb) { RClass *klass = defineClass(mrb, "Plane"); disposableBindingInit<Plane> (mrb, klass); viewportElementBindingInit<Plane>(mrb, klass); mrb_define_method(mrb, klass, "initialize", planeInitialize, MRB_ARGS_OPT(1)); INIT_PROP_BIND( Plane, Bitmap, "bitmap" ); INIT_PROP_BIND( Plane, OX, "ox" ); INIT_PROP_BIND( Plane, OY, "oy" ); INIT_PROP_BIND( Plane, ZoomX, "zoom_x" ); INIT_PROP_BIND( Plane, ZoomY, "zoom_y" ); INIT_PROP_BIND( Plane, Opacity, "opacity" ); INIT_PROP_BIND( Plane, BlendType, "blend_type" ); INIT_PROP_BIND( Plane, Color, "color" ); INIT_PROP_BIND( Plane, Tone, "tone" ); mrb_define_method(mrb, klass, "inspect", inspectObject, MRB_ARGS_NONE()); }
void mrb_init_core(mrb_state *mrb) { mrb_init_symtbl(mrb); mrb_init_class(mrb); mrb_init_object(mrb); mrb_init_kernel(mrb); mrb_init_comparable(mrb); mrb_init_enumerable(mrb); mrb_init_symbols(mrb); mrb_init_proc(mrb); mrb_init_string(mrb); Init_version(mrb); /* after init_string */ mrb_init_array(mrb); mrb_init_hash(mrb); mrb_init_numeric(mrb); mrb_init_range(mrb); mrb_init_struct(mrb); mrb_init_gc(mrb); #ifdef INCLUDE_REGEXP mrb_init_regexp(mrb); mrb_init_encoding(mrb); #endif mrb_init_exception(mrb); mrb_init_print(mrb); mrb_init_time(mrb); #ifdef MANDEL mrb_define_method(mrb, mrb->kernel_module, "pow", mpow, ARGS_REQ(2)); mrb_define_method(mrb, mrb->kernel_module, "sqrt", msqrt, ARGS_REQ(1)); mrb_define_method(mrb, mrb->kernel_module, "putc", mputc, ARGS_REQ(1)); #endif mrb_init_mrblib(mrb); mrb_gc_arena_restore(mrb, 0); }
void grn_mrb_void_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, "Void", mrb->object_class); MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); mrb_define_method(mrb, klass, "initialize", mrb_grn_void_initialize, MRB_ARGS_REQ(1)); }
void mrb_setup_arduino() { mrb = mrb_open(); if (mrb == NULL) Serial.println("Invalid mrb interpreter, IAS won't work!"); else print_hint(); cxt = mrbc_context_new(mrb); cxt->capture_errors = 1; ai = mrb_gc_arena_save(mrb); krn = mrb->kernel_module; mrb_define_method(mrb, krn, "p", my_p, MRB_ARGS_REQ(1)); mrb_define_method(mrb, krn, "print", my_print, MRB_ARGS_REQ(1)); mrb_define_method(mrb, krn, "puts", my_puts, MRB_ARGS_REQ(1)); led = mrb_define_class(mrb, "Led", mrb->object_class); mrb_define_class_method(mrb, led, "high!", mrb_led_high, MRB_ARGS_NONE()); mrb_define_class_method(mrb, led, "low!", mrb_led_low, MRB_ARGS_NONE()); mrb_define_class_method(mrb, led, "blink", mrb_led_blink, MRB_ARGS_NONE()); }
void init_cfunc_rubyvm(mrb_state *mrb, struct RClass* module, void (*mrb_state_init)(mrb_state*)) { cfunc_state(mrb)->mrb_state_init = mrb_state_init; struct RClass *rubyvm_class = mrb_define_class_under(mrb, module, "RubyVM", mrb->object_class); cfunc_state(mrb)->rubyvm_class = rubyvm_class; mrb_define_class_method(mrb, rubyvm_class, "thread", cfunc_rubyvm_class_thread, ARGS_REQ(1)); mrb_define_method(mrb, rubyvm_class, "dispatch", cfunc_rubyvm_dispatch, ARGS_ANY()); struct RClass *rubyvm_task_class = mrb_define_class_under(mrb, cfunc_state(mrb)->rubyvm_class, "Task", mrb->object_class); cfunc_state(mrb)->rubyvm_task_class = rubyvm_task_class; mrb_define_method(mrb, rubyvm_task_class, "wait", cfunc_rubyvm_task_wait, ARGS_NONE()); mrb_define_method(mrb, rubyvm_task_class, "result", cfunc_rubyvm_task_result, ARGS_NONE()); mrb_define_method(mrb, rubyvm_task_class, "status", cfunc_rubyvm_task_status, ARGS_NONE()); mrb_define_const(mrb, rubyvm_task_class, "QUEUED", mrb_fixnum_value(queue_task_queued)); mrb_define_const(mrb, rubyvm_task_class, "RUNNING", mrb_fixnum_value(queue_task_running)); mrb_define_const(mrb, rubyvm_task_class, "FINISHED", mrb_fixnum_value(queue_task_finished)); }
void mrb_mruby_kernel_ext_gem_init(mrb_state *mrb) { struct RClass *krn = mrb->kernel_module; mrb_define_module_function(mrb, krn, "fail", mrb_f_raise, MRB_ARGS_OPT(2)); mrb_define_method(mrb, krn, "__method__", mrb_f_method, MRB_ARGS_NONE()); mrb_define_module_function(mrb, krn, "Integer", mrb_f_integer, MRB_ARGS_ANY()); mrb_define_module_function(mrb, krn, "Float", mrb_f_float, MRB_ARGS_REQ(1)); mrb_define_module_function(mrb, krn, "String", mrb_f_string, MRB_ARGS_REQ(1)); mrb_define_module_function(mrb, krn, "Array", mrb_f_array, MRB_ARGS_REQ(1)); mrb_define_module_function(mrb, krn, "Hash", mrb_f_hash, MRB_ARGS_REQ(1)); }
void grn_mrb_eval_context_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, "EvalContext", mrb->object_class); mrb_define_method(mrb, klass, "compile", eval_context_compile, MRB_ARGS_REQ(1)); }
void mrb_pp_graphics_2d_init(mrb_state *mrb) { mrb_pp_graphics_2d_class = mrb_define_class_under(mrb, mrb_pp_module, "Graphics2D", mrb_pp_resource_class); MRB_SET_INSTANCE_TT(mrb_pp_graphics_2d_class, MRB_TT_DATA); mrb_define_method(mrb, mrb_pp_graphics_2d_class, "initialize", initialize, MRB_ARGS_REQ(3)); mrb_define_method(mrb, mrb_pp_graphics_2d_class, "size", size, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb_pp_graphics_2d_class, "paint_image_data", paint_image_data, MRB_ARGS_ARG(2,1)); mrb_define_method(mrb, mrb_pp_graphics_2d_class, "scroll", scroll, MRB_ARGS_REQ(2)); mrb_define_method(mrb, mrb_pp_graphics_2d_class, "replace_contents", replace_contents, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mrb_pp_graphics_2d_class, "flush", flush, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mrb_pp_graphics_2d_class, "set_scale", set_scale, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mrb_pp_graphics_2d_class, "get_scale", get_scale, MRB_ARGS_NONE()); }
void h2o_mruby_send_chunked_init_context(h2o_mruby_shared_context_t *shared_ctx) { mrb_state *mrb = shared_ctx->mrb; h2o_mruby_eval_expr_location(mrb, H2O_MRUBY_CODE_CHUNKED, "(h2o)lib/handler/mruby/embedded/chunked.rb", 1); h2o_mruby_assert(mrb); mrb_define_method(mrb, mrb->kernel_module, "_h2o_send_chunk", send_chunked_method, MRB_ARGS_ARG(1, 0)); h2o_mruby_define_callback(mrb, "_h2o_send_chunk_eos", send_chunked_eos_callback); mrb_ary_set(mrb, shared_ctx->constants, H2O_MRUBY_CHUNKED_PROC_EACH_TO_FIBER, mrb_funcall(mrb, mrb_top_self(mrb), "_h2o_chunked_proc_each_to_fiber", 0)); h2o_mruby_assert(mrb); }
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 }; *call_irep = mrb_irep_zero; call_irep->flags = MRB_ISEQ_NO_FREE; call_irep->iseq = call_iseq; call_irep->ilen = 1; mrb_define_class_method(mrb, mrb->proc_class, "new", mrb_proc_s_new, MRB_ARGS_ANY()); 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_task_gem_init(mrb_state* mrb) { struct RClass * ev3rt_class = mrb_class_get(mrb, "EV3RT"); struct RClass * task_class = mrb_define_class_under(mrb, ev3rt_class, "Task", mrb->object_class); mrb_define_method(mrb, task_class, "initialize", mrb_mruby_task_initialize, MRB_ARGS_NONE()); mrb_define_class_method(mrb, task_class, "sleep", mrb_mruby_task_sleep, MRB_ARGS_REQ(1)); mrb_define_class_method(mrb, task_class, "wakeup", mrb_mruby_task_wake_up, MRB_ARGS_REQ(1)); mrb_define_class_method(mrb, task_class, "active", mrb_mruby_task_active, MRB_ARGS_REQ(1)); mrb_define_class_method(mrb, task_class, "exit", mrb_mruby_task_exit, MRB_ARGS_NONE()); mrb_define_class_method(mrb, task_class, "start_cyclic", mrb_mruby_task_start_cyclic, MRB_ARGS_REQ(1)); mrb_define_class_method(mrb, task_class, "stop_cyclic", mrb_mruby_task_stop_cyclic, MRB_ARGS_REQ(1)); }
void mruby_allegro_config_init(mrb_state *mrb) { struct RClass *am = M_ALLEGRO; struct RClass *cc = mrb_define_class_under(mrb, am, "Config", mrb->object_class); MRB_SET_INSTANCE_TT(cc, MRB_TT_DATA); mrb_define_class_method(mrb, cc, "create", config_create, MRB_ARGS_NONE()); mrb_define_alias(mrb, cc->c, "new", "create"); mrb_define_method(mrb, cc, "destroy", config_destroy, MRB_ARGS_NONE()); mrb_define_method(mrb, cc, "destroyed?", config_destroyed, MRB_ARGS_NONE()); mrb_define_class_method(mrb, cc, "load_file", config_load_file, MRB_ARGS_REQ(1)); mrb_define_method(mrb, cc, "save_file", config_save_file, MRB_ARGS_REQ(1)); mrb_define_method(mrb, cc, "add_section", config_add_section, MRB_ARGS_REQ(1)); mrb_define_method(mrb, cc, "add_comment", config_add_comment, MRB_ARGS_REQ(2)); mrb_define_method(mrb, cc, "get_value", config_get_value, MRB_ARGS_REQ(2)); mrb_define_method(mrb, cc, "set_value", config_set_value, MRB_ARGS_REQ(3)); mrb_define_method(mrb, cc, "merge", config_merge, MRB_ARGS_REQ(1)); mrb_define_method(mrb, cc, "merge_into", config_merge_into, MRB_ARGS_REQ(1)); mrb_define_alias(mrb, cc, "merge!", "merge_into"); }
//************************************************** // ライブラリを定義します //************************************************** void i2c_Init(mrb_state *mrb) { //0:Wire, 1:Wire1, 2:Wire2, 3:Wire3 4:Wire4 5:Wire5 RbWire[0] = &Wire; RbWire[1] = &Wire1; RbWire[2] = &Wire2; RbWire[3] = &Wire3; RbWire[4] = &Wire4; RbWire[5] = &Wire5; struct RClass *i2cModule = mrb_define_class(mrb, "I2c", mrb->object_class); MRB_SET_INSTANCE_TT(i2cModule, MRB_TT_DATA); mrb_define_method(mrb, i2cModule, "initialize", mrb_i2c_initialize, MRB_ARGS_REQ(1)); mrb_define_method(mrb, i2cModule, "write", mrb_i2c_write, MRB_ARGS_REQ(3)); mrb_define_method(mrb, i2cModule, "read", mrb_i2c_read, MRB_ARGS_REQ(2)|MRB_ARGS_OPT(1)); mrb_define_method(mrb, i2cModule, "begin", mrb_i2c_beginTransmission, MRB_ARGS_REQ(1)); mrb_define_method(mrb, i2cModule, "lwrite", mrb_i2c_lwrite, MRB_ARGS_REQ(1)); mrb_define_method(mrb, i2cModule, "end", mrb_i2c_endTransmission, MRB_ARGS_OPT(1)); mrb_define_method(mrb, i2cModule, "request", mrb_i2c_requestFrom, MRB_ARGS_REQ(2)); mrb_define_method(mrb, i2cModule, "lread", mrb_i2c_lread, MRB_ARGS_NONE()); mrb_define_method(mrb, i2cModule, "available", mrb_i2c_available, MRB_ARGS_NONE()); mrb_define_method(mrb, i2cModule, "frequency", mrb_i2c_frequency, MRB_ARGS_REQ(1)); }
void grn_mrb_index_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, "IndexCursor", mrb->object_class); MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); mrb_define_class_method(mrb, klass, "open_raw", mrb_grn_index_cursor_class_open_raw, MRB_ARGS_ARG(2, 1)); mrb_define_method(mrb, klass, "initialize", mrb_grn_index_cursor_initialize, MRB_ARGS_REQ(1)); mrb_define_method(mrb, klass, "close", mrb_grn_index_cursor_close, MRB_ARGS_NONE()); mrb_define_method(mrb, klass, "count", mrb_grn_index_cursor_count, MRB_ARGS_NONE()); mrb_define_method(mrb, klass, "select", mrb_grn_index_cursor_select, MRB_ARGS_ARG(1, 1)); }
void grn_mrb_variable_size_column_init(grn_ctx *ctx) { grn_mrb_data *data = &(ctx->impl->mrb); mrb_state *mrb = data->state; struct RClass *module = data->module; struct RClass *column_class; struct RClass *klass; column_class = mrb_class_get_under(mrb, module, "Column"); klass = mrb_define_class_under(mrb, module, "VariableSizeColumn", column_class); MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); mrb_define_method(mrb, klass, "initialize", mrb_grn_variable_size_column_initialize, MRB_ARGS_REQ(1)); }
void install(mrb_state* mrb) { struct RClass *tc = mrb_define_class(mrb, "World", mrb->object_class); MRB_SET_INSTANCE_TT(tc, MRB_TT_DATA); mrb_define_method(mrb, tc, "initialize", initialize, ARGS_NONE()); mrb_define_method(mrb, tc, "inspect", to_s, ARGS_NONE()); mrb_define_method(mrb, tc, "to_s", to_s, ARGS_NONE()); mrb_define_method(mrb, tc, "init", init, ARGS_NONE()); mrb_define_method(mrb, tc, "updateworld", updateworld, ARGS_NONE()); mrb_define_method(mrb, tc, "eraseobjects", eraseobjects, ARGS_NONE()); mrb_define_method(mrb, tc, "isobjectselected", isobjectselected, ARGS_NONE()); }
void mrb_cp_ratchet_joint_init(mrb_state *mrb, struct RClass *cp_module) { mrb_cp_ratchet_joint_class = mrb_define_class_under(mrb, cp_module, "RatchetJoint", mrb_cp_get_constraint_class()); MRB_SET_INSTANCE_TT(mrb_cp_ratchet_joint_class, MRB_TT_DATA); mrb_define_method(mrb, mrb_cp_ratchet_joint_class, "initialize", ratchet_joint_initialize, MRB_ARGS_REQ(4)); mrb_define_method(mrb, mrb_cp_ratchet_joint_class, "angle", ratchet_joint_get_angle, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb_cp_ratchet_joint_class, "angle=", ratchet_joint_set_angle, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mrb_cp_ratchet_joint_class, "phase", ratchet_joint_get_phase, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb_cp_ratchet_joint_class, "phase=", ratchet_joint_set_phase, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mrb_cp_ratchet_joint_class, "ratchet", ratchet_joint_get_ratchet, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb_cp_ratchet_joint_class, "ratchet=", ratchet_joint_set_ratchet, MRB_ARGS_REQ(1)); }
void mrb_init_exception(mrb_state *mrb) { struct RClass *e; struct RClass *eTypeError_class; struct RClass *eArgumentError_class; struct RClass *eIndexError_class; struct RClass *eRangeError_class; struct RClass *eNameError_class; struct RClass *eNoMethodError_class; struct RClass *eScriptError_class; struct RClass *eSyntaxError_class; struct RClass *eLoadError_class; struct RClass *eSystemCallError_class; struct RClass *eLocalJumpError_class; struct RClass *eRegexpError_class; struct RClass *eZeroDivisionError_class; struct RClass *eEncodingError_class; struct RClass *eNotImpError_class; struct RClass *eFloatDomainError_class; struct RClass *eKeyError_class; mrb->eException_class = e = mrb_define_class(mrb, "Exception", mrb->object_class); /* 15.2.22 */ mrb_define_class_method(mrb, e, "exception", mrb_instance_new, ARGS_ANY()); mrb_define_method(mrb, e, "exception", exc_exception, ARGS_ANY()); mrb_define_method(mrb, e, "initialize", exc_initialize, ARGS_ANY()); mrb_define_method(mrb, e, "==", exc_equal, ARGS_REQ(1)); mrb_define_method(mrb, e, "to_s", exc_to_s, ARGS_NONE()); mrb_define_method(mrb, e, "message", exc_message, ARGS_NONE()); mrb_define_method(mrb, e, "inspect", exc_inspect, ARGS_NONE()); mrb->eStandardError_class = mrb_define_class(mrb, "StandardError", mrb->eException_class); /* 15.2.23 */ mrb->eRuntimeError_class = mrb_define_class(mrb, "RuntimeError", mrb->eStandardError_class); /* 15.2.28 */ eTypeError_class = mrb_define_class(mrb, "TypeError", mrb->eStandardError_class); /* 15.2.29 */ eArgumentError_class = mrb_define_class(mrb, "ArgumentError", mrb->eStandardError_class); /* 15.2.24 */ eIndexError_class = mrb_define_class(mrb, "IndexError", mrb->eStandardError_class); /* 15.2.33 */ eRangeError_class = mrb_define_class(mrb, "RangeError", mrb->eStandardError_class); /* 15.2.26 */ eNameError_class = mrb_define_class(mrb, "NameError", mrb->eStandardError_class); /* 15.2.31 */ eNoMethodError_class = mrb_define_class(mrb, "NoMethodError", eNameError_class); /* 15.2.32 */ eScriptError_class = mrb_define_class(mrb, "ScriptError", mrb->eException_class); /* 15.2.37 */ eSyntaxError_class = mrb_define_class(mrb, "SyntaxError", eScriptError_class); /* 15.2.38 */ eLoadError_class = mrb_define_class(mrb, "LoadError", eScriptError_class); /* 15.2.39 */ eSystemCallError_class = mrb_define_class(mrb, "SystemCallError", mrb->eStandardError_class); /* 15.2.36 */ eLocalJumpError_class = mrb_define_class(mrb, "LocalJumpError", mrb->eStandardError_class); /* 15.2.25 */ eRegexpError_class = mrb_define_class(mrb, "RegexpError", mrb->eStandardError_class); /* 15.2.27 */ eZeroDivisionError_class = mrb_define_class(mrb, "ZeroDivisionError", mrb->eStandardError_class); /* 15.2.30 */ eEncodingError_class = mrb_define_class(mrb, "EncodingError", mrb->eStandardError_class); eNotImpError_class = mrb_define_class(mrb, "NotImplementedError", eScriptError_class); eFloatDomainError_class = mrb_define_class(mrb, "FloatDomainError", eRangeError_class); eKeyError_class = mrb_define_class(mrb, "KeyError", eIndexError_class); }
int main() { // Enable run-time memory check for debug builds. _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF); auto const mrb = mrb_open(); if(!mrb){ return -1; } mrb_define_method(mrb, mrb->kernel_module, "mytest", mytest, MRB_ARGS_NONE()); Exec(*mrb, "test.rb"); mrb_close(mrb); return 0; }
/* * A <code>Struct</code> is a convenient way to bundle a number of * attributes together, using accessor methods, without having to write * an explicit class. * * The <code>Struct</code> class is a generator of specific classes, * each one of which is defined to hold a set of variables and their * accessors. In these examples, we'll call the generated class * ``<i>Customer</i>Class,'' and we'll show an example instance of that * class as ``<i>Customer</i>Inst.'' * * In the descriptions that follow, the parameter <i>symbol</i> refers * to a symbol, which is either a quoted string or a * <code>Symbol</code> (such as <code>:name</code>). */ void mrb_mruby_struct_gem_init(mrb_state* mrb) { struct RClass *st; st = mrb_define_class(mrb, "Struct", mrb->object_class); mrb_define_class_method(mrb, st, "new", mrb_struct_s_def, MRB_ARGS_ANY()); /* 15.2.18.3.1 */ mrb_define_method(mrb, st, "==", mrb_struct_equal, MRB_ARGS_REQ(1)); /* 15.2.18.4.1 */ mrb_define_method(mrb, st, "[]", mrb_struct_aref, MRB_ARGS_REQ(1)); /* 15.2.18.4.2 */ mrb_define_method(mrb, st, "[]=", mrb_struct_aset, MRB_ARGS_REQ(2)); /* 15.2.18.4.3 */ mrb_define_method(mrb, st, "members", mrb_struct_members_m, MRB_ARGS_NONE()); /* 15.2.18.4.6 */ mrb_define_method(mrb, st, "initialize", mrb_struct_initialize_m,MRB_ARGS_ANY()); /* 15.2.18.4.8 */ mrb_define_method(mrb, st, "initialize_copy", mrb_struct_init_copy, MRB_ARGS_REQ(1)); /* 15.2.18.4.9 */ mrb_define_method(mrb, st, "inspect", mrb_struct_inspect, MRB_ARGS_NONE()); /* 15.2.18.4.10(x) */ mrb_define_alias(mrb, st, "to_s", "inspect"); /* 15.2.18.4.11(x) */ mrb_define_method(mrb, st, "eql?", mrb_struct_eql, MRB_ARGS_REQ(1)); /* 15.2.18.4.12(x) */ }
void init_mrb_sdl_event(mrb_state* mrb, struct RClass* mrb_sdl_class) { mrb_sdl_event_class = mrb_define_class_under(mrb, mrb_sdl_class, "Event", mrb->object_class); MRB_SET_INSTANCE_TT(mrb_sdl_event_class, MRB_TT_DATA); mrb_define_method(mrb, mrb_sdl_event_class, "key", mrb_sdl_event_key, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb_sdl_event_class, "resize_width", mrb_sdl_event_resize_width, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb_sdl_event_class, "resize_height", mrb_sdl_event_resize_height, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb_sdl_event_class, "mouse_button_x", mrb_sdl_event_mouse_button_x, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb_sdl_event_class, "mouse_button_y", mrb_sdl_event_mouse_button_y, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb_sdl_event_class, "text", mrb_sdl_event_text, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb_sdl_event_class, "type", mrb_sdl_event_type, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb_sdl_event_class, "inspect", mrb_sdl_event_inspect, MRB_ARGS_NONE()); }