static mrb_value mrb_thread_join(mrb_state* mrb, mrb_value self) { mrb_value value_context = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "context")); mrb_thread_context* context = NULL; Data_Get_Struct(mrb, value_context, &mrb_thread_context_type, context); pthread_join(context->thread, NULL); context->result = migrate_simple_value(mrb, context->result, mrb); mrb_close(context->mrb); context->mrb = NULL; return context->result; }
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)); } }
MRB_API void mrb_gc_register(mrb_state *mrb, mrb_value obj) { mrb_sym root = mrb_intern_lit(mrb, GC_ROOT_NAME); mrb_value table = mrb_gv_get(mrb, root); if (mrb_nil_p(table) || mrb_type(table) != MRB_TT_ARRAY) { table = mrb_ary_new(mrb); mrb_gv_set(mrb, root, table); } mrb_ary_push(mrb, table, obj); }
void mrb_mruby_method_gem_init(mrb_state* mrb) { struct RClass *unbound_method = mrb_define_class(mrb, "UnboundMethod", mrb->object_class); struct RClass *method = mrb_define_class(mrb, "Method", mrb->object_class); mrb_undef_class_method(mrb, unbound_method, "new"); mrb_define_method(mrb, unbound_method, "bind", unbound_method_bind, MRB_ARGS_REQ(1)); mrb_define_method(mrb, unbound_method, "super_method", method_super_method, MRB_ARGS_NONE()); mrb_define_method(mrb, unbound_method, "==", method_eql, MRB_ARGS_REQ(1)); mrb_alias_method(mrb, unbound_method, mrb_intern_lit(mrb, "eql?"), mrb_intern_lit(mrb, "==")); mrb_define_method(mrb, unbound_method, "to_s", method_to_s, MRB_ARGS_NONE()); mrb_define_method(mrb, unbound_method, "inspect", method_to_s, MRB_ARGS_NONE()); mrb_define_method(mrb, unbound_method, "arity", method_arity, MRB_ARGS_NONE()); mrb_define_method(mrb, unbound_method, "source_location", method_source_location, MRB_ARGS_NONE()); mrb_define_method(mrb, unbound_method, "parameters", method_parameters, MRB_ARGS_NONE()); mrb_undef_class_method(mrb, method, "new"); mrb_define_method(mrb, method, "==", method_eql, MRB_ARGS_REQ(1)); mrb_alias_method(mrb, method, mrb_intern_lit(mrb, "eql?"), mrb_intern_lit(mrb, "==")); mrb_define_method(mrb, method, "to_s", method_to_s, MRB_ARGS_NONE()); mrb_define_method(mrb, method, "inspect", method_to_s, MRB_ARGS_NONE()); mrb_define_method(mrb, method, "call", method_call, MRB_ARGS_ANY()); mrb_alias_method(mrb, method, mrb_intern_lit(mrb, "[]"), mrb_intern_lit(mrb, "call")); mrb_define_method(mrb, method, "unbind", method_unbind, MRB_ARGS_NONE()); mrb_define_method(mrb, method, "super_method", method_super_method, MRB_ARGS_NONE()); mrb_define_method(mrb, method, "arity", method_arity, MRB_ARGS_NONE()); mrb_define_method(mrb, method, "source_location", method_source_location, MRB_ARGS_NONE()); mrb_define_method(mrb, method, "parameters", method_parameters, MRB_ARGS_NONE()); mrb_define_method(mrb, mrb->kernel_module, "method", mrb_kernel_method, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mrb->module_class, "instance_method", mrb_module_instance_method, MRB_ARGS_REQ(1)); }
static mrb_value method_unbind(mrb_state *mrb, mrb_value self) { struct RObject *ume; mrb_value owner = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@owner")); mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@name")); mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "proc")); mrb_value klass = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@klass")); ume = method_object_alloc(mrb, mrb_class_get(mrb, "UnboundMethod")); mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "@owner"), owner); mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "@recv"), mrb_nil_value()); mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "@name"), name); mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "proc"), proc); mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "@klass"), klass); return mrb_obj_value(ume); }
static mrb_value make_exception(mrb_state *mrb, int argc, const mrb_value *argv, mrb_bool isstr) { mrb_value mesg; int n; mesg = mrb_nil_value(); switch (argc) { case 0: break; case 1: if (mrb_nil_p(argv[0])) break; if (isstr) { mesg = mrb_check_string_type(mrb, argv[0]); if (!mrb_nil_p(mesg)) { mesg = mrb_exc_new_str(mrb, E_RUNTIME_ERROR, mesg); break; } } n = 0; goto exception_call; case 2: case 3: n = 1; exception_call: { mrb_sym exc = mrb_intern_lit(mrb, "exception"); if (mrb_respond_to(mrb, argv[0], exc)) { mesg = mrb_funcall_argv(mrb, argv[0], exc, n, argv+1); } else { /* undef */ mrb_raise(mrb, E_TYPE_ERROR, "exception class/object expected"); } } break; default: mrb_raisef(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (%S for 0..3)", mrb_fixnum_value(argc)); break; } if (argc > 0) { if (!mrb_obj_is_kind_of(mrb, mesg, mrb->eException_class)) mrb_raise(mrb, mrb->eException_class, "exception object expected"); if (argc > 2) set_backtrace(mrb, mesg, argv[2]); } return mesg; }
static mrb_value mrb_thread_kill(mrb_state* mrb, mrb_value self) { mrb_value value_context = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "context")); mrb_thread_context* context = NULL; Data_Get_Struct(mrb, value_context, &mrb_thread_context_type, context); if (context->mrb == NULL) { return mrb_nil_value(); } pthread_kill(context->thread, SIGINT); mrb_close(context->mrb); context->mrb = NULL; return context->result; }
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; }
/* * call-seq: * btn.pressed? # => true/false * * Get button status. * * Returns button status. (true:pressed, false:released) */ static mrb_value mrb_btn_pressed(mrb_state *mrb, mrb_value self) { int32_t pressed = FALSE; mrb_value key; key = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@key")); if (!mrb_nil_p(key)) { pressed = ev3_button_is_pressed((int16_t)mrb_fixnum(key)); } return mrb_bool_value(pressed); }
/* * call-seq: * LCD.new(font, x, y, width, height, color) # => LCD * * Creates LCD object. * * Parameters: * +font+ font size. * :small small font (6x8, default) * :medium medium font (8x16) * +x+ Window origin (left) X coordinate. (default: 0) * +y+ Window origin (top) Y coordinate. (default: 0) * +width+ Width of window. (default: LCD::WIDTH) * +height+ Height of window. (default: LCD::HEIGHT) * +color+ LCD foreground color. * :black black (default) * :white while * * Returns LCD object. */ static mrb_value mrb_lcd_init(mrb_state *mrb, mrb_value self) { struct RClass *lcd = mrb_obj_class(mrb, self); mrb_value fmap = mrb_const_get(mrb, mrb_obj_value(lcd), mrb_intern_lit(mrb, "FONT")); mrb_value cmap = mrb_const_get(mrb, mrb_obj_value(lcd), mrb_intern_lit(mrb, "COLOR")); mrb_sym font = mrb_intern_lit(mrb, "small"); mrb_sym col = mrb_intern_lit(mrb, "black"); mrb_value fontv; mrb_value colv; mrb_lcd_t *plcd; DATA_TYPE(self) = &mrb_lcd_type; plcd = (mrb_lcd_t*)mrb_malloc(mrb, sizeof(mrb_lcd_t)); DATA_PTR(self) = plcd; memset(plcd, 0, sizeof(mrb_lcd_t)); plcd->width = EV3_LCD_WIDTH; plcd->height = EV3_LCD_HEIGHT; mrb_get_args(mrb, "|niiiin", &font, &plcd->left, &plcd->top, &plcd->width, &plcd->height, &col); fontv = mrb_hash_get(mrb, fmap, mrb_symbol_value(font)); if (mrb_nil_p(fontv)) { mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid font size :%S", mrb_sym2str(mrb, font)); } plcd->font = mrb_fixnum(fontv); if (_font_size[plcd->font].w == 0) { /* initialize font size at 1st time */ ev3_font_get_size(plcd->font, &_font_size[plcd->font].w, &_font_size[plcd->font].h); } colv = mrb_hash_get(mrb, cmap, mrb_symbol_value(col)); if (mrb_nil_p(colv)) { mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid foreground color :%S", mrb_sym2str(mrb, col)); } plcd->color = mrb_fixnum(colv); return self; }
MRB_API mrb_value mrb_ary_splat(mrb_state *mrb, mrb_value v) { if (mrb_array_p(v)) { return v; } if (mrb_respond_to(mrb, v, mrb_intern_lit(mrb, "to_a"))) { return mrb_funcall(mrb, v, "to_a", 0); } else { return mrb_ary_new_from_values(mrb, 1, &v); } }
static void mrb_load_fail(mrb_state *mrb, mrb_value path, const char *err) { mrb_value mesg, exc; mesg = mrb_str_new_cstr(mrb, err); mrb_str_cat_lit(mrb, mesg, " -- "); mrb_str_cat_str(mrb, mesg, path); exc = mrb_funcall(mrb, mrb_obj_value(E_LOAD_ERROR), "new", 1, mesg); mrb_iv_set(mrb, exc, mrb_intern_lit(mrb, "path"), path); mrb_exc_raise(mrb, exc); }
mrb_value mrb_struct_s_members(mrb_state *mrb, mrb_value klass) { mrb_value members = struct_ivar_get(mrb, klass, mrb_intern_lit(mrb, "__members__")); if (mrb_nil_p(members)) { mrb_raise(mrb, E_TYPE_ERROR, "uninitialized struct"); } if (!mrb_array_p(members)) { mrb_raise(mrb, E_TYPE_ERROR, "corrupted struct"); } return members; }
static mrb_value mrb_thread_init(mrb_state* mrb, mrb_value self) { mrb_value proc = mrb_nil_value(); mrb_int argc; mrb_value* argv; mrb_get_args(mrb, "&*", &proc, &argv, &argc); if (!mrb_nil_p(proc) && MRB_PROC_CFUNC_P(mrb_proc_ptr(proc))) { mrb_raise(mrb, E_RUNTIME_ERROR, "forking C defined block"); } if (!mrb_nil_p(proc)) { int i, l; mrb_thread_context* context = (mrb_thread_context*) malloc(sizeof(mrb_thread_context)); context->mrb_caller = mrb; context->mrb = mrb_open_allocf(mrb->allocf, mrb->allocf_ud); migrate_all_symbols(mrb, context->mrb); context->proc = mrb_proc_new(mrb, mrb_proc_ptr(proc)->body.irep); context->proc->target_class = context->mrb->object_class; context->argc = argc; context->argv = calloc(sizeof (mrb_value), context->argc); context->result = mrb_nil_value(); context->alive = TRUE; for (i = 0; i < context->argc; i++) { context->argv[i] = migrate_simple_value(mrb, argv[i], context->mrb); } { mrb_value gv = mrb_funcall(mrb, self, "global_variables", 0, NULL); l = RARRAY_LEN(gv); for (i = 0; i < l; i++) { mrb_int len; int ai = mrb_gc_arena_save(mrb); mrb_value k = mrb_ary_entry(gv, i); mrb_value o = mrb_gv_get(mrb, mrb_symbol(k)); if (is_safe_migratable_simple_value(mrb, o, context->mrb)) { const char *p = mrb_sym2name_len(mrb, mrb_symbol(k), &len); mrb_gv_set(context->mrb, mrb_intern_static(context->mrb, p, len), migrate_simple_value(mrb, o, context->mrb)); } mrb_gc_arena_restore(mrb, ai); } } mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "context"), mrb_obj_value( Data_Wrap_Struct(mrb, mrb->object_class, &mrb_thread_context_type, (void*) context))); pthread_create(&context->thread, NULL, &mrb_thread_func, (void*) context); } return self; }
static mrb_value make_struct(mrb_state *mrb, mrb_value name, mrb_value members, struct RClass * klass) { mrb_value nstr, *ptr_members; mrb_sym id; mrb_int i, len; struct RClass *c; int ai; if (mrb_nil_p(name)) { c = mrb_class_new(mrb, klass); } else { /* old style: should we warn? */ name = mrb_str_to_str(mrb, name); id = mrb_obj_to_sym(mrb, name); if (!mrb_is_const_id(id)) { mrb_name_error(mrb, id, "identifier %S needs to be constant", name); } if (mrb_const_defined_at(mrb, klass, id)) { mrb_warn(mrb, "redefining constant Struct::%S", name); /* ?rb_mod_remove_const(klass, mrb_sym2name(mrb, id)); */ } c = mrb_define_class_under(mrb, klass, RSTRING_PTR(name), klass); } MRB_SET_INSTANCE_TT(c, MRB_TT_ARRAY); nstr = mrb_obj_value(c); mrb_iv_set(mrb, nstr, mrb_intern_lit(mrb, "__members__"), members); mrb_define_class_method(mrb, c, "new", mrb_instance_new, MRB_ARGS_ANY()); mrb_define_class_method(mrb, c, "[]", mrb_instance_new, MRB_ARGS_ANY()); mrb_define_class_method(mrb, c, "members", mrb_struct_s_members_m, MRB_ARGS_NONE()); /* RSTRUCT(nstr)->basic.c->super = c->c; */ ptr_members = RARRAY_PTR(members); len = RARRAY_LEN(members); ai = mrb_gc_arena_save(mrb); for (i=0; i< len; i++) { mrb_sym id = mrb_symbol(ptr_members[i]); if (mrb_is_local_id(id) || mrb_is_const_id(id)) { if (i < N_REF_FUNC) { mrb_define_method_id(mrb, c, id, ref_func[i], MRB_ARGS_NONE()); } else { mrb_define_method_id(mrb, c, id, mrb_struct_ref, MRB_ARGS_NONE()); } mrb_define_method_id(mrb, c, mrb_id_attrset(mrb, id), mrb_struct_set_m, MRB_ARGS_REQ(1)); mrb_gc_arena_restore(mrb, ai); } } return nstr; }
void mrb_init_proc(mrb_state *mrb) { struct RProc *m; mrb_irep *call_irep = (mrb_irep *)mrb_malloc(mrb, sizeof(mrb_irep)); static const mrb_irep mrb_irep_zero = { 0 }; *call_irep = mrb_irep_zero; call_irep->flags = MRB_ISEQ_NO_FREE; call_irep->iseq = call_iseq; call_irep->ilen = 1; mrb_define_class_method(mrb, mrb->proc_class, "new", mrb_proc_s_new, MRB_ARGS_ANY()); mrb_define_method(mrb, mrb->proc_class, "initialize_copy", mrb_proc_init_copy, MRB_ARGS_REQ(1)); mrb_define_method(mrb, mrb->proc_class, "arity", mrb_proc_arity, MRB_ARGS_NONE()); m = mrb_proc_new(mrb, call_irep); mrb_define_method_raw(mrb, mrb->proc_class, mrb_intern_lit(mrb, "call"), m); mrb_define_method_raw(mrb, mrb->proc_class, mrb_intern_lit(mrb, "[]"), m); mrb_define_class_method(mrb, mrb->kernel_module, "lambda", proc_lambda, MRB_ARGS_NONE()); /* 15.3.1.2.6 */ mrb_define_method(mrb, mrb->kernel_module, "lambda", proc_lambda, MRB_ARGS_NONE()); /* 15.3.1.3.27 */ }
static mrb_value mrb_mruby_motor_setPWM(mrb_state *mrb, mrb_value self) { mrb_int pwm; mrb_get_args(mrb, "i", &pwm); motor_port_t port = mrb_fixnum(mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@port"))); if (pwm == 0) { ev3_motor_stop(port, true); } else { ev3_motor_set_power(port, pwm); } return self; }
void mrb_mruby_string_ext_gem_init(mrb_state* mrb) { struct RClass * s = mrb->string_class; mrb_define_method(mrb, s, "dump", mrb_str_dump, MRB_ARGS_NONE()); mrb_define_method(mrb, s, "getbyte", mrb_str_getbyte, MRB_ARGS_REQ(1)); mrb_define_method(mrb, s, "swapcase!", mrb_str_swapcase_bang, MRB_ARGS_NONE()); mrb_define_method(mrb, s, "swapcase", mrb_str_swapcase, MRB_ARGS_NONE()); mrb_define_method(mrb, s, "concat", mrb_str_concat2, MRB_ARGS_REQ(1)); mrb_define_method(mrb, s, "<<", mrb_str_concat2, MRB_ARGS_REQ(1)); mrb_define_method(mrb, s, "start_with?", mrb_str_start_with, MRB_ARGS_REST()); mrb_define_method(mrb, s, "end_with?", mrb_str_end_with, MRB_ARGS_REST()); mrb_define_method(mrb, s, "hex", mrb_str_hex, MRB_ARGS_NONE()); mrb_define_method(mrb, s, "oct", mrb_str_oct, MRB_ARGS_NONE()); mrb_define_method(mrb, s, "chr", mrb_str_chr, MRB_ARGS_NONE()); mrb_define_method(mrb, s, "lines", mrb_str_lines, MRB_ARGS_NONE()); mrb_define_method(mrb, s, "succ", mrb_str_succ, MRB_ARGS_NONE()); mrb_define_method(mrb, s, "succ!", mrb_str_succ_bang, MRB_ARGS_NONE()); mrb_define_method(mrb, s, "prepend", mrb_str_prepend, MRB_ARGS_REQ(1)); mrb_alias_method(mrb, s, mrb_intern_lit(mrb, "next"), mrb_intern_lit(mrb, "succ")); mrb_alias_method(mrb, s, mrb_intern_lit(mrb, "next!"), mrb_intern_lit(mrb, "succ!")); }
static mrb_value mrb_ssp_thread_iact(mrb_state *mrb, mrb_value self) { ER retval; mrb_value id = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@task_id")); mrb_int id_num = mrb_fixnum(id); retval = iact_tsk(id_num); if (retval != E_OK) { return(mrb_false_value()); } return(mrb_true_value()); }
static mrb_value hash_equal(mrb_state *mrb, mrb_value hash1, mrb_value hash2, mrb_bool eql) { khash_t(ht) *h1, *h2; mrb_bool eq; if (mrb_obj_equal(mrb, hash1, hash2)) return mrb_true_value(); if (!mrb_hash_p(hash2)) { if (!mrb_respond_to(mrb, hash2, mrb_intern_lit(mrb, "to_hash"))) { return mrb_false_value(); } else { if (eql) { eq = mrb_eql(mrb, hash2, hash1); } else { eq = mrb_equal(mrb, hash2, hash1); } return mrb_bool_value(eq); } } h1 = RHASH_TBL(hash1); h2 = RHASH_TBL(hash2); if (!h1) { return mrb_bool_value(!h2); } if (!h2) return mrb_false_value(); if (kh_size(h1) != kh_size(h2)) return mrb_false_value(); else { khiter_t k1, k2; mrb_value key; for (k1 = kh_begin(h1); k1 != kh_end(h1); k1++) { if (!kh_exist(h1, k1)) continue; key = kh_key(h1,k1); k2 = kh_get(ht, mrb, h2, key); if (k2 != kh_end(h2)) { if (eql) eq = mrb_eql(mrb, kh_value(h1,k1), kh_value(h2,k2)); else eq = mrb_equal(mrb, kh_value(h1,k1), kh_value(h2,k2)); if (eq) { continue; /* next key */ } } return mrb_false_value(); } } return mrb_true_value(); }
// ssp_thread で登録されるtask本体 void mrb_ssp_thread_call(intptr_t exf) { mrb_int task_id = (mrb_int)exf; // taskID mrb_value self; char name_cstr[20]; // memcpy(&self,&task_self_tbl[task_id-1],sizeof(mrb_value)); self = task_self_tbl[task_id-1]; #if 1 printf("thread_call &self = %08x self = %08x %08x\n", (int)&self,*((int*)&self),*(((int*)&self)+1)); #endif mrb_value name = mrb_iv_get(mrb_global, self, mrb_intern_lit(mrb_global, "@task_name")); mrb_value id = mrb_iv_get(mrb_global, self, mrb_intern_lit(mrb_global, "@task_id")); // char *name_cstr = mrb_str_to_cstr(mrb_global, name); strncpy(name_cstr, RSTRING_PTR(name), RSTRING_LEN(name)); name_cstr[RSTRING_LEN(name)]='\0'; #if 1 printf("mrb_ssp_thread_call exf = %d cstr=%s id = %d\n", exf,name_cstr,mrb_fixnum(id)); #endif #if 0 mrb_funcall(mrb_global, mrb_top_self(mrb_global), "thread",1, id); #else mrb_funcall(mrb_global, self, (const char *)name_cstr,1, id); // mrb_funcall(mrb_global, self, "thread",1, id); #endif }
mrb_value mrb_matchdata_init_copy(mrb_state *mrb, mrb_value copy) { mrb_value src; struct mrb_matchdata *mrb_md_copy, *mrb_md_src; int vecsize; mrb_get_args(mrb, "o", &src); if (mrb_obj_equal(mrb, copy, src)) return copy; if (!mrb_obj_is_instance_of(mrb, src, mrb_obj_class(mrb, copy))) { mrb_raise(mrb, E_TYPE_ERROR, "wrong argument class"); } mrb_md_copy = (struct mrb_matchdata *)mrb_malloc(mrb, sizeof(*mrb_md_copy)); mrb_md_src = DATA_PTR(src); if (mrb_md_src->ovector == NULL) { mrb_md_copy->ovector = NULL; mrb_md_copy->length = -1; } else { vecsize = sizeof(int) * mrb_md_src->length * 3; mrb_md_copy->ovector = mrb_malloc(mrb, vecsize); memcpy(mrb_md_copy->ovector, mrb_md_src->ovector, vecsize); mrb_md_copy->length = mrb_md_src->length; } if (DATA_PTR(copy) != NULL) { mrb_matchdata_free(mrb, DATA_PTR(copy)); } DATA_PTR(copy) = mrb_md_copy; mrb_iv_set(mrb, copy, mrb_intern_lit(mrb, "@regexp"), mrb_iv_get(mrb, src, mrb_intern_lit(mrb, "@regexp"))); mrb_iv_set(mrb, copy, mrb_intern_lit(mrb, "@string"), mrb_iv_get(mrb, src, mrb_intern_lit(mrb, "@string"))); return copy; }
void inputBindingInit(mrb_state *mrb) { RClass *module = mrb_define_module(mrb, "Input"); mrb_define_module_function(mrb, module, "update", inputUpdate, MRB_ARGS_NONE()); mrb_define_module_function(mrb, module, "press?", inputPress, MRB_ARGS_REQ(1)); mrb_define_module_function(mrb, module, "trigger?", inputTrigger, MRB_ARGS_REQ(1)); mrb_define_module_function(mrb, module, "repeat?", inputRepeat, MRB_ARGS_REQ(1)); mrb_define_module_function(mrb, module, "dir4", inputDir4, MRB_ARGS_NONE()); mrb_define_module_function(mrb, module, "dir8", inputDir8, MRB_ARGS_NONE()); mrb_define_module_function(mrb, module, "mouse_x", inputMouseX, MRB_ARGS_NONE()); mrb_define_module_function(mrb, module, "mouse_y", inputMouseY, MRB_ARGS_NONE()); mrb_value modVal = mrb_obj_value(module); if (rgssVer >= 3) { mrb_value symHash = mrb_hash_new_capa(mrb, buttonCodesN); for (size_t i = 0; i < buttonCodesN; ++i) { const char *str = buttonCodes[i].str; mrb_sym sym = mrb_intern_static(mrb, str, strlen(str)); mrb_value symVal = mrb_symbol_value(sym); mrb_value val = mrb_fixnum_value(buttonCodes[i].val); /* In RGSS3 all Input::XYZ constants are equal to :XYZ symbols, * to be compatible with the previous convention */ mrb_const_set(mrb, modVal, sym, symVal); mrb_hash_set(mrb, symHash, symVal, val); } mrb_iv_set(mrb, modVal, mrb_intern_lit(mrb, "buttoncodes"), symHash); getMrbData(mrb)->buttoncodeHash = symHash; } else { for (size_t i = 0; i < buttonCodesN; ++i) { const char *str = buttonCodes[i].str; mrb_sym sym = mrb_intern_static(mrb, str, strlen(str)); mrb_value val = mrb_fixnum_value(buttonCodes[i].val); mrb_const_set(mrb, modVal, sym, val); } } }
static mrb_value exc_to_s(mrb_state *mrb, mrb_value exc) { mrb_value mesg = mrb_attr_get(mrb, exc, mrb_intern_lit(mrb, "mesg")); struct RObject *p; if (!mrb_string_p(mesg)) { return mrb_str_new_cstr(mrb, mrb_obj_classname(mrb, exc)); } p = mrb_obj_ptr(mesg); if (!p->c) { p->c = mrb->string_class; } return mesg; }
static mrb_value exc_exception(mrb_state *mrb, mrb_value self) { mrb_value exc; mrb_value a; int argc; argc = mrb_get_args(mrb, "|o", &a); if (argc == 0) return self; if (mrb_obj_equal(mrb, self, a)) return self; exc = mrb_obj_clone(mrb, self); mrb_iv_set(mrb, exc, mrb_intern_lit(mrb, "mesg"), a); return exc; }
static mrb_value mrb_queue_init(mrb_state* mrb, mrb_value self) { mrb_queue_context* context = (mrb_queue_context*) malloc(sizeof(mrb_queue_context)); pthread_mutex_init(&context->mutex, NULL); pthread_mutex_init(&context->queue_lock, NULL); if (pthread_mutex_lock(&context->queue_lock) != 0) { mrb_raise(mrb, E_RUNTIME_ERROR, "cannot lock"); } context->mrb = mrb; context->queue = mrb_ary_new(mrb); mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "queue"), context->queue); DATA_PTR(self) = context; DATA_TYPE(self) = &mrb_queue_context_type; return self; }
mrb_value mrb_f_syslog_close(mrb_state *mrb, mrb_value self) { mrb_value opened; opened = mrb_cv_get(mrb, self, mrb_intern_lit(mrb, "@opened")); if (! mrb_bool(opened)) { mrb_raise(mrb, E_RUNTIME_ERROR, "syslog not opened"); } closelog(); reset_vars(mrb, self); return mrb_nil_value(); }
static mrb_value exc_inspect(mrb_state *mrb, mrb_value exc) { mrb_value str, mesg, file, line; mesg = mrb_attr_get(mrb, exc, mrb_intern_lit(mrb, "mesg")); file = mrb_attr_get(mrb, exc, mrb_intern_lit(mrb, "file")); line = mrb_attr_get(mrb, exc, mrb_intern_lit(mrb, "line")); if (!mrb_nil_p(file) && !mrb_nil_p(line)) { str = file; mrb_str_cat(mrb, str, ":", 1); mrb_str_append(mrb, str, line); mrb_str_cat(mrb, str, ": ", 2); if (!mrb_nil_p(mesg) && RSTRING_LEN(mesg) > 0) { mrb_str_append(mrb, str, mesg); mrb_str_cat(mrb, str, " (", 2); } mrb_str_cat_cstr(mrb, str, mrb_obj_classname(mrb, exc)); if (!mrb_nil_p(mesg) && RSTRING_LEN(mesg) > 0) { mrb_str_cat(mrb, str, ")", 1); } } else { str = mrb_str_new_cstr(mrb, mrb_obj_classname(mrb, exc)); if (!mrb_nil_p(mesg) && RSTRING_LEN(mesg) > 0) { mrb_str_cat(mrb, str, ": ", 2); mrb_str_append(mrb, str, mesg); } else { mrb_str_cat(mrb, str, ": ", 2); mrb_str_cat_cstr(mrb, str, mrb_obj_classname(mrb, exc)); } } return str; }
static mrb_value mrb_ecdsa_generate_key(mrb_state *mrb, mrb_value self) { ctr_drbg_context *ctr_drbg; ecdsa_context *ecdsa; mrb_int curve=0; mrb_value obj, curve_obj; int ret; ecdsa = DATA_CHECK_GET_PTR(mrb, self, &mrb_ecdsa_type, ecdsa_context); obj = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@ctr_drbg")); curve_obj = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@curve")); ctr_drbg = DATA_CHECK_GET_PTR(mrb, obj, &mrb_ctr_drbg_type, ctr_drbg_context); if (mrb_fixnum_p(curve_obj)) { curve = mrb_fixnum(curve_obj); } else { return mrb_false_value(); } if(ecdsa_genkey(ecdsa, curve, ctr_drbg_random, ctr_drbg) == 0) { return mrb_true_value(); } else { return mrb_false_value(); } }
static mrb_value mrb_ssp_cyclic_istp(mrb_state *mrb, mrb_value self) { ER retval; mrb_value id = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@cyclic_id")); mrb_int id_num = mrb_fixnum(id); retval = istp_cyc(id_num); if (retval == E_OK) { return(mrb_false_value()); } return(mrb_true_value()); }