static mrb_value hs_regexp_equal(mrb_state *mrb, mrb_value self) { mrb_value other; struct mrb_hs_regexp *self_reg, *other_reg; mrb_get_args(mrb, "o", &other); if (mrb_obj_equal(mrb, self, other)){ return mrb_true_value(); } if (mrb_type(other) != MRB_TT_DATA || DATA_TYPE(other) != &mrb_hs_regexp_type){ return mrb_false_value(); } self_reg = (struct mrb_hs_regexp *)DATA_PTR(self); other_reg = (struct mrb_hs_regexp *)DATA_PTR(other); if (!self_reg || !other_reg){ mrb_raise(mrb, E_RUNTIME_ERROR, "Invalid HsRegexp"); } if (self_reg->flag != other_reg->flag){ return mrb_false_value(); } return mrb_str_equal(mrb, mrb_iv_get(mrb, self, INTERN("@source")), mrb_iv_get(mrb, other, INTERN("@source"))) ? mrb_true_value() : mrb_false_value(); }
// ssp_thread で登録されるtask本体 void mrb_ssp_alarm_call(intptr_t exf) { mrb_int alarm_id = (mrb_int)exf; // alarmID mrb_value self = alarm_self_tbl[alarm_id-1]; char name_cstr[20]; #if MRB_DEBUG1 printf("alarm_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, "@alarm_name")); mrb_value id = mrb_iv_get(mrb_global, self, mrb_intern_lit(mrb_global, "@alarm_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 MRB_DEBUG1 printf("mrb_alarm_call exf = %d cstr=%s id = %d\n", exf,name_cstr,mrb_fixnum(id)); #endif t_lock_cpu(); #if 0 mrb_funcall(mrb_global, mrb_top_self(mrb_global), name_cstr,1, id); #else mrb_funcall(mrb_global, self, name_cstr,1, id); #endif t_unlock_cpu(); }
static mrb_value pcre_regexp_equal(mrb_state *mrb, mrb_value self) { mrb_value other, regexp_self, regexp_other; struct mrb_pcre_regexp *self_reg, *other_reg; mrb_get_args(mrb, "o", &other); if (mrb_obj_equal(mrb, self, other)){ return mrb_true_value(); } if (mrb_nil_p(other)) { return mrb_false_value(); } regexp_self = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@regexp")); regexp_other = mrb_iv_get(mrb, other, mrb_intern_lit(mrb, "@regexp")); Data_Get_Struct(mrb, regexp_self, &mrb_pcre_regexp_type, self_reg); Data_Get_Struct(mrb, regexp_other, &mrb_pcre_regexp_type, other_reg); if (!self_reg || !other_reg){ mrb_raise(mrb, E_RUNTIME_ERROR, "Invalid PcreRegexp"); } if (self_reg->flag != other_reg->flag){ return mrb_false_value(); } return mrb_str_equal(mrb, mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@source")), mrb_iv_get(mrb, other, mrb_intern_lit(mrb, "@source"))) ? mrb_true_value() : mrb_false_value(); }
static mrb_value unbound_method_bind(mrb_state *mrb, mrb_value self) { struct RObject *me; 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")); mrb_value recv; mrb_get_args(mrb, "o", &recv); if (mrb_type(owner) != MRB_TT_MODULE && mrb_class_ptr(owner) != mrb_obj_class(mrb, recv) && !mrb_obj_is_kind_of(mrb, recv, mrb_class_ptr(owner))) { if (mrb_type(owner) == MRB_TT_SCLASS) { mrb_raise(mrb, E_TYPE_ERROR, "singleton method called for a different object"); } else { const char *s = mrb_class_name(mrb, mrb_class_ptr(owner)); mrb_raisef(mrb, E_TYPE_ERROR, "bind argument must be an instance of %S", mrb_str_new_static(mrb, s, strlen(s))); } } me = method_object_alloc(mrb, mrb_class_get(mrb, "Method")); mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "@owner"), owner); mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "@recv"), recv); mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "@name"), name); mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "proc"), proc); mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "@klass"), klass); return mrb_obj_value(me); }
static mrb_value regexp_equal(mrb_state *mrb, mrb_value self) { mrb_value other; struct mrb_regexp_pcre *self_reg, *other_reg; mrb_get_args(mrb, "o", &other); if (mrb_obj_equal(mrb, self, other)) { return mrb_true_value(); } if (mrb_type(other) != MRB_TT_DATA || DATA_TYPE(other) != &mrb_regexp_type) { return mrb_false_value(); } self_reg = (struct mrb_regexp_pcre *)DATA_PTR(self); other_reg = (struct mrb_regexp_pcre *)DATA_PTR(other); if (!self_reg || !other_reg) { mrb_raise(mrb, E_RUNTIME_ERROR, "Invalid Regexp"); } if (mrb_str_equal(mrb, mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@source")), mrb_iv_get(mrb, other, mrb_intern_lit(mrb, "@source")))) { return mrb_true_value(); } return mrb_false_value(); }
static mrb_value method_to_s(mrb_state *mrb, mrb_value self) { mrb_value owner = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@owner")); mrb_value klass = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@klass")); mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@name")); mrb_value str = mrb_str_new_lit(mrb, "#<"); struct RClass *rklass; mrb_str_cat_cstr(mrb, str, mrb_obj_classname(mrb, self)); mrb_str_cat_lit(mrb, str, ": "); rklass = mrb_class_ptr(klass); if (mrb_class_ptr(owner) == rklass) { mrb_str_cat_str(mrb, str, mrb_funcall(mrb, owner, "to_s", 0)); mrb_str_cat_lit(mrb, str, "#"); mrb_str_cat_str(mrb, str, mrb_funcall(mrb, name, "to_s", 0)); } else { mrb_str_cat_cstr(mrb, str, mrb_class_name(mrb, rklass)); mrb_str_cat_lit(mrb, str, "("); mrb_str_cat_str(mrb, str, mrb_funcall(mrb, owner, "to_s", 0)); mrb_str_cat_lit(mrb, str, ")#"); mrb_str_cat_str(mrb, str, mrb_funcall(mrb, name, "to_s", 0)); } mrb_str_cat_lit(mrb, str, ">"); return str; }
// ssp_thread で登録されるtask本体 void mrb_ssp_cyclic_call(intptr_t exf) { mrb_int cyclic_id = (mrb_int)exf; // cyclicID mrb_value self = cyclic_self_tbl[cyclic_id-1]; char name_cstr[20]; #if MRB_DEBUG1 printf("cyclic_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, "@cyclic_name")); mrb_value id = mrb_iv_get(mrb_global, self, mrb_intern_lit(mrb_global, "@cyclic_id")); // char *name_cstr = mrb_str_to_cstr(mrb_global, name); //メモリリーク? 開放しないため4回目で落ちる strncpy(name_cstr, RSTRING_PTR(name), RSTRING_LEN(name)); name_cstr[RSTRING_LEN(name)]='\0'; #if MRB_DEBUG1 printf("mrb_cyclic_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), "cyclic",1, id); #else mrb_funcall(mrb_global, self, (const char*)name_cstr,1, id); #endif }
static mrb_value method_call(mrb_state *mrb, mrb_value self) { mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "proc")); mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@name")); mrb_value recv = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@recv")); struct RClass *owner = mrb_class_ptr(mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@owner"))); mrb_int argc; mrb_value *argv, ret, block; mrb_sym orig_mid; mrb_get_args(mrb, "*&", &argv, &argc, &block); orig_mid = mrb->c->ci->mid; mrb->c->ci->mid = mrb_symbol(name); if (mrb_nil_p(proc)) { mrb_value missing_argv = mrb_ary_new_from_values(mrb, argc, argv); mrb_ary_unshift(mrb, missing_argv, name); ret = mrb_funcall_argv(mrb, recv, mrb_intern_lit(mrb, "method_missing"), argc + 1, RARRAY_PTR(missing_argv)); } else if (!mrb_nil_p(block)) { /* workaround since `mrb_yield_with_class` does not support passing block as parameter need new API that initializes `mrb->c->stack[argc+1]` with block passed by argument */ ret = mrb_funcall_with_block(mrb, recv, mrb_symbol(name), argc, argv, block); } else { ret = mrb_yield_with_class(mrb, proc, argc, argv, recv, owner); } mrb->c->ci->mid = orig_mid; return ret; }
static mrb_value mrb_sqlite3_resultset_next(mrb_state *mrb, mrb_value self) { mrb_value value_context = mrb_iv_get(mrb, self, mrb_intern(mrb, "context")); mrb_sqlite3_resultset* rs = NULL; int r; Data_Get_Struct(mrb, value_context, &mrb_sqlite3_resultset_type, rs); if (!rs) { mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument"); } r = sqlite3_step(rs->stmt); if (r != SQLITE_ROW && r != SQLITE_OK && r != SQLITE_DONE) { mrb_value vdb = mrb_iv_get(mrb, self, mrb_intern(mrb, "db")); if (!mrb_nil_p(vdb)) { mrb_sqlite3_database* db = NULL; value_context = mrb_iv_get(mrb, vdb, mrb_intern(mrb, "context")); Data_Get_Struct(mrb, value_context, &mrb_sqlite3_database_type, db); if (db) { mrb_raise(mrb, E_RUNTIME_ERROR, sqlite3_errmsg(db->db)); } } return mrb_nil_value(); } if (r == SQLITE_DONE) { mrb_iv_set(mrb, self, mrb_intern(mrb, "eof"), mrb_true_value()); return mrb_nil_value(); } return row_to_value(mrb, rs->stmt); }
static mrb_value mrb_future_value(mrb_state *mrb, mrb_value self) { mrb_future_context *context = (mrb_future_context *)mrb_cptr(mrb_iv_get(mrb, self, mrb_intern_cstr(mrb, "_context"))); if (mrb_fixnum(mrb_iv_get(mrb, self, mrb_intern_cstr(mrb, "_state"))) == FUTURE_RUNNING) { pthread_join(context->thread, NULL); } return mrb_iv_get(mrb, self, mrb_intern_cstr(mrb, "value")); }
static mrb_value mrb_ipvs_dest_set_weight(mrb_state *mrb, mrb_value self){ struct mrb_ipvs_entry *svc, *dest; mrb_int weight; dest = DATA_PTR(self); mrb_get_args(mrb, "i", &weight); dest->dest.weight = weight; if (mrb_nil_p(mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@service")))) { svc = DATA_PTR(mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@service"))); ipvs_update_dest(&svc->svc, &dest->dest); } return mrb_nil_value(); }
static void _uv_thread_proc(void *arg) { mrb_uv_thread* context = (mrb_uv_thread*) arg; mrb_state* mrb = context->mrb; mrb_value proc, thread_arg; if (!mrb) return; proc = mrb_iv_get(mrb, context->instance, mrb_intern_lit(mrb, "thread_proc")); thread_arg = mrb_iv_get(mrb, context->instance, mrb_intern_lit(mrb, "thread_arg")); if (!mrb_nil_p(proc)) { mrb_value args[1]; args[0] = thread_arg; mrb_yield_argv(mrb, proc, 1, args); } }
void cfunc_closure_call_binding(ffi_cif *cif, void *ret, void **args, void *self_) { mrb_value self = mrb_obj_value(self_); struct cfunc_closure_data *data = DATA_PTR(self); int ai = mrb_gc_arena_save(data->mrb); mrb_value *ary = mrb_malloc(data->mrb, sizeof(mrb_value) * data->argc); int i; for (i = 0; i < data->argc; ++i) { // TODO: I felt too much consume memory void *p = mrb_malloc(data->mrb, data->arg_ffi_types[i]->size); memcpy(p, args[i], data->arg_ffi_types[i]->size); mrb_value pointer = cfunc_pointer_new_with_pointer(data->mrb, p, true); ary[i] = mrb_funcall(data->mrb, data->arg_types[i], "refer", 1, pointer); } mrb_value block = mrb_iv_get(data->mrb, self, mrb_intern_cstr(data->mrb, "@block")); mrb_value result = mrb_funcall_argv(data->mrb, block, mrb_intern_cstr(data->mrb, "call"), data->argc, ary); mrb_free(data->mrb, ary); mrb_value ret_pointer = cfunc_pointer_new_with_pointer(data->mrb, ret, false); mrb_funcall(data->mrb, data->return_type, "set", 2, ret_pointer, result); mrb_gc_arena_restore(data->mrb, ai); }
static mrb_value mrb_http_request_schema(mrb_state *mrb, mrb_value self) { mrb_value value_context; mrb_http_parser_context* context; value_context = mrb_iv_get(mrb, self, mrb_intern(mrb, "parser_context")); Data_Get_Struct(mrb, value_context, &http_parser_context_type, context); if (!context) { mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument"); } if (context->handle.field_set & (1<<UF_SCHEMA)) { return mrb_str_substr(mrb, mrb_iv_get(mrb, context->instance, mrb_intern(mrb, "buf")), context->handle.field_data[UF_SCHEMA].off, context->handle.field_data[UF_SCHEMA].len); } return mrb_nil_value(); }
static mrb_value mrb_addrinfo_getnameinfo(mrb_state *mrb, mrb_value self) { mrb_int flags; mrb_value ary, host, sastr, serv; int error; flags = 0; mrb_get_args(mrb, "|i", &flags); host = mrb_str_buf_new(mrb, NI_MAXHOST); serv = mrb_str_buf_new(mrb, NI_MAXSERV); sastr = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@sockaddr")); if (!mrb_string_p(sastr)) { mrb_raise(mrb, E_SOCKET_ERROR, "invalid sockaddr"); } error = getnameinfo((struct sockaddr *)RSTRING_PTR(sastr), (socklen_t)RSTRING_LEN(sastr), RSTRING_PTR(host), NI_MAXHOST, RSTRING_PTR(serv), NI_MAXSERV, flags); if (error != 0) { mrb_raisef(mrb, E_SOCKET_ERROR, "getnameinfo: %s", gai_strerror(error)); } ary = mrb_ary_new_capa(mrb, 2); mrb_str_resize(mrb, host, strlen(RSTRING_PTR(host))); mrb_ary_push(mrb, ary, host); mrb_str_resize(mrb, serv, strlen(RSTRING_PTR(serv))); mrb_ary_push(mrb, ary, serv); return ary; }
static mrb_value mrb_mruby_motor_stop(mrb_state *mrb, mrb_value self) { motor_port_t port = mrb_fixnum(mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@port"))); ev3_motor_stop(port, false); return self; }
static mrb_value mrb_mruby_motor_resetCount(mrb_state *mrb, mrb_value self) { motor_port_t port = mrb_fixnum(mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@port"))); ev3_motor_reset_counts(port); return mrb_true_value(); }
static mrb_value mrb_sdl_palette_destroy (mrb_state *mrb, mrb_value self) { mrb_sdl_context* context = NULL; mrb_value value_context = mrb_iv_get(mrb, self, mrb_intern(mrb, "context")); Data_Get_Struct(mrb, value_context, &sdl_context_type, context); sdl_context_free(mrb, context); return self; }
/* * call-seq: * tsk.activate # => nil * * Activates Task. * * Returns nil. */ static mrb_value mrb_task_activate(mrb_state *mrb, mrb_value self) { mrb_value id = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "id")); RTOS_act_tsk(mrb, mrb_fixnum(id)); return mrb_nil_value(); }
static mrb_value mrb_rx_gpio_input(mrb_state *mrb, mrb_value self) { mrb_value pin = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@pin")); mrb_int pin_no = mrb_fixnum(pin); int bit; int ddr; int status=0; volatile struct st_port0 *port = (volatile struct st_port0 *)get_port(pin_no,&bit,&ddr); #if MRB_DEBUG1 printf("rx_gpio_input port = %08x bit = %d\n",(int)port,bit); #endif if (ddr == 0) // IN { status = port->PIDR.BYTE & BITTBL[bit]; if (status != 0) { return(mrb_true_value()); } } return(mrb_false_value()); }
static mrb_value mrb_ecdsa_sign(mrb_state *mrb, mrb_value self) { ctr_drbg_context *ctr_drbg; unsigned char buf[512], str[1024]; int i, j, len=0, ret=0; ecdsa_context *ecdsa; mrb_value hash, obj; memset(buf, 0, sizeof( buf ) ); mrb_get_args(mrb, "S", &hash); obj = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@ctr_drbg")); ecdsa = DATA_CHECK_GET_PTR(mrb, self, &mrb_ecdsa_type, ecdsa_context); ctr_drbg = DATA_CHECK_GET_PTR(mrb, obj, &mrb_ctr_drbg_type, ctr_drbg_context); ret = ecdsa_write_signature(ecdsa, RSTRING_PTR(hash), RSTRING_LEN(hash), buf, &len, ctr_drbg_random, ctr_drbg); for(i=0, j=0; i < len; i++,j+=2) { sprintf(&str[j], "%c%c", "0123456789ABCDEF" [buf[i] / 16], "0123456789ABCDEF" [buf[i] % 16] ); } if (ret == 0) { return mrb_str_new(mrb, &str, len*2); } else { return mrb_fixnum_value(ret); } }
static mrb_value mrb_wslay_event_context_client_init(mrb_state *mrb, mrb_value self) { mrb_value callbacks_obj; mrb_get_args(mrb, "o", &callbacks_obj); mrb_value recv_callback, send_callback, on_msg_recv_callback; recv_callback = mrb_iv_get(mrb, callbacks_obj, mrb_intern_lit(mrb, "@recv_callback")); if (mrb_type(recv_callback) != MRB_TT_PROC) { mrb_raise(mrb, E_ARGUMENT_ERROR, "recv_callback missing"); } send_callback = mrb_iv_get(mrb, callbacks_obj, mrb_intern_lit(mrb, "@send_callback")); if (mrb_type(send_callback) != MRB_TT_PROC) { mrb_raise(mrb, E_ARGUMENT_ERROR, "send_callback missing"); } on_msg_recv_callback = mrb_iv_get(mrb, callbacks_obj, mrb_intern_lit(mrb, "@on_msg_recv_callback")); if (mrb_type(on_msg_recv_callback) != MRB_TT_PROC) { mrb_raise(mrb, E_ARGUMENT_ERROR, "on_msg_recv_callback missing"); } mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "callbacks"), callbacks_obj); mrb_wslay_user_data *data = (mrb_wslay_user_data *) mrb_malloc(mrb, sizeof(mrb_wslay_user_data)); mrb_data_init(self, data, &mrb_wslay_user_data_type); data->mrb = mrb; data->recv_callback = recv_callback; data->send_callback = send_callback; data->on_msg_recv_callback = on_msg_recv_callback; struct wslay_event_callbacks client_callbacks = { mrb_wslay_event_recv_callback, mrb_wslay_event_send_callback, mrb_wslay_event_genmask_callback, NULL, NULL, NULL, mrb_wslay_event_on_msg_recv_callback }; int err = wslay_event_context_client_init(&data->ctx, &client_callbacks, data); if (err == WSLAY_ERR_NOMEM) { mrb_sys_fail(mrb, "wslay_event_context_client_init"); } else if (err != 0) { return MRB_WSLAY_ERROR(mrb_fixnum_value(err)); } return self; }
struct RData* mrb_mruby_opencv_mat_object_alloc(mrb_state* mrb, cv::Mat* mat) { struct RClass* cv_class = mrb_class_get(mrb, "CV"); struct RClass* mat_class = mrb_class_ptr(mrb_iv_get(mrb, mrb_obj_value(cv_class), mrb_intern_lit(mrb, "Mat"))); struct RData* data = mrb_data_object_alloc(mrb, mat_class, mat, &mrb_mruby_opencv_data_type); return data; }
static mrb_value mrb_thread_alive(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); return context->alive ? mrb_true_value() : mrb_false_value(); }
static mrb_value mrb_uv_key_destroy(mrb_state *mrb, mrb_value self) { uv_key_t *key = (uv_key_t*)mrb_uv_get_ptr(mrb, self, &mrb_uv_key_type); mrb_ary_clear(mrb, mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "values"))); uv_key_delete(key); return self; }
static mrb_value mrb_sdl2_video_surface_set_color_mod(mrb_state *mrb, mrb_value self) { mrb_value color; SDL_Surface *s = mrb_sdl2_video_surface_get_ptr(mrb, self); mrb_get_args(mrb, "o", &color); if (!mrb_obj_is_kind_of(mrb, color, mrb_class_get_under(mrb, mod_SDL2, "RGB"))) { mrb_raise(mrb, E_TYPE_ERROR, "given 1st argument is unexpected type (expected RGB)."); } uint8_t const r = mrb_fixnum(mrb_iv_get(mrb, color, mrb_intern(mrb, "@r", 2))); uint8_t const g = mrb_fixnum(mrb_iv_get(mrb, color, mrb_intern(mrb, "@g", 2))); uint8_t const b = mrb_fixnum(mrb_iv_get(mrb, color, mrb_intern(mrb, "@b", 2))); if (0 != SDL_SetSurfaceColorMod(s, r, g, b)) { mruby_sdl2_raise_error(mrb); } return self; }
void draw_sprite (mrb_state *mrb, mrb_value sprite, kmMat4* matrices) { MCL_Sprite *spr = DATA_PTR (sprite); MCL_Bitmap *bmp; mrb_value shader; MCL_Shader *shaderid; if (!spr->visible) { return; } bmp = DATA_PTR (mrb_iv_get (mrb, sprite, mrb_intern_lit (mrb, "@bitmap"))); if (lastVao != spr->vao) { glBindVertexArray (spr->vao); lastVao = spr->vao; } if (lastVbo != spr->vbo) { glBindBuffer (GL_ARRAY_BUFFER, spr->vbo); lastVbo = spr->vbo; } if (!eabbind) { glGenBuffers (1, &eab); glBindBuffer (GL_ELEMENT_ARRAY_BUFFER, eab); glBufferData (GL_ELEMENT_ARRAY_BUFFER, sizeof (indices), indices, GL_STATIC_DRAW); eabbind = TRUE; } glBindBuffer (GL_ELEMENT_ARRAY_BUFFER, eab); if (lastTexture != bmp->glTexture) { glBindTexture (GL_TEXTURE_2D, bmp->glTexture); lastTexture = bmp->glTexture; } kmMat4Identity(&matrices[0]); shader = mrb_iv_get (mrb, sprite, mrb_intern_lit (mrb, "@shader")); shaderid = DATA_PTR (shader); bind_shader_attributes (shaderid->shaderId, matrices); glDrawElements (GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0); }
// For FLTK::Widget#callback void mrb_fltk_widget_callback_function( Fl_Widget *fl_widget, void *data ) { mrb_fltk_widget_callback_context *context = (mrb_fltk_widget_callback_context *)data; mrb_state *mrb = context->mrb; mrb_value self = context->self; mrb_value block = mrb_iv_get( mrb, self, mrb_intern_cstr( mrb, "callback" ) ); mrb_funcall_with_block( mrb, self, mrb_intern_cstr( mrb, "instance_eval" ), 0, NULL, block ); }
static int mrb_io_read_data_pending(mrb_state *mrb, mrb_value io) { mrb_value buf = mrb_iv_get(mrb, io, mrb_intern_cstr(mrb, "@buf")); if (mrb_type(buf) == MRB_TT_STRING && RSTRING_LEN(buf) > 0) { return 1; } return 0; }
/* * call-seq: * obj.instance_variable_get(symbol) -> obj * * Returns the value of the given instance variable, or nil if the * instance variable is not set. The <code>@</code> part of the * variable name should be included for regular instance * variables. Throws a <code>NameError</code> exception if the * supplied symbol is not valid as an instance variable name. * * class Fred * def initialize(p1, p2) * @a, @b = p1, p2 * end * end * fred = Fred.new('cat', 99) * fred.instance_variable_get(:@a) #=> "cat" * fred.instance_variable_get("@b") #=> 99 */ static mrb_value mrb_obj_ivar_get(mrb_state *mrb, mrb_value self) { mrb_sym iv_name; mrb_get_args(mrb, "n", &iv_name); mrb_iv_check(mrb, iv_name); return mrb_iv_get(mrb, self, iv_name); }