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