static int
read_rite_irep_record(mrb_state *mrb, unsigned char *src, mrb_irep *irep, uint32_t* len)
{
int i, ret = MRB_DUMP_OK;
char *buf;
unsigned char *recordStart, *pStart;
uint16_t crc, tt, pdl, snl, offset, bufsize=MRB_DUMP_DEFAULT_STR_LEN;
mrb_int fix_num;
mrb_float f;
mrb_value str;
recordStart = src;
buf = mrb_malloc(mrb, bufsize);
if (buf == NULL) {
ret = MRB_DUMP_INVALID_IREP;
goto error_exit;
}
//Header Section
pStart = src;
if (*src != RITE_IREP_IDENFIFIER)
return MRB_DUMP_INVALID_IREP;
src += (sizeof(unsigned char) * 2);
irep->nlocals = bin_to_uint16(src); //number of local variable
src += MRB_DUMP_SIZE_OF_SHORT;
irep->nregs = bin_to_uint16(src); //number of register variable
src += MRB_DUMP_SIZE_OF_SHORT;
offset = bin_to_uint16(src); //offset of isec block
src += MRB_DUMP_SIZE_OF_SHORT;
crc = calc_crc_16_ccitt(pStart, src - pStart); //Calculate CRC
if (crc != bin_to_uint16(src)) //header CRC
return MRB_DUMP_INVALID_IREP;
src += offset;
//Binary Data Section
//ISEQ BLOCK
pStart = src;
irep->ilen = bin_to_uint32(src); //iseq length
src += MRB_DUMP_SIZE_OF_LONG;
if (irep->ilen > 0) {
if ((irep->iseq = mrb_malloc(mrb, sizeof(mrb_code) * irep->ilen)) == NULL) {
ret = MRB_DUMP_GENERAL_FAILURE;
goto error_exit;
}
for (i=0; i<irep->ilen; i++) {
irep->iseq[i] = bin_to_uint32(src); //iseq
src += MRB_DUMP_SIZE_OF_LONG;
}
}
crc = calc_crc_16_ccitt((unsigned char *)pStart, src - pStart); //Calculate CRC
if (crc != bin_to_uint16(src)) { //iseq CRC
ret = MRB_DUMP_INVALID_IREP;
goto error_exit;
}
src += MRB_DUMP_SIZE_OF_SHORT;
//POOL BLOCK
pStart = src;
irep->plen = bin_to_uint32(src); //pool length
src += MRB_DUMP_SIZE_OF_LONG;
if (irep->plen > 0) {
irep->pool = mrb_malloc(mrb, sizeof(mrb_value) * irep->plen);
if (irep->pool == NULL) {
ret = MRB_DUMP_INVALID_IREP;
goto error_exit;
}
for (i=0; i<irep->plen; i++) {
tt = *src; //pool TT
src += sizeof(unsigned char);
pdl = bin_to_uint16(src); //pool data length
src += MRB_DUMP_SIZE_OF_SHORT;
if (pdl > bufsize - 1) {
mrb_free(mrb, buf);
bufsize = pdl + 1;
if ((buf = mrb_malloc(mrb, bufsize)) == NULL) {
ret = MRB_DUMP_GENERAL_FAILURE;
goto error_exit;
}
}
memcpy(buf, src, pdl);
src += pdl;
buf[pdl] = '\0';
switch (tt) { //pool data
case MRB_TT_FIXNUM:
sscanf(buf, "%d", &fix_num);
irep->pool[i] = mrb_fixnum_value(fix_num);
break;
case MRB_TT_FLOAT:
sscanf(buf, "%le", &f);
irep->pool[i] = mrb_float_value(f);
break;
case MRB_TT_STRING:
irep->pool[i] = mrb_str_new(mrb, buf, pdl);
break;
#ifdef INCLUDE_REGEXP
case MRB_TT_REGEX:
str = mrb_str_new(mrb, buf, pdl);
irep->pool[i] = mrb_reg_quote(mrb, str);
break;
#endif
default:
irep->pool[i] = mrb_nil_value();
break;
}
}
}
crc = calc_crc_16_ccitt((unsigned char *)pStart, src - pStart); //Calculate CRC
if (crc != bin_to_uint16(src)) { //pool CRC
ret = MRB_DUMP_INVALID_IREP;
goto error_exit;
}
src += MRB_DUMP_SIZE_OF_SHORT;
//SYMS BLOCK
pStart = src;
irep->slen = bin_to_uint32(src); //syms length
src += MRB_DUMP_SIZE_OF_LONG;
if (irep->slen > 0) {
if ((irep->syms = mrb_malloc(mrb, MRB_DUMP_SIZE_OF_INT * irep->slen)) == NULL) {
ret = MRB_DUMP_INVALID_IREP;
goto error_exit;
}
memset(irep->syms, 0, sizeof(mrb_sym)*(irep->slen));
for (i=0; i<irep->slen; i++) {
snl = bin_to_uint16(src); //symbol name length
src += MRB_DUMP_SIZE_OF_SHORT;
if (snl == MRB_DUMP_NULL_SYM_LEN) {
irep->syms[i] = 0;
continue;
}
if (snl > bufsize - 1) {
mrb_free(mrb, buf);
bufsize = snl + 1;
if ((buf = mrb_malloc(mrb, bufsize)) == NULL) {
ret = MRB_DUMP_GENERAL_FAILURE;
goto error_exit;
}
}
memcpy(buf, src, snl); //symbol name
src += snl;
buf[snl] = '\0';
irep->syms[i] = mrb_intern(mrb, buf);
}
}
crc = calc_crc_16_ccitt((unsigned char *)pStart, src - pStart); //Calculate CRC
if (crc != bin_to_uint16(src)) { //syms CRC
ret = MRB_DUMP_INVALID_IREP;
goto error_exit;
}
src += MRB_DUMP_SIZE_OF_SHORT;
*len = src - recordStart;
error_exit:
if (buf)
mrb_free(mrb, buf);
return ret;
}
/*
* Document-method: __id__
* Document-method: object_id
*
* call-seq:
* obj.__id__ -> fixnum
* obj.object_id -> fixnum
*
* Returns an integer identifier for <i>obj</i>. The same number will
* be returned on all calls to <code>id</code> for a given object, and
* no two active objects will share an id.
* <code>Object#object_id</code> is a different concept from the
* <code>:name</code> notation, which returns the symbol id of
* <code>name</code>. Replaces the deprecated <code>Object#id</code>.
*/
static mrb_value
mrb_obj_id_m(mrb_state *mrb, mrb_value self)
{
return mrb_fixnum_value(mrb_obj_id(self));
}
static mrb_value
pcre_regexp_initialize_copy(mrb_state *mrb, mrb_value copy) {
mrb_value regexp;
struct mrb_pcre_regexp *reg;
mrb_get_args(mrb, "o", ®exp);
if (mrb_obj_equal(mrb, copy, regexp)){
return copy;
}
if (!mrb_obj_is_instance_of(mrb, regexp, mrb_obj_class(mrb, copy))){
mrb_raise(mrb, E_TYPE_ERROR, "wrong argument class");
}
Data_Get_Struct(mrb, regexp, &mrb_pcre_regexp_type, reg);
pcre_regexp_init(mrb, copy, mrb_funcall_argv(mrb, regexp, mrb_intern_lit(mrb, "source"), 0, NULL), mrb_fixnum_value(reg->flag));
return copy;
}
static mrb_value
mrb_ipvs_service_get_port(mrb_state *mrb, mrb_value self){
struct mrb_ipvs_entry *ie;
ie = DATA_PTR(self);
return mrb_fixnum_value(ntohs(ie->svc.port));
}
static mrb_value
mrb_str_size(mrb_state *mrb, mrb_value str)
{
return mrb_fixnum_value(mrb_utf8_strlen(str, -1));
}
static mrb_value
fix_uminus(mrb_state *mrb, mrb_value num)
{
return mrb_fixnum_value(0 - mrb_fixnum(num));
}
mrb_value
mrb_vm_special_get(mrb_state *mrb, mrb_sym i)
{
return mrb_fixnum_value(0);
}
static mrb_value
mrb_sqlite3_database_execute_batch(mrb_state *mrb, mrb_value self) {
int argc = 0;
mrb_value *argv;
mrb_value value_context;
mrb_sqlite3_database* db = NULL;
mrb_value query;
int len;
char* top;
const char *tail, *sql;
mrb_get_args(mrb, "*", &argv, &argc);
if (argc == 0) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
}
value_context = mrb_iv_get(mrb, self, mrb_intern(mrb, "context"));
Data_Get_Struct(mrb, value_context, &mrb_sqlite3_database_type, db);
if (!db) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
}
query = argv[0];
len = RSTRING_LEN(query);
top = malloc(len + 1);
if (!top) {
mrb_raise(mrb, E_RUNTIME_ERROR, "can't memory alloc");
}
memcpy(top, RSTRING_PTR(query), len);
top[len] = 0;
tail = (const char*) top;
while (*(sql = tail)) {
sqlite3_stmt* stmt = NULL;
int r = sqlite3_prepare_v2(db->db, sql, -1, &stmt, &tail);
if (argc > 1) {
const char* error = bind_values(mrb, db->db, stmt, argc-1, &argv[1]);
argc = 0;
if (error) {
free(top);
mrb_raise(mrb, E_ARGUMENT_ERROR, error);
}
}
if (r != SQLITE_OK) {
if (stmt) {
sqlite3_finalize(stmt);
sqlite3_reset(stmt);
}
free(top);
mrb_raise(mrb, E_RUNTIME_ERROR, sqlite3_errmsg(db->db));
}
if (stmt) {
r = sqlite3_step(stmt);
sqlite3_finalize(stmt);
if (r != SQLITE_OK && r != SQLITE_DONE) {
free(top);
mrb_raise(mrb, E_RUNTIME_ERROR, sqlite3_errmsg(db->db));
}
}
}
free(top);
return mrb_fixnum_value(sqlite3_changes(db->db));
}
/*
* call-seq:
* struct.length -> Fixnum
* struct.size -> Fixnum
*
* Returns number of struct members.
*/
static mrb_value
mrb_struct_len(mrb_state *mrb, mrb_value self)
{
return mrb_fixnum_value(RSTRUCT_LEN(self));
}
mrb_value fake_c_method2(mrb_state *mrb, mrb_value self){
return mrb_fixnum_value(777);
}
mrb_value fake_c_method1(mrb_state *mrb, mrb_value self){
return mrb_fixnum_value(999);
}
static mrb_value
mrb_sdl2_keyboard_get_mod_state(mrb_state *mrb, mrb_value mod)
{
return mrb_fixnum_value(SDL_GetModState());
}
void
mruby_sdl2_keyboard_init(mrb_state *mrb)
{
struct RClass *mod_Input = mrb_module_get_under(mrb, mod_SDL2, "Input");
mod_Keyboard = mrb_define_module_under(mrb, mod_Input, "Keyboard");
mrb_define_module_function(mrb, mod_Keyboard, "key_from_name", mrb_sdl2_keyboard_key_from_name, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, mod_Keyboard, "key_from_scancode", mrb_sdl2_keyboard_key_from_scancode, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, mod_Keyboard, "key_name", mrb_sdl2_keyboard_key_name, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, mod_Keyboard, "keyboard_focus", mrb_sdl2_keyboard_keyboard_focus, MRB_ARGS_NONE());
mrb_define_module_function(mrb, mod_Keyboard, "mod_state", mrb_sdl2_keyboard_get_mod_state, MRB_ARGS_NONE());
mrb_define_module_function(mrb, mod_Keyboard, "mod_state=", mrb_sdl2_keyboard_set_mod_state, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, mod_Keyboard, "scancode_from_key", mrb_sdl2_keyboard_scancode_from_key, MRB_ARGS_NONE());
mrb_define_module_function(mrb, mod_Keyboard, "scancode_from_name", mrb_sdl2_keyboard_scancode_from_name, MRB_ARGS_NONE());
mrb_define_module_function(mrb, mod_Keyboard, "scancode_name", mrb_sdl2_keyboard_scancode_name, MRB_ARGS_NONE());
mrb_define_module_function(mrb, mod_Keyboard, "text_input_rect", mrb_sdl2_keyboard_text_input_rect, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, mod_Keyboard, "text_input_start", mrb_sdl2_keyboard_text_input_start, MRB_ARGS_NONE());
mrb_define_module_function(mrb, mod_Keyboard, "text_input_stop", mrb_sdl2_keyboard_text_input_stop, MRB_ARGS_NONE());
class_Keysym = mrb_define_class_under(mrb, mod_Keyboard, "Keysym", mrb->object_class);
MRB_SET_INSTANCE_TT(class_Keysym, MRB_TT_DATA);
mrb_define_method(mrb, class_Keysym, "scancode", mrb_sdl2_keyboard_keysym_get_scancode, MRB_ARGS_NONE());
mrb_define_method(mrb, class_Keysym, "symbol", mrb_sdl2_keyboard_keysym_get_symbol, MRB_ARGS_NONE());
mrb_define_method(mrb, class_Keysym, "modifier", mrb_sdl2_keyboard_keysym_get_modifier, MRB_ARGS_NONE());
int arena_size = mrb_gc_arena_save(mrb);
/* SDL_Scancode */
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_0", mrb_fixnum_value(SDL_SCANCODE_0));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_1", mrb_fixnum_value(SDL_SCANCODE_1));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_2", mrb_fixnum_value(SDL_SCANCODE_2));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_3", mrb_fixnum_value(SDL_SCANCODE_3));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_4", mrb_fixnum_value(SDL_SCANCODE_4));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_5", mrb_fixnum_value(SDL_SCANCODE_5));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_6", mrb_fixnum_value(SDL_SCANCODE_6));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_7", mrb_fixnum_value(SDL_SCANCODE_7));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_8", mrb_fixnum_value(SDL_SCANCODE_8));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_9", mrb_fixnum_value(SDL_SCANCODE_9));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_A", mrb_fixnum_value(SDL_SCANCODE_A));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_B", mrb_fixnum_value(SDL_SCANCODE_B));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_C", mrb_fixnum_value(SDL_SCANCODE_C));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_D", mrb_fixnum_value(SDL_SCANCODE_D));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_E", mrb_fixnum_value(SDL_SCANCODE_E));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F", mrb_fixnum_value(SDL_SCANCODE_F));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_G", mrb_fixnum_value(SDL_SCANCODE_G));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_H", mrb_fixnum_value(SDL_SCANCODE_H));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_I", mrb_fixnum_value(SDL_SCANCODE_I));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_J", mrb_fixnum_value(SDL_SCANCODE_J));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_K", mrb_fixnum_value(SDL_SCANCODE_K));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_L", mrb_fixnum_value(SDL_SCANCODE_L));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_M", mrb_fixnum_value(SDL_SCANCODE_M));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_N", mrb_fixnum_value(SDL_SCANCODE_N));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_O", mrb_fixnum_value(SDL_SCANCODE_O));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_P", mrb_fixnum_value(SDL_SCANCODE_P));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_Q", mrb_fixnum_value(SDL_SCANCODE_Q));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_R", mrb_fixnum_value(SDL_SCANCODE_R));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_S", mrb_fixnum_value(SDL_SCANCODE_S));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_T", mrb_fixnum_value(SDL_SCANCODE_T));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_U", mrb_fixnum_value(SDL_SCANCODE_U));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_V", mrb_fixnum_value(SDL_SCANCODE_V));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_W", mrb_fixnum_value(SDL_SCANCODE_W));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_X", mrb_fixnum_value(SDL_SCANCODE_X));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_Y", mrb_fixnum_value(SDL_SCANCODE_Y));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_Z", mrb_fixnum_value(SDL_SCANCODE_Z));
mrb_gc_arena_restore(mrb, arena_size);
arena_size = mrb_gc_arena_save(mrb);
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F1", mrb_fixnum_value(SDL_SCANCODE_F1));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F2", mrb_fixnum_value(SDL_SCANCODE_F2));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F3", mrb_fixnum_value(SDL_SCANCODE_F3));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F4", mrb_fixnum_value(SDL_SCANCODE_F4));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F5", mrb_fixnum_value(SDL_SCANCODE_F5));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F6", mrb_fixnum_value(SDL_SCANCODE_F6));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F7", mrb_fixnum_value(SDL_SCANCODE_F7));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F8", mrb_fixnum_value(SDL_SCANCODE_F8));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F9", mrb_fixnum_value(SDL_SCANCODE_F9));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F10", mrb_fixnum_value(SDL_SCANCODE_F10));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F11", mrb_fixnum_value(SDL_SCANCODE_F11));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F12", mrb_fixnum_value(SDL_SCANCODE_F12));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F13", mrb_fixnum_value(SDL_SCANCODE_F13));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F14", mrb_fixnum_value(SDL_SCANCODE_F14));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F15", mrb_fixnum_value(SDL_SCANCODE_F15));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F16", mrb_fixnum_value(SDL_SCANCODE_F16));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F17", mrb_fixnum_value(SDL_SCANCODE_F17));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F18", mrb_fixnum_value(SDL_SCANCODE_F18));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F19", mrb_fixnum_value(SDL_SCANCODE_F19));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F20", mrb_fixnum_value(SDL_SCANCODE_F20));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F21", mrb_fixnum_value(SDL_SCANCODE_F21));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F22", mrb_fixnum_value(SDL_SCANCODE_F22));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F23", mrb_fixnum_value(SDL_SCANCODE_F23));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_F24", mrb_fixnum_value(SDL_SCANCODE_F24));
mrb_gc_arena_restore(mrb, arena_size);
arena_size = mrb_gc_arena_save(mrb);
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_BACKSPACE", mrb_fixnum_value(SDL_SCANCODE_BACKSPACE));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_CAPSLOCK", mrb_fixnum_value(SDL_SCANCODE_CAPSLOCK));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_DELETE", mrb_fixnum_value(SDL_SCANCODE_DELETE));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_ESCAPE", mrb_fixnum_value(SDL_SCANCODE_ESCAPE));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_END", mrb_fixnum_value(SDL_SCANCODE_END));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_HOME", mrb_fixnum_value(SDL_SCANCODE_HOME));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_INSERT", mrb_fixnum_value(SDL_SCANCODE_INSERT));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_LALT", mrb_fixnum_value(SDL_SCANCODE_LALT));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_LCTRL", mrb_fixnum_value(SDL_SCANCODE_LCTRL));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_LEFT", mrb_fixnum_value(SDL_SCANCODE_LEFT));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_LSHIFT", mrb_fixnum_value(SDL_SCANCODE_LSHIFT));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_PAGEDOWN", mrb_fixnum_value(SDL_SCANCODE_PAGEDOWN));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_PAGEUP", mrb_fixnum_value(SDL_SCANCODE_PAGEUP));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_PRINTSCREEN", mrb_fixnum_value(SDL_SCANCODE_PRINTSCREEN));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_RALT", mrb_fixnum_value(SDL_SCANCODE_RALT));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_RCTRL", mrb_fixnum_value(SDL_SCANCODE_RCTRL));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_RETURN", mrb_fixnum_value(SDL_SCANCODE_RETURN));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_RIGHT", mrb_fixnum_value(SDL_SCANCODE_RIGHT));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_RSHIFT", mrb_fixnum_value(SDL_SCANCODE_RSHIFT));
mrb_define_const(mrb, mod_Keyboard, "SDL_SCANCODE_UNKNOWN", mrb_fixnum_value(SDL_SCANCODE_UNKNOWN));
mrb_gc_arena_restore(mrb, arena_size);
arena_size = mrb_gc_arena_save(mrb);
/* SDL_Keycode */
mrb_define_const(mrb, mod_Keyboard, "SDLK_0", mrb_fixnum_value(SDLK_0));
mrb_define_const(mrb, mod_Keyboard, "SDLK_1", mrb_fixnum_value(SDLK_1));
mrb_define_const(mrb, mod_Keyboard, "SDLK_2", mrb_fixnum_value(SDLK_2));
mrb_define_const(mrb, mod_Keyboard, "SDLK_3", mrb_fixnum_value(SDLK_3));
mrb_define_const(mrb, mod_Keyboard, "SDLK_4", mrb_fixnum_value(SDLK_4));
mrb_define_const(mrb, mod_Keyboard, "SDLK_5", mrb_fixnum_value(SDLK_5));
mrb_define_const(mrb, mod_Keyboard, "SDLK_6", mrb_fixnum_value(SDLK_6));
mrb_define_const(mrb, mod_Keyboard, "SDLK_7", mrb_fixnum_value(SDLK_7));
mrb_define_const(mrb, mod_Keyboard, "SDLK_8", mrb_fixnum_value(SDLK_8));
mrb_define_const(mrb, mod_Keyboard, "SDLK_9", mrb_fixnum_value(SDLK_9));
mrb_define_const(mrb, mod_Keyboard, "SDLK_A", mrb_fixnum_value(SDLK_a));
mrb_define_const(mrb, mod_Keyboard, "SDLK_B", mrb_fixnum_value(SDLK_b));
mrb_define_const(mrb, mod_Keyboard, "SDLK_C", mrb_fixnum_value(SDLK_c));
mrb_define_const(mrb, mod_Keyboard, "SDLK_D", mrb_fixnum_value(SDLK_d));
mrb_define_const(mrb, mod_Keyboard, "SDLK_E", mrb_fixnum_value(SDLK_e));
mrb_define_const(mrb, mod_Keyboard, "SDLK_F", mrb_fixnum_value(SDLK_f));
mrb_define_const(mrb, mod_Keyboard, "SDLK_G", mrb_fixnum_value(SDLK_g));
mrb_define_const(mrb, mod_Keyboard, "SDLK_H", mrb_fixnum_value(SDLK_h));
mrb_define_const(mrb, mod_Keyboard, "SDLK_I", mrb_fixnum_value(SDLK_i));
mrb_define_const(mrb, mod_Keyboard, "SDLK_J", mrb_fixnum_value(SDLK_j));
mrb_define_const(mrb, mod_Keyboard, "SDLK_K", mrb_fixnum_value(SDLK_k));
mrb_define_const(mrb, mod_Keyboard, "SDLK_L", mrb_fixnum_value(SDLK_l));
mrb_define_const(mrb, mod_Keyboard, "SDLK_M", mrb_fixnum_value(SDLK_m));
mrb_define_const(mrb, mod_Keyboard, "SDLK_N", mrb_fixnum_value(SDLK_n));
mrb_define_const(mrb, mod_Keyboard, "SDLK_O", mrb_fixnum_value(SDLK_o));
mrb_define_const(mrb, mod_Keyboard, "SDLK_P", mrb_fixnum_value(SDLK_p));
mrb_define_const(mrb, mod_Keyboard, "SDLK_Q", mrb_fixnum_value(SDLK_q));
mrb_define_const(mrb, mod_Keyboard, "SDLK_R", mrb_fixnum_value(SDLK_r));
mrb_define_const(mrb, mod_Keyboard, "SDLK_S", mrb_fixnum_value(SDLK_s));
mrb_define_const(mrb, mod_Keyboard, "SDLK_T", mrb_fixnum_value(SDLK_t));
mrb_define_const(mrb, mod_Keyboard, "SDLK_U", mrb_fixnum_value(SDLK_u));
mrb_define_const(mrb, mod_Keyboard, "SDLK_V", mrb_fixnum_value(SDLK_v));
mrb_define_const(mrb, mod_Keyboard, "SDLK_W", mrb_fixnum_value(SDLK_w));
mrb_define_const(mrb, mod_Keyboard, "SDLK_X", mrb_fixnum_value(SDLK_x));
mrb_define_const(mrb, mod_Keyboard, "SDLK_Y", mrb_fixnum_value(SDLK_y));
mrb_define_const(mrb, mod_Keyboard, "SDLK_Z", mrb_fixnum_value(SDLK_z));
mrb_gc_arena_restore(mrb, arena_size);
arena_size = mrb_gc_arena_save(mrb);
mrb_define_const(mrb, mod_Keyboard, "SDLK_F1", mrb_fixnum_value(SDLK_F1));
mrb_define_const(mrb, mod_Keyboard, "SDLK_F2", mrb_fixnum_value(SDLK_F2));
mrb_define_const(mrb, mod_Keyboard, "SDLK_F3", mrb_fixnum_value(SDLK_F3));
mrb_define_const(mrb, mod_Keyboard, "SDLK_F4", mrb_fixnum_value(SDLK_F4));
mrb_define_const(mrb, mod_Keyboard, "SDLK_F5", mrb_fixnum_value(SDLK_F5));
mrb_define_const(mrb, mod_Keyboard, "SDLK_F6", mrb_fixnum_value(SDLK_F6));
mrb_define_const(mrb, mod_Keyboard, "SDLK_F7", mrb_fixnum_value(SDLK_F7));
mrb_define_const(mrb, mod_Keyboard, "SDLK_F8", mrb_fixnum_value(SDLK_F8));
mrb_define_const(mrb, mod_Keyboard, "SDLK_F9", mrb_fixnum_value(SDLK_F9));
mrb_define_const(mrb, mod_Keyboard, "SDLK_F10", mrb_fixnum_value(SDLK_F10));
mrb_define_const(mrb, mod_Keyboard, "SDLK_F11", mrb_fixnum_value(SDLK_F11));
mrb_define_const(mrb, mod_Keyboard, "SDLK_F12", mrb_fixnum_value(SDLK_F12));
mrb_define_const(mrb, mod_Keyboard, "SDLK_F13", mrb_fixnum_value(SDLK_F13));
mrb_define_const(mrb, mod_Keyboard, "SDLK_F14", mrb_fixnum_value(SDLK_F14));
mrb_define_const(mrb, mod_Keyboard, "SDLK_F15", mrb_fixnum_value(SDLK_F15));
mrb_define_const(mrb, mod_Keyboard, "SDLK_F16", mrb_fixnum_value(SDLK_F16));
mrb_define_const(mrb, mod_Keyboard, "SDLK_F17", mrb_fixnum_value(SDLK_F17));
mrb_define_const(mrb, mod_Keyboard, "SDLK_F18", mrb_fixnum_value(SDLK_F18));
mrb_define_const(mrb, mod_Keyboard, "SDLK_F19", mrb_fixnum_value(SDLK_F19));
mrb_define_const(mrb, mod_Keyboard, "SDLK_F20", mrb_fixnum_value(SDLK_F20));
mrb_define_const(mrb, mod_Keyboard, "SDLK_F21", mrb_fixnum_value(SDLK_F21));
mrb_define_const(mrb, mod_Keyboard, "SDLK_F22", mrb_fixnum_value(SDLK_F22));
mrb_define_const(mrb, mod_Keyboard, "SDLK_F23", mrb_fixnum_value(SDLK_F23));
mrb_define_const(mrb, mod_Keyboard, "SDLK_F24", mrb_fixnum_value(SDLK_F24));
mrb_gc_arena_restore(mrb, arena_size);
arena_size = mrb_gc_arena_save(mrb);
mrb_define_const(mrb, mod_Keyboard, "SDLK_BACKSPACE", mrb_fixnum_value(SDLK_BACKSPACE));
mrb_define_const(mrb, mod_Keyboard, "SDLK_CAPSLOCK", mrb_fixnum_value(SDLK_CAPSLOCK));
mrb_define_const(mrb, mod_Keyboard, "SDLK_DELETE", mrb_fixnum_value(SDLK_DELETE));
mrb_define_const(mrb, mod_Keyboard, "SDLK_ESCAPE", mrb_fixnum_value(SDLK_ESCAPE));
mrb_define_const(mrb, mod_Keyboard, "SDLK_END", mrb_fixnum_value(SDLK_END));
mrb_define_const(mrb, mod_Keyboard, "SDLK_HOME", mrb_fixnum_value(SDLK_HOME));
mrb_define_const(mrb, mod_Keyboard, "SDLK_INSERT", mrb_fixnum_value(SDLK_INSERT));
mrb_define_const(mrb, mod_Keyboard, "SDLK_LALT", mrb_fixnum_value(SDLK_LALT));
mrb_define_const(mrb, mod_Keyboard, "SDLK_LCTRL", mrb_fixnum_value(SDLK_LCTRL));
mrb_define_const(mrb, mod_Keyboard, "SDLK_LEFT", mrb_fixnum_value(SDLK_LEFT));
mrb_define_const(mrb, mod_Keyboard, "SDLK_LSHIFT", mrb_fixnum_value(SDLK_LSHIFT));
mrb_define_const(mrb, mod_Keyboard, "SDLK_PAGEDOWN", mrb_fixnum_value(SDLK_PAGEDOWN));
mrb_define_const(mrb, mod_Keyboard, "SDLK_PAGEUP", mrb_fixnum_value(SDLK_PAGEUP));
mrb_define_const(mrb, mod_Keyboard, "SDLK_PRINTSCREEN", mrb_fixnum_value(SDLK_PRINTSCREEN));
mrb_define_const(mrb, mod_Keyboard, "SDLK_RALT", mrb_fixnum_value(SDLK_RALT));
mrb_define_const(mrb, mod_Keyboard, "SDLK_RCTRL", mrb_fixnum_value(SDLK_RCTRL));
mrb_define_const(mrb, mod_Keyboard, "SDLK_RETURN", mrb_fixnum_value(SDLK_RETURN));
mrb_define_const(mrb, mod_Keyboard, "SDLK_RIGHT", mrb_fixnum_value(SDLK_RIGHT));
mrb_define_const(mrb, mod_Keyboard, "SDLK_RSHIFT", mrb_fixnum_value(SDLK_RSHIFT));
mrb_define_const(mrb, mod_Keyboard, "SDLK_AMPERSAND", mrb_fixnum_value(SDLK_AMPERSAND));
mrb_define_const(mrb, mod_Keyboard, "SDLK_ASTERISK", mrb_fixnum_value(SDLK_ASTERISK));
mrb_define_const(mrb, mod_Keyboard, "SDLK_AT", mrb_fixnum_value(SDLK_AT));
mrb_define_const(mrb, mod_Keyboard, "SDLK_CARET", mrb_fixnum_value(SDLK_CARET));
mrb_define_const(mrb, mod_Keyboard, "SDLK_COLON", mrb_fixnum_value(SDLK_COLON));
mrb_define_const(mrb, mod_Keyboard, "SDLK_DOLLAR", mrb_fixnum_value(SDLK_DOLLAR));
mrb_define_const(mrb, mod_Keyboard, "SDLK_EXCLAIM", mrb_fixnum_value(SDLK_EXCLAIM));
mrb_define_const(mrb, mod_Keyboard, "SDLK_GREATER", mrb_fixnum_value(SDLK_GREATER));
mrb_define_const(mrb, mod_Keyboard, "SDLK_HASH", mrb_fixnum_value(SDLK_HASH));
mrb_define_const(mrb, mod_Keyboard, "SDLK_LEFTPAREN", mrb_fixnum_value(SDLK_LEFTPAREN));
mrb_define_const(mrb, mod_Keyboard, "SDLK_LESS", mrb_fixnum_value(SDLK_LESS));
mrb_define_const(mrb, mod_Keyboard, "SDLK_PERCENT", mrb_fixnum_value(SDLK_PERCENT));
mrb_define_const(mrb, mod_Keyboard, "SDLK_PLUS", mrb_fixnum_value(SDLK_PLUS));
mrb_define_const(mrb, mod_Keyboard, "SDLK_QUESTION", mrb_fixnum_value(SDLK_QUESTION));
mrb_define_const(mrb, mod_Keyboard, "SDLK_QUOTEDBL", mrb_fixnum_value(SDLK_QUOTEDBL));
mrb_define_const(mrb, mod_Keyboard, "SDLK_RIGHTPAREN", mrb_fixnum_value(SDLK_RIGHTPAREN));
mrb_define_const(mrb, mod_Keyboard, "SDLK_UNDERSCORE", mrb_fixnum_value(SDLK_UNDERSCORE));
mrb_define_const(mrb, mod_Keyboard, "SDLK_UNKNOWN", mrb_fixnum_value(SDLK_UNKNOWN));
mrb_gc_arena_restore(mrb, arena_size);
arena_size = mrb_gc_arena_save(mrb);
/* SDL_Keymod */
mrb_define_const(mrb, mod_Keyboard, "KMOD_NONE", mrb_fixnum_value(KMOD_NONE));
mrb_define_const(mrb, mod_Keyboard, "KMOD_LSHIFT", mrb_fixnum_value(KMOD_LSHIFT));
mrb_define_const(mrb, mod_Keyboard, "KMOD_RSHIFT", mrb_fixnum_value(KMOD_RSHIFT));
mrb_define_const(mrb, mod_Keyboard, "KMOD_LCTRL", mrb_fixnum_value(KMOD_LCTRL));
mrb_define_const(mrb, mod_Keyboard, "KMOD_RCTRL", mrb_fixnum_value(KMOD_RCTRL));
mrb_define_const(mrb, mod_Keyboard, "KMOD_LALT", mrb_fixnum_value(KMOD_LALT));
mrb_define_const(mrb, mod_Keyboard, "KMOD_RALT", mrb_fixnum_value(KMOD_RALT));
mrb_define_const(mrb, mod_Keyboard, "KMOD_LGUI", mrb_fixnum_value(KMOD_LGUI));
mrb_define_const(mrb, mod_Keyboard, "KMOD_RGUI", mrb_fixnum_value(KMOD_RGUI));
mrb_define_const(mrb, mod_Keyboard, "KMOD_NUM", mrb_fixnum_value(KMOD_NUM));
mrb_define_const(mrb, mod_Keyboard, "KMOD_CAPS", mrb_fixnum_value(KMOD_CAPS));
mrb_define_const(mrb, mod_Keyboard, "KMOD_MODE", mrb_fixnum_value(KMOD_MODE));
mrb_define_const(mrb, mod_Keyboard, "KMOD_CTRL", mrb_fixnum_value(KMOD_CTRL));
mrb_define_const(mrb, mod_Keyboard, "KMOD_SHIFT", mrb_fixnum_value(KMOD_SHIFT));
mrb_define_const(mrb, mod_Keyboard, "KMOD_ALT", mrb_fixnum_value(KMOD_ALT));
mrb_define_const(mrb, mod_Keyboard, "KMOD_GUI", mrb_fixnum_value(KMOD_GUI));
mrb_gc_arena_restore(mrb, arena_size);
}
static mrb_value
mrb_io_s_select(mrb_state *mrb, mrb_value klass)
{
mrb_value *argv;
mrb_int argc;
mrb_value read, read_io, write, except, timeout, list;
struct timeval *tp, timerec;
fd_set pset, rset, wset, eset;
fd_set *rp, *wp, *ep;
struct mrb_io *fptr;
int pending = 0;
mrb_value result;
int max = 0;
int interrupt_flag = 0;
int i, n;
mrb_get_args(mrb, "*", &argv, &argc);
if (argc < 1 || argc > 4) {
mrb_raisef(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (%S for 1..4)", mrb_fixnum_value(argc));
}
timeout = mrb_nil_value();
except = mrb_nil_value();
write = mrb_nil_value();
if (argc > 3)
timeout = argv[3];
if (argc > 2)
except = argv[2];
if (argc > 1)
write = argv[1];
read = argv[0];
if (mrb_nil_p(timeout)) {
tp = NULL;
} else {
timerec = time2timeval(mrb, timeout);
tp = &timerec;
}
FD_ZERO(&pset);
if (!mrb_nil_p(read)) {
mrb_check_type(mrb, read, MRB_TT_ARRAY);
rp = &rset;
FD_ZERO(rp);
for (i = 0; i < RARRAY_LEN(read); i++) {
read_io = RARRAY_PTR(read)[i];
fptr = io_get_open_fptr(mrb, read_io);
FD_SET(fptr->fd, rp);
if (mrb_io_read_data_pending(mrb, read_io)) {
pending++;
FD_SET(fptr->fd, &pset);
}
if (max < fptr->fd)
max = fptr->fd;
}
if (pending) {
timerec.tv_sec = timerec.tv_usec = 0;
tp = &timerec;
}
} else {
rp = NULL;
}
if (!mrb_nil_p(write)) {
mrb_check_type(mrb, write, MRB_TT_ARRAY);
wp = &wset;
FD_ZERO(wp);
for (i = 0; i < RARRAY_LEN(write); i++) {
fptr = io_get_open_fptr(mrb, RARRAY_PTR(write)[i]);
FD_SET(fptr->fd, wp);
if (max < fptr->fd)
max = fptr->fd;
if (fptr->fd2 >= 0) {
FD_SET(fptr->fd2, wp);
if (max < fptr->fd2)
max = fptr->fd2;
}
}
} else {
wp = NULL;
}
if (!mrb_nil_p(except)) {
mrb_check_type(mrb, except, MRB_TT_ARRAY);
ep = &eset;
FD_ZERO(ep);
for (i = 0; i < RARRAY_LEN(except); i++) {
fptr = io_get_open_fptr(mrb, RARRAY_PTR(except)[i]);
FD_SET(fptr->fd, ep);
if (max < fptr->fd)
max = fptr->fd;
if (fptr->fd2 >= 0) {
FD_SET(fptr->fd2, ep);
if (max < fptr->fd2)
max = fptr->fd2;
}
}
} else {
ep = NULL;
}
max++;
retry:
n = select(max, rp, wp, ep, tp);
if (n < 0) {
if (errno != EINTR)
mrb_sys_fail(mrb, "select failed");
if (tp == NULL)
goto retry;
interrupt_flag = 1;
}
if (!pending && n == 0)
return mrb_nil_value();
result = mrb_ary_new_capa(mrb, 3);
mrb_ary_push(mrb, result, rp? mrb_ary_new(mrb) : mrb_ary_new_capa(mrb, 0));
mrb_ary_push(mrb, result, wp? mrb_ary_new(mrb) : mrb_ary_new_capa(mrb, 0));
mrb_ary_push(mrb, result, ep? mrb_ary_new(mrb) : mrb_ary_new_capa(mrb, 0));
if (interrupt_flag == 0) {
if (rp) {
list = RARRAY_PTR(result)[0];
for (i = 0; i < RARRAY_LEN(read); i++) {
fptr = io_get_open_fptr(mrb, RARRAY_PTR(read)[i]);
if (FD_ISSET(fptr->fd, rp) ||
FD_ISSET(fptr->fd, &pset)) {
mrb_ary_push(mrb, list, RARRAY_PTR(read)[i]);
}
}
}
if (wp) {
list = RARRAY_PTR(result)[1];
for (i = 0; i < RARRAY_LEN(write); i++) {
fptr = io_get_open_fptr(mrb, RARRAY_PTR(write)[i]);
if (FD_ISSET(fptr->fd, wp)) {
mrb_ary_push(mrb, list, RARRAY_PTR(write)[i]);
} else if (fptr->fd2 >= 0 && FD_ISSET(fptr->fd2, wp)) {
mrb_ary_push(mrb, list, RARRAY_PTR(write)[i]);
}
}
}
if (ep) {
list = RARRAY_PTR(result)[2];
for (i = 0; i < RARRAY_LEN(except); i++) {
fptr = io_get_open_fptr(mrb, RARRAY_PTR(except)[i]);
if (FD_ISSET(fptr->fd, ep)) {
mrb_ary_push(mrb, list, RARRAY_PTR(except)[i]);
} else if (fptr->fd2 >= 0 && FD_ISSET(fptr->fd2, ep)) {
mrb_ary_push(mrb, list, RARRAY_PTR(except)[i]);
}
}
}
}
return result;
}
static mrb_value
fix_succ(mrb_state *mrb, mrb_value num)
{
return mrb_fixnum_value(mrb_fixnum(num)+1);
}
mrb_value mrb_serial_available(mrb_state *mrb, mrb_value self){
return mrb_fixnum_value(Serial.available());
}
/*
* call-seq:
* int.next -> integer
* int.succ -> integer
*
* Returns the <code>Integer</code> equal to <i>int</i> + 1.
*
* 1.next #=> 2
* (-1).next #=> 0
*/
static mrb_value
int_succ(mrb_state *mrb, mrb_value num)
{
if (mrb_fixnum_p(num)) return fix_succ(mrb, num);
return mrb_funcall(mrb, num, "+", 1, mrb_fixnum_value(1));
}
mrb_value mrb_arduino_shiftIn(mrb_state *mrb, mrb_value self){
mrb_int dataPin, clockPin, bitOrder;
int n = mrb_get_args(mrb, "iii", &dataPin, &clockPin, &bitOrder);
return mrb_fixnum_value(shiftIn(dataPin, clockPin, bitOrder));
}
static mrb_value
json_value_to_mrb_value(mrb_state* mrb, JSON_Value* value) {
mrb_value ret;
switch (json_value_get_type(value)) {
case JSONError:
case JSONNull:
ret = mrb_nil_value();
break;
case JSONString:
ret = mrb_str_new_cstr(mrb, json_value_get_string(value));
break;
case JSONNumber:
{
double d = json_value_get_number(value);
if (floor(d) == d) {
ret = mrb_fixnum_value(d);
}
else {
ret = mrb_float_value(mrb, d);
}
}
break;
case JSONObject:
{
mrb_value hash = mrb_hash_new(mrb);
JSON_Object* object = json_value_get_object(value);
size_t count = json_object_get_count(object);
size_t n;
for (n = 0; n < count; n++) {
int ai = mrb_gc_arena_save(mrb);
const char* name = json_object_get_name(object, n);
mrb_hash_set(mrb, hash, mrb_str_new_cstr(mrb, name),
json_value_to_mrb_value(mrb, json_object_get_value(object, name)));
mrb_gc_arena_restore(mrb, ai);
}
ret = hash;
}
break;
case JSONArray:
{
mrb_value ary;
JSON_Array* array;
size_t n, count;
ary = mrb_ary_new(mrb);
array = json_value_get_array(value);
count = json_array_get_count(array);
for (n = 0; n < count; n++) {
int ai = mrb_gc_arena_save(mrb);
JSON_Value* elem = json_array_get_value(array, n);
mrb_ary_push(mrb, ary, json_value_to_mrb_value(mrb, elem));
mrb_gc_arena_restore(mrb, ai);
}
ret = ary;
}
break;
case JSONBoolean:
if (json_value_get_boolean(value))
ret = mrb_true_value();
else
ret = mrb_false_value();
break;
default:
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
}
return ret;
}
mrb_value mrb_arduino_micros(mrb_state *mrb, mrb_value self){
return mrb_fixnum_value(micros());
}
static mrb_value
mrb_ipvs_dest_get_weight(mrb_state *mrb, mrb_value self){
struct mrb_ipvs_entry *ie;
ie = DATA_PTR(self);
return mrb_fixnum_value(ie->dest.weight);
}
mrb_value mrb_arduino_map(mrb_state *mrb, mrb_value self){
mrb_int value, fromLow, fromHigh, toLow, toHigh;
int n = mrb_get_args(mrb, "iiiii", &value, &fromLow, &fromHigh, &toLow, &toHigh);
mrb_int ret = map(value, fromLow, fromHigh, toLow, toHigh);
return mrb_fixnum_value(ret);
}
mrb_value
qgame_texture_asset_load_from_file(mrb_state* mrb, mrb_value self)
{
GLuint texture; // This is a handle to our texture object
SDL_Surface *surface; // This surface will tell us the details of the image
GLenum texture_format;
mrb_value path;
mrb_get_args(mrb, "S", &path);
char* file = mrb_string_value_ptr(mrb, path);
if ( (surface = IMG_Load(file)) ) {
// Check that the image's width is a power of 2
if ( (surface->w & (surface->w - 1)) != 0 ) {
printf("warning: %s's width is not a power of 2\n", file);
}
// Also check if the height is a power of 2
if ( (surface->h & (surface->h - 1)) != 0 ) {
printf("warning: %s's height is not a power of 2\n", file);
}
// get the number of channels in the SDL surface
GLint nOfColors = surface->format->BytesPerPixel;
if (nOfColors == 4) // contains an alpha channel
{
if (surface->format->Rmask == 0x000000ff)
texture_format = GL_RGBA;
else
texture_format = GL_BGRA;
} else if (nOfColors == 3) // no alpha channel
{
if (surface->format->Rmask == 0x000000ff)
texture_format = GL_RGB;
else
texture_format = GL_BGRA;
} else {
printf("warning: the image is not truecolor.. this will probably break\n");
}
// Have OpenGL generate a texture object handle for us
glGenTextures( 1, &texture );
// Bind the texture object
glBindTexture( GL_TEXTURE_2D, texture );
// Set the texture's stretching properties
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
// Edit the texture object's image data using the information SDL_Surface gives us
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, surface->w, surface->h, 0,
texture_format, GL_UNSIGNED_BYTE, surface->pixels );
GLenum err = glGetError();
if (err != GL_NO_ERROR) {
printf("Error loading image into GL: %i\n", err);
}
mrb_value texture_id = mrb_fixnum_value(texture);
mrb_iv_set(mrb, self, mrb_intern(mrb, "texture_id"), texture_id);
mrb_value mrb_width = mrb_fixnum_value(surface->w);
mrb_iv_set(mrb, self, mrb_intern(mrb, "@width"), mrb_width);
mrb_value mrb_height = mrb_fixnum_value(surface->h);
mrb_iv_set(mrb, self, mrb_intern(mrb, "@height"), mrb_height);
}
else {
printf("SDL could not load image.bmp: %s\n", SDL_GetError());
}
// Free the SDL_Surface only if it was successfully created
if ( surface ) {
SDL_FreeSurface( surface );
}
return self;
}
void
mrb_mruby_arduino_gem_init(mrb_state* mrb) {
RClass *serialClass = mrb_define_class(mrb, "Serial", mrb->object_class);
mrb_define_class_method(mrb, serialClass, "available", mrb_serial_available, ARGS_NONE());
mrb_define_class_method(mrb, serialClass, "begin",mrb_serial_begin, ARGS_REQ(1));
mrb_define_class_method(mrb, serialClass, "println", mrb_serial_println, ARGS_REQ(1));
RClass *servoClass = mrb_define_class(mrb, "Servo", mrb->object_class);
MRB_SET_INSTANCE_TT(servoClass, MRB_TT_DATA);
mrb_define_method(mrb, servoClass, "initialize", mrb_servo_initialize, ARGS_NONE());
mrb_define_method(mrb, servoClass, "attach", mrb_servo_attach, ARGS_REQ(1));
mrb_define_method(mrb, servoClass, "write", mrb_servo_write, ARGS_REQ(1));
mrb_define_method(mrb, servoClass, "detach", mrb_servo_detach, ARGS_NONE());
RClass *arduinoModule = mrb_define_module(mrb, "Arduino");
mrb_define_module_function(mrb, arduinoModule, "pinMode", mrb_arduino_pinMode, ARGS_REQ(2));
mrb_define_module_function(mrb, arduinoModule, "digitalWrite", mrb_arduino_digitalWrite, ARGS_REQ(2));
mrb_define_module_function(mrb, arduinoModule, "digitalRead", mrb_arduino_digitalRead, ARGS_REQ(1));
mrb_define_module_function(mrb, arduinoModule, "analogReference", mrb_arduino_analogReference, ARGS_REQ(1));
mrb_define_module_function(mrb, arduinoModule, "analogWrite", mrb_arduino_analogWrite, ARGS_REQ(2));
mrb_define_module_function(mrb, arduinoModule, "analogRead", mrb_arduino_analogRead, ARGS_REQ(1));
mrb_define_module_function(mrb, arduinoModule, "tone", mrb_arduino_tone, ARGS_REQ(2) | ARGS_OPT(1));
mrb_define_module_function(mrb, arduinoModule, "noTone", mrb_arduino_noTone, ARGS_REQ(1));
mrb_define_module_function(mrb, arduinoModule, "shiftOut", mrb_arduino_shiftOut, ARGS_REQ(4));
mrb_define_module_function(mrb, arduinoModule, "shiftIn", mrb_arduino_shiftOut, ARGS_REQ(3));
mrb_define_module_function(mrb, arduinoModule, "pulseIn", mrb_arduino_pulseIn, ARGS_REQ(2) | ARGS_OPT(1));
mrb_define_module_function(mrb, arduinoModule, "millis", mrb_arduino_millis, ARGS_NONE());
mrb_define_module_function(mrb, arduinoModule, "micros", mrb_arduino_micros, ARGS_NONE());
mrb_define_module_function(mrb, arduinoModule, "delay", mrb_arduino_delay, ARGS_REQ(1));
mrb_define_module_function(mrb, arduinoModule, "delayMicroseconds", mrb_arduino_delayMicroseconds, ARGS_REQ(1));
mrb_define_module_function(mrb, arduinoModule, "map", mrb_arduino_map, ARGS_REQ(5));
mrb_define_module_function(mrb, arduinoModule, "randomSeed", mrb_arduino_randomSeed, ARGS_REQ(1));
mrb_define_module_function(mrb, arduinoModule, "random", mrb_arduino_random, ARGS_REQ(1) | ARGS_OPT(1));
mrb_define_module_function(mrb, arduinoModule, "interrupts", mrb_arduino_interrupts, ARGS_NONE());
mrb_define_module_function(mrb, arduinoModule, "noInterrupts", mrb_arduino_noInterrupts, ARGS_NONE());
mrb_define_const(mrb, arduinoModule, "HIGH", mrb_fixnum_value(HIGH));
mrb_define_const(mrb, arduinoModule, "LOW", mrb_fixnum_value(LOW));
mrb_define_const(mrb, arduinoModule, "INPUT", mrb_fixnum_value(INPUT));
mrb_define_const(mrb, arduinoModule, "OUTPUT", mrb_fixnum_value(OUTPUT));
#ifdef INPUT_PULLUP
mrb_define_const(mrb, arduinoModule, "INPUT_PULLUP", mrb_fixnum_value(INPUT_PULLUP));
#endif
mrb_define_const(mrb, arduinoModule, "DEFAULT", mrb_fixnum_value(DEFAULT));
mrb_define_const(mrb, arduinoModule, "INTERNAL", mrb_fixnum_value(INTERNAL));
mrb_define_const(mrb, arduinoModule, "EXTERNAL", mrb_fixnum_value(EXTERNAL));
//for chipKit, below are not defined.
#ifdef INTERNAL1V1
mrb_define_const(mrb, arduinoModule, "INTERNAL1V1", mrb_fixnum_value(INTERNAL1V1));
#endif
#ifdef INTERNAL2V56
mrb_define_const(mrb, arduinoModule, "INTERNAL2V56", mrb_fixnum_value(INTERNAL2V56));
#endif
mrb_define_const(mrb, arduinoModule, "MSBFIRST", mrb_fixnum_value(MSBFIRST));
mrb_define_const(mrb, arduinoModule, "LSBFIRST", mrb_fixnum_value(LSBFIRST));
}
mrb_value
mrb_str_format(mrb_state *mrb, int argc, const mrb_value *argv, mrb_value fmt)
{
const char *p, *end;
char *buf;
long blen, bsiz;
mrb_value result;
int n;
int width, prec, flags = FNONE;
int nextarg = 1;
int posarg = 0;
mrb_value nextvalue;
mrb_value tmp;
mrb_value str;
mrb_value hash = mrb_undef_value();
#define CHECK_FOR_WIDTH(f) \
if ((f) & FWIDTH) { \
mrb_raise(mrb, E_ARGUMENT_ERROR, "width given twice"); \
} \
if ((f) & FPREC0) { \
mrb_raise(mrb, E_ARGUMENT_ERROR, "width after precision"); \
}
#define CHECK_FOR_FLAGS(f) \
if ((f) & FWIDTH) { \
mrb_raise(mrb, E_ARGUMENT_ERROR, "flag after width"); \
} \
if ((f) & FPREC0) { \
mrb_raise(mrb, E_ARGUMENT_ERROR, "flag after precision"); \
}
++argc;
--argv;
mrb_string_value(mrb, &fmt);
p = RSTRING_PTR(fmt);
end = p + RSTRING_LEN(fmt);
blen = 0;
bsiz = 120;
result = mrb_str_buf_new(mrb, bsiz);
buf = RSTRING_PTR(result);
memset(buf, 0, bsiz);
for (; p < end; p++) {
const char *t;
mrb_sym id = 0;
for (t = p; t < end && *t != '%'; t++) ;
PUSH(p, t - p);
if (t >= end)
goto sprint_exit; /* end of fmt string */
p = t + 1; /* skip `%' */
width = prec = -1;
nextvalue = mrb_undef_value();
retry:
switch (*p) {
default:
mrb_raisef(mrb, E_ARGUMENT_ERROR, "malformed format string - %%%c", *p);
break;
case ' ':
CHECK_FOR_FLAGS(flags);
flags |= FSPACE;
p++;
goto retry;
case '#':
CHECK_FOR_FLAGS(flags);
flags |= FSHARP;
p++;
goto retry;
case '+':
CHECK_FOR_FLAGS(flags);
flags |= FPLUS;
p++;
goto retry;
case '-':
CHECK_FOR_FLAGS(flags);
flags |= FMINUS;
p++;
goto retry;
case '0':
CHECK_FOR_FLAGS(flags);
flags |= FZERO;
p++;
goto retry;
case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
n = 0;
GETNUM(n, width);
if (*p == '$') {
if (!mrb_undef_p(nextvalue)) {
mrb_raisef(mrb, E_ARGUMENT_ERROR, "value given twice - %d$", n);
}
nextvalue = GETPOSARG(n);
p++;
goto retry;
}
CHECK_FOR_WIDTH(flags);
width = n;
flags |= FWIDTH;
goto retry;
case '<':
case '{': {
const char *start = p;
char term = (*p == '<') ? '>' : '}';
mrb_value symname;
for (; p < end && *p != term; )
p++;
if (id) {
mrb_raisef(mrb, E_ARGUMENT_ERROR, "name%.*s after <%s>",
(int)(p - start + 1), start, mrb_sym2name(mrb, id));
}
symname = mrb_str_new(mrb, start + 1, p - start - 1);
id = mrb_intern_str(mrb, symname);
nextvalue = GETNAMEARG(mrb_symbol_value(id), start, (int)(p - start + 1));
if (mrb_undef_p(nextvalue)) {
mrb_raisef(mrb, E_KEY_ERROR, "key%.*s not found", (int)(p - start + 1), start);
}
if (term == '}') goto format_s;
p++;
goto retry;
}
case '*':
CHECK_FOR_WIDTH(flags);
flags |= FWIDTH;
GETASTER(width);
if (width < 0) {
flags |= FMINUS;
width = -width;
}
p++;
goto retry;
case '.':
if (flags & FPREC0) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "precision given twice");
}
flags |= FPREC|FPREC0;
prec = 0;
p++;
if (*p == '*') {
GETASTER(prec);
if (prec < 0) { /* ignore negative precision */
flags &= ~FPREC;
}
p++;
goto retry;
}
GETNUM(prec, precision);
goto retry;
case '\n':
case '\0':
p--;
case '%':
if (flags != FNONE) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid format character - %");
}
PUSH("%", 1);
break;
case 'c': {
mrb_value val = GETARG();
mrb_value tmp;
unsigned int c;
tmp = mrb_check_string_type(mrb, val);
if (!mrb_nil_p(tmp)) {
if (RSTRING_LEN(tmp) != 1 ) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "%c requires a character");
}
c = RSTRING_PTR(tmp)[0];
n = 1;
}
else {
c = mrb_fixnum(val);
n = 1;
}
if (n <= 0) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid character");
}
if (!(flags & FWIDTH)) {
CHECK(n);
buf[blen] = c;
blen += n;
}
else if ((flags & FMINUS)) {
CHECK(n);
buf[blen] = c;
blen += n;
FILL(' ', width-1);
}
else {
FILL(' ', width-1);
CHECK(n);
buf[blen] = c;
blen += n;
}
}
break;
case 's':
case 'p':
format_s:
{
mrb_value arg = GETARG();
long len, slen;
if (*p == 'p') arg = mrb_inspect(mrb, arg);
str = mrb_obj_as_string(mrb, arg);
len = RSTRING_LEN(str);
RSTRING_LEN(result) = blen;
if (flags&(FPREC|FWIDTH)) {
slen = RSTRING_LEN(str);
if (slen < 0) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid mbstring sequence");
}
if ((flags&FPREC) && (prec < slen)) {
char *p = RSTRING_PTR(str) + prec;
slen = prec;
len = p - RSTRING_PTR(str);
}
/* need to adjust multi-byte string pos */
if ((flags&FWIDTH) && (width > slen)) {
width -= (int)slen;
if (!(flags&FMINUS)) {
CHECK(width);
while (width--) {
buf[blen++] = ' ';
}
}
CHECK(len);
memcpy(&buf[blen], RSTRING_PTR(str), len);
blen += len;
if (flags&FMINUS) {
CHECK(width);
while (width--) {
buf[blen++] = ' ';
}
}
break;
}
}
PUSH(RSTRING_PTR(str), len);
}
break;
case 'd':
case 'i':
case 'o':
case 'x':
case 'X':
case 'b':
case 'B':
case 'u': {
mrb_value val = GETARG();
char fbuf[32], nbuf[64], *s;
const char *prefix = 0;
int sign = 0, dots = 0;
char sc = 0;
long v = 0, org_v = 0;
int base;
int len;
switch (*p) {
case 'd':
case 'i':
case 'u':
sign = 1; break;
case 'o':
case 'x':
case 'X':
case 'b':
case 'B':
if (flags&(FPLUS|FSPACE)) sign = 1;
break;
default:
break;
}
if (flags & FSHARP) {
switch (*p) {
case 'o': prefix = "0"; break;
case 'x': prefix = "0x"; break;
case 'X': prefix = "0X"; break;
case 'b': prefix = "0b"; break;
case 'B': prefix = "0B"; break;
default: break;
}
}
bin_retry:
switch (mrb_type(val)) {
case MRB_TT_FLOAT:
if (FIXABLE(mrb_float(val))) {
val = mrb_fixnum_value((mrb_int)mrb_float(val));
goto bin_retry;
}
val = mrb_flt2big(mrb, mrb_float(val));
if (mrb_fixnum_p(val)) goto bin_retry;
break;
case MRB_TT_STRING:
val = mrb_str_to_inum(mrb, val, 0, TRUE);
goto bin_retry;
case MRB_TT_FIXNUM:
v = (long)mrb_fixnum(val);
break;
default:
val = mrb_Integer(mrb, val);
goto bin_retry;
}
switch (*p) {
case 'o':
base = 8; break;
case 'x':
case 'X':
base = 16; break;
case 'b':
case 'B':
base = 2; break;
case 'u':
case 'd':
case 'i':
default:
base = 10; break;
}
if (base == 2) {
org_v = v;
if ( v < 0 && !sign ) {
val = mrb_fix2binstr(mrb, mrb_fixnum_value(v), base);
dots = 1;
}
else {
val = mrb_fix2str(mrb, mrb_fixnum_value(v), base);
}
v = mrb_fixnum(mrb_str_to_inum(mrb, val, 10, 0/*Qfalse*/));
}
if (sign) {
char c = *p;
if (c == 'i') c = 'd'; /* %d and %i are identical */
if (base == 2) c = 'd';
if (v < 0) {
v = -v;
sc = '-';
width--;
}
else if (flags & FPLUS) {
sc = '+';
width--;
}
else if (flags & FSPACE) {
sc = ' ';
width--;
}
snprintf(fbuf, sizeof(fbuf), "%%l%c", c);
snprintf(nbuf, sizeof(nbuf), fbuf, v);
s = nbuf;
}
else {
char c = *p;
if (c == 'X') c = 'x';
if (base == 2) c = 'd';
s = nbuf;
if (v < 0) {
dots = 1;
}
snprintf(fbuf, sizeof(fbuf), "%%l%c", c);
snprintf(++s, sizeof(nbuf) - 1, fbuf, v);
if (v < 0) {
char d;
s = remove_sign_bits(s, base);
switch (base) {
case 16: d = 'f'; break;
case 8: d = '7'; break;
case 2: d = '1'; break;
default: d = 0; break;
}
if (d && *s != d) {
*--s = d;
}
}
}
len = (int)strlen(s);
if (dots) {
prec -= 2;
width -= 2;
}
if (*p == 'X') {
char *pp = s;
int c;
while ((c = (int)(unsigned char)*pp) != 0) {
*pp = toupper(c);
pp++;
}
}
if (prefix && !prefix[1]) { /* octal */
if (dots) {
prefix = 0;
}
else if (len == 1 && *s == '0') {
len = 0;
if (flags & FPREC) prec--;
}
else if ((flags & FPREC) && (prec > len)) {
prefix = 0;
}
}
else if (len == 1 && *s == '0') {
prefix = 0;
}
if (prefix) {
width -= (int)strlen(prefix);
}
if ((flags & (FZERO|FMINUS|FPREC)) == FZERO) {
prec = width;
width = 0;
}
else {
if (prec < len) {
if (!prefix && prec == 0 && len == 1 && *s == '0') len = 0;
prec = len;
}
width -= prec;
}
if (!(flags&FMINUS)) {
CHECK(width);
while (width-- > 0) {
buf[blen++] = ' ';
}
}
if (sc) PUSH(&sc, 1);
if (prefix) {
int plen = (int)strlen(prefix);
PUSH(prefix, plen);
}
CHECK(prec - len);
if (dots) PUSH("..", 2);
if (v < 0 || (base == 2 && org_v < 0)) {
char c = sign_bits(base, p);
while (len < prec--) {
buf[blen++] = c;
}
}
else if ((flags & (FMINUS|FPREC)) != FMINUS) {
char c = '0';
while (len < prec--) {
buf[blen++] = c;
}
}
PUSH(s, len);
CHECK(width);
while (width-- > 0) {
buf[blen++] = ' ';
}
}
break;
case 'f':
case 'g':
case 'G':
case 'e':
case 'E':
case 'a':
case 'A': {
mrb_value val = GETARG();
double fval;
int i, need = 6;
char fbuf[32];
fval = mrb_float(mrb_Float(mrb, val));
if (isnan(fval) || isinf(fval)) {
const char *expr;
const int elen = 3;
if (isnan(fval)) {
expr = "NaN";
}
else {
expr = "Inf";
}
need = elen;
if ((!isnan(fval) && fval < 0.0) || (flags & FPLUS))
need++;
if ((flags & FWIDTH) && need < width)
need = width;
CHECK(need + 1);
n = snprintf(&buf[blen], need + 1, "%*s", need, "");
if (flags & FMINUS) {
if (!isnan(fval) && fval < 0.0)
buf[blen++] = '-';
else if (flags & FPLUS)
buf[blen++] = '+';
else if (flags & FSPACE)
blen++;
memcpy(&buf[blen], expr, elen);
}
else {
if (!isnan(fval) && fval < 0.0)
buf[blen + need - elen - 1] = '-';
else if (flags & FPLUS)
buf[blen + need - elen - 1] = '+';
else if ((flags & FSPACE) && need > width)
blen++;
memcpy(&buf[blen + need - elen], expr, elen);
}
blen += strlen(&buf[blen]);
break;
}
fmt_setup(fbuf, sizeof(fbuf), *p, flags, width, prec);
need = 0;
if (*p != 'e' && *p != 'E') {
i = INT_MIN;
frexp(fval, &i);
if (i > 0)
need = BIT_DIGITS(i);
}
need += (flags&FPREC) ? prec : 6;
if ((flags&FWIDTH) && need < width)
need = width;
need += 20;
CHECK(need);
n = snprintf(&buf[blen], need, fbuf, fval);
blen += n;
}
break;
}
flags = FNONE;
}
sprint_exit:
#if 0
/* XXX - We cannot validate the number of arguments if (digit)$ style used.
*/
if (posarg >= 0 && nextarg < argc) {
const char *mesg = "too many arguments for format string";
if (mrb_test(ruby_debug)) mrb_raise(mrb, E_ARGUMENT_ERROR, mesg);
if (mrb_test(ruby_verbose)) mrb_warn("%s", mesg);
}
#endif
mrb_str_resize(mrb, result, blen);
return result;
}
mrb_value mrb_arduino_digitalRead(mrb_state *mrb, mrb_value self){
mrb_int pin;
int n = mrb_get_args(mrb, "i", &pin);
int val = digitalRead(pin);
return mrb_fixnum_value(val);
}
/*
* call-seq:
* obj.hash -> fixnum
*
* Generates a <code>Fixnum</code> hash value for this object. This
* function must have the property that <code>a.eql?(b)</code> implies
* <code>a.hash == b.hash</code>. The hash value is used by class
* <code>Hash</code>. Any hash value that exceeds the capacity of a
* <code>Fixnum</code> will be truncated before being used.
*/
MRB_API mrb_value
mrb_obj_hash(mrb_state *mrb, mrb_value self)
{
return mrb_fixnum_value(mrb_obj_id(self));
}
mrb_value
mrb_flt2big(mrb_state *mrb, mrb_float d)
{
return mrb_fixnum_value(flt2big(mrb, d));
}
static mrb_value
gc_step_ratio_get(mrb_state *mrb, mrb_value obj)
{
return mrb_fixnum_value(mrb->gc_step_ratio);
}
static mrb_value mrb_setuid(mrb_state *mrb, mrb_value self)
{
mrb_int i;
mrb_get_args(mrb, "i", &i);
return mrb_fixnum_value(setuid(i));
}
