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); //メモリリーク？ 開放しないため４回目で落ちる
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);
}
