/*
* call-seq:
* fix.divmod(numeric) -> array
*
* See <code>Numeric#divmod</code>.
*/
static mrb_value
fix_divmod(mrb_state *mrb, mrb_value x)
{
mrb_value y;
mrb_get_args(mrb, "o", &y);
if (mrb_fixnum_p(y)) {
mrb_int div, mod;
if (mrb_fixnum(y) == 0) {
return mrb_assoc_new(mrb, mrb_float_value(mrb, INFINITY),
mrb_float_value(mrb, NAN));
}
fixdivmod(mrb, mrb_fixnum(x), mrb_fixnum(y), &div, &mod);
return mrb_assoc_new(mrb, mrb_fixnum_value(div), mrb_fixnum_value(mod));
}
else {
mrb_float div, mod;
mrb_value a, b;
flodivmod(mrb, (mrb_float)mrb_fixnum(x), mrb_to_flo(mrb, y), &div, &mod);
a = mrb_float_value(mrb, (mrb_int)div);
b = mrb_float_value(mrb, mod);
return mrb_assoc_new(mrb, a, b);
}
}
static mrb_value
mrb_hash_shift(mrb_state *mrb, mrb_value hash)
{
khash_t(ht) *h = RHASH_TBL(hash);
khiter_t k;
mrb_value delKey, delVal;
mrb_hash_modify(mrb, hash);
if (h) {
if (kh_size(h) > 0) {
for (k = kh_begin(h); k != kh_end(h); k++) {
if (!kh_exist(h,k)) continue;
delKey = kh_key(h,k);
mrb_gc_protect(mrb, delKey);
delVal = mrb_hash_delete_key(mrb, hash, delKey);
mrb_gc_protect(mrb, delVal);
return mrb_assoc_new(mrb, delKey, delVal);
}
}
}
if (MRB_RHASH_PROCDEFAULT_P(hash)) {
return mrb_funcall(mrb, RHASH_PROCDEFAULT(hash), "call", 2, hash, mrb_nil_value());
}
else {
return RHASH_IFNONE(hash);
}
}
static mrb_value
mrb_io_s_pipe(mrb_state *mrb, mrb_value klass)
{
mrb_value r = mrb_nil_value();
mrb_value w = mrb_nil_value();
struct mrb_io *fptr_r;
struct mrb_io *fptr_w;
int pipes[2];
if (mrb_pipe(mrb, pipes) == -1) {
mrb_sys_fail(mrb, "pipe");
}
r = mrb_obj_value(mrb_data_object_alloc(mrb, mrb_class_ptr(klass), NULL, &mrb_io_type));
mrb_iv_set(mrb, r, mrb_intern_cstr(mrb, "@buf"), mrb_str_new_cstr(mrb, ""));
fptr_r = mrb_io_alloc(mrb);
fptr_r->fd = pipes[0];
fptr_r->readable = 1;
fptr_r->writable = 0;
fptr_r->sync = 0;
DATA_TYPE(r) = &mrb_io_type;
DATA_PTR(r) = fptr_r;
w = mrb_obj_value(mrb_data_object_alloc(mrb, mrb_class_ptr(klass), NULL, &mrb_io_type));
mrb_iv_set(mrb, w, mrb_intern_cstr(mrb, "@buf"), mrb_str_new_cstr(mrb, ""));
fptr_w = mrb_io_alloc(mrb);
fptr_w->fd = pipes[1];
fptr_w->readable = 0;
fptr_w->writable = 1;
fptr_w->sync = 1;
DATA_TYPE(w) = &mrb_io_type;
DATA_PTR(w) = fptr_w;
return mrb_assoc_new(mrb, r, w);
}
mrb_value
mrb_mraa_i2c_read(mrb_state *mrb, mrb_value self){
mraa_i2c_context i2c;
mrb_int length;
uint8_t *rbuf;
mrb_int num_of_read;
int ai, i;
mrb_value mrv_rbuf;
Data_Get_Struct(mrb, self, &mrb_mraa_i2c_ctx_type, i2c);
mrb_get_args(mrb, "i", &length);
rbuf = (uint8_t*)mrb_malloc(mrb, sizeof(uint8_t) * length);
memset(rbuf, 0, sizeof(uint8_t) * length);
num_of_read = mraa_i2c_read(i2c, rbuf, length);
mrv_rbuf = mrb_ary_new_capa(mrb, num_of_read);
ai = mrb_gc_arena_save(mrb);
for (i = 0; i < num_of_read; i++){
mrb_ary_push(mrb, mrv_rbuf, mrb_fixnum_value(rbuf[i]));
mrb_gc_arena_restore(mrb, ai);
}
mrb_free(mrb, rbuf);
return mrb_assoc_new(mrb, mrv_rbuf, mrb_fixnum_value(num_of_read));
}
static mrb_value
mrb_proc_parameters(mrb_state *mrb, mrb_value self)
{
struct parameters_type {
int size;
const char *name;
} *p, parameters_list [] = {
{0, "req"},
{0, "opt"},
{0, "rest"},
{0, "req"},
{0, "block"},
{0, NULL}
};
const struct RProc *proc = mrb_proc_ptr(self);
const struct mrb_irep *irep = proc->body.irep;
mrb_aspec aspec;
mrb_value parameters;
int i, j;
if (MRB_PROC_CFUNC_P(proc)) {
// TODO cfunc aspec is not implemented yet
return mrb_ary_new(mrb);
}
if (!irep) {
return mrb_ary_new(mrb);
}
if (!irep->lv) {
return mrb_ary_new(mrb);
}
if (GET_OPCODE(*irep->iseq) != OP_ENTER) {
return mrb_ary_new(mrb);
}
if (!MRB_PROC_STRICT_P(proc)) {
parameters_list[0].name = "opt";
parameters_list[3].name = "opt";
}
aspec = GETARG_Ax(*irep->iseq);
parameters_list[0].size = MRB_ASPEC_REQ(aspec);
parameters_list[1].size = MRB_ASPEC_OPT(aspec);
parameters_list[2].size = MRB_ASPEC_REST(aspec);
parameters_list[3].size = MRB_ASPEC_POST(aspec);
parameters_list[4].size = MRB_ASPEC_BLOCK(aspec);
parameters = mrb_ary_new_capa(mrb, irep->nlocals-1);
for (i = 0, p = parameters_list; p->name; p++) {
mrb_value sname = mrb_symbol_value(mrb_intern_cstr(mrb, p->name));
for (j = 0; j < p->size; i++, j++) {
mrb_assert(i < (irep->nlocals-1));
mrb_ary_push(mrb, parameters, mrb_assoc_new(mrb,
sname,
mrb_symbol_value(irep->lv[i].name)
));
}
}
return parameters;
}
/*
* call-seq:
* Math.frexp(numeric) -> [ fraction, exponent ]
*
* Returns a two-element array containing the normalized fraction (a
* <code>Float</code>) and exponent (a <code>Fixnum</code>) of
* <i>numeric</i>.
*
* fraction, exponent = Math.frexp(1234) #=> [0.6025390625, 11]
* fraction * 2**exponent #=> 1234.0
*/
static mrb_value
math_frexp(mrb_state *mrb, mrb_value obj)
{
mrb_float x;
int exp;
mrb_get_args(mrb, "f", &x);
x = frexp(x, &exp);
return mrb_assoc_new(mrb, mrb_float_value(mrb, x), mrb_fixnum_value(exp));
}
static mrb_value
enum_partition(mrb_state *mrb, mrb_value obj)
{
mrb_value ary[2];
//RETURN_ENUMERATOR(obj, 0, 0);
ary[0] = mrb_ary_new(mrb);
ary[1] = mrb_ary_new(mrb);
mrb_block_call(mrb, obj, id_each, 0, 0, partition_i, ary);
return mrb_assoc_new(mrb, ary[0], ary[1]);
}
static mrb_value
flo_divmod(mrb_state *mrb, mrb_value x)
{
mrb_value y;
mrb_float div, mod;
mrb_value a, b;
mrb_get_args(mrb, "o", &y);
flodivmod(mrb, mrb_float(x), mrb_to_flo(mrb, y), &div, &mod);
a = mrb_float_value(mrb, (mrb_int)div);
b = mrb_float_value(mrb, mod);
return mrb_assoc_new(mrb, a, b);
}
mrb_value
mrb_hash_rassoc(mrb_state *mrb, mrb_value hash)
{
mrb_value key, value, has_key;
mrb_get_args(mrb, "o", &key);
has_key = mrb_hash_has_keyWithKey(mrb, hash, key);
if (mrb_test(has_key)) {
value = mrb_hash_get(mrb, hash, key);
return mrb_assoc_new(mrb, value, key);
}
else {
return mrb_nil_value();
}
}
mrb_value
mrb_hash_assoc(mrb_state *mrb, mrb_value hash)
{
mrb_value key, value, has_key;
mrb_get_args(mrb, "o", &key);
if (mrb_nil_p(key))
mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments");
has_key = mrb_hash_has_keyWithKey(mrb, hash, key);
if (mrb_test(has_key)) {
value = mrb_hash_get(mrb, hash, key);
return mrb_assoc_new(mrb, key, value);
}
else {
return mrb_nil_value();
}
}
static mrb_value
mrb_proc_source_location(mrb_state *mrb, mrb_value self)
{
struct RProc *p = mrb_proc_ptr(self);
if (MRB_PROC_CFUNC_P(p)) {
return mrb_nil_value();
}
else {
mrb_irep *irep = p->body.irep;
int32_t line;
const char *filename;
filename = mrb_debug_get_filename(irep, 0);
line = mrb_debug_get_line(irep, 0);
return (!filename && line == -1)? mrb_nil_value()
: mrb_assoc_new(mrb, mrb_str_new_cstr(mrb, filename), mrb_fixnum_value(line));
}
}
