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));
}
