mrb_value MCL_viewport_new (mrb_state *mrb, int x, int y, int w, int h) { mrb_value rect; mrb_value constructorparams[4]; constructorparams[0] = mrb_fixnum_value (x); constructorparams[1] = mrb_fixnum_value (y); constructorparams[2] = mrb_fixnum_value (w); constructorparams[3] = mrb_fixnum_value (h); rect = mrb_obj_new (mrb, mrb_class_get (mrb, "Rect"), 4, constructorparams); return mrb_obj_new (mrb, mrb_class_get (mrb, "Viewport"), 1, &rect); }
static mrb_value mrb_grn_expression_singleton_create(mrb_state *mrb, mrb_value klass) { grn_ctx *ctx = (grn_ctx *)mrb->ud; mrb_value mrb_expr; mrb_value mrb_table; mrb_value mrb_new_arguments[1]; grn_obj *expr, *variable = NULL; mrb_get_args(mrb, "o", &mrb_table); if (mrb_nil_p(mrb_table)) { expr = grn_expr_create(ctx, NULL, 0); } else { grn_obj *table = DATA_PTR(mrb_table); GRN_EXPR_CREATE_FOR_QUERY(ctx, table, expr, variable); } if (!expr) { grn_mrb_ctx_check(mrb); return mrb_nil_value(); } mrb_new_arguments[0] = mrb_cptr_value(mrb, expr); mrb_expr = mrb_obj_new(mrb, mrb_class_ptr(klass), 1, mrb_new_arguments); { mrb_value mrb_variable = mrb_nil_value(); if (variable) { mrb_variable = grn_mrb_value_from_grn_obj(mrb, variable); } mrb_iv_set(mrb, mrb_expr, mrb_intern_lit(mrb, "@variable"), mrb_variable); } return mrb_expr; }
static mrb_value indexable_find_index(mrb_state *mrb, mrb_value self) { grn_ctx *ctx = (grn_ctx *)mrb->ud; grn_obj *object; mrb_value mrb_operator; grn_operator operator; grn_index_datum index_datum; int n_index_data; mrb_get_args(mrb, "o", &mrb_operator); object = DATA_PTR(self); operator = grn_mrb_value_to_operator(mrb, mrb_operator); n_index_data = grn_column_find_index_data(ctx, object, operator, &index_datum, 1); if (n_index_data == 0) { return mrb_nil_value(); } else { grn_mrb_data *data; struct RClass *klass; mrb_value args[2]; data = &(ctx->impl->mrb); klass = mrb_class_get_under(mrb, data->module, "IndexInfo"); args[0] = grn_mrb_value_from_grn_obj(mrb, index_datum.index); args[1] = mrb_fixnum_value(index_datum.section); return mrb_obj_new(mrb, klass, 2, args); } }
mrb_value mrb_exec_command(mrb_state *mrb, mrb_value obj) { mrb_value command_str; mrb_get_args(mrb, "o", &command_str); char *command_p = mrb_str_to_cstr(mrb, command_str); char result_buff[BUF_SIZE]; FILE *fp; mrb_value buff_str; if ( (fp = popen(command_p, "r")) == NULL) { return mrb_nil_value(); } mrb_value str = mrb_obj_new(mrb, mrb_class_get(mrb, "String"), 0, NULL); while(fgets(result_buff, BUF_SIZE, fp) != NULL) { buff_str = mrb_str_new_cstr(mrb, result_buff); mrb_str_concat(mrb, str, buff_str); } int rc = pclose(fp); // Set the return code variable mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$?"), mrb_fixnum_value(WEXITSTATUS(rc))); return str; }
static mrb_value object_find_index(mrb_state *mrb, mrb_value self) { grn_ctx *ctx = (grn_ctx *)mrb->ud; grn_obj *object; mrb_value mrb_operator; grn_obj *index; int n_indexes; int section_id; mrb_get_args(mrb, "o", &mrb_operator); object = DATA_PTR(self); n_indexes = grn_column_index(ctx, object, mrb_fixnum(mrb_operator), &index, 1, §ion_id); if (n_indexes == 0) { return mrb_nil_value(); } else { grn_mrb_data *data; struct RClass *klass; mrb_value args[2]; data = &(ctx->impl->mrb); klass = mrb_class_get_under(mrb, data->module, "IndexInfo"); args[0] = grn_mrb_value_from_grn_obj(mrb, index); args[1] = mrb_fixnum_value(section_id); return mrb_obj_new(mrb, klass, 2, args); } }
mrb_value mrb_cp_contact_point_set_value(mrb_state *mrb, cpContactPointSet *points) { mrb_value cps; cps = mrb_obj_new(mrb, mrb_cp_contact_point_set_class, 0, NULL); mrb_iv_set(mrb, cps, mrb_intern_lit(mrb, "@count"), mrb_fixnum_value(points->count)); mrb_iv_set(mrb, cps, mrb_intern_lit(mrb, "@normal"), mrb_cp_vect_value(mrb, points->normal)); mrb_iv_set(mrb, cps, mrb_intern_lit(mrb, "@points"), mrb_cp_contact_points_value(mrb, points)); return cps; }
mrb_value MCL_rect_new (mrb_state *mrb, mrb_int x, mrb_int y, mrb_int w, mrb_int h) { mrb_value constructorparams[4]; constructorparams[0] = mrb_fixnum_value (x); constructorparams[1] = mrb_fixnum_value (y); constructorparams[2] = mrb_fixnum_value (w); constructorparams[3] = mrb_fixnum_value (h); return mrb_obj_new (mrb, mrb_class_get (mrb, "Rect"), 4, constructorparams); }
mrb_value MCL_color_new (mrb_state *mrb, mrb_int r, mrb_int g, mrb_int b, mrb_int a) { mrb_value constructorparams[4]; constructorparams[0] = mrb_fixnum_value (r); constructorparams[1] = mrb_fixnum_value (g); constructorparams[2] = mrb_fixnum_value (b); constructorparams[3] = mrb_fixnum_value (a); return mrb_obj_new (mrb, mrb_class_get (mrb, "Color"), 4, constructorparams); }
/* * call-seq: * Button[key] # => Button * * Get button object. * * Parameters: * +key+ Button name * :left Left button * :right Right button * :up Up button * :down Down button * :enter Enter button * :back Back button * * Returns Button object */ static mrb_value mrb_btn_get(mrb_state *mrb, mrb_value self) { mrb_sym sym; mrb_value symv; mrb_get_args(mrb, "n", &sym); symv = mrb_symbol_value(sym); return mrb_obj_new(mrb, mrb_class_ptr(self), 1, &symv); }
static mrb_value mrb_grn_scan_info_new(mrb_state *mrb, scan_info *scan_info) { grn_ctx *ctx = (grn_ctx *)mrb->ud; struct RClass *module = ctx->impl->mrb.module; struct RClass *klass; mrb_value mrb_scan_info; mrb_scan_info = mrb_cptr_value(mrb, scan_info); klass = mrb_class_get_under(mrb, module, "ScanInfo"); return mrb_obj_new(mrb, klass, 1, &mrb_scan_info); }
static mrb_value mrb_grn_expr_code_new(mrb_state *mrb, grn_expr_code *code) { grn_ctx *ctx = (grn_ctx *)mrb->ud; struct RClass *module = ctx->impl->mrb.module; struct RClass *klass; mrb_value mrb_code; mrb_code = mrb_cptr_value(mrb, code); klass = mrb_class_get_under(mrb, module, "ExpressionCode"); return mrb_obj_new(mrb, klass, 1, &mrb_code); }
/* * @return [Chipmunk2d::Transform] */ MRB_CP_EXTERN mrb_value mrb_cp_transform_value(mrb_state* mrb, cpTransform transform) { mrb_value result; mrb_value zero = mrb_float_value(mrb, 0.0f); mrb_value argv[6] = { zero, zero, zero, zero, zero, zero }; cpTransform* result_transform; result = mrb_obj_new(mrb, mrb_cp_transform_class, 6, argv); result_transform = mrb_cp_get_transform_ptr(mrb, result); *result_transform = transform; return result; }
static mrb_value eval_context_compile(mrb_state *mrb, mrb_value self) { char *script; mrb_int script_length; mrbc_context* compile_ctx; struct mrb_parser_state *parser; struct RProc *proc; mrb_get_args(mrb, "s", &script, &script_length); compile_ctx = mrbc_context_new(mrb); if (!compile_ctx) { mrb_raise(mrb, E_RUNTIME_ERROR, "[mruby][eval][compile] failed to allocate context"); } compile_ctx->capture_errors = TRUE; parser = mrb_parse_nstring(mrb, script, script_length, compile_ctx); if (!parser) { mrbc_context_free(mrb, compile_ctx); mrb_raise(mrb, E_RUNTIME_ERROR, "[mruby][eval][compile] failed to allocate parser"); } if (parser->nerr > 0) { struct mrb_parser_message *error = &(parser->error_buffer[0]); mrb_value new_args[1]; mrb_value exception; new_args[0] = mrb_format(mrb, "line %S:%S: %S", mrb_fixnum_value(error->lineno), mrb_fixnum_value(error->column), mrb_str_new_cstr(mrb, error->message)); exception = mrb_obj_new(mrb, E_SYNTAX_ERROR, 1, new_args); mrb_parser_free(parser); mrbc_context_free(mrb, compile_ctx); mrb_exc_raise(mrb, exception); } proc = mrb_generate_code(mrb, parser); { mrb_code *iseq = proc->body.irep->iseq; while (GET_OPCODE(*iseq) != OP_STOP) { iseq++; } *iseq = MKOP_AB(OP_RETURN, 1, OP_R_NORMAL); } mrb_parser_free(parser); mrbc_context_free(mrb, compile_ctx); return mrb_obj_value(proc); }
static mrb_value h2o_mrb_get_class_obj(mrb_state *mrb, mrb_value self, char *obj_id, char *class_name) { mrb_value obj; struct RClass *obj_class, *h2o_class; obj = mrb_iv_get(mrb, self, mrb_intern_cstr(mrb, obj_id)); if (mrb_nil_p(obj)) { h2o_class = mrb_class_get(mrb, "H2O"); obj_class = (struct RClass *)mrb_class_ptr(mrb_const_get(mrb, mrb_obj_value(h2o_class), mrb_intern_cstr(mrb, class_name))); obj = mrb_obj_new(mrb, obj_class, 0, NULL); mrb_iv_set(mrb, self, mrb_intern_cstr(mrb, obj_id), obj); } return obj; }
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; }
static mrb_value mrb_sdl2_video_surface_get_color_mod(mrb_state *mrb, mrb_value self) { uint8_t r, g, b; SDL_Surface *s = mrb_sdl2_video_surface_get_ptr(mrb, self); if (0 != SDL_GetSurfaceColorMod(s, &r, &g, &b)) { mruby_sdl2_raise_error(mrb); } mrb_value rgb[3] = { mrb_fixnum_value(r), mrb_fixnum_value(g), mrb_fixnum_value(b) }; return mrb_obj_new(mrb, mrb_class_get_under(mrb, mod_SDL2, "RGB"), 3, rgb); }
int main(void) { mrb_state *mrb = mrb_open(); struct RClass* cv = mrb_class_get(mrb, "String"); mrb_value code = mrb_str_new(mrb, "p 'hello world!'", 16); mrb_value str = mrb_obj_new(mrb, cv, 1, &code); printf("str#size is %d \n", mrb_funcall(mrb, str, "size", 0, 0)); printf("str is '%s' \n", RSTRING_PTR(str)); mrb_load_string(mrb, RSTRING_PTR(str)); return 0; }
MRB_API mrb_noreturn void mrb_name_error(mrb_state *mrb, mrb_sym id, const char *fmt, ...) { mrb_value exc; mrb_value argv[2]; va_list args; va_start(args, fmt); argv[0] = mrb_vformat(mrb, fmt, args); va_end(args); argv[1] = mrb_symbol_value(id); exc = mrb_obj_new(mrb, E_NAME_ERROR, 2, argv); mrb_exc_raise(mrb, exc); }
static mrb_value mrb_cgroup_get_cpuacct_obj(mrb_state *mrb, mrb_value self) { mrb_value cpuacct_value; struct RClass *cpuacct_class, *cgroup_class; mrb_cgroup_context *mrb_cg_cxt = mrb_cgroup_get_context(mrb, self, "mrb_cgroup_context"); cpuacct_value = mrb_iv_get(mrb, self, mrb_intern_cstr(mrb, "cpuacct_obj")); if (mrb_nil_p(cpuacct_value)) { cgroup_class = mrb_class_get(mrb, "Cgroup"); cpuacct_class = (struct RClass*)mrb_class_ptr(mrb_const_get(mrb, mrb_obj_value(cgroup_class), mrb_intern_cstr(mrb, "CPUACCT"))); cpuacct_value = mrb_obj_new(mrb, cpuacct_class, 1, &mrb_cg_cxt->group_name); mrb_iv_set(mrb, self, mrb_intern_cstr(mrb, "cpuacct_obj"), cpuacct_value); } return cpuacct_value; }
static mrb_value pcre_regexp_match(mrb_state *mrb, mrb_value self) { const char *str; char global_match[3]; mrb_value regexp; struct mrb_pcre_regexp *reg; int i; mrb_value mrb_i, mrb_match; size_t nmatch = 999; int match[999]; int regno; int ai; struct RClass* clazz; mrb_value c; mrb_value args[2]; mrb_get_args(mrb, "z", &str); regexp = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@regexp")); Data_Get_Struct(mrb, regexp, &mrb_pcre_regexp_type, reg); regno = pcre_exec(reg->re, NULL, str, strlen(str), 0, 0, match, nmatch); if (regno < 0) return mrb_nil_value(); mrb_obj_iv_set(mrb, (struct RObject *)mrb_class_real(RDATA(self)->c), mrb_intern_lit(mrb, "@last_match"), mrb_nil_value()); ai = mrb_gc_arena_save(mrb); clazz = mrb_class_get(mrb, "PcreMatchData"); c = mrb_obj_new(mrb, clazz, 0, NULL); mrb_iv_set(mrb, c,mrb_intern_lit(mrb, "@string"), mrb_str_new_cstr(mrb, str)); for (i = 0; i < regno; i++) { args[0] = mrb_fixnum_value(match[i * 2]); args[1] = mrb_fixnum_value(match[i * 2 + 1] - match[i * 2]); mrb_funcall_argv(mrb, c, mrb_intern_lit(mrb, "push"), sizeof(args)/sizeof(args[0]), &args[0]); if (i > 0 && i < 10) { sprintf(global_match, "$%i", i); mrb_i = mrb_fixnum_value(i); mrb_match = mrb_funcall_argv(mrb, c, mrb_intern_lit(mrb, "[]"), 1, &mrb_i); mrb_gv_set(mrb, mrb_intern_cstr(mrb, global_match), mrb_match); } mrb_gc_arena_restore(mrb, ai); } mrb_obj_iv_set(mrb, (struct RObject *)mrb_class_real(RDATA(self)->c), mrb_intern_lit(mrb, "@last_match"), c); return c; }
static mrb_value mrb_cp_contact_points_value(mrb_state *mrb, cpContactPointSet *contact_point_set) { mrb_value points; mrb_value point; int i; points = mrb_ary_new_capa(mrb, contact_point_set->count); for (i = 0; i < contact_point_set->count; ++i) { point = mrb_obj_new(mrb, mrb_cp_contact_point_class, 0, NULL); mrb_iv_set(mrb, point, mrb_intern_lit(mrb, "@point_a"), mrb_cp_vect_value(mrb, contact_point_set->points[i].pointA)); mrb_iv_set(mrb, point, mrb_intern_lit(mrb, "@point_b"), mrb_cp_vect_value(mrb, contact_point_set->points[i].pointB)); mrb_iv_set(mrb, point, mrb_intern_lit(mrb, "@distance"), mrb_float_value(mrb, contact_point_set->points[i].distance)); mrb_ary_set(mrb, points, i, point); } return points; }
mrb_value grn_mrb_value_from_grn_obj(mrb_state *mrb, grn_obj *object) { struct RClass *mrb_class; mrb_value mrb_new_arguments[1]; mrb_value mrb_object; if (!object) { return mrb_nil_value(); } mrb_class = grn_mrb_class_from_grn_obj(mrb, object); mrb_new_arguments[0] = mrb_cptr_value(mrb, object); mrb_object = mrb_obj_new(mrb, mrb_class, 1, mrb_new_arguments); return mrb_object; }
static mrb_value mrb_http_parser_parse_url(mrb_state *mrb, mrb_value self) { mrb_value uri_string; mrb_bool is_connect = FALSE; mrb_get_args(mrb, "S|b", &uri_string, &is_connect); struct http_parser_url parser; http_parser_url_init(&parser); enum http_parser_url_rcs rc = http_parser_parse_url(RSTRING_PTR(uri_string), RSTRING_LEN(uri_string), is_connect, &parser); switch (rc) { case URL_OKAY: { mrb_value argv[UF_MAX + 1]; for (int curr_url_field = 0; curr_url_field < UF_MAX; curr_url_field++) { if (parser.field_set & (1 << curr_url_field)) { if (curr_url_field == UF_PORT) { argv[curr_url_field] = mrb_fixnum_value(parser.port); } else { argv[curr_url_field] = mrb_str_substr(mrb, uri_string, parser.field_data[curr_url_field].off, parser.field_data[curr_url_field].len); } } else { argv[curr_url_field] = mrb_nil_value(); } } argv[UF_MAX] = uri_string; return mrb_obj_new(mrb, MRB_URI_PARSED, sizeof(argv) / sizeof(argv[0]), argv); } break; case MALFORMED_URL: mrb_raise(mrb, E_URI_MALFORMED, "Malformed URL"); break; case HOST_NOT_PRESENT: mrb_raise(mrb, E_URI_HOST_NOT_PRESENT, "Host not present"); break; case HOST_NOT_PARSEABLE: mrb_raise(mrb, E_URI_HOST_NOT_PARSEABLE, "Host not parseable"); break; case CONNECT_MALFORMED: mrb_raise(mrb, E_URI_CONNECT_MALFORMED, "Connect malformed"); break; case PORT_TOO_LARGE: mrb_raise(mrb, E_URI_PORT_TOO_LARGE, "Port too large"); break; } }
static mrb_value indexable_indexes(mrb_state *mrb, mrb_value self) { grn_ctx *ctx = (grn_ctx *)mrb->ud; grn_obj *object; grn_index_datum index_datum; grn_index_datum *index_data; int i, n_index_data; mrb_value mrb_indexes; object = DATA_PTR(self); n_index_data = grn_column_get_all_index_data(ctx, object, &index_datum, 1); if (n_index_data == 0) { return mrb_ary_new(mrb); } if (n_index_data == 1) { index_data = &index_datum; } else { index_data = GRN_MALLOCN(grn_index_datum, n_index_data); n_index_data = grn_column_get_all_index_data(ctx, object, index_data, n_index_data); } mrb_indexes = mrb_ary_new_capa(mrb, n_index_data); for (i = 0; i < n_index_data; i++) { grn_mrb_data *data; struct RClass *klass; mrb_value args[2]; data = &(ctx->impl->mrb); klass = mrb_class_get_under(mrb, data->module, "IndexInfo"); args[0] = grn_mrb_value_from_grn_obj(mrb, index_data[i].index); args[1] = mrb_fixnum_value(index_data[i].section); mrb_ary_push(mrb, mrb_indexes, mrb_obj_new(mrb, klass, 2, args)); } if (index_data != &index_datum) { GRN_FREE(index_data); } return mrb_indexes; }
int main(void) { mrb_state *mrb = mrb_open(); struct RClass* cv = mrb_class_get(mrb, "String"); mrb_value str = mrb_obj_new(mrb, cv, 0, 0); mrb_value head = mrb_str_new(mrb,"p 'hello",8); mrb_value tail = mrb_str_new(mrb," world'",7); str = mrb_funcall_argv(mrb, str, mrb_intern2(mrb, "+", 1), 1, &head); str = mrb_funcall_argv(mrb, str, mrb_intern2(mrb, "+", 1), 1, &tail); printf("str#size is %d \n", mrb_funcall(mrb, str, "size", 0, 0)); printf("str is '%s' \n", RSTRING_PTR(str)); mrb_load_string(mrb, RSTRING_PTR(str)); return 0; }
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 mrb_value mrb_module_instance_method(mrb_state *mrb, mrb_value self) { struct RClass *unbound_method = mrb_class_get(mrb, "UnboundMethod"); struct RClass *owner; struct RProc *proc; mrb_value id; mrb_value ume; mrb_value argv[4]; mrb_get_args(mrb, "o", &id); mrb_search_method_owner(mrb, mrb_class_ptr(self), self, id, &owner, &proc); argv[0] = self; argv[1] = mrb_obj_value(owner); argv[2] = id; argv[3] = mrb_obj_value(proc); ume = mrb_obj_new(mrb, unbound_method, 4, argv); return ume; }
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_kernel_method(mrb_state *mrb, mrb_value self) { struct RClass *method = mrb_class_get(mrb, "Method"); struct RClass *owner; struct RProc *proc; mrb_value id; mrb_value me; mrb_value argv[5]; mrb_get_args(mrb, "o", &id); mrb_search_method_owner(mrb, mrb_class(mrb, self), self, id, &owner, &proc); argv[0] = mrb_obj_value(mrb_obj_class(mrb, self)); argv[1] = mrb_obj_value(owner); argv[2] = self; argv[3] = id; argv[4] = mrb_obj_value(proc); me = mrb_obj_new(mrb, method, 5, argv); return me; }
void mrb_mruby_random_gem_init(mrb_state *mrb) { struct RClass *random; struct RClass *array = mrb->array_class; mrb_define_method(mrb, mrb->kernel_module, "rand", mrb_random_g_rand, MRB_ARGS_OPT(1)); mrb_define_method(mrb, mrb->kernel_module, "srand", mrb_random_g_srand, MRB_ARGS_OPT(1)); random = mrb_define_class(mrb, "Random", mrb->object_class); MRB_SET_INSTANCE_TT(random, MRB_TT_DATA); mrb_define_class_method(mrb, random, "rand", mrb_random_g_rand, MRB_ARGS_OPT(1)); mrb_define_class_method(mrb, random, "srand", mrb_random_g_srand, MRB_ARGS_OPT(1)); mrb_define_method(mrb, random, "initialize", mrb_random_init, MRB_ARGS_OPT(1)); mrb_define_method(mrb, random, "rand", mrb_random_rand, MRB_ARGS_OPT(1)); mrb_define_method(mrb, random, "srand", mrb_random_srand, MRB_ARGS_OPT(1)); mrb_define_method(mrb, array, "shuffle", mrb_ary_shuffle, MRB_ARGS_OPT(1)); mrb_define_method(mrb, array, "shuffle!", mrb_ary_shuffle_bang, MRB_ARGS_OPT(1)); mrb_const_set(mrb, mrb_obj_value(random), mrb_intern_lit(mrb, "DEFAULT"), mrb_obj_new(mrb, random, 0, NULL)); }