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_sym
migrate_sym(mrb_state *mrb, mrb_sym sym, mrb_state *mrb2)
{
mrb_int len;
const char *p = mrb_sym2name_len(mrb, sym, &len);
return mrb_intern_static(mrb2, p, len);
}
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 int
read_section_debug(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, mrb_bool alloc)
{
const uint8_t *bin;
ptrdiff_t diff;
struct rite_section_debug_header *header;
uint16_t i;
size_t len = 0;
int result;
uint16_t filenames_len;
mrb_sym *filenames;
bin = start;
header = (struct rite_section_debug_header *)bin;
bin += sizeof(struct rite_section_debug_header);
filenames_len = bin_to_uint16(bin);
bin += sizeof(uint16_t);
filenames = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym) * (size_t)filenames_len);
for (i = 0; i < filenames_len; ++i) {
uint16_t f_len = bin_to_uint16(bin);
bin += sizeof(uint16_t);
if (alloc) {
filenames[i] = mrb_intern(mrb, (const char *)bin, (size_t)f_len);
}
else {
filenames[i] = mrb_intern_static(mrb, (const char *)bin, (size_t)f_len);
}
bin += f_len;
}
result = read_debug_record(mrb, bin, irep, &len, filenames, filenames_len);
if (result != MRB_DUMP_OK) goto debug_exit;
bin += len;
diff = bin - start;
mrb_assert(diff >= 0);
mrb_assert(diff <= UINT32_MAX);
if ((uint32_t)diff != bin_to_uint32(header->section_size)) {
result = MRB_DUMP_GENERAL_FAILURE;
}
debug_exit:
mrb_free(mrb, filenames);
return result;
}
static int
option_to_fd(mrb_state *mrb, mrb_value obj, const char *key)
{
mrb_value opt = mrb_funcall(mrb, obj, "[]", 1, mrb_symbol_value(mrb_intern_static(mrb, key, strlen(key))));
if (mrb_nil_p(opt)) {
return -1;
}
switch (mrb_type(opt)) {
case MRB_TT_DATA: /* IO */
return (int)mrb_fixnum(mrb_io_fileno(mrb, opt));
case MRB_TT_FIXNUM:
return (int)mrb_fixnum(opt);
default:
mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong exec redirect action");
break;
}
return -1; /* never reached */
}
static mrb_irep*
read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flags)
{
int i;
const uint8_t *src = bin;
ptrdiff_t diff;
uint16_t tt, pool_data_len, snl;
int plen;
int ai = mrb_gc_arena_save(mrb);
mrb_irep *irep = mrb_add_irep(mrb);
/* skip record size */
src += sizeof(uint32_t);
/* number of local variable */
irep->nlocals = bin_to_uint16(src);
src += sizeof(uint16_t);
/* number of register variable */
irep->nregs = bin_to_uint16(src);
src += sizeof(uint16_t);
/* number of child irep */
irep->rlen = (size_t)bin_to_uint16(src);
src += sizeof(uint16_t);
/* Binary Data Section */
/* ISEQ BLOCK */
irep->ilen = (uint16_t)bin_to_uint32(src);
src += sizeof(uint32_t);
src += skip_padding(src);
if (irep->ilen > 0) {
if (SIZE_ERROR_MUL(irep->ilen, sizeof(mrb_code))) {
return NULL;
}
if ((flags & FLAG_SRC_MALLOC) == 0 &&
(flags & FLAG_BYTEORDER_NATIVE)) {
irep->iseq = (mrb_code*)src;
src += sizeof(mrb_code) * irep->ilen;
irep->flags |= MRB_ISEQ_NO_FREE;
}
else {
size_t data_len = sizeof(mrb_code) * irep->ilen;
irep->iseq = (mrb_code *)mrb_malloc(mrb, data_len);
memcpy(irep->iseq, src, data_len);
src += data_len;
}
}
/* POOL BLOCK */
plen = bin_to_uint32(src); /* number of pool */
src += sizeof(uint32_t);
if (plen > 0) {
if (SIZE_ERROR_MUL(plen, sizeof(mrb_value))) {
return NULL;
}
irep->pool = (mrb_value*)mrb_malloc(mrb, sizeof(mrb_value) * plen);
for (i = 0; i < plen; i++) {
mrb_value s;
tt = *src++; /* pool TT */
pool_data_len = bin_to_uint16(src); /* pool data length */
src += sizeof(uint16_t);
if (flags & FLAG_SRC_MALLOC) {
s = mrb_str_new(mrb, (char *)src, pool_data_len);
}
else {
s = mrb_str_new_static(mrb, (char *)src, pool_data_len);
}
src += pool_data_len;
switch (tt) { /* pool data */
case IREP_TT_FIXNUM: {
mrb_value num = mrb_str_to_inum(mrb, s, 10, FALSE);
#ifdef MRB_WITHOUT_FLOAT
irep->pool[i] = num;
#else
irep->pool[i] = mrb_float_p(num)? mrb_float_pool(mrb, mrb_float(num)) : num;
#endif
}
break;
#ifndef MRB_WITHOUT_FLOAT
case IREP_TT_FLOAT:
irep->pool[i] = mrb_float_pool(mrb, mrb_str_to_dbl(mrb, s, FALSE));
break;
#endif
case IREP_TT_STRING:
irep->pool[i] = mrb_str_pool(mrb, s);
break;
default:
/* should not happen */
irep->pool[i] = mrb_nil_value();
break;
}
irep->plen++;
mrb_gc_arena_restore(mrb, ai);
}
}
/* SYMS BLOCK */
irep->slen = (uint16_t)bin_to_uint32(src); /* syms length */
src += sizeof(uint32_t);
if (irep->slen > 0) {
if (SIZE_ERROR_MUL(irep->slen, sizeof(mrb_sym))) {
return NULL;
}
irep->syms = (mrb_sym *)mrb_malloc(mrb, sizeof(mrb_sym) * irep->slen);
for (i = 0; i < irep->slen; i++) {
snl = bin_to_uint16(src); /* symbol name length */
src += sizeof(uint16_t);
if (snl == MRB_DUMP_NULL_SYM_LEN) {
irep->syms[i] = 0;
continue;
}
if (flags & FLAG_SRC_MALLOC) {
irep->syms[i] = mrb_intern(mrb, (char *)src, snl);
}
else {
irep->syms[i] = mrb_intern_static(mrb, (char *)src, snl);
}
src += snl + 1;
mrb_gc_arena_restore(mrb, ai);
}
}
irep->reps = (mrb_irep**)mrb_malloc(mrb, sizeof(mrb_irep*)*irep->rlen);
diff = src - bin;
mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX);
*len = (size_t)diff;
return irep;
}
static mrb_irep*
read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, mrb_bool alloc)
{
size_t i;
const uint8_t *src = bin;
ptrdiff_t diff;
uint16_t tt, pool_data_len, snl;
size_t plen;
int ai = mrb_gc_arena_save(mrb);
mrb_irep *irep = mrb_add_irep(mrb);
/* skip record size */
src += sizeof(uint32_t);
/* number of local variable */
irep->nlocals = bin_to_uint16(src);
src += sizeof(uint16_t);
/* number of register variable */
irep->nregs = bin_to_uint16(src);
src += sizeof(uint16_t);
/* number of child irep */
irep->rlen = (size_t)bin_to_uint16(src);
src += sizeof(uint16_t);
/* Binary Data Section */
/* ISEQ BLOCK */
irep->ilen = (size_t)bin_to_uint32(src);
src += sizeof(uint32_t);
if (irep->ilen > 0) {
if (SIZE_ERROR_MUL(sizeof(mrb_code), irep->ilen)) {
return NULL;
}
irep->iseq = (mrb_code *)mrb_malloc(mrb, sizeof(mrb_code) * irep->ilen);
for (i = 0; i < irep->ilen; i++) {
irep->iseq[i] = (size_t)bin_to_uint32(src); /* iseq */
src += sizeof(uint32_t);
}
}
/* POOL BLOCK */
plen = (size_t)bin_to_uint32(src); /* number of pool */
src += sizeof(uint32_t);
if (plen > 0) {
if (SIZE_ERROR_MUL(sizeof(mrb_value), plen)) {
return NULL;
}
irep->pool = (mrb_value*)mrb_malloc(mrb, sizeof(mrb_value) * plen);
for (i = 0; i < plen; i++) {
mrb_value s;
tt = *src++; /* pool TT */
pool_data_len = bin_to_uint16(src); /* pool data length */
src += sizeof(uint16_t);
if (alloc) {
s = mrb_str_new(mrb, (char *)src, pool_data_len);
}
else {
s = mrb_str_new_static(mrb, (char *)src, pool_data_len);
}
src += pool_data_len;
switch (tt) { /* pool data */
case IREP_TT_FIXNUM:
irep->pool[i] = mrb_str_to_inum(mrb, s, 10, FALSE);
break;
case IREP_TT_FLOAT:
irep->pool[i] = mrb_float_pool(mrb, mrb_str_to_dbl(mrb, s, FALSE));
break;
case IREP_TT_STRING:
irep->pool[i] = mrb_str_pool(mrb, s);
break;
default:
/* should not happen */
irep->pool[i] = mrb_nil_value();
break;
}
irep->plen++;
mrb_gc_arena_restore(mrb, ai);
}
}
/* SYMS BLOCK */
irep->slen = (size_t)bin_to_uint32(src); /* syms length */
src += sizeof(uint32_t);
if (irep->slen > 0) {
if (SIZE_ERROR_MUL(sizeof(mrb_sym), irep->slen)) {
return NULL;
}
irep->syms = (mrb_sym *)mrb_malloc(mrb, sizeof(mrb_sym) * irep->slen);
for (i = 0; i < irep->slen; i++) {
snl = bin_to_uint16(src); /* symbol name length */
src += sizeof(uint16_t);
if (snl == MRB_DUMP_NULL_SYM_LEN) {
irep->syms[i] = 0;
continue;
}
if (alloc) {
irep->syms[i] = mrb_intern(mrb, (char *)src, snl);
}
else {
irep->syms[i] = mrb_intern_static(mrb, (char *)src, snl);
}
src += snl + 1;
mrb_gc_arena_restore(mrb, ai);
}
}
irep->reps = (mrb_irep**)mrb_malloc(mrb, sizeof(mrb_irep*)*irep->rlen);
diff = src - bin;
mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX);
*len = (size_t)diff;
return irep;
}
