static ssize_t
mrb_wslay_event_recv_callback(wslay_event_context_ptr ctx,
uint8_t *buf, size_t len, int flags, void *user_data)
{
mrb_wslay_user_data *data = (mrb_wslay_user_data *) user_data;
mrb_state*mrb = data->mrb;
int ai = mrb_gc_arena_save(mrb);
struct mrb_jmpbuf *prev_jmp = mrb->jmp;
struct mrb_jmpbuf c_jmp;
mrb_int ret = -1;
MRB_TRY(&c_jmp) {
mrb->jmp = &c_jmp;
mrb_value argv[2];
argv[0] = mrb_cptr_value(mrb, buf);
argv[1] = mrb_fixnum_value(len);
errno = 0;
mrb_assert(mrb_type(data->recv_callback) == MRB_TT_PROC);
mrb_value buf_obj = mrb_yield_argv(mrb, data->recv_callback, NELEMS(argv), argv);
if (mrb_fixnum_p(buf_obj)) {
ret = mrb_fixnum(buf_obj);
} else {
buf_obj = mrb_str_to_str(mrb, buf_obj);
ret = RSTRING_LEN(buf_obj);
if (ret < 0||ret > len) {
mrb_raise(mrb, E_RANGE_ERROR, "returned buf doesn't fit");
}
if (ret > 0) {
memmove(buf, (uint8_t *) RSTRING_PTR(buf_obj), ret);
}
}
mrb->jmp = prev_jmp;
} MRB_CATCH(&c_jmp) {
mrb->jmp = prev_jmp;
if (mrb_obj_is_kind_of(mrb,
mrb_obj_value(mrb->exc),
mrb_class_get_under(mrb,
mrb_module_get(mrb, "Errno"), "EAGAIN"))||
mrb_obj_is_kind_of(mrb,
mrb_obj_value(mrb->exc),
mrb_class_get_under(mrb,
mrb_module_get(mrb, "Errno"), "EWOULDBLOCK"))) {
mrb->exc = NULL;
wslay_event_set_error(ctx, WSLAY_ERR_WOULDBLOCK);
} else {
wslay_event_set_error(ctx, WSLAY_ERR_CALLBACK_FAILURE);
}
} MRB_END_EXC(&c_jmp);
mrb_gc_arena_restore(mrb, ai);
return ret;
}
static mrb_value
signal_trap(mrb_state *mrb, mrb_value mod)
{
mrb_value command, block;
int sig;
mrb_value *argv;
mrb_int argc;
sighandler_t func;
struct RClass *mrb_mSignal = mrb_module_get(mrb, "Signal");
mrb_get_args(mrb, "*&", &argv, &argc, &block);
if (argc != 1 && argc != 2)
mrb_raisef(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (1..2 for %S)", mrb_fixnum_value(argc));
sig = trap_signm(mrb, argv[0]);
if (argc == 1) {
if (mrb_type(block) != MRB_TT_PROC) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "block must set");
}
command = block;
func = sighandler;
}
else {
command = argv[1];
func = trap_handler(mrb, &command, sig);
}
return trap(mrb, mrb_obj_value(mrb_mSignal), sig, func, command);
}
void
mrb_init_io(mrb_state *mrb)
{
struct RClass *io;
io = mrb_define_class(mrb, "IO", mrb->object_class);
MRB_SET_INSTANCE_TT(io, MRB_TT_DATA);
mrb_include_module(mrb, io, mrb_module_get(mrb, "Enumerable")); /* 15.2.20.3 */
#ifndef _WIN32
mrb_define_class_method(mrb, io, "_popen", mrb_io_s_popen, MRB_ARGS_ANY());
mrb_define_class_method(mrb, io, "_sysclose", mrb_io_s_sysclose, MRB_ARGS_REQ(1));
#endif
mrb_define_class_method(mrb, io, "select", mrb_io_s_select, MRB_ARGS_ANY());
mrb_define_class_method(mrb, io, "sysopen", mrb_io_s_sysopen, MRB_ARGS_ANY());
mrb_define_method(mrb, io, "initialize", mrb_io_initialize, MRB_ARGS_ANY()); /* 15.2.20.5.21 (x)*/
mrb_define_method(mrb, io, "sync", mrb_io_sync, MRB_ARGS_NONE());
mrb_define_method(mrb, io, "sync=", mrb_io_set_sync, MRB_ARGS_REQ(1));
mrb_define_method(mrb, io, "sysread", mrb_io_sysread, MRB_ARGS_ANY());
mrb_define_method(mrb, io, "sysseek", mrb_io_sysseek, MRB_ARGS_REQ(1));
mrb_define_method(mrb, io, "syswrite", mrb_io_syswrite, MRB_ARGS_REQ(1));
mrb_define_method(mrb, io, "close", mrb_io_close, MRB_ARGS_NONE()); /* 15.2.20.5.1 */
mrb_define_method(mrb, io, "close_on_exec=", mrb_io_set_close_on_exec, MRB_ARGS_REQ(1));
mrb_define_method(mrb, io, "close_on_exec?", mrb_io_close_on_exec_p, MRB_ARGS_NONE());
mrb_define_method(mrb, io, "closed?", mrb_io_closed, MRB_ARGS_NONE()); /* 15.2.20.5.2 */
mrb_define_method(mrb, io, "pid", mrb_io_pid, MRB_ARGS_NONE()); /* 15.2.20.5.2 */
mrb_define_method(mrb, io, "fileno", mrb_io_fileno, MRB_ARGS_NONE());
mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$/"), mrb_str_new_cstr(mrb, "\n"));
}
void mrb_fltk_widget_class_init( mrb_state *mrb ) {
ARENA_SAVE;
struct RClass *mrb_fltk_module = mrb_module_get( mrb, "FLTK" );
DEFINE_CLASS( widget, Widget, mrb->object_class );
DEFINE_INSTANCE_METHOD( widget, activate, MRB_ARGS_NONE() );
DEFINE_INSTANCE_METHOD_ACCESSOR( widget, align );
DEFINE_INSTANCE_METHOD_ACCESSOR( widget, box );
DEFINE_INSTANCE_METHOD( widget, callback, MRB_ARGS_OPT( 1 ) );
DEFINE_INSTANCE_METHOD( widget, deactivate, MRB_ARGS_NONE() );
DEFINE_INSTANCE_METHOD_ACCESSOR( widget, height );
DEFINE_INSTANCE_METHOD( widget, hide, MRB_ARGS_NONE() );
DEFINE_INSTANCE_METHOD_ACCESSOR( widget, label );
DEFINE_INSTANCE_METHOD_ACCESSOR( widget, label_font );
DEFINE_INSTANCE_METHOD_ACCESSOR( widget, label_size );
DEFINE_INSTANCE_METHOD( widget, parent, MRB_ARGS_NONE() );
DEFINE_INSTANCE_METHOD( widget, redraw, MRB_ARGS_NONE() );
DEFINE_INSTANCE_METHOD( widget, show, MRB_ARGS_NONE() );
DEFINE_INSTANCE_METHOD( widget, take_focus, MRB_ARGS_NONE() );
DEFINE_INSTANCE_METHOD_ACCESSOR( widget, tooltip );
DEFINE_INSTANCE_METHOD_ACCESSOR( widget, type );
mrb_define_method( mrb, mrb_fltk_widget, "visible?", mrb_fltk_widget_visible_instance_method, MRB_ARGS_NONE() ); // TODO: DEFINE_INSTANCE_QUERY_METHOD macro
DEFINE_INSTANCE_METHOD_ACCESSOR( widget, when );
DEFINE_INSTANCE_METHOD_ACCESSOR( widget, width );
DEFINE_INSTANCE_METHOD_ACCESSOR( widget, x );
DEFINE_INSTANCE_METHOD_ACCESSOR( widget, y );
// mrb_define_method( mrb, mrb_fltk_widget_class, "image", mrb_fltk_widget_image_getter_instance_method, MRB_ARGS_NONE() );
// mrb_define_method( mrb, mrb_fltk_widget_class, "image=", mrb_fltk_widget_image_setter_instance_method, MRB_ARGS_REQ( 1 ) );
ARENA_RESTORE;
}
void
mrb_mruby_time_gem_init(mrb_state* mrb)
{
struct RClass *tc;
/* ISO 15.2.19.2 */
tc = mrb_define_class(mrb, "Time", mrb->object_class);
MRB_SET_INSTANCE_TT(tc, MRB_TT_DATA);
mrb_include_module(mrb, tc, mrb_module_get(mrb, "Comparable"));
mrb_define_class_method(mrb, tc, "at", mrb_time_at, MRB_ARGS_ARG(1, 1)); /* 15.2.19.6.1 */
mrb_define_class_method(mrb, tc, "gm", mrb_time_gm, MRB_ARGS_ARG(1,6)); /* 15.2.19.6.2 */
mrb_define_class_method(mrb, tc, "local", mrb_time_local, MRB_ARGS_ARG(1,6)); /* 15.2.19.6.3 */
mrb_define_class_method(mrb, tc, "mktime", mrb_time_local, MRB_ARGS_ARG(1,6));/* 15.2.19.6.4 */
mrb_define_class_method(mrb, tc, "now", mrb_time_now, MRB_ARGS_NONE()); /* 15.2.19.6.5 */
mrb_define_class_method(mrb, tc, "utc", mrb_time_gm, MRB_ARGS_ARG(1,6)); /* 15.2.19.6.6 */
mrb_define_method(mrb, tc, "==" , mrb_time_eq , MRB_ARGS_REQ(1));
mrb_define_method(mrb, tc, "<=>" , mrb_time_cmp , MRB_ARGS_REQ(1)); /* 15.2.19.7.1 */
mrb_define_method(mrb, tc, "+" , mrb_time_plus , MRB_ARGS_REQ(1)); /* 15.2.19.7.2 */
mrb_define_method(mrb, tc, "-" , mrb_time_minus , MRB_ARGS_REQ(1)); /* 15.2.19.7.3 */
mrb_define_method(mrb, tc, "to_s" , mrb_time_asctime, MRB_ARGS_NONE());
mrb_define_method(mrb, tc, "inspect", mrb_time_asctime, MRB_ARGS_NONE());
mrb_define_method(mrb, tc, "asctime", mrb_time_asctime, MRB_ARGS_NONE()); /* 15.2.19.7.4 */
mrb_define_method(mrb, tc, "ctime" , mrb_time_asctime, MRB_ARGS_NONE()); /* 15.2.19.7.5 */
mrb_define_method(mrb, tc, "day" , mrb_time_day , MRB_ARGS_NONE()); /* 15.2.19.7.6 */
mrb_define_method(mrb, tc, "dst?" , mrb_time_dst_p , MRB_ARGS_NONE()); /* 15.2.19.7.7 */
mrb_define_method(mrb, tc, "getgm" , mrb_time_getutc , MRB_ARGS_NONE()); /* 15.2.19.7.8 */
mrb_define_method(mrb, tc, "getlocal",mrb_time_getlocal,MRB_ARGS_NONE()); /* 15.2.19.7.9 */
mrb_define_method(mrb, tc, "getutc" , mrb_time_getutc , MRB_ARGS_NONE()); /* 15.2.19.7.10 */
mrb_define_method(mrb, tc, "gmt?" , mrb_time_utc_p , MRB_ARGS_NONE()); /* 15.2.19.7.11 */
mrb_define_method(mrb, tc, "gmtime" , mrb_time_utc , MRB_ARGS_NONE()); /* 15.2.19.7.13 */
mrb_define_method(mrb, tc, "hour" , mrb_time_hour, MRB_ARGS_NONE()); /* 15.2.19.7.15 */
mrb_define_method(mrb, tc, "localtime", mrb_time_localtime, MRB_ARGS_NONE()); /* 15.2.19.7.18 */
mrb_define_method(mrb, tc, "mday" , mrb_time_mday, MRB_ARGS_NONE()); /* 15.2.19.7.19 */
mrb_define_method(mrb, tc, "min" , mrb_time_min, MRB_ARGS_NONE()); /* 15.2.19.7.20 */
mrb_define_method(mrb, tc, "mon" , mrb_time_mon, MRB_ARGS_NONE()); /* 15.2.19.7.21 */
mrb_define_method(mrb, tc, "month", mrb_time_mon, MRB_ARGS_NONE()); /* 15.2.19.7.22 */
mrb_define_method(mrb, tc, "sec" , mrb_time_sec, MRB_ARGS_NONE()); /* 15.2.19.7.23 */
mrb_define_method(mrb, tc, "to_i", mrb_time_to_i, MRB_ARGS_NONE()); /* 15.2.19.7.25 */
mrb_define_method(mrb, tc, "to_f", mrb_time_to_f, MRB_ARGS_NONE()); /* 15.2.19.7.24 */
mrb_define_method(mrb, tc, "usec", mrb_time_usec, MRB_ARGS_NONE()); /* 15.2.19.7.26 */
mrb_define_method(mrb, tc, "utc" , mrb_time_utc, MRB_ARGS_NONE()); /* 15.2.19.7.27 */
mrb_define_method(mrb, tc, "utc?", mrb_time_utc_p,MRB_ARGS_NONE()); /* 15.2.19.7.28 */
mrb_define_method(mrb, tc, "wday", mrb_time_wday, MRB_ARGS_NONE()); /* 15.2.19.7.30 */
mrb_define_method(mrb, tc, "yday", mrb_time_yday, MRB_ARGS_NONE()); /* 15.2.19.7.31 */
mrb_define_method(mrb, tc, "year", mrb_time_year, MRB_ARGS_NONE()); /* 15.2.19.7.32 */
mrb_define_method(mrb, tc, "zone", mrb_time_zone, MRB_ARGS_NONE()); /* 15.2.19.7.33 */
mrb_define_method(mrb, tc, "initialize", mrb_time_initialize, MRB_ARGS_REQ(1)); /* 15.2.19.7.16 */
mrb_define_method(mrb, tc, "initialize_copy", mrb_time_initialize_copy, MRB_ARGS_REQ(1)); /* 15.2.19.7.17 */
/*
methods not available:
gmt_offset(15.2.19.7.12)
gmtoff(15.2.19.7.14)
utc_offset(15.2.19.7.29)
*/
}
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());
}
static ssize_t
mrb_wslay_event_send_callback(wslay_event_context_ptr ctx,
const uint8_t *buf, size_t len,
int flags, void *user_data)
{
mrb_wslay_user_data *data = (mrb_wslay_user_data *) user_data;
mrb_state* mrb = data->mrb;
int ai = mrb_gc_arena_save(mrb);
struct mrb_jmpbuf *prev_jmp = mrb->jmp;
struct mrb_jmpbuf c_jmp;
mrb_int ret = -1;
MRB_TRY(&c_jmp) {
data->mrb->jmp = &c_jmp;
errno = 0;
mrb_value buf_obj = mrb_str_new_static(mrb, (const char *) buf, len);
mrb_assert(mrb_type(data->send_callback) == MRB_TT_PROC);
mrb_value sent = mrb_yield(mrb, data->send_callback, buf_obj);
ret = mrb_int(mrb, sent);
mrb_assert(ret >= 0&&ret <= len);
mrb->jmp = prev_jmp;
} MRB_CATCH(&c_jmp) {
mrb->jmp = prev_jmp;
if (mrb_obj_is_kind_of(mrb,
mrb_obj_value(mrb->exc),
mrb_class_get_under(mrb,
mrb_module_get(mrb, "Errno"), "EAGAIN"))||
mrb_obj_is_kind_of(mrb,
mrb_obj_value(mrb->exc),
mrb_class_get_under(mrb,
mrb_module_get(mrb, "Errno"), "EWOULDBLOCK"))) {
mrb->exc = NULL;
wslay_event_set_error(ctx, WSLAY_ERR_WOULDBLOCK);
} else {
wslay_event_set_error(ctx, WSLAY_ERR_CALLBACK_FAILURE);
}
} MRB_END_EXC(&c_jmp);
mrb_gc_arena_restore(mrb, ai);
return ret;
}
static void
domain_error(mrb_state *mrb, const char *func)
{
struct RClass *math = mrb_module_get(mrb, "Math");
struct RClass *domainerror = mrb_class_get_under(mrb, math, "DomainError");
mrb_value str = mrb_str_new_cstr(mrb, func);
mrb_raisef(mrb, domainerror, "Numerical argument is out of domain - %S", str);
}
void
mrb_mruby_numeric_ext_gem_init(mrb_state* mrb)
{
struct RClass *i = mrb_module_get(mrb, "Integral");
mrb_define_method(mrb, i, "chr", mrb_int_chr, MRB_ARGS_NONE());
mrb_define_method(mrb, i, "allbits?", mrb_int_allbits, MRB_ARGS_REQ(1));
mrb_define_method(mrb, i, "anybits?", mrb_int_anybits, MRB_ARGS_REQ(1));
mrb_define_method(mrb, i, "nobits?", mrb_int_nobits, MRB_ARGS_REQ(1));
}
void
mrb_mruby_minigame_bmfont_gem_init(mrb_state *mrb)
{
struct RClass *c;
c = mrb_define_class_under(mrb, mrb_module_get(mrb, "Minigame"), "BMFont", mrb->object_class);
MRB_SET_INSTANCE_TT(c, MRB_TT_DATA);
mrb_define_method(mrb, c, "each_codepoint_from", bmfont_each_codepoint_from, MRB_ARGS_REQ(2));
}
static mrb_value
mrb_queue_create_instance(mrb_state *mrb)
{
struct RClass *dispatch_class, *queue_class;
dispatch_class = mrb_module_get(mrb, "Dispatch");
queue_class = mrb_class_get_under(mrb, dispatch_class, "Queue");
return mrb_obj_value(mrb_obj_alloc(mrb, MRB_TT_OBJECT, queue_class));
}
static RETSIGTYPE
sighandler(int sig)
{
mrb_state *mrb = global_mrb;
struct RClass *mrb_mSignal = mrb_module_get(mrb, "Signal");
mrb_value trap_list = mrb_iv_get(mrb, mrb_obj_value(mrb_mSignal), mrb_intern_lit(mrb, "trap_list"));
mrb_value command = mrb_ary_ref(mrb, trap_list, sig);
if (mrb_type(command) == MRB_TT_PROC) {
mrb_funcall(mrb, command, "call", 1, mrb_fixnum_value(sig));
} else {
mrb_signal(mrb, sig, sighandler);
/* default actions */
switch (sig) {
case SIGINT:
mrb_exc_raise(mrb, mrb_funcall(
mrb,
mrb_obj_value(mrb_class_get(mrb, "Interrupt")),
"new",
1,
mrb_str_new_cstr(mrb, "")
));
break;
#ifdef SIGHUP
case SIGHUP:
#endif
#ifdef SIGQUIT
case SIGQUIT:
#endif
#ifdef SIGTERM
case SIGTERM:
#endif
#ifdef SIGALRM
case SIGALRM:
#endif
#ifdef SIGUSR1
case SIGUSR1:
#endif
#ifdef SIGUSR2
case SIGUSR2:
#endif
mrb_exc_raise(mrb, mrb_funcall(
mrb,
mrb_obj_value(mrb_class_get(mrb, "SignalException")),
"new",
1,
mrb_fixnum_value(sig)
));
break;
default:
break;
}
}
}
static void
mrb_trap_exit(mrb_state *mrb)
{
struct RClass *mrb_mSignal = mrb_module_get(mrb, "Signal");
mrb_value trap_list = mrb_iv_get(mrb, mrb_obj_value(mrb_mSignal), mrb_intern_lit(mrb, "trap_list"));
mrb_value command = mrb_ary_ref(mrb, trap_list, 0);
if (mrb_type(command) == MRB_TT_PROC) {
mrb_ary_set(mrb, trap_list, 0, mrb_nil_value());
mrb_funcall(mrb, command, "call", 1, mrb_fixnum_value(0));
}
}
void mrb_fltk_input_class_init( mrb_state *mrb ) {
ARENA_SAVE;
struct RClass *mrb_fltk_module = mrb_module_get( mrb, "FLTK" );
struct RClass *mrb_fltk_widget_class = mrb_class_get_under( mrb, mrb_fltk_module, "Widget" );
DEFINE_CLASS( input, Input, mrb_fltk_widget_class );
DEFINE_INSTANCE_METHOD( input, initialize, ARGS_ANY() );
DEFINE_INSTANCE_METHOD_ACCESSOR( input, value );
ARENA_RESTORE;
}
static mrb_value
mrb_uv_thread_self(mrb_state *mrb, mrb_value self)
{
mrb_uv_thread *ctx;
ctx = (mrb_uv_thread*)mrb_malloc(mrb, sizeof(mrb_uv_thread));
ctx->instance = mrb_nil_value();
ctx->mrb = mrb;
ctx->thread = uv_thread_self();
return mrb_obj_value(Data_Wrap_Struct(
mrb, mrb_class_get_under(mrb, mrb_module_get(mrb, "UV"), "Thread"),
&mrb_uv_thread_type, ctx));
}
static mrb_value
mrb_http_parser_parse_url(mrb_state *mrb, mrb_value self)
{
mrb_value c;
mrb_value arg_data;
struct http_parser_url handle = {0};
struct RClass* _class_http, *_class_http_url;
mrb_get_args(mrb, "S", &arg_data);
if (http_parser_parse_url(RSTRING_PTR(arg_data), RSTRING_LEN(arg_data), FALSE, &handle)) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid URL");
}
_class_http = mrb_module_get(mrb, "HTTP");
_class_http_url = mrb_class_ptr(mrb_const_get(mrb, mrb_obj_value(_class_http), mrb_intern_cstr(mrb, "URL")));
c = mrb_obj_new(mrb, _class_http_url, 0, NULL);
if (handle.field_set & (1<<UF_SCHEMA)) {
OBJECT_SET(mrb, c, "schema", mrb_str_substr(mrb, arg_data, handle.field_data[UF_SCHEMA].off, handle.field_data[UF_SCHEMA].len));
}
if (handle.field_set & (1<<UF_HOST)) {
OBJECT_SET(mrb, c, "host", mrb_str_substr(mrb, arg_data, handle.field_data[UF_HOST].off, handle.field_data[UF_HOST].len));
}
if (handle.field_set & (1<<UF_HOST)) {
OBJECT_SET(mrb, c, "host", mrb_str_substr(mrb, arg_data, handle.field_data[UF_HOST].off, handle.field_data[UF_HOST].len));
}
if (handle.field_set & (1<<UF_PORT)) {
OBJECT_SET(mrb, c, "port", mrb_fixnum_value(handle.port));
} else {
if (handle.field_set & (1<<UF_SCHEMA)) {
mrb_value schema = mrb_str_substr(mrb, arg_data, handle.field_data[UF_SCHEMA].off, handle.field_data[UF_SCHEMA].len);
if (!mrb_nil_p(schema) && !strcmp("https", (char*) RSTRING_PTR(schema))) {
OBJECT_SET(mrb, c, "port", mrb_fixnum_value(443));
}
}
}
if (handle.field_set & (1<<UF_PATH)) {
OBJECT_SET(mrb, c, "path", mrb_str_substr(mrb, arg_data, handle.field_data[UF_PATH].off, handle.field_data[UF_PATH].len));
}
if (handle.field_set & (1<<UF_QUERY)) {
OBJECT_SET(mrb, c, "query", mrb_str_substr(mrb, arg_data, handle.field_data[UF_QUERY].off, handle.field_data[UF_QUERY].len));
}
if (handle.field_set & (1<<UF_FRAGMENT)) {
OBJECT_SET(mrb, c, "fragment", mrb_str_substr(mrb, arg_data, handle.field_data[UF_FRAGMENT].off, handle.field_data[UF_FRAGMENT].len));
}
return c;
}
void mrb_mruby_sample_buffer_gem_init(mrb_state* mrb)
{
struct RClass *sample_buffer_class;
sample_buffer_class = mrb_define_class(mrb, "SampleBuffer", mrb->object_class);
MRB_SET_INSTANCE_TT(sample_buffer_class, MRB_TT_DATA);
mrb_include_module(mrb, sample_buffer_class, mrb_module_get(mrb, "Enumerable"));
mrb_define_method(mrb, sample_buffer_class, "initialize", mrb_sample_buffer_initialize, MRB_ARGS_ARG(1, 1));
mrb_define_method(mrb, sample_buffer_class, "length", mrb_sample_buffer_length_method, MRB_ARGS_NONE());
mrb_define_method(mrb, sample_buffer_class, "size", mrb_sample_buffer_length_method, MRB_ARGS_NONE());
mrb_define_method(mrb, sample_buffer_class, "offset", mrb_sample_buffer_offset_method, MRB_ARGS_NONE());
mrb_define_method(mrb, sample_buffer_class, "[]", mrb_sample_buffer_get_method, MRB_ARGS_REQ(1));
mrb_define_method(mrb, sample_buffer_class, "[]=", mrb_sample_buffer_set_method, MRB_ARGS_REQ(2));
mrb_define_method(mrb, sample_buffer_class, "each", mrb_sample_buffer_each_method, MRB_ARGS_BLOCK());
mrb_define_method(mrb, sample_buffer_class, "slice", mrb_sample_buffer_slice_method, MRB_ARGS_ARG(1, 1));
mrb_define_method(mrb, sample_buffer_class, "channel", mrb_sample_buffer_channel_get_method, MRB_ARGS_REQ(0));
mrb_define_method(mrb, sample_buffer_class, "channel=", mrb_sample_buffer_channel_set_method, MRB_ARGS_REQ(1));
}
mrb_value mrb_mongo_collection_query(mrb_state *mrb, mrb_value self) {
mrb_value hash_query, query;
mrb_value query_params[2];
mrb_get_args(mrb, "|H", &hash_query);
if (!mrb_hash_p(hash_query)) {
hash_query = mrb_hash_new(mrb);
}
struct RClass *_class_mongo = mrb_module_get(mrb, "Mongo");
struct RClass *_class_mongo_query = mrb_class_ptr(mrb_const_get(mrb, mrb_obj_value(_class_mongo), mrb_intern_lit(mrb, "Query")));
query_params[0] = self;
query_params[1] = hash_query;
query = mrb_obj_new(mrb, _class_mongo_query, 2, query_params);
return query;
}
static void
io_set_process_status(mrb_state *mrb, pid_t pid, int status)
{
struct RClass *c_process, *c_status;
mrb_value v;
c_status = NULL;
if (mrb_class_defined(mrb, "Process")) {
c_process = mrb_module_get(mrb, "Process");
if (mrb_const_defined(mrb, mrb_obj_value(c_process), mrb_intern_cstr(mrb, "Status"))) {
c_status = mrb_class_get_under(mrb, c_process, "Status");
}
}
if (c_status != NULL) {
v = mrb_funcall(mrb, mrb_obj_value(c_status), "new", 2, mrb_fixnum_value(pid), mrb_fixnum_value(status));
} else {
v = mrb_fixnum_value(WEXITSTATUS(status));
}
mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$?"), v);
}
static mrb_value
mrb_sce_init(mrb_state *mrb, mrb_value self)
{
mrb_value c, e2c, m, str;
mrb_int n;
int argc, no_errno = 0;
char buf[20];
argc = mrb_get_args(mrb, "o|i", &m, &n);
if (argc == 1) {
if (mrb_type(m) == MRB_TT_FIXNUM) {
n = mrb_fixnum(m);
m = mrb_nil_value();
} else {
no_errno = 1;
}
}
if (!no_errno) {
e2c = mrb_const_get(mrb, mrb_obj_value(mrb_module_get(mrb, "Errno")), mrb_intern_lit(mrb, "Errno2class"));
c = mrb_hash_fetch(mrb, e2c, mrb_fixnum_value(n), mrb_nil_value());
if (!mrb_nil_p(c)) {
mrb_basic_ptr(self)->c = mrb_class_ptr(c);
str = mrb_str_new_cstr(mrb, strerror(n));
} else {
mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "errno"), mrb_fixnum_value(n));
str = mrb_str_new_cstr(mrb, "Unknown error: ");
snprintf(buf, sizeof(buf), "%d", (int)n);
mrb_str_cat2(mrb, str, buf);
}
} else {
str = mrb_str_new_cstr(mrb, "unknown error");
}
if (!mrb_nil_p(m)) {
mrb_str_cat2(mrb, str, " - ");
mrb_str_append(mrb, str, m);
}
mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "mesg"), str);
return self;
}
static void
mrb_wslay_event_on_msg_recv_callback(wslay_event_context_ptr ctx,
const struct wslay_event_on_msg_recv_arg *arg, void *user_data)
{
mrb_wslay_user_data *data = (mrb_wslay_user_data *) user_data;
mrb_state *mrb = data->mrb;
int ai = mrb_gc_arena_save(mrb);
struct mrb_jmpbuf *prev_jmp = mrb->jmp;
struct mrb_jmpbuf c_jmp;
MRB_TRY(&c_jmp) {
mrb->jmp = &c_jmp;
mrb_value argv[4];
argv[0] = mrb_fixnum_value(arg->rsv);
argv[1] = MRB_GET_OPCODE(mrb_fixnum_value(arg->opcode));
argv[2] = mrb_str_new(mrb, (const char *) arg->msg, arg->msg_length);
argv[3] = MRB_GET_STATUSCODE(mrb_fixnum_value(arg->status_code));
mrb_value on_msg_recv_arg = mrb_obj_new(mrb,
mrb_class_get_under(mrb,
mrb_module_get_under(mrb,
mrb_module_get(mrb, "Wslay"), "Event"), "OnMsgRecvArg"), NELEMS(argv), argv);
mrb_assert(mrb_type(data->on_msg_recv_callback) == MRB_TT_PROC);
mrb_yield(mrb, data->on_msg_recv_callback, on_msg_recv_arg);
mrb_gc_arena_restore(mrb, ai);
mrb->jmp = prev_jmp;
} MRB_CATCH(&c_jmp) {
mrb->jmp = prev_jmp;
wslay_event_set_error(ctx, WSLAY_ERR_CALLBACK_FAILURE);
mrb_gc_arena_restore(mrb, ai);
MRB_THROW(mrb->jmp);
} MRB_END_EXC(&c_jmp);
}
void mrb_fltk_native_file_chooser_class_init( mrb_state *mrb ) {
ARENA_SAVE;
struct RClass *mrb_fltk_module = mrb_module_get( mrb, "FLTK" );
DEFINE_CLASS( native_file_chooser, NativeFileChooser, mrb->object_class );
// enum Fl_Native_File_Chooser::Option
DEFINE_FIXNUM_CONSTANT( NO_OPTIONS, Fl_Native_File_Chooser::NO_OPTIONS, mrb_fltk_native_file_chooser ); // no options enabled
DEFINE_FIXNUM_CONSTANT( SAVEAS_CONFIRM, Fl_Native_File_Chooser::SAVEAS_CONFIRM, mrb_fltk_native_file_chooser ); // Show native 'Save As' overwrite confirm dialog (if supported)
DEFINE_FIXNUM_CONSTANT( NEW_FOLDER, Fl_Native_File_Chooser::NEW_FOLDER, mrb_fltk_native_file_chooser ); // Show 'New Folder' icon (if supported)
DEFINE_FIXNUM_CONSTANT( PREVIEW, Fl_Native_File_Chooser::PREVIEW, mrb_fltk_native_file_chooser ); // enable preview mode
// enum Fl_Native_File_Chooser::Type
DEFINE_FIXNUM_CONSTANT( BROWSE_FILE, Fl_Native_File_Chooser::BROWSE_FILE, mrb_fltk_native_file_chooser ); // browse files (lets user choose one file)
DEFINE_FIXNUM_CONSTANT( BROWSE_DIRECTORY, Fl_Native_File_Chooser::BROWSE_DIRECTORY, mrb_fltk_native_file_chooser ); // browse directories (lets user choose one directory)
DEFINE_FIXNUM_CONSTANT( BROWSE_MULTI_FILE, Fl_Native_File_Chooser::BROWSE_MULTI_FILE, mrb_fltk_native_file_chooser ); // browse files (lets user choose multiple files)
DEFINE_FIXNUM_CONSTANT( BROWSE_MULTI_DIRECTORY, Fl_Native_File_Chooser::BROWSE_MULTI_DIRECTORY, mrb_fltk_native_file_chooser ); // browse directories (lets user choose multiple directories)
DEFINE_FIXNUM_CONSTANT( BROWSE_SAVE_FILE, Fl_Native_File_Chooser::BROWSE_SAVE_FILE, mrb_fltk_native_file_chooser ); // browse to save a file
DEFINE_FIXNUM_CONSTANT( BROWSE_SAVE_DIRECTORY, Fl_Native_File_Chooser::BROWSE_SAVE_DIRECTORY, mrb_fltk_native_file_chooser ); // browse to save a directory
DEFINE_INSTANCE_METHOD( native_file_chooser, initialize, MRB_ARGS_OPT( 1 ) );
DEFINE_INSTANCE_METHOD_GETTER( native_file_chooser, count );
DEFINE_INSTANCE_METHOD_ACCESSOR( native_file_chooser, directory );
DEFINE_INSTANCE_METHOD_GETTER( native_file_chooser, error_message );
DEFINE_INSTANCE_METHOD( native_file_chooser, filename, MRB_ARGS_OPT( 1 ) );
DEFINE_INSTANCE_METHOD_ACCESSOR( native_file_chooser, filter );
DEFINE_INSTANCE_METHOD_ACCESSOR( native_file_chooser, filter_value );
DEFINE_INSTANCE_METHOD_GETTER( native_file_chooser, filters );
DEFINE_INSTANCE_METHOD_ACCESSOR( native_file_chooser, options );
DEFINE_INSTANCE_METHOD_ACCESSOR( native_file_chooser, preset_file );
DEFINE_INSTANCE_METHOD_GETTER( native_file_chooser, show );
DEFINE_INSTANCE_METHOD_ACCESSOR( native_file_chooser, title );
DEFINE_INSTANCE_METHOD_ACCESSOR( native_file_chooser, type );
ARENA_RESTORE;
}
/* Initializes the functionality that Eruta exposes to Ruby. */
int tr_init(mrb_state * mrb) {
// luaL_dostring(lua, "print 'Hello!' ");
struct RClass *krn;
struct RClass *pth;
struct RClass *sto;
struct RClass *gra;
struct RClass *spr;
struct RClass *thi;
struct RClass *eru;
struct RClass *aud;
struct RClass *cam;
struct RClass *sky;
mrb->ud = state_get();
eru = mrb_define_module(mrb, "Eruta");
pth = mrb_define_class_under(mrb, eru, "Path" , mrb->object_class);
MRB_SET_INSTANCE_TT(pth, MRB_TT_DATA);
/* Define some constants. */
TR_CONST_INT(mrb, eru, "FLIP_HORIZONTAL", ALLEGRO_FLIP_HORIZONTAL);
TR_CONST_INT(mrb, eru, "FLIP_VERTICAL" , ALLEGRO_FLIP_VERTICAL);
TR_CONST_INT(mrb, eru, "ALIGN_LEFT" , ALLEGRO_ALIGN_LEFT);
TR_CONST_INT(mrb, eru, "ALIGN_CENTRE" , ALLEGRO_ALIGN_CENTRE);
TR_CONST_INT(mrb, eru, "ALIGN_CENTER" , ALLEGRO_ALIGN_CENTER);
TR_CONST_INT(mrb, eru, "ALIGN_RIGHT" , ALLEGRO_ALIGN_RIGHT);
TR_CONST_INT(mrb, eru, "ALIGN_INTEGER" , ALLEGRO_ALIGN_INTEGER);
TR_CLASS_METHOD_NOARG(mrb, eru, "quit" , tr_state_done);
krn = mrb_module_get(mrb, "Kernel");
if(!krn) return -1;
TR_METHOD_ARGC(mrb, krn, "test" , tr_test , 1);
TR_METHOD_ARGC(mrb, krn, "warn" , tr_warn , 1);
TR_METHOD_ARGC(mrb, krn, "warning" , tr_warn , 1);
TR_METHOD_ARGC(mrb, krn, "log" , tr_log , 1);
TR_METHOD_ARGC(mrb, krn, "log_to" , tr_log_to , 2);
TR_METHOD_ARGC(mrb, krn, "log_enable" , tr_log_disable , 1);
TR_METHOD_ARGC(mrb, krn, "log_disable" , tr_log_enable , 1);
TR_METHOD_ARGC(mrb, krn, "script" , tr_script , 1);
cam = mrb_define_module_under(mrb, eru, "Camera");
TR_METHOD_ARGC(mrb, krn, "camera_track" , tr_camera_track, 1);
TR_METHOD_ARGC(mrb, krn, "camera_lockin", tr_lockin_maplayer, 1);
TR_METHOD_NOARG(mrb, krn, "camera_x" , tr_camera_x);
TR_METHOD_NOARG(mrb, krn, "camera_y" , tr_camera_y);
TR_METHOD_NOARG(mrb, krn, "camera_w" , tr_camera_w);
TR_METHOD_NOARG(mrb, krn, "camera_h" , tr_camera_h);
TR_METHOD_NOARG(mrb, krn, "camera_alpha", tr_camera_alpha);
TR_METHOD_NOARG(mrb, krn, "camera_theta", tr_camera_theta);
TR_METHOD_NOARG(mrb, krn, "camera_fov" , tr_camera_fov);
TR_CLASS_METHOD_NOARG(mrb, cam, "x" , tr_camera_x);
TR_CLASS_METHOD_NOARG(mrb, cam, "y" , tr_camera_y);
TR_CLASS_METHOD_NOARG(mrb, cam, "z" , tr_camera_z);
TR_CLASS_METHOD_NOARG(mrb, cam, "w" , tr_camera_w);
TR_CLASS_METHOD_NOARG(mrb, cam, "h" , tr_camera_h);
TR_CLASS_METHOD_NOARG(mrb, cam, "alpha", tr_camera_alpha);
TR_CLASS_METHOD_NOARG(mrb, cam, "theta", tr_camera_theta);
TR_CLASS_METHOD_NOARG(mrb, cam, "fov" , tr_camera_fov);
TR_CLASS_METHOD_ARGC(mrb, cam, "x=" , tr_camera_x_, 1);
TR_CLASS_METHOD_ARGC(mrb, cam, "y=" , tr_camera_y_, 1);
TR_CLASS_METHOD_ARGC(mrb, cam, "z=" , tr_camera_z_, 1);
TR_CLASS_METHOD_ARGC(mrb, cam, "alpha=", tr_camera_alpha_, 1);
TR_CLASS_METHOD_ARGC(mrb, cam, "theta=", tr_camera_theta_, 1);
TR_CLASS_METHOD_ARGC(mrb, cam, "fov=" , tr_camera_fov_, 1);
sky = mrb_define_module_under(mrb, eru, "Sky");
TR_CLASS_METHOD_ARGC(mrb, sky, "set_texture", tr_skybox_set_texture, 2);
TR_CLASS_METHOD_ARGC(mrb, sky, "set_rgb" , tr_skybox_set_rgb, 5);
TR_CONST_INT_EASY(mrb, sky, SKYBOX_, DIRECTION_UP);
TR_CONST_INT_EASY(mrb, sky, SKYBOX_, DIRECTION_DOWN);
TR_CONST_INT_EASY(mrb, sky, SKYBOX_, DIRECTION_NORTH);
TR_CONST_INT_EASY(mrb, sky, SKYBOX_, DIRECTION_EAST);
TR_CONST_INT_EASY(mrb, sky, SKYBOX_, DIRECTION_SOUTH);
TR_CONST_INT_EASY(mrb, sky, SKYBOX_, DIRECTION_WEST);
TR_CONST_INT(mrb, eru, "FLIP_HORIZONTAL", ALLEGRO_FLIP_HORIZONTAL);
/*
*/
TR_CLASS_METHOD_NOARG(mrb, eru, "show_fps", tr_show_fps);
TR_CLASS_METHOD_NOARG(mrb, eru, "show_area", tr_show_area);
TR_CLASS_METHOD_NOARG(mrb, eru, "show_graph", tr_show_graph);
TR_CLASS_METHOD_ARGC(mrb, eru, "show_fps=" , tr_show_fps_, 1);
TR_CLASS_METHOD_ARGC(mrb, eru, "show_area=" , tr_show_area_, 1);
TR_CLASS_METHOD_ARGC(mrb, eru, "show_graph=", tr_show_graph_, 1);
TR_CLASS_METHOD_ARGC(mrb, eru, "show_mouse_cursor=", tr_show_mouse_cursor_, 1);
TR_CLASS_METHOD_NOARG(mrb, eru, "time", tr_get_time);
/* Set up submodules. */
tr_sprite_init(mrb, eru);
tr_store_init(mrb, eru);
tr_graph_init(mrb, eru);
tr_audio_init(mrb, eru);
// must restore gc area here ????
mrb_gc_arena_restore(mrb, 0);
return 0;
}
mrb_value
mrb_uv_dlopen(mrb_state *mrb, char const *name)
{
mrb_value ret = mrb_obj_value(mrb_obj_alloc(mrb, MRB_TT_DATA, mrb_class_get_under(mrb, mrb_module_get(mrb, "UV"), "DL")));
uv_lib_t *lib = (uv_lib_t*)mrb_malloc(mrb, sizeof(uv_lib_t));
int err;
DATA_TYPE(ret) = &dl_type;
DATA_PTR(ret) = lib;
err = uv_dlopen(name, lib);
if (err == -1) {
mrb_raise(mrb, E_UV_ERROR, uv_dlerror(lib));
}
return ret;
}
/* Initializes the functionality that Eruta exposes to Ruby. */
int tr_init(mrb_state * mrb) {
// luaL_dostring(lua, "print 'Hello!' ");
struct RClass *krn;
struct RClass *pth;
struct RClass *sto;
struct RClass *gra;
struct RClass *spr;
struct RClass *thi;
struct RClass *eru;
struct RClass *aud;
eru = mrb_define_module(mrb, "Eruta");
pth = mrb_define_class_under(mrb, eru, "Path" , mrb->object_class);
MRB_SET_INSTANCE_TT(pth, MRB_TT_DATA);
/* Define some constants. */
TR_CONST_INT(mrb, eru, "FLIP_HORIZONTAL", ALLEGRO_FLIP_HORIZONTAL);
TR_CONST_INT(mrb, eru, "FLIP_VERTICAL" , ALLEGRO_FLIP_VERTICAL);
TR_CONST_INT(mrb, eru, "ALIGN_LEFT" , ALLEGRO_ALIGN_LEFT);
TR_CONST_INT(mrb, eru, "ALIGN_CENTRE" , ALLEGRO_ALIGN_CENTRE);
TR_CONST_INT(mrb, eru, "ALIGN_CENTER" , ALLEGRO_ALIGN_CENTER);
TR_CONST_INT(mrb, eru, "ALIGN_RIGHT" , ALLEGRO_ALIGN_RIGHT);
TR_CONST_INT(mrb, eru, "ALIGN_INTEGER" , ALLEGRO_ALIGN_INTEGER);
TR_CLASS_METHOD_NOARG(mrb, eru, "quit" , tr_state_done);
krn = mrb_module_get(mrb, "Kernel");
if(!krn) return -1;
TR_METHOD_ARGC(mrb, krn, "test" , tr_test , 1);
TR_METHOD_ARGC(mrb, krn, "warn" , tr_warn , 1);
TR_METHOD_ARGC(mrb, krn, "warning" , tr_warn , 1);
TR_METHOD_ARGC(mrb, krn, "log" , tr_log , 1);
TR_METHOD_ARGC(mrb, krn, "log_to" , tr_log_to , 2);
TR_METHOD_ARGC(mrb, krn, "log_enable" , tr_log_disable , 1);
TR_METHOD_ARGC(mrb, krn, "log_disable" , tr_log_enable , 1);
TR_METHOD_ARGC(mrb, krn, "script" , tr_script , 1);
TR_METHOD_ARGC(mrb, krn, "camera_track" , tr_camera_track, 1);
TR_METHOD_ARGC(mrb, krn, "camera_lockin", tr_lockin_maplayer, 1);
TR_METHOD_NOARG(mrb, krn, "camera_x" , tr_camera_x);
TR_METHOD_NOARG(mrb, krn, "camera_y" , tr_camera_y);
TR_METHOD_NOARG(mrb, krn, "camera_w" , tr_camera_w);
TR_METHOD_NOARG(mrb, krn, "camera_h" , tr_camera_h);
/*
*/
TR_METHOD_NOARG(mrb, krn, "active_map", tr_active_map);
TR_METHOD_ARGC(mrb, krn, "active_map_", tr_active_map_, 1);
TR_CLASS_METHOD_NOARG(mrb, eru, "active_map", tr_active_map);
TR_CLASS_METHOD_ARGC(mrb, eru, "active_map_", tr_active_map_, 1);
TR_CLASS_METHOD_NOARG(mrb, eru, "show_fps", tr_show_fps);
TR_CLASS_METHOD_NOARG(mrb, eru, "show_area", tr_show_area);
TR_CLASS_METHOD_NOARG(mrb, eru, "show_graph", tr_show_graph);
TR_CLASS_METHOD_NOARG(mrb, eru, "show_physics", tr_show_physics);
TR_CLASS_METHOD_ARGC(mrb, eru, "show_fps=" , tr_show_fps_, 1);
TR_CLASS_METHOD_ARGC(mrb, eru, "show_area=" , tr_show_area_, 1);
TR_CLASS_METHOD_ARGC(mrb, eru, "show_graph=", tr_show_graph_, 1);
TR_CLASS_METHOD_NOARG(mrb, eru, "show_physics=", tr_show_physics_);
TR_CLASS_METHOD_ARGC(mrb, eru, "show_mouse_cursor=", tr_show_mouse_cursor_, 1);
TR_CLASS_METHOD_NOARG(mrb, eru, "time", tr_get_time);
/* Set up submodules. */
tr_sprite_init(mrb, eru);
tr_thing_init(mrb, eru);
tr_store_init(mrb, eru);
tr_graph_init(mrb, eru);
tr_audio_init(mrb, eru);
// must restore gc area here ????
mrb_gc_arena_restore(mrb, 0);
return 0;
}
static mrb_value
mrb_sce_errno(mrb_state *mrb, mrb_value self)
{
struct RClass *c;
mrb_sym sym;
c = mrb_class(mrb, self);
sym = mrb_intern_lit(mrb, "Errno");
#if MRUBY_RELEASE_NO < 10000
if (mrb_const_defined_at(mrb, c, sym)) {
#else
if (mrb_const_defined_at(mrb, mrb_obj_value(c), sym)) {
#endif
return mrb_const_get(mrb, mrb_obj_value(c), sym);
} else {
sym = mrb_intern_lit(mrb, "errno");
return mrb_attr_get(mrb, self, sym);
}
}
static mrb_value
mrb_sce_to_s(mrb_state *mrb, mrb_value self)
{
return mrb_attr_get(mrb, self, mrb_intern_lit(mrb, "mesg"));
}
static mrb_value
mrb_sce_sys_fail(mrb_state *mrb, mrb_value cls)
{
struct RClass *cl, *sce;
mrb_value e, msg;
mrb_int no;
int argc;
char name[8];
sce = mrb_class_get(mrb, "SystemCallError");
argc = mrb_get_args(mrb, "i|S", &no, &msg);
if (argc == 1) {
e = mrb_funcall(mrb, mrb_obj_value(sce), "new", 1, mrb_fixnum_value(no));
} else {
e = mrb_funcall(mrb, mrb_obj_value(sce), "new", 2, msg, mrb_fixnum_value(no));
}
if (mrb_obj_class(mrb, e) == sce) {
snprintf(name, sizeof(name), "E%03ld", (long)no);
cl = mrb_define_class_under(mrb, mrb_module_get(mrb, "Errno"), name, sce);
mrb_define_const(mrb, cl, "Errno", mrb_fixnum_value(no));
mrb_basic_ptr(e)->c = cl;
}
mrb_exc_raise(mrb, e);
return mrb_nil_value(); /* NOTREACHED */
}
static mrb_value
mrb_exxx_init(mrb_state *mrb, mrb_value self)
{
mrb_value m, no, str;
no = mrb_const_get(mrb, mrb_obj_value(mrb_class(mrb, self)), mrb_intern_lit(mrb, "Errno"));
str = mrb_str_new_cstr(mrb, strerror(mrb_fixnum(no)));
m = mrb_nil_value();
mrb_get_args(mrb, "|S", &m);
if (!mrb_nil_p(m)) {
mrb_str_cat2(mrb, str, " - ");
mrb_str_append(mrb, str, m);
}
mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "mesg"), str);
return self;
}
static mrb_value
_http_parser_parse(mrb_state *mrb, mrb_value self, int type)
{
mrb_value arg_data = mrb_nil_value();
mrb_value value_context;
mrb_http_parser_context* context;
mrb_value b = mrb_nil_value();
struct RClass* _class_http;
struct RClass* clazz;
char* data;
size_t len;
char* eol;
size_t done;
value_context = mrb_iv_get(mrb, self, mrb_intern_cstr(mrb, "context"));
Data_Get_Struct(mrb, value_context, &http_parser_context_type, context);
if (!context) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
}
mrb_get_args(mrb, "|&o", &b, &arg_data);
if (mrb_nil_p(arg_data)) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
}
context->parser.data = context;
_class_http = mrb_module_get(mrb, "HTTP");
if (type == HTTP_REQUEST) {
clazz = mrb_class_ptr(mrb_const_get(mrb, mrb_obj_value(_class_http), mrb_intern_cstr(mrb, "Request")));
context->instance = mrb_obj_new(mrb, clazz, 0, NULL);
} else {
clazz = mrb_class_ptr(mrb_const_get(mrb, mrb_obj_value(_class_http), mrb_intern_cstr(mrb, "Response")));
context->instance = mrb_obj_new(mrb, clazz, 0, NULL);
}
context->was_header_value = TRUE;
http_parser_init(&context->parser, type);
context->type = type;
context->settings.on_url = parser_settings_on_url;
context->settings.on_header_field = parser_settings_on_header_field;
context->settings.on_header_value = parser_settings_on_header_value;
context->settings.on_headers_complete = parser_settings_on_headers_complete;
context->settings.on_body = parser_settings_on_body;
context->settings.on_message_complete = parser_settings_on_message_complete;
data = RSTRING_PTR(arg_data);
len = RSTRING_LEN(arg_data);
eol = strpbrk(data, "\r\n");
if (eol) {
}
RETRY:
if (len > 10 && (!strncmp(data+9, "200 Connection established\r\n", 28) ||
!strncmp(data+9, "100 Continue\r\n", 14) || *(data+9) == '3')) {
char* next = strstr(data, "\r\n\r\n");
if (next) {
len -= (next + 4 - data);
data = next + 4;
goto RETRY;
}
}
done = http_parser_execute(&context->parser, &context->settings, data, len);
if (done < len) {
OBJECT_SET(mrb, context->instance, "body", mrb_str_new(mrb, data + done, len - done));
}
if (!mrb_nil_p(b)) {
mrb_value args[1];
args[0] = context->instance;
mrb_yield_argv(mrb, b, 1, args);
return mrb_nil_value();
}
return context->instance;
}
static mrb_value
mrb_jpeg_decompress_common(mrb_state *mrb, mrb_value self, enum decompress_type dtype)
{
struct jpeg_decompress_struct dinfo;
struct jpeg_error_mgr jpeg_error;
long scanline_size;
void *jpeg_data;
int row = 0;
struct RClass* module_jpeg;
struct RClass* class_jpeg_image;
mrb_value ivar;
mrb_value arg_config_hash = mrb_nil_value();
mrb_value arg_data = mrb_nil_value();
int argc = mrb_get_args(mrb, "S|H", &arg_data, &arg_config_hash);
if (mrb_nil_p(arg_data) || mrb_type(arg_data) != MRB_TT_STRING)
{
mrb_raise(mrb, E_ARGUMENT_ERROR, "Invalid argument");
}
if(argc > 1 && mrb_type(arg_config_hash) != MRB_TT_HASH)
{
mrb_raise(mrb, E_ARGUMENT_ERROR, "Invalid argument");
}
dinfo.client_data = mrb;
dinfo.err = jpeg_std_error(&jpeg_error);
dinfo.err->error_exit = jpeg_error_func;
jpeg_create_decompress(&dinfo);
if(dtype == FILE_SRC)
{
FILE *fp = fopen(RSTRING_PTR(arg_data), "r");
if(fp == NULL)
{
jpeg_destroy_decompress(&dinfo);
mrb_raise(mrb, E_RUNTIME_ERROR, "Could not open input file.");
}
jpeg_stdio_src(&dinfo, fp);
}
else
{
jpeg_memory_src(&dinfo, (const JOCTET *)RSTRING_PTR(arg_data), RSTRING_LEN(arg_data));
}
jpeg_read_header(&dinfo, 1);
if(!mrb_obj_equal(mrb, arg_config_hash, mrb_nil_value()) && HASH_TRUE(mrb, arg_config_hash, "force_grayscale"))
{
dinfo.output_components = 1;
}
else
{
if (dinfo.out_color_space == JCS_GRAYSCALE)
{
dinfo.output_components = 1;
}
else
{
dinfo.output_components = 3;
dinfo.out_color_space = JCS_RGB;
}
}
jpeg_start_decompress(&dinfo);
scanline_size = dinfo.image_width * dinfo.output_components;
jpeg_data = malloc(scanline_size * dinfo.image_height);
for(row = 0; row < dinfo.image_height; row++)
{
JSAMPROW jpeg_row = (JSAMPROW)(jpeg_data + (scanline_size * row));
jpeg_read_scanlines(&dinfo, &jpeg_row, 1);
}
module_jpeg = mrb_module_get(mrb, "JPEG");
class_jpeg_image = mrb_class_ptr(mrb_const_get(mrb, mrb_obj_value(module_jpeg), mrb_intern_lit(mrb, "JPEGImage")));
ivar = mrb_class_new_instance(mrb, 0, NULL, class_jpeg_image);
mrb_iv_set(mrb, ivar, mrb_intern_lit(mrb, "data"), mrb_str_new(mrb, jpeg_data, scanline_size * dinfo.image_height));
mrb_iv_set(mrb, ivar, mrb_intern_lit(mrb, "width"), mrb_fixnum_value(dinfo.image_width));
mrb_iv_set(mrb, ivar, mrb_intern_lit(mrb, "height"), mrb_fixnum_value(dinfo.image_height));
jpeg_finish_decompress(&dinfo);
jpeg_destroy_decompress(&dinfo);
return ivar;
}
void mrb_mruby_cgroup_gem_init(mrb_state *mrb)
{
struct RClass *cgroup;
struct RClass *cpu;
struct RClass *cpuacct;
struct RClass *cpuset;
struct RClass *blkio;
struct RClass *memory;
cgroup = mrb_define_module(mrb, "Cgroup");
mrb_define_module_function(mrb, cgroup, "create", mrb_cgroup_create, MRB_ARGS_NONE());
// BUG? cgroup_modify_cgroup fail fclose on cg_set_control_value: line:1389 when get existing cgroup controller
//mrb_define_module_function(mrb, cgroup, "modify", mrb_cgroup_modify, MRB_ARGS_NONE());
mrb_define_module_function(mrb, cgroup, "modify", mrb_cgroup_create, MRB_ARGS_NONE());
mrb_define_module_function(mrb, cgroup, "open", mrb_cgroup_create, MRB_ARGS_NONE());
mrb_define_module_function(mrb, cgroup, "delete", mrb_cgroup_delete, MRB_ARGS_NONE());
mrb_define_module_function(mrb, cgroup, "close", mrb_cgroup_delete, MRB_ARGS_NONE());
mrb_define_module_function(mrb, cgroup, "attach", mrb_cgroup_attach, MRB_ARGS_OPT(1));
//mrb_define_module_function(mrb, cgroup, "path", mrb_cgroup_get_current_path, MRB_ARGS_OPT(1));
mrb_define_module_function(mrb, cgroup, "exist?", mrb_cgroup_exist_p, MRB_ARGS_NONE());
mrb_define_module_function(mrb, cgroup, "attach", mrb_cgroup_attach, MRB_ARGS_ANY());
DONE;
cpu = mrb_define_class_under(mrb, cgroup, "CPU", mrb->object_class);
mrb_include_module(mrb, cpu, mrb_module_get(mrb, "Cgroup"));
mrb_define_method(mrb, cpu, "initialize", mrb_cgroup_cpu_init, MRB_ARGS_ANY());
mrb_define_method(mrb, cpu, "cfs_quota_us=", mrb_cgroup_set_cpu_cfs_quota_us, MRB_ARGS_ANY());
mrb_define_method(mrb, cpu, "cfs_quota_us", mrb_cgroup_get_cpu_cfs_quota_us, MRB_ARGS_NONE());
mrb_define_method(mrb, cpu, "cfs_period_us=", mrb_cgroup_set_cpu_cfs_period_us, MRB_ARGS_ANY());
mrb_define_method(mrb, cpu, "cfs_period_us", mrb_cgroup_get_cpu_cfs_period_us, MRB_ARGS_NONE());
mrb_define_method(mrb, cpu, "rt_period_us=", mrb_cgroup_set_cpu_rt_period_us, MRB_ARGS_ANY());
mrb_define_method(mrb, cpu, "rt_period_us", mrb_cgroup_get_cpu_rt_period_us, MRB_ARGS_NONE());
mrb_define_method(mrb, cpu, "rt_runtime_us=", mrb_cgroup_set_cpu_rt_runtime_us, MRB_ARGS_ANY());
mrb_define_method(mrb, cpu, "rt_runtime_us", mrb_cgroup_get_cpu_rt_runtime_us, MRB_ARGS_NONE());
mrb_define_method(mrb, cpu, "shares=", mrb_cgroup_set_cpu_shares, MRB_ARGS_ANY());
mrb_define_method(mrb, cpu, "shares", mrb_cgroup_get_cpu_shares, MRB_ARGS_NONE());
mrb_define_method(mrb, cpu, "stat", mrb_cgroup_get_cpu_stat, MRB_ARGS_NONE());
mrb_define_method(mrb, cpu, "cpuacct", mrb_cgroup_get_cpuacct_obj, MRB_ARGS_NONE());
DONE;
cpuacct = mrb_define_class_under(mrb, cgroup, "CPUACCT", mrb->object_class);
mrb_include_module(mrb, cpuacct, mrb_module_get(mrb, "Cgroup"));
mrb_define_method(mrb, cpuacct, "initialize", mrb_cgroup_cpuacct_init, MRB_ARGS_REQ(1));
mrb_define_method(mrb, cpuacct, "stat", mrb_cgroup_get_cpuacct_stat, MRB_ARGS_NONE());
mrb_define_method(mrb, cpuacct, "usage", mrb_cgroup_get_cpuacct_usage, MRB_ARGS_NONE());
mrb_define_method(mrb, cpuacct, "usage=", mrb_cgroup_set_cpuacct_usage, MRB_ARGS_REQ(1));
mrb_define_method(mrb, cpuacct, "usage_percpu", mrb_cgroup_get_cpuacct_usage_percpu, MRB_ARGS_NONE());
DONE;
cpuset = mrb_define_class_under(mrb, cgroup, "CPUSET", mrb->object_class);
mrb_include_module(mrb, cpuset, mrb_module_get(mrb, "Cgroup"));
mrb_define_method(mrb, cpuset, "initialize", mrb_cgroup_cpuset_init, MRB_ARGS_ANY());
mrb_define_method(mrb, cpuset, "cpus=", mrb_cgroup_set_cpuset_cpus, MRB_ARGS_REQ(1));
mrb_define_method(mrb, cpuset, "cpus", mrb_cgroup_get_cpuset_cpus, MRB_ARGS_NONE());
mrb_define_method(mrb, cpuset, "mems=", mrb_cgroup_set_cpuset_mems, MRB_ARGS_REQ(1));
mrb_define_method(mrb, cpuset, "mems", mrb_cgroup_get_cpuset_mems, MRB_ARGS_NONE());
DONE;
blkio = mrb_define_class_under(mrb, cgroup, "BLKIO", mrb->object_class);
mrb_include_module(mrb, blkio, mrb_module_get(mrb, "Cgroup"));
mrb_define_method(mrb, blkio, "initialize", mrb_cgroup_blkio_init, MRB_ARGS_ANY());
mrb_define_method(mrb, blkio, "throttle_read_bps_device=", mrb_cgroup_set_blkio_throttle_read_bps_device, MRB_ARGS_ANY());
mrb_define_method(mrb, blkio, "throttle_read_bps_device", mrb_cgroup_get_blkio_throttle_read_bps_device, MRB_ARGS_NONE());
mrb_define_method(mrb, blkio, "throttle_write_bps_device=", mrb_cgroup_set_blkio_throttle_write_bps_device, MRB_ARGS_ANY());
mrb_define_method(mrb, blkio, "throttle_write_bps_device", mrb_cgroup_get_blkio_throttle_write_bps_device, MRB_ARGS_ANY());
mrb_define_method(mrb, blkio, "throttle_read_iops_device=", mrb_cgroup_set_blkio_throttle_read_iops_device, MRB_ARGS_ANY());
mrb_define_method(mrb, blkio, "throttle_read_iops_device", mrb_cgroup_get_blkio_throttle_read_iops_device, MRB_ARGS_NONE());
mrb_define_method(mrb, blkio, "throttle_write_iops_device=", mrb_cgroup_set_blkio_throttle_write_iops_device, MRB_ARGS_ANY());
mrb_define_method(mrb, blkio, "throttle_write_iops_device", mrb_cgroup_get_blkio_throttle_write_iops_device, MRB_ARGS_NONE());
DONE;
memory = mrb_define_class_under(mrb, cgroup, "MEMORY", mrb->object_class);
mrb_include_module(mrb, memory, mrb_module_get(mrb, "Cgroup"));
mrb_define_method(mrb, memory, "initialize", mrb_cgroup_memory_init, MRB_ARGS_ANY());
mrb_define_method(mrb, memory, "limit_in_bytes=", mrb_cgroup_set_memory_limit_in_bytes, MRB_ARGS_ANY());
mrb_define_method(mrb, memory, "limit_in_bytes", mrb_cgroup_get_memory_limit_in_bytes, MRB_ARGS_NONE());
mrb_define_method(mrb, memory, "usage_in_bytes", mrb_cgroup_get_memory_usage_in_bytes, MRB_ARGS_NONE());
mrb_define_method(mrb, memory, "max_usage_in_bytes", mrb_cgroup_get_memory_max_usage_in_bytes, MRB_ARGS_NONE());
mrb_define_method(mrb, memory, "cgroup_event_control=", mrb_cgroup_set_memory_cgroup_event_control, MRB_ARGS_ANY());
mrb_define_method(mrb, memory, "oom_control=", mrb_cgroup_set_memory_oom_control, MRB_ARGS_ANY());
mrb_define_method(mrb, memory, "oom_control", mrb_cgroup_get_memory_oom_control, MRB_ARGS_NONE());
mrb_define_method(mrb, memory, "memsw_limit_in_bytes=", mrb_cgroup_set_memory_memsw_limit_in_bytes, MRB_ARGS_ANY());
mrb_define_method(mrb, memory, "memsw_limit_in_bytes", mrb_cgroup_get_memory_memsw_limit_in_bytes, MRB_ARGS_NONE());
mrb_define_method(mrb, memory, "memsw_usage_in_bytes", mrb_cgroup_get_memory_memsw_usage_in_bytes, MRB_ARGS_NONE());
mrb_define_method(mrb, memory, "memsw_max_usage_in_bytes", mrb_cgroup_get_memory_memsw_max_usage_in_bytes, MRB_ARGS_NONE());
DONE;
}
