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; }