/*
* call-seq:
* enum.inject(initial, sym) -> obj
* enum.inject(sym) -> obj
* enum.inject(initial) {| memo, obj | block } -> obj
* enum.inject {| memo, obj | block } -> obj
*
* enum.reduce(initial, sym) -> obj
* enum.reduce(sym) -> obj
* enum.reduce(initial) {| memo, obj | block } -> obj
* enum.reduce {| memo, obj | block } -> obj
*
* Combines all elements of <i>enum</i> by applying a binary
* operation, specified by a block or a symbol that names a
* method or operator.
*
* If you specify a block, then for each element in <i>enum</i>
* the block is passed an accumulator value (<i>memo</i>) and the element.
* If you specify a symbol instead, then each element in the collection
* will be passed to the named method of <i>memo</i>.
* In either case, the result becomes the new value for <i>memo</i>.
* At the end of the iteration, the final value of <i>memo</i> is the
* return value fo the method.
*
* If you do not explicitly specify an <i>initial</i> value for <i>memo</i>,
* then uses the first element of collection is used as the initial value
* of <i>memo</i>.
*
* Examples:
*
* # Sum some numbers
* (5..10).reduce(:+) #=> 45
* # Same using a block and inject
* (5..10).inject {|sum, n| sum + n } #=> 45
* # Multiply some numbers
* (5..10).reduce(1, :*) #=> 151200
* # Same using a block
* (5..10).inject(1) {|product, n| product * n } #=> 151200
* # find the longest word
* longest = %w{ cat sheep bear }.inject do |memo,word|
* memo.length > word.length ? memo : word
* end
* longest #=> "sheep"
*
*/
static mrb_value
enum_inject(mrb_state *mrb, int argc, mrb_value *argv, mrb_value obj)
{
mrb_value memo[2];
mrb_value (*iter)(mrb_state *mrb, mrb_value, mrb_value, int, mrb_value*) = inject_i;
//switch (mrb_scan_args(argc, argv, "02", &memo[0], &memo[1])) {
switch (argc) {
case 0:
memo[0].tt = MRB_TT_FREE;
break;
case 1:
if (mrb_block_given_p()) {
break;
}
memo[1] = mrb_symbol_value(mrb_to_id(mrb, argv[0]));
memo[0].tt = MRB_TT_FREE;
iter = inject_op_i;
break;
case 2:
if (mrb_block_given_p()) {
mrb_warning("given block not used");
}
memo[0] = argv[0];
memo[1] = mrb_symbol_value(mrb_to_id(mrb, argv[1]));
iter = inject_op_i;
break;
}
mrb_block_call(mrb, obj, id_each, 0, 0, iter, memo);
if (memo[0].tt == MRB_TT_FREE) return mrb_nil_value();
return memo[0];
}
static mrb_value
mrb_magnetic_s__read(mrb_state *mrb, mrb_value self)
{
mrb_int ret;
mrb_value hash;
BYTE abTk1[256], abTk2[256], abTk3[256];
UINT uiLen1 = 0,uiLen2 = 0,uiLen3 = 0 ;
uiLen1 = sizeof(abTk1);
uiLen2 = sizeof(abTk2);
uiLen3 = sizeof(abTk3);
ret = GEDI_MSR_Read(abTk1, &uiLen1, abTk2, &uiLen2, abTk3, &uiLen3);
hash = mrb_hash_new(mrb);
mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_cstr(mrb, "ret")), mrb_fixnum_value(ret));
if (ret == GEDI_MSR_STATUS_SUCCESS) {
mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_cstr(mrb, "track1")), mrb_str_new(mrb, abTk1, uiLen1));
mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_cstr(mrb, "track2")), mrb_str_new(mrb, abTk2, uiLen2));
mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_cstr(mrb, "track3")), mrb_str_new(mrb, abTk3, uiLen3));
}
return hash;
}
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;
}
static mrb_value
os_count_objects(mrb_state *mrb, mrb_value self)
{
struct os_count_struct obj_count = { 0 };
mrb_int i;
mrb_value hash;
if (mrb_get_args(mrb, "|H", &hash) == 0) {
hash = mrb_hash_new(mrb);
}
if (!mrb_test(mrb_hash_empty_p(mrb, hash))) {
mrb_hash_clear(mrb, hash);
}
mrb_objspace_each_objects(mrb, os_count_object_type, &obj_count);
mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_lit(mrb, "TOTAL")), mrb_fixnum_value(obj_count.total));
mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_lit(mrb, "FREE")), mrb_fixnum_value(obj_count.freed));
for (i = MRB_TT_FALSE; i < MRB_TT_MAXDEFINE; i++) {
mrb_value type;
switch (i) {
#define COUNT_TYPE(t) case (MRB_T ## t): type = mrb_symbol_value(mrb_intern_lit(mrb, #t)); break;
COUNT_TYPE(T_FALSE);
COUNT_TYPE(T_FREE);
COUNT_TYPE(T_TRUE);
COUNT_TYPE(T_FIXNUM);
COUNT_TYPE(T_SYMBOL);
COUNT_TYPE(T_UNDEF);
COUNT_TYPE(T_FLOAT);
COUNT_TYPE(T_CPTR);
COUNT_TYPE(T_OBJECT);
COUNT_TYPE(T_CLASS);
COUNT_TYPE(T_MODULE);
COUNT_TYPE(T_ICLASS);
COUNT_TYPE(T_SCLASS);
COUNT_TYPE(T_PROC);
COUNT_TYPE(T_ARRAY);
COUNT_TYPE(T_HASH);
COUNT_TYPE(T_STRING);
COUNT_TYPE(T_RANGE);
COUNT_TYPE(T_EXCEPTION);
COUNT_TYPE(T_FILE);
COUNT_TYPE(T_ENV);
COUNT_TYPE(T_DATA);
COUNT_TYPE(T_FIBER);
#undef COUNT_TYPE
default:
type = mrb_fixnum_value(i);
break;
}
if (obj_count.counts[i])
mrb_hash_set(mrb, hash, type, mrb_fixnum_value(obj_count.counts[i]));
}
return hash;
}
// FLTK.measure(text)
// Get the width and height of a string, according to the last call to FLTK.font.
mrb_value mrb_fltk_measure_module_method( mrb_state *mrb, mrb_value self ) {
int width = 0;
int height = 0;
char *text;
mrb_get_args( mrb, "z", &text );
fl_measure( text, width, height );
mrb_value result = mrb_hash_new( mrb );
mrb_hash_set( mrb, result, mrb_symbol_value( mrb_intern_cstr( mrb, "width" ) ), mrb_fixnum_value( width ) );
mrb_hash_set( mrb, result, mrb_symbol_value( mrb_intern_cstr( mrb, "height" ) ), mrb_fixnum_value( height ) );
return result;
}
void
mrb_ev3_lcd_init(mrb_state *mrb, struct RClass *ev3)
{
struct RClass *lcd;
mrb_value lcdo;
mrb_value font;
mrb_value col;
/* LCD class */
lcd = mrb_define_class_under(mrb, ev3, "LCD", mrb->object_class);
lcdo = mrb_obj_value(lcd);
font = mrb_hash_new(mrb);
mrb_hash_set(mrb, font, mrb_symbol_value(mrb_intern_lit(mrb, "small")), mrb_fixnum_value(EV3_FONT_SMALL));
mrb_hash_set(mrb, font, mrb_symbol_value(mrb_intern_lit(mrb, "medium")), mrb_fixnum_value(EV3_FONT_MEDIUM));
mrb_const_set(mrb, lcdo, mrb_intern_lit(mrb, "FONT"), font);
col = mrb_hash_new(mrb);
mrb_hash_set(mrb, col, mrb_symbol_value(mrb_intern_lit(mrb, "white")), mrb_fixnum_value(EV3_LCD_WHITE));
mrb_hash_set(mrb, col, mrb_symbol_value(mrb_intern_lit(mrb, "black")), mrb_fixnum_value(EV3_LCD_BLACK));
mrb_const_set(mrb, lcdo, mrb_intern_lit(mrb, "COLOR"), col);
mrb_const_set(mrb, lcdo, mrb_intern_lit(mrb, "WIDTH"), mrb_fixnum_value(EV3_LCD_WIDTH));
mrb_const_set(mrb, lcdo, mrb_intern_lit(mrb, "HEIGHT"), mrb_fixnum_value(EV3_LCD_HEIGHT));
mrb_mod_cv_set(mrb, lcd, mrb_intern_lit(mrb, "@@font"), mrb_fixnum_value(EV3_FONT_SMALL));
mrb_define_class_method(mrb, lcd, "font=", mrb_lcd_set_font, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, lcd, "draw", mrb_lcd_draw_string, MRB_ARGS_REQ(3));
mrb_define_method(mrb, lcd, "initialize", mrb_lcd_init, MRB_ARGS_OPT(6));
mrb_define_method(mrb, lcd, "print", mrb_lcd_print, MRB_ARGS_ANY());
mrb_define_method(mrb, lcd, "puts", mrb_lcd_puts, MRB_ARGS_ANY());
mrb_define_method(mrb, lcd, "locate", mrb_lcd_locate, MRB_ARGS_ARG(1, 1));
mrb_define_method(mrb, lcd, "clear", mrb_lcd_clear, MRB_ARGS_OPT(1));
mrb_define_method(mrb, lcd, "font", mrb_lcd_get_font, MRB_ARGS_NONE());
mrb_define_method(mrb, lcd, "left", mrb_lcd_get_left, MRB_ARGS_NONE());
mrb_define_method(mrb, lcd, "top", mrb_lcd_get_top, MRB_ARGS_NONE());
mrb_define_method(mrb, lcd, "width", mrb_lcd_get_width, MRB_ARGS_NONE());
mrb_define_method(mrb, lcd, "height", mrb_lcd_get_height, MRB_ARGS_NONE());
mrb_define_method(mrb, lcd, "cx", mrb_lcd_get_csrx, MRB_ARGS_NONE());
mrb_define_method(mrb, lcd, "cy", mrb_lcd_get_csry, MRB_ARGS_NONE());
mrb_define_method(mrb, lcd, "color", mrb_lcd_get_color, MRB_ARGS_NONE());
// mrb_undef_method(mrb, mrb->kernel_module, "__printstr__");
// mrb_define_method(mrb, mrb->kernel_module, "__printstr__", mrb_lcd_print, MRB_ARGS_ANY());
}
static mrb_value
mrb_wslay_event_queue_close(mrb_state *mrb, mrb_value self)
{
mrb_wslay_user_data *data = (mrb_wslay_user_data *) DATA_PTR(self);
mrb_assert(data);
mrb_sym status_code;
char *reason = NULL;
mrb_int reason_length = 0;
mrb_get_args(mrb, "n|s!", &status_code, &reason, &reason_length);
mrb_int stc = mrb_fixnum(MRB_GET_STATUSCODE(mrb_symbol_value(status_code)));
int err = wslay_event_queue_close(data->ctx, stc, (const uint8_t *) reason, reason_length);
if (err == WSLAY_ERR_NOMEM) {
mrb_sys_fail(mrb, "wslay_event_queue_close");
}
else if (err == WSLAY_ERR_NO_MORE_MSG) {
mrb_raise(mrb, E_WSLAY_ERROR, "further message queueing is not allowed");
}
else if (err == WSLAY_ERR_INVALID_ARGUMENT) {
mrb_raise(mrb, E_WSLAY_ERROR, "the given message is invalid");
}
else if (err != 0) {
return MRB_WSLAY_ERROR(mrb_fixnum_value(err));
}
return self;
}
static mrb_value
const_get(mrb_state *mrb, struct RClass *base, mrb_sym sym)
{
struct RClass *c = base;
mrb_value v;
iv_tbl *t;
mrb_bool retry = FALSE;
mrb_value name;
L_RETRY:
while (c) {
if (c->iv) {
t = c->iv;
if (iv_get(mrb, t, sym, &v))
return v;
}
c = c->super;
}
if (!retry && base && base->tt == MRB_TT_MODULE) {
c = mrb->object_class;
retry = TRUE;
goto L_RETRY;
}
name = mrb_symbol_value(sym);
return mrb_funcall_argv(mrb, mrb_obj_value(base), mrb_intern_lit(mrb, "const_missing"), 1, &name);
}
static inline void
assign_class_name(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
{
if (namespace_p(obj->tt) && namespace_p(mrb_type(v))) {
struct RObject *c = mrb_obj_ptr(v);
if (obj != c && ISUPPER(mrb_sym2name(mrb, sym)[0])) {
mrb_sym id_classname = mrb_intern_lit(mrb, "__classname__");
mrb_value o = mrb_obj_iv_get(mrb, c, id_classname);
if (mrb_nil_p(o)) {
mrb_sym id_outer = mrb_intern_lit(mrb, "__outer__");
o = mrb_obj_iv_get(mrb, c, id_outer);
if (mrb_nil_p(o)) {
if ((struct RClass *)obj == mrb->object_class) {
mrb_obj_iv_set(mrb, c, id_classname, mrb_symbol_value(sym));
}
else {
mrb_obj_iv_set(mrb, c, id_outer, mrb_obj_value(obj));
}
}
}
}
}
}
/*
* call-seq:
* SerialPort.new(port) # => SerialPort
*
* Open serial port.
*
* Parameters:
* +port+ font size.
* :default Default serial port
* :uart UART
* :bt Bluetooth
*
* Returns SerialPort object.
*/
static mrb_value
mrb_serial_init(mrb_state *mrb, mrb_value self)
{
struct RClass *ser = mrb_obj_class(mrb, self);
mrb_value pmap = mrb_const_get(mrb, mrb_obj_value(ser), mrb_intern_lit(mrb, "PORT"));
mrb_sym port;
mrb_value portv;
FILE *fp;
mrb_get_args(mrb, "n", &port);
portv = mrb_hash_get(mrb, pmap, mrb_symbol_value(port));
if (mrb_nil_p(portv)) {
mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid port :%S", mrb_sym2str(mrb, port));
}
fp = ev3_serial_open_file((serial_port_t)mrb_fixnum(portv));
if (fp == NULL) {
mrb_raisef(mrb, E_IO_ERROR, "Serial port cannot open :%S", mrb_sym2str(mrb, port));
}
mrb_file_attach(self, fp);
return self;
}
/*
* call-seq:
* lcd.clear(col) # => nil
*
* Clear window.
*
* Parameters:
* +col+ LCD foreground color.
* :black black (default)
* :white while
*
* Returns nil.
*/
static mrb_value
mrb_lcd_clear(mrb_state *mrb, mrb_value self)
{
mrb_lcd_t *plcd = (mrb_lcd_t*)DATA_PTR(self);
struct RClass *lcd = mrb_obj_class(mrb, self);
mrb_value cmap = mrb_const_get(mrb, mrb_obj_value(lcd), mrb_intern_lit(mrb, "COLOR"));
mrb_sym col = mrb_intern_lit(mrb, "black");
mrb_value colv;
mrb_get_args(mrb, "|n", &col);
colv = mrb_hash_get(mrb, cmap, mrb_symbol_value(col));
if (mrb_nil_p(colv)) {
mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid foreground color :%S", mrb_sym2str(mrb, col));
}
ev3_lcd_fill_rect(
plcd->left,
plcd->top,
plcd->width,
plcd->height,
mrb_fixnum(colv) ? 0 : 1
);
plcd->cx = plcd->cy = 0;
return mrb_nil_value();
}
static int
gv_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p)
{
mrb_value ary;
ary = *(mrb_value*)p;
mrb_ary_push(mrb, ary, mrb_symbol_value(sym));
return 0;
}
/*
* call-seq:
* __method__ -> symbol
*
* Returns the name at the definition of the current method as a
* Symbol.
* If called outside of a method, it returns <code>nil</code>.
*
*/
static mrb_value
mrb_f_method(mrb_state *mrb, mrb_value self)
{
mrb_callinfo *ci = mrb->c->ci;
ci--;
if (ci->mid)
return mrb_symbol_value(ci->mid);
else
return mrb_nil_value();
}
MRB_API mrb_value
mrb_check_intern(mrb_state *mrb, const char *name, size_t len)
{
mrb_sym sym;
sym_validate_len(mrb, len);
sym = find_symbol(mrb, name, len, symhash(name, len));
if (sym > 0) return mrb_symbol_value(sym);
return mrb_nil_value();
}
void
mrb_mruby_rtos_toppers_gem_init(mrb_state *mrb)
{
struct RClass *rtos;
struct RClass *tsk;
mrb_value wmd;
mrb_value tmo;
/* RTOS module */
rtos = mrb_define_module(mrb, "RTOS");
/* RTOS api */
mrb_define_module_function(mrb, rtos, "delay", mrb_rtos_delay, MRB_ARGS_REQ(1));
mrb_define_module_function(mrb, rtos, "millis", mrb_rtos_millis, MRB_ARGS_NONE());
wmd = mrb_hash_new(mrb);
mrb_hash_set(mrb, wmd, mrb_symbol_value(mrb_intern_lit(mrb, "and")), mrb_fixnum_value(TWF_ANDW));
mrb_hash_set(mrb, wmd, mrb_symbol_value(mrb_intern_lit(mrb, "or")), mrb_fixnum_value(TWF_ORW));
mrb_mod_cv_set(mrb, rtos, mrb_intern_lit(mrb, "WAITMODE"), wmd);
tmo = mrb_hash_new(mrb);
mrb_hash_set(mrb, tmo, mrb_symbol_value(mrb_intern_lit(mrb, "polling")), mrb_fixnum_value(TMO_POL));
mrb_hash_set(mrb, tmo, mrb_symbol_value(mrb_intern_lit(mrb, "forever")), mrb_fixnum_value(TMO_FEVR));
mrb_mod_cv_set(mrb, rtos, mrb_intern_lit(mrb, "TIMEOUT"), tmo);
/* Task class */
tsk = mrb_define_class_under(mrb, rtos, "Task", mrb->object_class);
mrb_define_method(mrb, tsk, "initialize", mrb_task_init, MRB_ARGS_REQ(1));
mrb_define_method(mrb, tsk, "activate", mrb_task_activate, MRB_ARGS_NONE());
mrb_define_method(mrb, tsk, "suspend", mrb_task_suspend, MRB_ARGS_NONE());
mrb_define_method(mrb, tsk, "resume", mrb_task_resume, MRB_ARGS_NONE());
mrb_define_method(mrb, tsk, "terminate", mrb_task_terminate, MRB_ARGS_NONE());
/* EventFlag class */
mrb_rtos_flag_init(mrb, rtos);
/* MemoryPool, MemoryBuffer */
mrb_rtos_memory_init(mrb, rtos);
/* DataQueue */
mrb_rtos_dataqueue_init(mrb, rtos);
}
static mrb_value Cache__shm_status(mrb_state *mrb, mrb_value self)
{
mrb_value hash = mrb_hash_new(mrb);
local_memcache_t *lmc = get_Cache(mrb, self);
if (!lmc_lock_shm_region("shm_status", lmc))
return mrb_nil_value();
lmc_mem_status_t ms = lmc_status(lmc->base, "shm_status");
if (!lmc_unlock_shm_region("shm_status", lmc))
return mrb_nil_value();
mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_cstr(mrb, "free_bytes")), mrb_fixnum_value(ms.total_free_mem));
mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_cstr(mrb, "total_bytes")), mrb_fixnum_value(ms.total_shm_size));
mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_cstr(mrb, "used_bytes")),
mrb_fixnum_value(ms.total_shm_size - ms.total_free_mem));
mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_cstr(mrb, "free_chunks")), mrb_fixnum_value(ms.free_chunks));
mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_cstr(mrb, "largest_chunk")), mrb_fixnum_value(ms.largest_chunk));
return hash;
}
mrb_value
mrb_funcall_with_block(mrb_state *mrb, mrb_value self, const char *name, int argc, mrb_value *argv, struct RProc *blk)
{
struct RProc *p;
struct RClass *c;
mrb_sym mid = mrb_intern(mrb, name);
mrb_sym undef = 0;
mrb_callinfo *ci;
int n = mrb->ci->nregs;
mrb_value val;
c = mrb_class(mrb, self);
p = mrb_method_search_vm(mrb, &c, mid);
if (!p) {
undef = mid;
mid = mrb_intern(mrb, "method_missing");
p = mrb_method_search_vm(mrb, &c, mid);
n++; argc++;
}
ci = cipush(mrb);
ci->mid = mid;
ci->proc = p;
ci->stackidx = mrb->stack - mrb->stbase;
ci->argc = argc;
ci->target_class = p->target_class;
ci->nregs = argc + 2;
ci->acc = -1;
mrb->stack = mrb->stack + n;
stack_extend(mrb, ci->nregs, 0);
mrb->stack[0] = self;
if (undef) {
mrb->stack[1] = mrb_symbol_value(undef);
memcpy(mrb->stack+2, argv, sizeof(mrb_value)*(argc-1));
}
else if (argc > 0) {
memcpy(mrb->stack+1, argv, sizeof(mrb_value)*argc);
}
if (!blk) {
mrb->stack[argc+1] = mrb_nil_value();
}
else {
mrb->stack[argc+1] = mrb_obj_value(blk);
}
if (MRB_PROC_CFUNC_P(p)) {
val = p->body.func(mrb, self);
mrb->stack = mrb->stbase + ci->stackidx;
cipop(mrb);
}
else {
val = mrb_run(mrb, p, self);
}
return val;
}
/*
* call-seq:
* Button[key] # => Button
*
* Get button object.
*
* Parameters:
* +key+ Button name
* :left Left button
* :right Right button
* :up Up button
* :down Down button
* :enter Enter button
* :back Back button
*
* Returns Button object
*/
static mrb_value
mrb_btn_get(mrb_state *mrb, mrb_value self)
{
mrb_sym sym;
mrb_value symv;
mrb_get_args(mrb, "n", &sym);
symv = mrb_symbol_value(sym);
return mrb_obj_new(mrb, mrb_class_ptr(self), 1, &symv);
}
void
mrb_ev3_serial_init(mrb_state *mrb, struct RClass *ev3)
{
struct RClass *file = mrb_class_get(mrb, "File");
struct RClass *ser;
mrb_value sero;
mrb_value port;
/* SerialPort class */
ser = mrb_define_class_under(mrb, ev3, "SerialPort", file);
sero = mrb_obj_value(ser);
port = mrb_hash_new(mrb);
mrb_hash_set(mrb, port, mrb_symbol_value(mrb_intern_lit(mrb, "default")), mrb_fixnum_value(EV3_SERIAL_DEFAULT));
mrb_hash_set(mrb, port, mrb_symbol_value(mrb_intern_lit(mrb, "uart")), mrb_fixnum_value(EV3_SERIAL_UART));
mrb_hash_set(mrb, port, mrb_symbol_value(mrb_intern_lit(mrb, "bt")), mrb_fixnum_value(EV3_SERIAL_BT));
mrb_const_set(mrb, sero, mrb_intern_lit(mrb, "PORT"), port);
mrb_define_method(mrb, ser, "initialize", mrb_serial_init, MRB_ARGS_REQ(1));
}
static void
method_entry_loop(mrb_state *mrb, struct RClass* klass, mrb_value ary)
{
int i;
khash_t(mt) *h = klass->mt;
for (i=0;i<kh_end(h);i++) {
if (kh_exist(h, i)) {
mrb_ary_push(mrb, ary, mrb_symbol_value(kh_key(h,i)));
}
}
}
/*
* call-seq:
* Symbol.all_symbols => array
*
* Returns an array of all the symbols currently in Ruby's symbol
* table.
*
* Symbol.all_symbols.size #=> 903
* Symbol.all_symbols[1,20] #=> [:floor, :ARGV, :Binding, :symlink,
* :chown, :EOFError, :$;, :String,
* :LOCK_SH, :"setuid?", :$<,
* :default_proc, :compact, :extend,
* :Tms, :getwd, :$=, :ThreadGroup,
* :wait2, :$>]
*/
static mrb_value
mrb_sym_all_symbols(mrb_state *mrb, mrb_value self)
{
mrb_sym i, lim;
mrb_value ary = mrb_ary_new_capa(mrb, mrb->symidx);
for (i=1, lim=mrb->symidx+1; i<lim; i++) {
mrb_ary_push(mrb, ary, mrb_symbol_value(i));
}
return ary;
}
MRB_API mrb_noreturn void
mrb_no_method_error(mrb_state *mrb, mrb_sym id, mrb_value args, char const* fmt, ...)
{
mrb_value exc;
va_list ap;
va_start(ap, fmt);
exc = mrb_funcall(mrb, mrb_obj_value(E_NOMETHOD_ERROR), "new", 3,
mrb_vformat(mrb, fmt, ap), mrb_symbol_value(id), args);
va_end(ap);
mrb_exc_raise(mrb, exc);
}
void
mrb_ev3_led_init(mrb_state *mrb, struct RClass *ev3)
{
struct RClass *led;
mrb_value ledo;
mrb_value col;
/* LED class */
led = mrb_define_class_under(mrb, ev3, "LED", mrb->object_class);
ledo = mrb_obj_value(led);
col = mrb_hash_new(mrb);
mrb_hash_set(mrb, col, mrb_symbol_value(mrb_intern_lit(mrb, "off")), mrb_fixnum_value(LED_OFF));
mrb_hash_set(mrb, col, mrb_symbol_value(mrb_intern_lit(mrb, "red")), mrb_fixnum_value(LED_RED));
mrb_hash_set(mrb, col, mrb_symbol_value(mrb_intern_lit(mrb, "green")), mrb_fixnum_value(LED_GREEN));
mrb_hash_set(mrb, col, mrb_symbol_value(mrb_intern_lit(mrb, "orange")), mrb_fixnum_value(LED_ORANGE));
mrb_const_set(mrb, ledo, mrb_intern_lit(mrb, "COLOR"), col);
mrb_define_class_method(mrb, led, "color=", mrb_led_color, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, led, "off", mrb_led_off, MRB_ARGS_NONE());
}
void
mrb_ev3_button_init(mrb_state *mrb, struct RClass *ev3)
{
struct RClass *btn;
mrb_value btno;
mrb_value keys;
/* Button class */
btn = mrb_define_class_under(mrb, ev3, "Button", mrb->object_class);
btno = mrb_obj_value(btn);
keys = mrb_hash_new(mrb);
mrb_hash_set(mrb, keys, mrb_symbol_value(mrb_intern_lit(mrb, "left")), mrb_fixnum_value(LEFT_BUTTON));
mrb_hash_set(mrb, keys, mrb_symbol_value(mrb_intern_lit(mrb, "right")), mrb_fixnum_value(RIGHT_BUTTON));
mrb_hash_set(mrb, keys, mrb_symbol_value(mrb_intern_lit(mrb, "up")), mrb_fixnum_value(UP_BUTTON));
mrb_hash_set(mrb, keys, mrb_symbol_value(mrb_intern_lit(mrb, "down")), mrb_fixnum_value(DOWN_BUTTON));
mrb_hash_set(mrb, keys, mrb_symbol_value(mrb_intern_lit(mrb, "enter")), mrb_fixnum_value(ENTER_BUTTON));
mrb_hash_set(mrb, keys, mrb_symbol_value(mrb_intern_lit(mrb, "back")), mrb_fixnum_value(BACK_BUTTON));
mrb_const_set(mrb, btno, mrb_intern_lit(mrb, "KEY"), keys);
mrb_define_class_method(mrb, btn, "[]", mrb_btn_get, MRB_ARGS_REQ(1));
mrb_define_method(mrb, btn, "initialize", mrb_btn_init, MRB_ARGS_REQ(1));
mrb_define_method(mrb, btn, "pressed?", mrb_btn_pressed, MRB_ARGS_NONE());
}
static mrb_value
mrb_local_variables(mrb_state *mrb, mrb_value self)
{
mrb_value ret;
struct RProc *proc;
struct mrb_irep *irep;
size_t i;
proc = mrb->c->ci[-1].proc;
if (MRB_PROC_CFUNC_P(proc)) {
return mrb_ary_new(mrb);
}
irep = proc->body.irep;
if (!irep->lv) {
return mrb_ary_new(mrb);
}
ret = mrb_ary_new_capa(mrb, irep->nlocals - 1);
for (i = 0; i + 1 < irep->nlocals; ++i) {
mrb_ary_push(mrb, ret, mrb_symbol_value(irep->lv[i].name));
}
if (proc->env) {
struct REnv *e = proc->env;
while (e) {
if (!MRB_PROC_CFUNC_P(mrb->c->cibase[e->cioff].proc)) {
irep = mrb->c->cibase[e->cioff].proc->body.irep;
if (irep->lv) {
for (i = 0; i + 1 < irep->nlocals; ++i) {
mrb_ary_push(mrb, ret, mrb_symbol_value(irep->lv[i].name));
}
}
}
e = (struct REnv*)e->c;
}
}
return ret;
}
void mrb_name_error(mrb_state *mrb, mrb_sym id, const char *fmt, ...)
{
mrb_value exc;
mrb_value argv[2];
va_list args;
va_start(args, fmt);
argv[0] = mrb_vformat(mrb, fmt, args)->wrap();
va_end(args);
argv[1] = mrb_symbol_value(id);
exc = E_NAME_ERROR->new_instance(2, argv);
mrb_exc_raise(mrb, exc);
}
/*
* call-seq:
* LCD.new(font, x, y, width, height, color) # => LCD
*
* Creates LCD object.
*
* Parameters:
* +font+ font size.
* :small small font (6x8, default)
* :medium medium font (8x16)
* +x+ Window origin (left) X coordinate. (default: 0)
* +y+ Window origin (top) Y coordinate. (default: 0)
* +width+ Width of window. (default: LCD::WIDTH)
* +height+ Height of window. (default: LCD::HEIGHT)
* +color+ LCD foreground color.
* :black black (default)
* :white while
*
* Returns LCD object.
*/
static mrb_value
mrb_lcd_init(mrb_state *mrb, mrb_value self)
{
struct RClass *lcd = mrb_obj_class(mrb, self);
mrb_value fmap = mrb_const_get(mrb, mrb_obj_value(lcd), mrb_intern_lit(mrb, "FONT"));
mrb_value cmap = mrb_const_get(mrb, mrb_obj_value(lcd), mrb_intern_lit(mrb, "COLOR"));
mrb_sym font = mrb_intern_lit(mrb, "small");
mrb_sym col = mrb_intern_lit(mrb, "black");
mrb_value fontv;
mrb_value colv;
mrb_lcd_t *plcd;
DATA_TYPE(self) = &mrb_lcd_type;
plcd = (mrb_lcd_t*)mrb_malloc(mrb, sizeof(mrb_lcd_t));
DATA_PTR(self) = plcd;
memset(plcd, 0, sizeof(mrb_lcd_t));
plcd->width = EV3_LCD_WIDTH;
plcd->height = EV3_LCD_HEIGHT;
mrb_get_args(mrb, "|niiiin", &font, &plcd->left, &plcd->top, &plcd->width, &plcd->height, &col);
fontv = mrb_hash_get(mrb, fmap, mrb_symbol_value(font));
if (mrb_nil_p(fontv)) {
mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid font size :%S", mrb_sym2str(mrb, font));
}
plcd->font = mrb_fixnum(fontv);
if (_font_size[plcd->font].w == 0) {
/* initialize font size at 1st time */
ev3_font_get_size(plcd->font, &_font_size[plcd->font].w, &_font_size[plcd->font].h);
}
colv = mrb_hash_get(mrb, cmap, mrb_symbol_value(col));
if (mrb_nil_p(colv)) {
mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid foreground color :%S", mrb_sym2str(mrb, col));
}
plcd->color = mrb_fixnum(colv);
return self;
}
/*
* call-seq:
* Struct.new( [aString] [, aSym]+> ) -> StructClass
* StructClass.new(arg, ...) -> obj
* StructClass[arg, ...] -> obj
*
* Creates a new class, named by <i>aString</i>, containing accessor
* methods for the given symbols. If the name <i>aString</i> is
* omitted, an anonymous structure class will be created. Otherwise,
* the name of this struct will appear as a constant in class
* <code>Struct</code>, so it must be unique for all
* <code>Struct</code>s in the system and should start with a capital
* letter. Assigning a structure class to a constant effectively gives
* the class the name of the constant.
*
* <code>Struct::new</code> returns a new <code>Class</code> object,
* which can then be used to create specific instances of the new
* structure. The number of actual parameters must be
* less than or equal to the number of attributes defined for this
* class; unset parameters default to <code>nil</code>. Passing too many
* parameters will raise an <code>ArgumentError</code>.
*
* The remaining methods listed in this section (class and instance)
* are defined for this generated class.
*
* # Create a structure with a name in Struct
* Struct.new("Customer", :name, :address) #=> Struct::Customer
* Struct::Customer.new("Dave", "123 Main") #=> #<struct Struct::Customer name="Dave", address="123 Main">
*
* # Create a structure named by its constant
* Customer = Struct.new(:name, :address) #=> Customer
* Customer.new("Dave", "123 Main") #=> #<struct Customer name="Dave", address="123 Main">
*/
static mrb_value
mrb_struct_s_def(mrb_state *mrb, mrb_value klass)
{
mrb_value name, rest;
mrb_value *pargv;
int argcnt;
mrb_int i;
mrb_value b, st;
mrb_sym id;
mrb_value *argv;
int argc;
name = mrb_nil_value();
rest = mrb_nil_value();
mrb_get_args(mrb, "*&", &argv, &argc, &b);
if (argc == 0) { /* special case to avoid crash */
rest = mrb_ary_new(mrb);
}
else {
if (argc > 0) name = argv[0];
if (argc > 1) rest = argv[1];
if (mrb_array_p(rest)) {
if (!mrb_nil_p(name) && mrb_symbol_p(name)) {
/* 1stArgument:symbol -> name=nil rest=argv[0]-[n] */
mrb_ary_unshift(mrb, rest, name);
name = mrb_nil_value();
}
}
else {
pargv = &argv[1];
argcnt = argc-1;
if (!mrb_nil_p(name) && mrb_symbol_p(name)) {
/* 1stArgument:symbol -> name=nil rest=argv[0]-[n] */
name = mrb_nil_value();
pargv = &argv[0];
argcnt++;
}
rest = mrb_ary_new_from_values(mrb, argcnt, pargv);
}
for (i=0; i<RARRAY_LEN(rest); i++) {
id = mrb_obj_to_sym(mrb, RARRAY_PTR(rest)[i]);
RARRAY_PTR(rest)[i] = mrb_symbol_value(id);
}
}
st = make_struct(mrb, name, rest, struct_class(mrb));
if (!mrb_nil_p(b)) {
mrb_yield_with_class(mrb, b, 1, &st, st, mrb_class_ptr(klass));
}
return st;
}
static int
cv_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p)
{
mrb_value ary;
const char* s;
size_t len;
ary = *(mrb_value*)p;
s = mrb_sym2name_len(mrb, sym, &len);
if (len > 2 && s[0] == '@' && s[1] == '@') {
mrb_ary_push(mrb, ary, mrb_symbol_value(sym));
}
return 0;
}
static int
const_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p)
{
mrb_value ary;
const char* s;
size_t len;
ary = *(mrb_value*)p;
s = mrb_sym2name_len(mrb, sym, &len);
if (len > 1 && ISUPPER(s[0])) {
mrb_ary_push(mrb, ary, mrb_symbol_value(sym));
}
return 0;
}
