static mrb_int
aget_index(mrb_state *mrb, mrb_value index)
{
if (mrb_fixnum_p(index)) {
return mrb_fixnum(index);
}
else if (mrb_float_p(index)) {
return (mrb_int)mrb_float(index);
}
else {
mrb_int i, argc;
mrb_value *argv;
mrb_get_args(mrb, "i*", &i, &argv, &argc);
return i;
}
}
bool rubyval_to_carray_float(mrb_state* mrb, mrb_value arg, float** outValue, const char* funcName)
{
if (! mrb_array_p(arg)) {
return false;
}
mrb_int len = mrb_ary_len(mrb, arg);
float arr[len];
for (mrb_int i = 0; i < len; i++) {
mrb_value val = mrb_ary_ref(mrb, arg, i);
if (! mrb_float_p(val)) {
return false;
}
arr[i] = mrb_float(val);
}
*outValue = arr;
return true;
}
static mrb_int
aget_index(mrb_state *mrb, mrb_value index)
{
if (mrb_fixnum_p(index)) {
return mrb_fixnum(index);
}
#ifndef MRB_WITHOUT_FLOAT
else if (mrb_float_p(index)) {
return (mrb_int)mrb_float(index);
}
#endif
else {
mrb_int i, argc;
mrb_value *argv;
mrb_get_args(mrb, "i*!", &i, &argv, &argc);
return i;
}
}
/* ------------------------------------------------------------------------*/
MRB_API mrb_value
mrb_flo_to_fixnum(mrb_state *mrb, mrb_value x)
{
mrb_int z;
if (!mrb_float_p(x)) {
mrb_raise(mrb, E_TYPE_ERROR, "non float value");
z = 0; /* not reached. just suppress warnings. */
}
else {
mrb_float d = mrb_float(x);
if (isinf(d)) {
mrb_raise(mrb, E_FLOATDOMAIN_ERROR, d < 0 ? "-Infinity" : "Infinity");
}
if (isnan(d)) {
mrb_raise(mrb, E_FLOATDOMAIN_ERROR, "NaN");
}
z = (mrb_int)d;
}
return mrb_fixnum_value(z);
}
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;
}
mrb_value
mrb_flo_to_str(mrb_state *mrb, mrb_value flo, int max_digit)
{
mrb_value result;
mrb_float n;
if (max_digit > 40) {
mrb_raise(mrb, E_RANGE_ERROR, "Too large max_digit.");
}
else if (!mrb_float_p(flo)) {
mrb_raise(mrb, E_TYPE_ERROR, "non float value");
}
n = mrb_float(flo);
if (isnan(n)) {
result = mrb_str_new(mrb, "NaN", 3);
}
else if (isinf(n)) {
if (n < 0) {
result = mrb_str_new(mrb, "-inf", 4);
}
else {
result = mrb_str_new(mrb, "inf", 3);
}
}
else {
int digit;
int m;
int exp;
int e = 0;
char s[48];
char *c = &s[0];
if (n < 0) {
n = -n;
*(c++) = '-';
}
exp = (int)log10(n);
if ((exp < 0 ? -exp : exp) > max_digit) {
/* exponent representation */
e = 1;
m = exp;
if (m < 0) {
m -= 1;
}
n = n / pow(10.0, m);
m = 0;
}
else {
/* un-exponent (normal) representation */
m = exp;
if (m < 0) {
m = 0;
}
}
/* puts digits */
while (max_digit >= 0) {
mrb_float weight = pow(10.0, m);
digit = (int)floor(n / weight + FLT_EPSILON);
*(c++) = '0' + digit;
n -= (digit * weight);
max_digit--;
if (m-- == 0) {
*(c++) = '.';
}
else if (m < -1 && n < FLT_EPSILON) {
break;
}
}
if (e) {
*(c++) = 'e';
if (exp > 0) {
*(c++) = '+';
}
else {
*(c++) = '-';
exp = -exp;
}
if (exp >= 100) {
mrb_raise(mrb, E_RANGE_ERROR, "Too large exponent.");
}
*(c++) = '0' + exp / 10;
*(c++) = '0' + exp % 10;
}
*c = '\0';
result = mrb_str_new(mrb, &s[0], c - &s[0]);
}
return result;
}
