コード例 #1
0
ファイル: mrb_base58.c プロジェクト: h2so5/mruby-base58
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;
}
コード例 #2
0
ファイル: packer_class.c プロジェクト: ysei/mruby-msgpack
void MessagePack_Packer_module_init(mrb_state* mrb, struct RClass *mMessagePack)
{
  sym_pack_data = mrb_intern_cstr(mrb, "pack_data");
  //s_to_msgpack = mrb_intern_cstr(mrb, "to_msgpack");
  s_write = mrb_intern_cstr(mrb, "write");

  cMessagePack_Packer = mrb_define_class_under(mrb, mMessagePack, "Packer", mrb->object_class);

  mrb_define_method(mrb, cMessagePack_Packer, "initialize", Packer_initialize, MRB_ARGS_ANY()/* -1 */);
  mrb_define_method(mrb, cMessagePack_Packer, "buffer", Packer_buffer, MRB_ARGS_NONE()/*0*/);
  mrb_define_method(mrb, cMessagePack_Packer, "write", Packer_write, MRB_ARGS_REQ(1) /*1*/);
  mrb_define_alias(mrb, cMessagePack_Packer,  "pack", "write");
  mrb_define_method(mrb, cMessagePack_Packer, "write_nil", Packer_write_nil,  MRB_ARGS_NONE()/*0*/);
  mrb_define_method(mrb, cMessagePack_Packer, "write_array_header", Packer_write_array_header, MRB_ARGS_REQ(1) /*1*/);
  mrb_define_method(mrb, cMessagePack_Packer, "write_map_header", Packer_write_map_header, MRB_ARGS_REQ(1) /*1*/);
  mrb_define_method(mrb, cMessagePack_Packer, "flush", Packer_flush, MRB_ARGS_NONE()/*0*/);


  /* delegation methods */
  mrb_define_method(mrb, cMessagePack_Packer, "clear", Packer_clear, MRB_ARGS_NONE());
  mrb_define_method(mrb, cMessagePack_Packer, "size", Packer_size, MRB_ARGS_NONE());
  mrb_define_method(mrb, cMessagePack_Packer, "empty?", Packer_empty_p, MRB_ARGS_NONE());
  //mrb_define_method(mrb, cMessagePack_Packer, "write_to", Packer_write_to, MRB_ARGS_REQ(1) );
  mrb_define_method(mrb, cMessagePack_Packer, "to_str", Packer_to_str, MRB_ARGS_NONE());
  mrb_define_alias(mrb, cMessagePack_Packer, "to_s", "to_str");
  mrb_define_method(mrb, cMessagePack_Packer, "to_a", Packer_to_a, MRB_ARGS_NONE());

  /* MessagePack.pack(x) */
  mrb_define_module_function(mrb, mMessagePack, "pack", MessagePack_pack_module_method, MRB_ARGS_ANY()/* -1 */);
  mrb_define_module_function(mrb, mMessagePack, "dump", MessagePack_dump_module_method, MRB_ARGS_ANY()/* -1 */);
}
コード例 #3
0
ファイル: mrb_dir.c プロジェクト: Archytaus/mruby-dir
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));
}
コード例 #4
0
ファイル: pcap.c プロジェクト: selman/mruby-pcap
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());
}
コード例 #5
0
ファイル: mruby_setuid.c プロジェクト: KUM-Kiel/seisconvert2
void mrb_mruby_setuid_gem_init(mrb_state *mrb)
{
  struct RClass *kernel = mrb_module_get(mrb, "Kernel");
  mrb_define_module_function(mrb, kernel, "setuid", mrb_setuid, MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, kernel, "getuid", mrb_getuid, MRB_ARGS_NONE());
  mrb_define_module_function(mrb, kernel, "seteuid", mrb_seteuid, MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, kernel, "geteuid", mrb_geteuid, MRB_ARGS_NONE());
}
コード例 #6
0
ファイル: mrb_lz4.c プロジェクト: Asmod4n/mruby-lz4
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));
}
コード例 #7
0
ファイル: proc.c プロジェクト: IceDragon200/mruby
void mrb_mruby_proc_ext_gem_test(mrb_state *mrb)
{
  struct RClass *cls;

  cls = mrb_define_class(mrb, "ProcExtTest", mrb->object_class);
  mrb_define_module_function(mrb, cls, "mrb_proc_new_cfunc_with_env", proc_new_cfunc_with_env, MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, cls, "mrb_cfunc_env_get", cfunc_env_get, MRB_ARGS_REQ(2));
  mrb_define_module_function(mrb, cls, "cfunc_without_env", cfunc_without_env, MRB_ARGS_NONE());
}
コード例 #8
0
ファイル: sdl2_clipboard.c プロジェクト: Moon4u/mruby-sdl2
void
mruby_sdl2_clipboard_init(mrb_state *mrb)
{
  struct RClass *mod_Clipboard = mrb_define_module_under(mrb, mod_SDL2, "Clipboard");

  mrb_define_module_function(mrb, mod_Clipboard, "text",      mrb_sdl2_clipboard_text,     MRB_ARGS_NONE()); // SDL_GetClipboardText
  mrb_define_module_function(mrb, mod_Clipboard, "text=",     mrb_sdl2_clipboard_set_text, MRB_ARGS_REQ(1)); // SDL_SetClipboardText
  mrb_define_module_function(mrb, mod_Clipboard, "has_text?", mrb_sdl2_clipboard_has_text, MRB_ARGS_NONE()); // SDL_HasClipboardText
}
コード例 #9
0
ファイル: kernel.c プロジェクト: sadasant/mruby
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, "String", mrb_f_string, MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, krn, "Array", mrb_f_array, MRB_ARGS_REQ(1));
}
コード例 #10
0
ファイル: exception.c プロジェクト: ASnow/mruby
void
mrb_mruby_error_gem_test(mrb_state *mrb)
{
  struct RClass *cls;

  cls = mrb_define_class(mrb, "ExceptionTest", mrb->object_class);
  mrb_define_module_function(mrb, cls, "mrb_protect", run_protect, MRB_ARGS_NONE() | MRB_ARGS_BLOCK());
  mrb_define_module_function(mrb, cls, "mrb_ensure", run_ensure, MRB_ARGS_REQ(2));
  mrb_define_module_function(mrb, cls, "mrb_rescue", run_rescue, MRB_ARGS_REQ(2));
  mrb_define_module_function(mrb, cls, "mrb_rescue_exceptions", run_rescue_exceptions, MRB_ARGS_REQ(2));
}
コード例 #11
0
ファイル: time.c プロジェクト: cremno/mruby-allegro
void
mruby_allegro_time_init(mrb_state *mrb)
{
  struct RClass *am = M_ALLEGRO;
  struct RClass *tc = mrb_define_class_under(mrb, am, "Timeout", mrb->object_class);
  MRB_SET_INSTANCE_TT(tc, MRB_TT_DATA);
  mrb_define_module_function(mrb, am, "time", get_time, MRB_ARGS_NONE());
  mrb_define_module_function(mrb, am, "current_time", get_time, MRB_ARGS_NONE());
  mrb_define_method(mrb, tc, "initialize", timeout_initialize, MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, am, "rest", rest, MRB_ARGS_REQ(1));
}
コード例 #12
0
ファイル: sdl2_joystick.c プロジェクト: Moon4u/mruby-sdl2
void
mruby_sdl2_joystick_init(mrb_state *mrb)
{
  int arena_size;
  struct RClass *mod_Joystick = mrb_define_module_under(mrb, mod_SDL2, "Joysticks");
  class_Joystick = mrb_define_class_under(mrb, mod_Joystick, "Joystick", mrb->object_class);

  MRB_SET_INSTANCE_TT(class_Joystick, MRB_TT_DATA);

  mrb_define_module_function(mrb, mod_Joystick, "num",      mrb_sdl2_joystick_num, MRB_ARGS_NONE());
  mrb_define_module_function(mrb, mod_Joystick, "name_from_index", mrb_sdl2_joystick_get_name, MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mod_Joystick, "get_guid_from_index",       mrb_sdl2_joystick_get_guid, MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mod_Joystick, "get_guid_as_string",        mrb_sdl2_joystick_get_guid_as_string, MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, mod_Joystick, "get_guid_from_string",        mrb_sdl2_joystick_get_guid_from_string, MRB_ARGS_REQ(1));

  mrb_define_method(mrb, class_Joystick, "initialize",  mrb_sdl2_joystick_joystick_initialize,  MRB_ARGS_REQ(1));
  mrb_define_method(mrb, class_Joystick, "destroy",     mrb_sdl2_joystick_joystick_free,        MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Joystick, "free",        mrb_sdl2_joystick_joystick_free,        MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Joystick, "get_name",        mrb_sdl2_joystick_joystick_get_name, MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Joystick, "get_guid",        mrb_sdl2_joystick_joystick_get_guid, MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Joystick, "get_guid_as_string",        mrb_sdl2_joystick_joystick_get_guid_as_string, MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Joystick, "is_attached?",        mrb_sdl2_joystick_joystick_is_attached, MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Joystick, "get_id",         mrb_sdl2_joystick_joystick_get_id, MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Joystick, "get_general_num_axes",         mrb_sdl2_joystick_joystick_get_num_axes, MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Joystick, "get_general_num_balls",         mrb_sdl2_joystick_joystick_get_num_balls, MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Joystick, "get_general_num_hats",         mrb_sdl2_joystick_joystick_get_num_hats, MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Joystick, "get_general_num_buttons",         mrb_sdl2_joystick_joystick_get_num_buttons, MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Joystick, "update",         mrb_sdl2_joystick_joystick_update, MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Joystick, "event_state",         mrb_sdl2_joystick_joystick_event_state, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, class_Joystick, "get_axis",         mrb_sdl2_joystick_joystick_get_axis, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, class_Joystick, "get_axis_x", mrb_sdl2_joystick_joystick_get_axis_x, MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Joystick, "get_axis_y", mrb_sdl2_joystick_joystick_get_axis_y, MRB_ARGS_NONE());
  mrb_define_method(mrb, class_Joystick, "get_hat",         mrb_sdl2_joystick_joystick_get_hat, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, class_Joystick, "get_ball",         mrb_sdl2_joystick_joystick_get_ball, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, class_Joystick, "get_button",         mrb_sdl2_joystick_joystick_get_button, MRB_ARGS_REQ(1));


  arena_size = mrb_gc_arena_save(mrb);
  mrb_define_const(mrb, mod_Joystick, "SDL_HAT_CENTERED",  mrb_fixnum_value(SDL_HAT_CENTERED));
  mrb_define_const(mrb, mod_Joystick, "SDL_HAT_UP",        mrb_fixnum_value(SDL_HAT_UP));
  mrb_define_const(mrb, mod_Joystick, "SDL_HAT_RIGHT",     mrb_fixnum_value(SDL_HAT_RIGHT));
  mrb_define_const(mrb, mod_Joystick, "SDL_HAT_DOWN",      mrb_fixnum_value(SDL_HAT_DOWN));
  mrb_define_const(mrb, mod_Joystick, "SDL_HAT_LEFT",      mrb_fixnum_value(SDL_HAT_LEFT));
  mrb_define_const(mrb, mod_Joystick, "SDL_HAT_RIGHTUP",   mrb_fixnum_value(SDL_HAT_RIGHTUP));
  mrb_define_const(mrb, mod_Joystick, "SDL_HAT_RIGHTDOWN", mrb_fixnum_value(SDL_HAT_RIGHTDOWN));
  mrb_define_const(mrb, mod_Joystick, "SDL_HAT_LEFTUP",    mrb_fixnum_value(SDL_HAT_LEFTUP));
  mrb_define_const(mrb, mod_Joystick, "SDL_HAT_LEFTDOWN",  mrb_fixnum_value(SDL_HAT_LEFTDOWN));
  mrb_gc_arena_restore(mrb, arena_size);

}
コード例 #13
0
void
mrb_init_uefi_boot_service(mrb_state *mrb, struct RClass *mrb_uefi)
{
    struct RClass *bs;

    bs = mrb_define_module_under(mrb, mrb_uefi, "BootService");

    mrb_define_module_function(mrb, bs, "pointer", bs_pointer, ARGS_NONE());

    mrb_define_module_function(mrb, bs, "handle_protocol", bs_handle_protocol, ARGS_REQ(2));
    mrb_define_module_function(mrb, bs, "protocols_per_handle", bs_protocols_per_handle, ARGS_REQ(1));
    mrb_define_module_function(mrb, bs, "locate_handle_buffer", bs_locate_handle_buffer, ARGS_REQ(1));
    mrb_define_module_function(mrb, bs, "locate_protocol", bs_locate_protocol, ARGS_REQ(1));
}
コード例 #14
0
ファイル: kernel.c プロジェクト: anehing/mruby
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_NONE());
}
コード例 #15
0
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;
}
コード例 #16
0
ファイル: sKernel.cpp プロジェクト: tarosay/v2wrbbfirm
//**************************************************
// ライブラリを定義します
//**************************************************
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());
}
コード例 #17
0
ファイル: sSys.cpp プロジェクト: takumi2783/wrbb-v2lib-firm
//**************************************************
// ライブラリを定義します
//**************************************************
void sys_Init(mrb_state *mrb)
{
	struct RClass *systemModule = mrb_define_module(mrb, "System");

	mrb_define_module_function(mrb, systemModule, "exit", mrb_system_exit, MRB_ARGS_NONE());
	mrb_define_module_function(mrb, systemModule, "reset", mrb_system_reset, MRB_ARGS_NONE());
	mrb_define_module_function(mrb, systemModule, "setrun", mrb_system_setrun, MRB_ARGS_REQ(1));
	mrb_define_module_function(mrb, systemModule, "version", mrb_system_version, MRB_ARGS_OPT(1));

	mrb_define_module_function(mrb, systemModule, "push", mrb_system_push, MRB_ARGS_REQ(3));
	mrb_define_module_function(mrb, systemModule, "pop", mrb_system_pop, MRB_ARGS_REQ(2));

	mrb_define_module_function(mrb, systemModule, "fileload", mrb_system_fileload, MRB_ARGS_NONE());

	mrb_define_module_function(mrb, systemModule, "useSD", mrb_system_useSD, MRB_ARGS_NONE());
	mrb_define_module_function(mrb, systemModule, "useWiFi", mrb_system_useWiFi, MRB_ARGS_NONE());

	mrb_define_module_function(mrb, systemModule, "getMrbPath", mrb_system_getmrbpath, MRB_ARGS_NONE());
}
コード例 #18
0
ファイル: rtos.c プロジェクト: mimaki/mruby-rtos-toppers
void
mrb_mruby_rtos_toppers_gem_init(mrb_state *mrb)
{
  struct RClass *rtos;
  struct RClass *tsk;
  mrb_value wmd;
  mrb_value tmo;

  /* RTOS module */
  rtos = mrb_define_module(mrb, "RTOS");

  /* RTOS api */
  mrb_define_module_function(mrb, rtos, "delay",  mrb_rtos_delay,   MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, rtos, "millis", mrb_rtos_millis,  MRB_ARGS_NONE());

  wmd = mrb_hash_new(mrb);
  mrb_hash_set(mrb, wmd, mrb_symbol_value(mrb_intern_lit(mrb, "and")),   mrb_fixnum_value(TWF_ANDW));
  mrb_hash_set(mrb, wmd, mrb_symbol_value(mrb_intern_lit(mrb, "or")),    mrb_fixnum_value(TWF_ORW));
  mrb_mod_cv_set(mrb, rtos, mrb_intern_lit(mrb, "WAITMODE"), wmd);

  tmo = mrb_hash_new(mrb);
  mrb_hash_set(mrb, tmo, mrb_symbol_value(mrb_intern_lit(mrb, "polling")), mrb_fixnum_value(TMO_POL));
  mrb_hash_set(mrb, tmo, mrb_symbol_value(mrb_intern_lit(mrb, "forever")), mrb_fixnum_value(TMO_FEVR));
  mrb_mod_cv_set(mrb, rtos, mrb_intern_lit(mrb, "TIMEOUT"), tmo);

  /* Task class */
  tsk = mrb_define_class_under(mrb, rtos, "Task", mrb->object_class);

  mrb_define_method(mrb, tsk, "initialize", mrb_task_init,      MRB_ARGS_REQ(1));
  mrb_define_method(mrb, tsk, "activate",   mrb_task_activate,  MRB_ARGS_NONE());
  mrb_define_method(mrb, tsk, "suspend",    mrb_task_suspend,   MRB_ARGS_NONE());
  mrb_define_method(mrb, tsk, "resume",     mrb_task_resume,    MRB_ARGS_NONE());
  mrb_define_method(mrb, tsk, "terminate",  mrb_task_terminate, MRB_ARGS_NONE());

  /* EventFlag class */
  mrb_rtos_flag_init(mrb, rtos);

  /* MemoryPool, MemoryBuffer */
  mrb_rtos_memory_init(mrb, rtos);

  /* DataQueue */
  mrb_rtos_dataqueue_init(mrb, rtos);
}
コード例 #19
0
ファイル: proc.c プロジェクト: mitchblank/mruby
void
mrb_mruby_proc_ext_gem_init(mrb_state* mrb)
{
  struct RClass *p = mrb->proc_class;
  mrb_define_method(mrb, p, "lambda?",         mrb_proc_lambda,          MRB_ARGS_NONE());
  mrb_define_method(mrb, p, "source_location", mrb_proc_source_location, MRB_ARGS_NONE());
  mrb_define_method(mrb, p, "to_s",            mrb_proc_inspect,         MRB_ARGS_NONE());
  mrb_define_method(mrb, p, "inspect",         mrb_proc_inspect,         MRB_ARGS_NONE());

  mrb_define_class_method(mrb, mrb->kernel_module, "proc", mrb_kernel_proc, MRB_ARGS_NONE());
  mrb_define_method(mrb, mrb->kernel_module,       "proc", mrb_kernel_proc, MRB_ARGS_NONE());
  mrb_define_module_function(mrb, mrb->kernel_module, "local_variables", mrb_local_variables, MRB_ARGS_NONE());
}
コード例 #20
0
ファイル: input-binding.cpp プロジェクト: Alex223124/mkxp
void
inputBindingInit(mrb_state *mrb)
{
	RClass *module = mrb_define_module(mrb, "Input");

	mrb_define_module_function(mrb, module, "update", inputUpdate, MRB_ARGS_NONE());
	mrb_define_module_function(mrb, module, "press?", inputPress, MRB_ARGS_REQ(1));
	mrb_define_module_function(mrb, module, "trigger?", inputTrigger, MRB_ARGS_REQ(1));
	mrb_define_module_function(mrb, module, "repeat?", inputRepeat, MRB_ARGS_REQ(1));
	mrb_define_module_function(mrb, module, "dir4", inputDir4, MRB_ARGS_NONE());
	mrb_define_module_function(mrb, module, "dir8", inputDir8, MRB_ARGS_NONE());

	mrb_define_module_function(mrb, module, "mouse_x", inputMouseX, MRB_ARGS_NONE());
	mrb_define_module_function(mrb, module, "mouse_y", inputMouseY, MRB_ARGS_NONE());

	mrb_value modVal = mrb_obj_value(module);

	if (rgssVer >= 3)
	{
		mrb_value symHash = mrb_hash_new_capa(mrb, buttonCodesN);

		for (size_t i = 0; i < buttonCodesN; ++i)
		{
			const char *str = buttonCodes[i].str;
			mrb_sym sym = mrb_intern_static(mrb, str, strlen(str));
			mrb_value symVal = mrb_symbol_value(sym);
			mrb_value val = mrb_fixnum_value(buttonCodes[i].val);

			/* In RGSS3 all Input::XYZ constants are equal to :XYZ symbols,
			 * to be compatible with the previous convention */
			mrb_const_set(mrb, modVal, sym, symVal);
			mrb_hash_set(mrb, symHash, symVal, val);
		}

		mrb_iv_set(mrb, modVal, mrb_intern_lit(mrb, "buttoncodes"), symHash);
		getMrbData(mrb)->buttoncodeHash = symHash;
	}
	else
	{
		for (size_t i = 0; i < buttonCodesN; ++i)
		{
			const char *str = buttonCodes[i].str;
			mrb_sym sym = mrb_intern_static(mrb, str, strlen(str));
			mrb_value val = mrb_fixnum_value(buttonCodes[i].val);

			mrb_const_set(mrb, modVal, sym, val);
		}
	}
}
コード例 #21
0
void
mrb_mruby_uri_parser_gem_init(mrb_state* mrb)
{
#ifdef _WIN32
  WSADATA wsaData;
  errno = 0;
  int err = WSAStartup(MAKEWORD(2, 2), &wsaData);
  if (err != 0) {
    mrb_sys_fail(mrb, "WSAStartup");
  }
#endif
  struct RClass *uri_mod, *uri_error_class;
  uri_mod = mrb_define_module(mrb, "URI");
  uri_error_class = mrb_define_class_under(mrb, uri_mod, "Error", E_RUNTIME_ERROR);
  mrb_define_class_under(mrb, uri_mod, "Malformed", uri_error_class);
  mrb_define_class_under(mrb, uri_mod, "HostNotPresent", uri_error_class);
  mrb_define_class_under(mrb, uri_mod, "HostNotParseable", uri_error_class);
  mrb_define_class_under(mrb, uri_mod, "ConnectMalformed", uri_error_class);
  mrb_define_class_under(mrb, uri_mod, "PortTooLarge", uri_error_class);
  mrb_define_module_function(mrb, uri_mod, "parse", mrb_http_parser_parse_url, MRB_ARGS_ARG(1, 1));
  mrb_define_module_function(mrb, uri_mod, "get_port", mrb_uri_parser_get_port, MRB_ARGS_ARG(1, 1));
}
コード例 #22
0
ファイル: mrb_thread.c プロジェクト: blackant2/mruby-cocos2dx
void
mrb_mruby_thread_gem_init(mrb_state* mrb) {
  struct RClass *_class_thread, *_class_mutex, *_class_queue;

  _class_thread = mrb_define_class(mrb, "Thread", mrb->object_class);
  MRB_SET_INSTANCE_TT(_class_thread, MRB_TT_DATA);
  mrb_define_method(mrb, _class_thread, "initialize", mrb_thread_init, MRB_ARGS_OPT(1));
  mrb_define_method(mrb, _class_thread, "join", mrb_thread_join, MRB_ARGS_NONE());
  mrb_define_method(mrb, _class_thread, "kill", mrb_thread_kill, MRB_ARGS_NONE());
  mrb_define_method(mrb, _class_thread, "terminate", mrb_thread_kill, MRB_ARGS_NONE());
  mrb_define_method(mrb, _class_thread, "alive?", mrb_thread_alive, MRB_ARGS_NONE());
  mrb_define_module_function(mrb, _class_thread, "sleep", mrb_thread_sleep, MRB_ARGS_REQ(1));
  mrb_define_module_function(mrb, _class_thread, "start", mrb_thread_init, MRB_ARGS_REQ(1));

  _class_mutex = mrb_define_class(mrb, "Mutex", mrb->object_class);
  MRB_SET_INSTANCE_TT(_class_mutex, MRB_TT_DATA);
  mrb_define_method(mrb, _class_mutex, "initialize", mrb_mutex_init, MRB_ARGS_NONE());
  mrb_define_method(mrb, _class_mutex, "lock", mrb_mutex_lock, MRB_ARGS_NONE());
  mrb_define_method(mrb, _class_mutex, "try_lock", mrb_mutex_try_lock, MRB_ARGS_NONE());
  mrb_define_method(mrb, _class_mutex, "locked?", mrb_mutex_locked, MRB_ARGS_NONE());
  mrb_define_method(mrb, _class_mutex, "sleep", mrb_mutex_sleep, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, _class_mutex, "synchronize", mrb_mutex_synchronize, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, _class_mutex, "unlock", mrb_mutex_unlock, MRB_ARGS_NONE());

  _class_queue = mrb_define_class(mrb, "Queue", mrb->object_class);
  MRB_SET_INSTANCE_TT(_class_queue, MRB_TT_DATA);
  mrb_define_method(mrb, _class_queue, "initialize", mrb_queue_init, MRB_ARGS_NONE());
  mrb_define_method(mrb, _class_queue, "clear", mrb_queue_clear, MRB_ARGS_NONE());
  mrb_define_method(mrb, _class_queue, "push", mrb_queue_push, MRB_ARGS_NONE());
  mrb_define_alias(mrb, _class_queue, "<<", "push");
  mrb_define_method(mrb, _class_queue, "unshift", mrb_queue_unshift, MRB_ARGS_NONE());
  mrb_define_alias(mrb, _class_queue, "enq", "unshift");
  mrb_define_method(mrb, _class_queue, "pop", mrb_queue_pop, MRB_ARGS_OPT(1));
  mrb_define_alias(mrb, _class_queue, "deq", "pop");
  mrb_define_method(mrb, _class_queue, "shift", mrb_queue_shift, MRB_ARGS_OPT(1));
  mrb_define_method(mrb, _class_queue, "size", mrb_queue_size, MRB_ARGS_NONE());
  mrb_define_method(mrb, _class_queue, "num_waiting", mrb_queue_num_waiting, MRB_ARGS_NONE());
  mrb_define_method(mrb, _class_queue, "empty?", mrb_queue_empty_p, MRB_ARGS_NONE());
}
コード例 #23
0
ファイル: sMp3.cpp プロジェクト: wakayamarb/wrbb-v2lib-firm
//**************************************************
// ライブラリを定義します
//**************************************************
int mp3_Init(mrb_state *mrb,int pausePin, int stopPin)
{
	PausePin = pausePin;
	StopPin = stopPin;

	//使用できるピンかどうかチェック
	if(PausePin == StopPin){
		return 0;
	}
	if(!chkCanUsePin(PausePin) || !chkCanUsePin(StopPin)){
		return 0;
	}

	//SDカードが利用可能か確かめます
	if(!sdcard_Init(mrb)){
		return 0;
	}

	//インスタンスを作成する前には、強制gcを入れる
	mrb_full_gc(mrb);

	//インスタンスを生成します。
	if(Wavmp3p == 0){
		Wavmp3p = new WavMp3p(44100);
	}

	pinMode(PausePin, INPUT_PULLUP);
	pinMode(StopPin, INPUT_PULLUP);

	MsTimer2::set(100, cyclic_handler);

	struct RClass *mp3Module = mrb_define_module(mrb, MP3_CLASS);

	mrb_define_module_function(mrb, mp3Module, "play", mrb_mp3_play, MRB_ARGS_REQ(1));
	mrb_define_module_function(mrb, mp3Module, "led", mrb_mp3_led, MRB_ARGS_REQ(1));

	return 1;
}
コード例 #24
0
ファイル: mrb_sdl_gl.c プロジェクト: Archytaus/mruby-sdl
void
init_mrb_sdl_gl(mrb_state* mrb) {
  mrb_sdl_gl_class = mrb_define_module(mrb, "GL");
  mrb_define_module_function(mrb, mrb_sdl_gl_class, "clear", mrb_sdl_gl_clear, MRB_ARGS_NONE());
  mrb_define_module_function(mrb, mrb_sdl_gl_class, "set_clear_color", mrb_sdl_gl_set_clear_color, MRB_ARGS_REQ(3));
  mrb_define_module_function(mrb, mrb_sdl_gl_class, "set_clear_flags", mrb_sdl_gl_set_clear_flags, MRB_ARGS_REQ(1));
  
  mrb_define_module_function(mrb, mrb_sdl_gl_class, "error", mrb_sdl_gl_error, MRB_ARGS_NONE());

  
  mrb_define_module_function(mrb, mrb_sdl_gl_class, "blend_alpha_transparency_without_depth", mrb_sdl_gl_blend_alpha_transparency_without_depth, MRB_ARGS_NONE());
  mrb_define_module_function(mrb, mrb_sdl_gl_class, "blend_alpha_transparency", mrb_sdl_gl_blend_alpha_transparency, MRB_ARGS_NONE());
  mrb_define_module_function(mrb, mrb_sdl_gl_class, "blend_opaque", mrb_sdl_gl_blend_opaque, MRB_ARGS_NONE());
  
  mrb_define_module_function(mrb, mrb_sdl_gl_class, "viewport", mrb_sdl_gl_viewport, MRB_ARGS_REQ(4));
}
コード例 #25
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_module_function(mrb, krn, "caller", mrb_f_caller, MRB_ARGS_NONE());
  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));
}
コード例 #26
0
ファイル: sI2c.cpp プロジェクト: tarosay/v2wrbbfirm
//**************************************************
// ライブラリを定義します
//**************************************************
void i2c_Init(mrb_state *mrb)
{
	//0:Wire1, 1:Wire3, 2:Wire2, 3:Wire6 4:Wire7
	RbWire[0] = &Wire1;
	RbWire[1] = &Wire3;
	RbWire[2] = &Wire2;
	RbWire[3] = &Wire6;
	RbWire[4] = &Wire7;

	struct RClass *i2cModule = mrb_define_module(mrb, "I2c");

	mrb_define_module_function(mrb, i2cModule, "begin", mrb_i2c_begin, MRB_ARGS_REQ(1));
	mrb_define_module_function(mrb, i2cModule, "write", mrb_i2c_write, MRB_ARGS_REQ(4));
	mrb_define_module_function(mrb, i2cModule, "read", mrb_i2c_read, MRB_ARGS_REQ(3)|MRB_ARGS_OPT(1));
	
	mrb_define_module_function(mrb, i2cModule, "begin", mrb_i2c_beginTransmission, MRB_ARGS_REQ(2));
	mrb_define_module_function(mrb, i2cModule, "lwrite", mrb_i2c_lwrite, MRB_ARGS_REQ(2));
	mrb_define_module_function(mrb, i2cModule, "end", mrb_i2c_endTransmission, MRB_ARGS_REQ(1));
	mrb_define_module_function(mrb, i2cModule, "request", mrb_i2c_requestFrom, MRB_ARGS_REQ(3));
	mrb_define_module_function(mrb, i2cModule, "lread", mrb_i2c_lread, MRB_ARGS_REQ(1));
	mrb_define_module_function(mrb, i2cModule, "available", mrb_i2c_available, MRB_ARGS_REQ(1));
}
コード例 #27
0
ファイル: main.cpp プロジェクト: kyab/mruby-thread-freertos
bool init_mruby()
{
    Serial2.println("init_mruby enter");
    g_mrb = mrb_open_allocf(myallocfCCM, NULL);
    // g_mrb = mrb_open_allocf(myallocf, NULL);
    Serial2.print("mrb_open done. total allocated : ");
    Serial2.println(total_size, DEC);

    mrb_load_irep(g_mrb, blinker);

    RClass *freeRTOSModule = mrb_define_module(g_mrb, "FreeRTOS");
    mrb_define_module_function(g_mrb, freeRTOSModule, "sleep", mrb_freertos_sleep, ARGS_REQ(1));

    Serial2.println("mruby initialized");

    return true;
}
コード例 #28
0
ファイル: input-binding.cpp プロジェクト: BlackLotus/mkxp
void
inputBindingInit(mrb_state *mrb)
{
	RClass *module = mrb_define_module(mrb, "Input");

	mrb_define_module_function(mrb, module, "update", inputUpdate, MRB_ARGS_NONE());
	mrb_define_module_function(mrb, module, "press?", inputPress, MRB_ARGS_REQ(1));
	mrb_define_module_function(mrb, module, "trigger?", inputTrigger, MRB_ARGS_REQ(1));
	mrb_define_module_function(mrb, module, "repeat?", inputRepeat, MRB_ARGS_REQ(1));
	mrb_define_module_function(mrb, module, "dir4", inputDir4, MRB_ARGS_NONE());
	mrb_define_module_function(mrb, module, "dir8", inputDir8, MRB_ARGS_NONE());

	DEF_CONST_I("DOWN",  Input::Down );
	DEF_CONST_I("LEFT",  Input::Left );
	DEF_CONST_I("RIGHT", Input::Right);
	DEF_CONST_I("UP",    Input::Up   );

	DEF_CONST_I("A",     Input::A    );
	DEF_CONST_I("B",     Input::B    );
	DEF_CONST_I("C",     Input::C    );
	DEF_CONST_I("X",     Input::X    );
	DEF_CONST_I("Y",     Input::Y    );
	DEF_CONST_I("Z",     Input::Z    );
	DEF_CONST_I("L",     Input::L    );
	DEF_CONST_I("R",     Input::R    );

	DEF_CONST_I("SHIFT", Input::Shift);
	DEF_CONST_I("CTRL",  Input::Ctrl );
	DEF_CONST_I("ALT",   Input::Alt  );

	DEF_CONST_I("F5",    Input::F5   );
	DEF_CONST_I("F6",    Input::F6   );
	DEF_CONST_I("F7",    Input::F7   );
	DEF_CONST_I("F8",    Input::F8   );
	DEF_CONST_I("F9",    Input::F9   );

	mrb_define_module_function(mrb, module, "mouse_x", inputMouseX, MRB_ARGS_NONE());
	mrb_define_module_function(mrb, module, "mouse_y", inputMouseY, MRB_ARGS_NONE());

	DEF_CONST_I("MOUSELEFT",   Input::MouseLeft  );
	DEF_CONST_I("MOUSEMIDDLE", Input::MouseMiddle);
	DEF_CONST_I("MOUSERIGHT",  Input::MouseRight );
}
コード例 #29
0
ファイル: mrb_thread.c プロジェクト: postmodern/mruby-thread
void
mrb_mruby_thread_gem_init(mrb_state* mrb) {
  struct RClass *_class_thread, *_class_mutex;
  _class_thread = mrb_define_class(mrb, "Thread", mrb->object_class);
  mrb_define_method(mrb, _class_thread, "initialize", mrb_thread_init, ARGS_OPT(1));
  mrb_define_method(mrb, _class_thread, "join", mrb_thread_join, ARGS_NONE());
  mrb_define_method(mrb, _class_thread, "kill", mrb_thread_kill, ARGS_NONE());
  mrb_define_method(mrb, _class_thread, "terminate", mrb_thread_kill, ARGS_NONE());
  mrb_define_method(mrb, _class_thread, "alive?", mrb_thread_alive, ARGS_NONE());
  mrb_define_module_function(mrb, _class_thread, "sleep", mrb_thread_sleep, ARGS_REQ(1));
  _class_mutex = mrb_define_class(mrb, "Mutex", mrb->object_class);
  mrb_define_method(mrb, _class_mutex, "initialize", mrb_mutex_init, ARGS_NONE());
  mrb_define_method(mrb, _class_mutex, "lock", mrb_mutex_lock, ARGS_NONE());
  mrb_define_method(mrb, _class_mutex, "try_lock", mrb_mutex_try_lock, ARGS_NONE());
  mrb_define_method(mrb, _class_mutex, "locked?", mrb_mutex_locked, ARGS_NONE());
  mrb_define_method(mrb, _class_mutex, "sleep", mrb_mutex_sleep, ARGS_REQ(1));
  mrb_define_method(mrb, _class_mutex, "synchronize", mrb_mutex_synchronize, ARGS_REQ(1));
  mrb_define_method(mrb, _class_mutex, "unlock", mrb_mutex_unlock, ARGS_NONE());
}
コード例 #30
0
ファイル: sServo.cpp プロジェクト: takumi2783/wrbb-v2lib-firm
//**************************************************
// ライブラリを定義します
//**************************************************
void servo_Init(mrb_state *mrb)
{
	for (int i = 0; i < ATTACH_MAX; i++){
		servo[i] = 0;
	}

	struct RClass *servoModule = mrb_define_module(mrb, "Servo");

	mrb_define_module_function(mrb, servoModule, "attach", mrb_servo_attach, MRB_ARGS_REQ(2) | MRB_ARGS_OPT(2));
	mrb_define_module_function(mrb, servoModule, "write", mrb_servo_write, MRB_ARGS_REQ(2));
	mrb_define_module_function(mrb, servoModule, "us", mrb_servo_us, MRB_ARGS_REQ(2));
	mrb_define_module_function(mrb, servoModule, "read", mrb_servo_read, MRB_ARGS_REQ(1));
	mrb_define_module_function(mrb, servoModule, "attached", mrb_servo_attached, MRB_ARGS_REQ(1));
	mrb_define_module_function(mrb, servoModule, "detach", mrb_servo_detach, MRB_ARGS_REQ(1));
}