static void
os_each_object_cb(mrb_state *mrb, struct RBasic *obj, void *ud)
{
struct os_each_object_data *d = (struct os_each_object_data*)ud;
/* filter dead objects */
if (mrb_object_dead_p(mrb, obj)) {
return;
}
/* filter internal objects */
switch (obj->tt) {
case MRB_TT_ENV:
case MRB_TT_ICLASS:
return;
default:
break;
}
/* filter half baked (or internal) objects */
if (!obj->c) return;
/* filter class kind if target module defined */
if (d->target_module && !mrb_obj_is_kind_of(mrb, mrb_obj_value(obj), d->target_module)) {
return;
}
mrb_yield(mrb, d->block, mrb_obj_value(obj));
++d->count;
}
static mrb_value
reject_i(mrb_state *mrb, mrb_value i, mrb_value ary, int argc, mrb_value *argv)
{
ENUM_WANT_SVALUE(mrb);
if (!RTEST(mrb_yield(i))) {
mrb_ary_push(mrb, ary, i);
}
return mrb_nil_value();
}
static mrb_value
find_i(mrb_state *mrb, mrb_value i, mrb_value *memo, int argc, mrb_value *argv)
{
ENUM_WANT_SVALUE(mrb);
if (RTEST(mrb_yield(i))) {
*memo = i;
mrb_iter_break();
}
return mrb_nil_value();
}
static mrb_value
grep_iter_i(mrb_state *mrb, mrb_value i, mrb_value args, int argc, mrb_value *argv)
{
mrb_value *arg = &args;
ENUM_WANT_SVALUE(mrb);
if (RTEST(mrb_funcall(mrb, arg[0], "===", 1, i))) {
mrb_ary_push(mrb, arg[1], mrb_yield(i));
}
return mrb_nil_value();
}
static mrb_value
partition_i(mrb_state *mrb, mrb_value i, mrb_value *ary, int argc, mrb_value *argv)
{
ENUM_WANT_SVALUE(mrb);
if (RTEST(mrb_yield(i))) {
mrb_ary_push(mrb, ary[0], i);
}
else {
mrb_ary_push(mrb, ary[1], i);
}
return mrb_nil_value();
}
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 mrb_value
mrb_queue_after(mrb_state *mrb, mrb_value self)
{
mrb_float delay_f;
mrb_value blk;
dispatch_queue_t q;
mrb_get_args(mrb, "f&", &delay_f, &blk);
DISPATCH_ENSURE_BLOCK_GIVEN(mrb, blk);
q = (dispatch_queue_t)DATA_PTR(self);
dispatch_time_t pop_time = dispatch_time(DISPATCH_TIME_NOW, (dispatch_time_t)(delay_f * NSEC_PER_SEC));
dispatch_after(pop_time, q, ^{
mrb_yield(mrb, blk, mrb_nil_value());
});
static void
os_each_object_cb(mrb_state *mrb, struct RBasic *obj, void *ud)
{
struct os_each_object_data *d = (struct os_each_object_data*)ud;
/* filter dead objects */
if (is_dead(mrb, obj)) {
return;
}
/* filter class kind if target module defined */
if (d->target_module && !mrb_obj_is_kind_of(mrb, mrb_obj_value(obj), d->target_module)) {
return;
}
mrb_yield(mrb, d->block, mrb_obj_value(obj));
++d->count;
}
static mrb_value mrb_sample_buffer_each_method(mrb_state *mrb, mrb_value self)
{
mrb_int i;
mrb_value block;
mrb_bool block_given;
mrb_sample_buffer *b = mrb_data_check_get_ptr(mrb, self, &mrb_sample_buffer_type);
mrb_get_args(mrb, "|&?", &block, &block_given);
if (block_given) {
for (i = 0; i < b->len; ++i) {
mrb_yield(mrb, block, mrb_float_value(mrb, MRB_SAMPLE_BUFFER_DATA(b)[i]));
}
return self;
} else {
return mrb_funcall(mrb, self, "enum_for", 1, mrb_symbol_value(mrb_intern_lit(mrb, "each")));
}
}
static int
parser_settings_on_message_complete(http_parser* parser)
{
mrb_value proc;
mrb_value c;
mrb_http_parser_context *context = (mrb_http_parser_context*) parser->data;
mrb_state* mrb = context->mrb;
proc = mrb_iv_get(context->mrb, context->instance, mrb_intern(context->mrb, "complete_cb"));
c = mrb_class_new_instance(mrb, 0, NULL, _class_http_request);
mrb_iv_set(mrb, c, mrb_intern(mrb, "parser_context"), mrb_obj_value(
Data_Wrap_Struct(mrb, mrb->object_class,
NULL, (void*) context)));
mrb_yield(context->mrb, proc, c);
return 0;
}
static mrb_value
bmfont_each_codepoint_from(mrb_state *mrb, mrb_value self)
{
char *cstr;
mrb_value blk;
ALLEGRO_USTR *ustr;
int pos = 0;
int codepoint = 0;
mrb_get_args(mrb, "z&", &cstr, &blk);
ustr = al_ustr_new(cstr);
for (codepoint = al_ustr_get_next(ustr, &pos); codepoint > 0; codepoint = al_ustr_get_next(ustr, &pos)) {
mrb_yield(mrb, blk, mrb_fixnum_value(codepoint));
}
if (ustr) al_ustr_free(ustr);
return mrb_nil_value();
}
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);
}
static mrb_value
mrb_f_fork(mrb_state *mrb, mrb_value klass)
{
mrb_value b, result;
int pid;
mrb_get_args(mrb, "&", &b);
switch (pid = fork()) {
case 0:
if (!mrb_nil_p(b)) {
mrb_yield(mrb, b, result);
_exit(0);
}
return mrb_nil_value();
case -1:
mrb_sys_fail(mrb, "fork failed");
return mrb_nil_value();
default:
return mrb_fixnum_value(pid);
}
}
