Example #1
0
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));
}
Example #3
0
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());
}
Example #4
0
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());
}
Example #5
0
File: string.c Project: denji/mruby
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());
}
Example #6
0
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));
}
Example #7
0
void
mrb_init_file(mrb_state *mrb)
{
  struct RClass *io, *file, *cnst;

  io   = mrb_class_get(mrb, "IO");
  file = mrb_define_class(mrb, "File", io);
  MRB_SET_INSTANCE_TT(file, MRB_TT_DATA);
  mrb_define_class_method(mrb, file, "umask",  mrb_file_s_umask, MRB_ARGS_REQ(1));
  mrb_define_class_method(mrb, file, "delete", mrb_file_s_unlink, MRB_ARGS_ANY());
  mrb_define_class_method(mrb, file, "unlink", mrb_file_s_unlink, MRB_ARGS_ANY());
  mrb_define_class_method(mrb, file, "rename", mrb_file_s_rename, MRB_ARGS_REQ(2));
  mrb_define_class_method(mrb, file, "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));

}
Example #8
0
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));
}
Example #9
0
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);

}
Example #10
0
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());
}
Example #11
0
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));
}
Example #13
0
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());
}
Example #14
0
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));
}
Example #15
0
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));
}
Example #16
0
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));
}
Example #17
0
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());
}
Example #18
0
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);
}
Example #19
0
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 */
}
Example #20
0
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));
}
Example #21
0
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");
}
Example #22
0
//**************************************************
// ライブラリを定義します
//**************************************************
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));
}
Example #23
0
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));
}
Example #25
0
        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());
        }
Example #26
0
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));
}
Example #27
0
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);
}
Example #28
0
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;
}
Example #29
0
File: struct.c Project: nyanp/mruby
/*
 *  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)  */
}
Example #30
0
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());
}