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_SDL_SDLHapticDirection_init(mrb_state* mrb) {
RClass* SDLHapticDirection_class = mrb_define_class_under(mrb, SDL_module(mrb), "HapticDirection", mrb->object_class);
MRB_SET_INSTANCE_TT(SDLHapticDirection_class, MRB_TT_DATA);
#if BIND_SDLHapticDirection_INITIALIZE
mrb_define_method(mrb, SDLHapticDirection_class, "initialize", mrb_SDL_SDLHapticDirection_initialize, MRB_ARGS_NONE());
#endif
mrb_define_class_method(mrb, SDLHapticDirection_class, "disown", mrb_SDL_SDLHapticDirection_disown, MRB_ARGS_ARG(1, 0));
mrb_define_class_method(mrb, SDLHapticDirection_class, "belongs_to_ruby?", mrb_SDL_SDLHapticDirection_belongs_to_ruby, MRB_ARGS_ARG(1, 0));
/*
* Fields
*/
#if BIND_SDLHapticDirection_type_FIELD_READER
mrb_define_method(mrb, SDLHapticDirection_class, "type", mrb_SDL_SDLHapticDirection_get_type, MRB_ARGS_ARG(0, 0));
#endif
#if BIND_SDLHapticDirection_type_FIELD_WRITER
mrb_define_method(mrb, SDLHapticDirection_class, "type=", mrb_SDL_SDLHapticDirection_set_type, MRB_ARGS_ARG(1, 0));
#endif
#if BIND_SDLHapticDirection_dir_FIELD_READER
mrb_define_method(mrb, SDLHapticDirection_class, "dir", mrb_SDL_SDLHapticDirection_get_dir, MRB_ARGS_ARG(0, 0));
#endif
#if BIND_SDLHapticDirection_dir_FIELD_WRITER
mrb_define_method(mrb, SDLHapticDirection_class, "dir=", mrb_SDL_SDLHapticDirection_set_dir, MRB_ARGS_ARG(1, 0));
#endif
}
void mrb_SDL_SDLQuitEvent_init(mrb_state* mrb) {
RClass* SDLQuitEvent_class = mrb_define_class_under(mrb, SDL_module(mrb), "QuitEvent", mrb->object_class);
MRB_SET_INSTANCE_TT(SDLQuitEvent_class, MRB_TT_DATA);
#if BIND_SDLQuitEvent_INITIALIZE
mrb_define_method(mrb, SDLQuitEvent_class, "initialize", mrb_SDL_SDLQuitEvent_initialize, MRB_ARGS_NONE());
#endif
mrb_define_class_method(mrb, SDLQuitEvent_class, "disown", mrb_SDL_SDLQuitEvent_disown, MRB_ARGS_ARG(1, 0));
mrb_define_class_method(mrb, SDLQuitEvent_class, "belongs_to_ruby?", mrb_SDL_SDLQuitEvent_belongs_to_ruby, MRB_ARGS_ARG(1, 0));
/*
* Fields
*/
#if BIND_SDLQuitEvent_type_FIELD_READER
mrb_define_method(mrb, SDLQuitEvent_class, "type", mrb_SDL_SDLQuitEvent_get_type, MRB_ARGS_ARG(0, 0));
#endif
#if BIND_SDLQuitEvent_type_FIELD_WRITER
mrb_define_method(mrb, SDLQuitEvent_class, "type=", mrb_SDL_SDLQuitEvent_set_type, MRB_ARGS_ARG(1, 0));
#endif
#if BIND_SDLQuitEvent_timestamp_FIELD_READER
mrb_define_method(mrb, SDLQuitEvent_class, "timestamp", mrb_SDL_SDLQuitEvent_get_timestamp, MRB_ARGS_ARG(0, 0));
#endif
#if BIND_SDLQuitEvent_timestamp_FIELD_WRITER
mrb_define_method(mrb, SDLQuitEvent_class, "timestamp=", mrb_SDL_SDLQuitEvent_set_timestamp, MRB_ARGS_ARG(1, 0));
#endif
}
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, "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, "size", mrb_file_size, MRB_ARGS_REQ(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));
#ifndef _WIN32
mrb_define_method(mrb, file, "flock", mrb_file_flock, MRB_ARGS_REQ(1));
#endif
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));
}
//----------------------------------------------------------
void BindImage::Bind(mrb_state* mrb)
{
struct RClass *cc = mrb_define_class(mrb, "Image", mrb->object_class);
mrb_define_class_method(mrb , cc, "load", load, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb , cc, "grab_screen", grab_screen, MRB_ARGS_OPT(4));
mrb_define_method(mrb, cc, "clone", clone, MRB_ARGS_NONE());
mrb_define_method(mrb, cc, "save", save, MRB_ARGS_ARG(2, 1));
mrb_define_method(mrb, cc, "color", color, MRB_ARGS_REQ(2));
mrb_define_method(mrb, cc, "set_color", set_color, MRB_ARGS_REQ(3));
mrb_define_method(mrb, cc, "resize", resize, MRB_ARGS_REQ(2));
mrb_define_method(mrb, cc, "set_image_type", set_image_type, MRB_ARGS_REQ(1));
mrb_define_method(mrb, cc, "crop", crop, MRB_ARGS_REQ(4));
mrb_define_method(mrb, cc, "crop!", crop_bang, MRB_ARGS_REQ(4));
mrb_define_method(mrb, cc, "rotate90", rotate90, MRB_ARGS_OPT(1));
mrb_define_method(mrb, cc, "mirror", mirror, MRB_ARGS_REQ(2));
mrb_define_method(mrb, cc, "update", update, MRB_ARGS_NONE());
mrb_define_method(mrb, cc, "set_anchor_percent", set_anchor_percent, MRB_ARGS_REQ(2));
mrb_define_method(mrb, cc, "set_anchor_point", set_anchor_point, MRB_ARGS_REQ(2));
mrb_define_method(mrb, cc, "reset_anchor", reset_anchor, MRB_ARGS_REQ(2));
mrb_define_method(mrb, cc, "draw", draw, MRB_ARGS_ARG(2, 2));
mrb_define_method(mrb, cc, "draw_sub", draw_sub, MRB_ARGS_ARG(6, 2));
mrb_define_method(mrb, cc, "height", height, MRB_ARGS_NONE());
mrb_define_method(mrb, cc, "width", width, MRB_ARGS_NONE());
mrb_define_method(mrb, cc, "each_pixels", each_pixels, MRB_ARGS_OPT(2));
mrb_define_method(mrb, cc, "map_pixels", map_pixels, MRB_ARGS_OPT(2));
}
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 ruby_register_cocos2dx_experimental_video_VideoPlayer(mrb_state* mrb, struct RClass* rmodule)
{
std::string typeName = typeid(cocos2d::experimental::ui::VideoPlayer).name();
g_rubyType[typeName] = "CCExp::VideoPlayer";
g_rubyDataType[typeName] = &ruby_cocos2dx_Ref_type;
struct RClass* p_rmodule = mrb->object_class;
p_rmodule = mrb_module_get_under(mrb, p_rmodule, "CCUI");
struct RClass* p_rclass = mrb_class_get_under(mrb, p_rmodule, "Widget");
struct RClass *rclass = mrb_define_class_under(mrb, rmodule, "VideoPlayer", p_rclass);
MRB_SET_INSTANCE_TT(rclass, MRB_TT_DATA);
mrb_define_method(mrb, rclass, "get_file_name", ruby_cocos2dx_experimental_video_VideoPlayer_getFileName, ARGS_NONE());
mrb_define_method(mrb, rclass, "get_url", ruby_cocos2dx_experimental_video_VideoPlayer_getURL, ARGS_NONE());
mrb_define_method(mrb, rclass, "play", ruby_cocos2dx_experimental_video_VideoPlayer_play, ARGS_NONE());
mrb_define_method(mrb, rclass, "pause", ruby_cocos2dx_experimental_video_VideoPlayer_pause, ARGS_NONE());
mrb_define_method(mrb, rclass, "set_keep_aspect_ratio_enabled", ruby_cocos2dx_experimental_video_VideoPlayer_setKeepAspectRatioEnabled, ARGS_REQ(1));
mrb_define_method(mrb, rclass, "resume", ruby_cocos2dx_experimental_video_VideoPlayer_resume, ARGS_NONE());
mrb_define_method(mrb, rclass, "stop", ruby_cocos2dx_experimental_video_VideoPlayer_stop, ARGS_NONE());
mrb_define_method(mrb, rclass, "set_full_screen_enabled", ruby_cocos2dx_experimental_video_VideoPlayer_setFullScreenEnabled, ARGS_REQ(1));
mrb_define_method(mrb, rclass, "set_file_name", ruby_cocos2dx_experimental_video_VideoPlayer_setFileName, ARGS_REQ(1));
mrb_define_method(mrb, rclass, "set_url", ruby_cocos2dx_experimental_video_VideoPlayer_setURL, ARGS_REQ(1));
mrb_define_method(mrb, rclass, "keep_aspect_ratio_enabled?", ruby_cocos2dx_experimental_video_VideoPlayer_isKeepAspectRatioEnabled, ARGS_NONE());
mrb_define_method(mrb, rclass, "on_play_event", ruby_cocos2dx_experimental_video_VideoPlayer_onPlayEvent, ARGS_REQ(1));
mrb_define_method(mrb, rclass, "full_screen_enabled?", ruby_cocos2dx_experimental_video_VideoPlayer_isFullScreenEnabled, ARGS_NONE());
mrb_define_method(mrb, rclass, "playing?", ruby_cocos2dx_experimental_video_VideoPlayer_isPlaying, ARGS_NONE());
mrb_define_method(mrb, rclass, "seek_to", ruby_cocos2dx_experimental_video_VideoPlayer_seekTo, ARGS_REQ(1));
mrb_define_class_method(mrb, rclass, "create", ruby_cocos2dx_experimental_video_VideoPlayer_create_static, ARGS_NONE());
struct RClass* renum_EventType = mrb_define_module_under(mrb, rclass, "EventType");
ruby_cocos2dx_experimental_video_VideoPlayer_EventType_enum_init(mrb, renum_EventType);
mrb_define_class_method(mrb, renum_EventType, "PLAYING", ruby_cocos2dx_experimental_video_constant_get, ARGS_NONE());
mrb_define_class_method(mrb, renum_EventType, "PAUSED", ruby_cocos2dx_experimental_video_constant_get, ARGS_NONE());
mrb_define_class_method(mrb, renum_EventType, "STOPPED", ruby_cocos2dx_experimental_video_constant_get, ARGS_NONE());
mrb_define_class_method(mrb, renum_EventType, "COMPLETED", ruby_cocos2dx_experimental_video_constant_get, ARGS_NONE());
}
void
init_cfunc_pointer(mrb_state *mrb, struct RClass* module)
{
struct RClass *pointer_class = mrb_define_class_under(mrb, module, "Pointer", mrb_ud(mrb)->cfunc_type_class);
mrb_value ffi_type = mrb_obj_value(Data_Wrap_Struct(mrb, mrb->object_class, &cfunc_pointer_ffi_data_type, &pointer_mrb_ffi_type));
mrb_obj_iv_set(mrb, (struct RObject*)pointer_class, mrb_intern(mrb, "ffi_type"), ffi_type);
mrb_ud(mrb)->cfunc_pointer_class = pointer_class;
mrb_define_class_method(mrb, pointer_class, "refer", cfunc_pointer_refer, ARGS_REQ(1));
mrb_define_class_method(mrb, pointer_class, "malloc", cfunc_pointer_class_malloc, ARGS_REQ(1));
mrb_define_method(mrb, pointer_class, "initialize", cfunc_pointer_initialize, ARGS_ANY());
mrb_define_method(mrb, pointer_class, "realloc", cfunc_pointer_realloc, ARGS_REQ(1));
mrb_define_method(mrb, pointer_class, "free", cfunc_pointer_free, ARGS_NONE());
mrb_define_method(mrb, pointer_class, "inspect", cfunc_pointer_inspect, ARGS_NONE());
mrb_define_method(mrb, pointer_class, "is_null?", cfunc_pointer_is_null, ARGS_NONE());
mrb_define_method(mrb, pointer_class, "autofree", cfunc_pointer_autofree, ARGS_NONE());
mrb_define_method(mrb, pointer_class, "offset", cfunc_pointer_offset, ARGS_REQ(1));
mrb_define_method(mrb, pointer_class, "to_s", cfunc_pointer_to_s, ARGS_NONE());
// add method to system classes
mrb_define_method(mrb, mrb->string_class, "to_pointer", cfunc_string_to_pointer, ARGS_NONE());
mrb_obj_iv_set(mrb, (struct RObject *)mrb->string_class, mrb_intern(mrb, "ffi_type"), ffi_type);
}
void mrb_SDL_SDLMessageBoxButtonData_init(mrb_state* mrb) {
RClass* SDLMessageBoxButtonData_class = mrb_define_class_under(mrb, SDL_module(mrb), "MessageBoxButtonData", mrb->object_class);
MRB_SET_INSTANCE_TT(SDLMessageBoxButtonData_class, MRB_TT_DATA);
#if BIND_SDLMessageBoxButtonData_INITIALIZE
mrb_define_method(mrb, SDLMessageBoxButtonData_class, "initialize", mrb_SDL_SDLMessageBoxButtonData_initialize, MRB_ARGS_NONE());
#endif
mrb_define_class_method(mrb, SDLMessageBoxButtonData_class, "disown", mrb_SDL_SDLMessageBoxButtonData_disown, MRB_ARGS_ARG(1, 0));
mrb_define_class_method(mrb, SDLMessageBoxButtonData_class, "belongs_to_ruby?", mrb_SDL_SDLMessageBoxButtonData_belongs_to_ruby, MRB_ARGS_ARG(1, 0));
/*
* Fields
*/
#if BIND_SDLMessageBoxButtonData_flags_FIELD_READER
mrb_define_method(mrb, SDLMessageBoxButtonData_class, "flags", mrb_SDL_SDLMessageBoxButtonData_get_flags, MRB_ARGS_ARG(0, 0));
#endif
#if BIND_SDLMessageBoxButtonData_flags_FIELD_WRITER
mrb_define_method(mrb, SDLMessageBoxButtonData_class, "flags=", mrb_SDL_SDLMessageBoxButtonData_set_flags, MRB_ARGS_ARG(1, 0));
#endif
#if BIND_SDLMessageBoxButtonData_buttonid_FIELD_READER
mrb_define_method(mrb, SDLMessageBoxButtonData_class, "buttonid", mrb_SDL_SDLMessageBoxButtonData_get_buttonid, MRB_ARGS_ARG(0, 0));
#endif
#if BIND_SDLMessageBoxButtonData_buttonid_FIELD_WRITER
mrb_define_method(mrb, SDLMessageBoxButtonData_class, "buttonid=", mrb_SDL_SDLMessageBoxButtonData_set_buttonid, MRB_ARGS_ARG(1, 0));
#endif
#if BIND_SDLMessageBoxButtonData_text_FIELD_READER
mrb_define_method(mrb, SDLMessageBoxButtonData_class, "text", mrb_SDL_SDLMessageBoxButtonData_get_text, MRB_ARGS_ARG(0, 0));
#endif
#if BIND_SDLMessageBoxButtonData_text_FIELD_WRITER
mrb_define_method(mrb, SDLMessageBoxButtonData_class, "text=", mrb_SDL_SDLMessageBoxButtonData_set_text, MRB_ARGS_ARG(1, 0));
#endif
}
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
mruby_sdl2_video_surface_init(mrb_state *mrb, struct RClass *mod_Video)
{
class_Surface = mrb_define_class_under(mrb, mod_Video, "Surface", mrb->object_class);
MRB_SET_INSTANCE_TT(class_Surface, MRB_TT_DATA);
mrb_define_method(mrb, class_Surface, "initialize", mrb_sdl2_video_surface_initialize, MRB_ARGS_REQ(8));
mrb_define_method(mrb, class_Surface, "free", mrb_sdl2_video_surface_free, MRB_ARGS_NONE());
mrb_define_method(mrb, class_Surface, "destroy", mrb_sdl2_video_surface_free, MRB_ARGS_NONE());
mrb_define_method(mrb, class_Surface, "blit_scaled", mrb_sdl2_video_surface_blit_scaled, MRB_ARGS_REQ(2) | MRB_ARGS_OPT(1));
mrb_define_method(mrb, class_Surface, "blit_surface", mrb_sdl2_video_surface_blit_surface, MRB_ARGS_REQ(3));
mrb_define_method(mrb, class_Surface, "blit_from_string",mrb_sdl2_video_surface_blit_from_string,MRB_ARGS_REQ(5));
mrb_define_method(mrb, class_Surface, "convert_format", mrb_sdl2_video_surface_convert_format, MRB_ARGS_REQ(2));
mrb_define_method(mrb, class_Surface, "fill_rect", mrb_sdl2_video_surface_fill_rect, MRB_ARGS_REQ(1) | MRB_ARGS_OPT(1));
mrb_define_method(mrb, class_Surface, "fill_rects", mrb_sdl2_video_surface_fill_rects, MRB_ARGS_REQ(2));
mrb_define_method(mrb, class_Surface, "clip_rect", mrb_sdl2_video_surface_get_clip_rect, MRB_ARGS_NONE());
mrb_define_method(mrb, class_Surface, "clip_rect=", mrb_sdl2_video_surface_set_clip_rect, MRB_ARGS_REQ(1));
mrb_define_method(mrb, class_Surface, "color_key_get", mrb_sdl2_video_surface_get_color_key, MRB_ARGS_NONE());
mrb_define_method(mrb, class_Surface, "color_key_set", mrb_sdl2_video_surface_get_solor_key, MRB_ARGS_REQ(2));
mrb_define_method(mrb, class_Surface, "alpha_mod", mrb_sdl2_video_surface_get_alpha_mod, MRB_ARGS_NONE());
mrb_define_method(mrb, class_Surface, "alpha_mod=", mrb_sdl2_video_surface_set_alpha_mod, MRB_ARGS_REQ(1));
mrb_define_method(mrb, class_Surface, "blend_mode", mrb_sdl2_video_surface_get_blend_mode, MRB_ARGS_NONE());
mrb_define_method(mrb, class_Surface, "blend_mode=", mrb_sdl2_video_surface_set_blend_mode, MRB_ARGS_REQ(1));
mrb_define_method(mrb, class_Surface, "color_mod", mrb_sdl2_video_surface_get_color_mod, MRB_ARGS_NONE());
mrb_define_method(mrb, class_Surface, "color_mod=", mrb_sdl2_video_surface_set_color_mod, MRB_ARGS_REQ(1));
mrb_define_method(mrb, class_Surface, "palette", mrb_sdl2_video_surface_set_palette, MRB_ARGS_REQ(1));
mrb_define_method(mrb, class_Surface, "rle", mrb_sdl2_video_surface_set_rle, MRB_ARGS_REQ(1));
mrb_define_method(mrb, class_Surface, "lock", mrb_sdl2_video_surface_lock, MRB_ARGS_NONE());
mrb_define_method(mrb, class_Surface, "unlock", mrb_sdl2_video_surface_unlock, MRB_ARGS_NONE());
mrb_define_class_method(mrb, class_Surface, "load_bmp", mrb_sdl2_video_surface_load_bmp, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, class_Surface, "save_bmp", mrb_sdl2_video_surface_save_bmp, MRB_ARGS_REQ(2));
}
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_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, "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);
mrb_alias_method(mrb, mrb->module_class, mrb_intern(mrb, "dup"), mrb_intern(mrb, "clone"));
}
void mrb_SDL_SDLVersion_init(mrb_state* mrb) {
RClass* SDLVersion_class = mrb_define_class_under(mrb, SDL_module(mrb), "Version", mrb->object_class);
MRB_SET_INSTANCE_TT(SDLVersion_class, MRB_TT_DATA);
#if BIND_SDLVersion_INITIALIZE
mrb_define_method(mrb, SDLVersion_class, "initialize", mrb_SDL_SDLVersion_initialize, MRB_ARGS_NONE());
#endif
mrb_define_class_method(mrb, SDLVersion_class, "disown", mrb_SDL_SDLVersion_disown, MRB_ARGS_ARG(1, 0));
mrb_define_class_method(mrb, SDLVersion_class, "belongs_to_ruby?", mrb_SDL_SDLVersion_belongs_to_ruby, MRB_ARGS_ARG(1, 0));
/*
* Fields
*/
#if BIND_SDLVersion_major_FIELD_READER
mrb_define_method(mrb, SDLVersion_class, "major", mrb_SDL_SDLVersion_get_major, MRB_ARGS_ARG(0, 0));
#endif
#if BIND_SDLVersion_major_FIELD_WRITER
mrb_define_method(mrb, SDLVersion_class, "major=", mrb_SDL_SDLVersion_set_major, MRB_ARGS_ARG(1, 0));
#endif
#if BIND_SDLVersion_minor_FIELD_READER
mrb_define_method(mrb, SDLVersion_class, "minor", mrb_SDL_SDLVersion_get_minor, MRB_ARGS_ARG(0, 0));
#endif
#if BIND_SDLVersion_minor_FIELD_WRITER
mrb_define_method(mrb, SDLVersion_class, "minor=", mrb_SDL_SDLVersion_set_minor, MRB_ARGS_ARG(1, 0));
#endif
#if BIND_SDLVersion_patch_FIELD_READER
mrb_define_method(mrb, SDLVersion_class, "patch", mrb_SDL_SDLVersion_get_patch, MRB_ARGS_ARG(0, 0));
#endif
#if BIND_SDLVersion_patch_FIELD_WRITER
mrb_define_method(mrb, SDLVersion_class, "patch=", mrb_SDL_SDLVersion_set_patch, MRB_ARGS_ARG(1, 0));
#endif
}
static mrb_value
make_struct(mrb_state *mrb, mrb_value name, mrb_value members, struct RClass * klass)
{
mrb_value nstr;
mrb_sym id;
struct RClass *c;
if (mrb_nil_p(name)) {
c = mrb_class_new(mrb, klass);
}
else {
/* old style: should we warn? */
name = mrb_str_to_str(mrb, name);
id = mrb_obj_to_sym(mrb, name);
if (!is_const_id(mrb, mrb_sym2name_len(mrb, id, NULL))) {
mrb_name_error(mrb, id, "identifier %S needs to be constant", name);
}
if (mrb_const_defined_at(mrb, mrb_obj_value(klass), id)) {
mrb_warn(mrb, "redefining constant Struct::%S", name);
mrb_const_remove(mrb, mrb_obj_value(klass), id);
}
c = mrb_define_class_under(mrb, klass, RSTRING_PTR(name), klass);
}
MRB_SET_INSTANCE_TT(c, MRB_TT_ARRAY);
nstr = mrb_obj_value(c);
mrb_iv_set(mrb, nstr, mrb_intern_lit(mrb, "__members__"), members);
mrb_define_class_method(mrb, c, "new", mrb_instance_new, MRB_ARGS_ANY());
mrb_define_class_method(mrb, c, "[]", mrb_instance_new, MRB_ARGS_ANY());
mrb_define_class_method(mrb, c, "members", mrb_struct_s_members_m, MRB_ARGS_NONE());
/* RSTRUCT(nstr)->basic.c->super = c->c; */
make_struct_define_accessors(mrb, members, c);
return nstr;
}
void
mrb_mruby_opencv_highgui_init(mrb_state* mrb, struct RClass *class_cv) {
mrb_define_class_method(mrb, class_cv, "imshow", mrb_mruby_opencv_imshow, ARGS_OPT(2));
mrb_define_class_method(mrb, class_cv, "namedWindow", mrb_mruby_opencv_namedWindow, ARGS_ANY());
mrb_define_class_method(mrb, class_cv, "waitKey", mrb_mruby_opencv_waitKey, ARGS_ANY());
mrb_define_class_method(mrb, class_cv, "imread", mrb_mruby_opencv_imread, ARGS_OPT(1));
}
void init_cfunc_platform(mrb_state *mrb, struct RClass* module)
{
struct RClass *struct_class = mrb_define_class_under(mrb, module, "Platform", mrb->object_class);
mrb_define_class_method(mrb, struct_class, "is_posix?", cfunc_platform_is_posix, ARGS_NONE());
mrb_define_class_method(mrb, struct_class, "is_win32?", cfunc_platform_is_win32, ARGS_NONE());
mrb_define_class_method(mrb, struct_class, "is_darwin?", cfunc_platform_is_darwin, ARGS_NONE());
}
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_ripemd_gem_init(mrb_state* mrb)
{
struct RClass *rmd160;
rmd160 = mrb_define_class(mrb, "RMD160", mrb->object_class);
mrb_define_class_method(mrb , rmd160, "hexdigest", mrb_rmd160_s__hexdigest, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb , rmd160, "digest", mrb_rmd160_s__digest, MRB_ARGS_REQ(1));
}
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_mruby_ipaddr_gem_init(mrb_state *mrb)
{
struct RClass *c;
c = mrb_define_class(mrb, "IPAddr", mrb->object_class);
mrb_define_class_method(mrb, c, "_pton", mrb_ipaddr_pton, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, c, "ntop", mrb_ipaddr_ntop, MRB_ARGS_REQ(1));
}
void
mrb_pp_core_init(mrb_state *mrb)
{
mrb_pp_core_module = mrb_define_module_under(mrb, mrb_pp_module, "Core");
mrb_define_class_method(mrb, mrb_pp_core_module, "get_time", get_time, MRB_ARGS_NONE());
mrb_define_class_method(mrb, mrb_pp_core_module, "get_time_ticks", get_time_ticks, MRB_ARGS_NONE());
//mrb_define_class_method(mrb, mrb_pp_core_module, "call_on_main_thread", call_on_main_thread, MRB_ARGS_ARG(2,1));
//mrb_define_class_method(mrb, mrb_pp_core_module, "is_main_thread", is_main_thread, 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));
}
static mrb_value
make_struct(mrb_state *mrb, mrb_value name, mrb_value members, struct RClass * klass)
{
mrb_value nstr, *ptr_members;
mrb_sym id;
long i, len;
struct RClass *c;
//OBJ_FREEZE(members);
if (mrb_nil_p(name)) {
c = mrb_class_new(mrb, klass);
//mrb_make_metaclass(nstr, RBASIC(klass)->c);
//mrb_class_inherited(klass, nstr);
}
else {
/* old style: should we warn? */
name = mrb_str_to_str(mrb, name);
id = mrb_to_id(mrb, name);
if (!mrb_is_const_id(id)) {
//mrb_name_error(id, "identifier %s needs to be constant", StringValuePtr(name));
mrb_name_error(mrb, id, "identifier %s needs to be constant", mrb_string_value_ptr(mrb, name));
}
if (mrb_const_defined_at(mrb, klass, id)) {
//mrb_warn("redefining constant Struct::%s", StringValuePtr(name));
mrb_warn("redefining constant Struct::%s", mrb_string_value_ptr(mrb, name));
//?rb_mod_remove_const(klass, mrb_sym2name(mrb, id));
}
c = mrb_define_class_under(mrb, klass, RSTRING_PTR(name), klass);
}
MRB_SET_INSTANCE_TT(c, MRB_TT_STRUCT);
nstr = mrb_obj_value(c);
mrb_iv_set(mrb, nstr, mrb_intern(mrb, "__members__"), members);
mrb_define_class_method(mrb, c, "new", mrb_class_new_instance_m, ARGS_ANY());
mrb_define_class_method(mrb, c, "[]", mrb_class_new_instance_m, ARGS_ANY());
mrb_define_class_method(mrb, c, "members", mrb_struct_s_members_m, ARGS_NONE());
//RSTRUCT(nstr)->basic.c->super = c->c;
ptr_members = RARRAY_PTR(members);
len = RARRAY_LEN(members);
for (i=0; i< len; i++) {
mrb_sym id = SYM2ID(ptr_members[i]);
if (mrb_is_local_id(id) || mrb_is_const_id(id)) {
if (i < N_REF_FUNC) {
mrb_define_method_id(mrb, c, id, (mrb_func_t)ref_func[i], 0);
}
else {
mrb_define_method_id(mrb, c, id, mrb_struct_ref, 0);
}
mrb_define_method_id(mrb, c, mrb_id_attrset(id), (mrb_func_t)mrb_struct_set, 1);
}
}
return nstr;
}
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_ev3_battery_init(mrb_state *mrb, struct RClass *ev3)
{
struct RClass *bat;
/* Battery class */
bat = mrb_define_class_under(mrb, ev3, "Battery", mrb->object_class);
mrb_define_class_method(mrb, bat, "mA", mrb_battery_mA, MRB_ARGS_NONE());
mrb_define_class_method(mrb, bat, "mV", mrb_battery_mV, MRB_ARGS_NONE());
}
void mrb_SDL_SDLTexture_init(mrb_state* mrb) {
RClass* SDLTexture_class = mrb_define_class_under(mrb, SDL_module(mrb), "Texture", mrb->object_class);
MRB_SET_INSTANCE_TT(SDLTexture_class, MRB_TT_DATA);
#if BIND_SDLTexture_INITIALIZE
mrb_define_method(mrb, SDLTexture_class, "initialize", mrb_SDL_SDLTexture_initialize, MRB_ARGS_NONE());
#endif
mrb_define_class_method(mrb, SDLTexture_class, "disown", mrb_SDL_SDLTexture_disown, MRB_ARGS_ARG(1, 0));
mrb_define_class_method(mrb, SDLTexture_class, "belongs_to_ruby?", mrb_SDL_SDLTexture_belongs_to_ruby, MRB_ARGS_ARG(1, 0));
}
void
mrb_network_init(mrb_state* mrb)
{
struct RClass *network, *platform;
platform = mrb_class_get(mrb, "Platform");
network = mrb_define_class_under(mrb, platform, "Network", mrb->object_class);
mrb_define_class_method(mrb, network, "_ping", mrb_network__ping, MRB_ARGS_REQ(2));
mrb_define_class_method(mrb, network, "_dhcp_client_start", mrb_wifi_dhcp_client_start, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, network, "_dhcp_client_check", mrb_wifi_dhcp_client_check, MRB_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);
}
