static mrb_value ngx_mrb_errlogger(mrb_state *mrb, mrb_value self) { mrb_value *argv; mrb_value msg; mrb_int argc; mrb_int log_level; ngx_http_request_t *r = ngx_mrb_get_request(); mrb_get_args(mrb, "*", &argv, &argc); if (argc != 2) { ngx_log_error(NGX_LOG_ERR , r->connection->log , 0 , "%s ERROR %s: argument is not 2" , MODULE_NAME , __func__ ); return self; } if (mrb_type(argv[0]) != MRB_TT_FIXNUM) { ngx_log_error(NGX_LOG_ERR , r->connection->log , 0 , "%s ERROR %s: argv[0] is not integer" , MODULE_NAME , __func__ ); return self; } log_level = mrb_fixnum(argv[0]); if (log_level < 0) { ngx_log_error(NGX_LOG_ERR , r->connection->log , 0 , "%s ERROR %s: log level is not positive number" , MODULE_NAME , __func__ ); return self; } if (mrb_type(argv[1]) != MRB_TT_STRING) { msg = mrb_funcall(mrb, argv[1], "to_s", 0, NULL); } else { msg = mrb_str_dup(mrb, argv[1]); } ngx_log_error((ngx_uint_t)log_level, r->connection->log, 0, "%s", RSTRING_PTR(msg)); return self; }
static mrb_value flo_eq(mrb_state *mrb, mrb_value x) { mrb_value y; mrb_get_args(mrb, "o", &y); switch (mrb_type(y)) { case MRB_TT_FIXNUM: return mrb_bool_value(mrb_float(x) == (mrb_float)mrb_fixnum(y)); case MRB_TT_FLOAT: return mrb_bool_value(mrb_float(x) == mrb_float(y)); default: return mrb_false_value(); } }
mrb_value mrb_serialport_test_write(mrb_state *mrb, mrb_value self) { char *string; size_t l = 0; ssize_t res = 0; int fd = mrb_fixnum(IV_GET("@fd")); mrb_get_args(mrb, "s", &string, &l); res = write(fd, (char *)string, l); printf("wrote '%s'", string); if (res < 0) { update_error(mrb, self); mrb_raise(mrb, E_RUNTIME_ERROR, strerror(errno)); } return mrb_fixnum_value(l); }
static void ev3_set_current_font(mrb_state *mrb, mrb_value self) { static mrb_bool first = TRUE; struct RClass *lcd = mrb_obj_class(mrb, self); mrb_int current = mrb_fixnum(mrb_cv_get(mrb, mrb_obj_value(lcd), mrb_intern_lit(mrb, "@@font"))); mrb_lcd_t *plcd = (mrb_lcd_t*)DATA_PTR(self); mrb_int target = plcd->font; if (first || current != target) { ev3_lcd_set_font((uint16_t)target); mrb_cv_set(mrb, mrb_obj_value(lcd), mrb_intern_lit(mrb, "@@font"), mrb_fixnum_value(target)); first = FALSE; } }
mrb_value mrb_fixnum_mul(mrb_state *mrb, mrb_value x, mrb_value y) { mrb_int a; a = mrb_fixnum(x); if (mrb_fixnum_p(y)) { mrb_int b, c; if (a == 0) return x; b = mrb_fixnum(y); if (mrb_int_mul_overflow(a, b, &c)) { #ifndef MRB_WITHOUT_FLOAT return mrb_float_value(mrb, (mrb_float)a * (mrb_float)b); #endif } return mrb_fixnum_value(c); } #ifdef MRB_WITHOUT_FLOAT mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value"); #else return mrb_float_value(mrb, (mrb_float)a * mrb_to_flo(mrb, y)); #endif }
static mrb_value mrb_ssp_cyclic_istp(mrb_state *mrb, mrb_value self) { ER retval; mrb_value id = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@cyclic_id")); mrb_int id_num = mrb_fixnum(id); retval = istp_cyc(id_num); if (retval == E_OK) { return(mrb_false_value()); } return(mrb_true_value()); }
static mrb_value mrb_ssp_thread_act(mrb_state *mrb, mrb_value self) { ER retval; mrb_value id = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@task_id")); mrb_int id_num = mrb_fixnum(id); retval = act_tsk(id_num); if (retval != E_OK) { return(mrb_false_value()); } return(mrb_true_value()); }
static inline khint_t mrb_hash_ht_hash_func(mrb_state *mrb, mrb_value key) { enum mrb_vtype t = mrb_type(key); mrb_value hv; const char *p; mrb_int i, len; khint_t h; switch (t) { case MRB_TT_STRING: p = RSTRING_PTR(key); len = RSTRING_LEN(key); break; case MRB_TT_SYMBOL: p = mrb_sym2name_len(mrb, mrb_symbol(key), &len); break; case MRB_TT_FIXNUM: return (khint_t)mrb_float_id((mrb_float)mrb_fixnum(key)); case MRB_TT_FLOAT: return (khint_t)mrb_float_id(mrb_float(key)); default: hv = mrb_funcall(mrb, key, "hash", 0); return (khint_t)t ^ mrb_fixnum(hv); } h = 0; for (i=0; i<len; i++) { h = (h << 5) - h + *p++; } return h; }
static mrb_value fix_mod(mrb_state *mrb, mrb_value x) { mrb_value y; mrb_int a; mrb_get_args(mrb, "o", &y); a = mrb_fixnum(x); if (mrb_fixnum_p(y)) { mrb_int b, mod; if ((b=mrb_fixnum(y)) == 0) { return mrb_float_value(mrb, NAN); } fixdivmod(mrb, a, b, 0, &mod); return mrb_fixnum_value(mod); } else { mrb_float mod; flodivmod(mrb, (mrb_float)a, mrb_to_flo(mrb, y), 0, &mod); return mrb_float_value(mrb, mod); } }
static mrb_value fix_mod(mrb_state *mrb, mrb_value x) { mrb_value y; mrb_int a, b; mrb_get_args(mrb, "o", &y); a = mrb_fixnum(x); if (mrb_fixnum_p(y) && (b=mrb_fixnum(y)) != 0) { mrb_int mod; if (mrb_fixnum(y) == 0) { return mrb_float_value(str_to_mrb_float("nan")); } fixdivmod(mrb, a, mrb_fixnum(y), 0, &mod); return mrb_fixnum_value(mod); } else { mrb_float mod; flodivmod(mrb, (mrb_float)a, mrb_to_flo(mrb, y), 0, &mod); return mrb_float_value(mod); } }
mrb_int mrb_range_beg_len(mrb_state *mrb, mrb_value range, mrb_int *begp, mrb_int *lenp, mrb_int len, mrb_int err) { mrb_int beg, end, b, e; struct RRange *r = mrb_range_ptr(range); //if (!mrb_obj_is_kind_of(mrb, range, mrb->range_class)) return FALSE; if (mrb_type(range) != MRB_TT_RANGE) return FALSE; beg = b = mrb_fixnum(r->edges->beg); end = e = mrb_fixnum(r->edges->end); if (beg < 0) { beg += len; if (beg < 0) goto out_of_range; } if (err == 0 || err == 2) { if (beg > len) goto out_of_range; if (end > len) end = len; } if (end < 0) end += len; if (!r->excl) end++; /* include end point */ len = end - beg; if (len < 0) len = 0; *begp = beg; *lenp = len; return TRUE; out_of_range: if (err) { mrb_raise(mrb, E_RANGE_ERROR, "%ld..%s%ld out of range", b, r->excl? "." : "", e); } return OTHER; }
int main(int argc, char **argv) { mrb_state *mrb = mrb_open(); int n = -1; struct _args args; mrbc_context *c; mrb_value result; if (mrb == NULL) { fprintf(stderr, "Invalid mrb_state, exiting mrbc"); return EXIT_FAILURE; } n = parse_args(mrb, argc, argv, &args); if (n < 0 || args.rfp == NULL) { cleanup(mrb, &args); usage(argv[0]); return n; } c = mrbc_context_new(mrb); if (args.verbose) c->dump_result = 1; c->no_exec = 1; result = mrb_load_file_cxt(mrb, args.rfp, c); if (mrb_undef_p(result) || mrb_fixnum(result) < 0) { cleanup(mrb, &args); return EXIT_FAILURE; } if (args.check_syntax) { printf("Syntax OK\n"); cleanup(mrb, &args); return EXIT_SUCCESS; } if (args.initname) { if (args.dump_type == DUMP_TYPE_BIN) n = mrb_bdump_irep(mrb, n, args.wfp, args.initname); else n = mrb_cdump_irep(mrb, n, args.wfp, args.initname); } else { n = mrb_dump_irep(mrb, n, args.wfp); } cleanup(mrb, &args); return EXIT_SUCCESS; }
mrb_value mrb_redis_select(mrb_state *mrb, mrb_value self) { mrb_value database; mrb_get_args(mrb, "o", &database); redisContext *rc = mrb_redis_get_context(mrb, self); if (mrb_type(database) != MRB_TT_FIXNUM) { mrb_raisef(mrb, E_TYPE_ERROR, "type mismatch: %S given", database); } redisReply *rs = redisCommand(rc, "SELECT %d", mrb_fixnum(database)); freeReplyObject(rs); return self; }
int mrb_cmpint(mrb_state *mrb, mrb_value val, mrb_value a, mrb_value b) { if (mrb_nil_p(val)) { mrb_cmperr(mrb, a, b); } if (FIXNUM_P(val)) { long l = mrb_fixnum(val); if (l > 0) return 1; if (l < 0) return -1; return 0; } if (mrb_test(mrb_funcall(mrb, val, ">", 1, mrb_fixnum_value(0)))) return 1; if (mrb_test(mrb_funcall(mrb, val, "<", 1, mrb_fixnum_value(0)))) return -1; return 0; }
/* set_flags * * Parameters: * - value: Uint32 */ mrb_value mrb_SDL_SDLMessageBoxButtonData_set_flags(mrb_state* mrb, mrb_value self) { SDL_MessageBoxButtonData * native_self = mruby_unbox_SDL_MessageBoxButtonData(self); mrb_value ruby_field; mrb_get_args(mrb, "o", &ruby_field); /* type checking */ if (!mrb_obj_is_kind_of(mrb, ruby_field, mrb->fixnum_class)) { mrb_raise(mrb, E_TYPE_ERROR, "Fixnum expected"); return mrb_nil_value(); } Uint32 native_field = mrb_fixnum(ruby_field); native_self->flags = native_field; return ruby_field; }
/* set_major * * Parameters: * - value: Uint8 */ mrb_value mrb_SDL_SDLVersion_set_major(mrb_state* mrb, mrb_value self) { struct SDL_version * native_self = mruby_unbox_SDL_version(self); mrb_value ruby_field; mrb_get_args(mrb, "o", &ruby_field); /* type checking */ if (!mrb_obj_is_kind_of(mrb, ruby_field, mrb->fixnum_class)) { mrb_raise(mrb, E_TYPE_ERROR, "Fixnum expected"); return mrb_nil_value(); } Uint8 native_field = mrb_fixnum(ruby_field); native_self->major = native_field; return ruby_field; }
TMO mrb_timeout_value(mrb_state *mrb, mrb_value tmo) { if (mrb_fixnum_p(tmo)) { return (TMO)mrb_fixnum(tmo); } if (mrb_symbol_p(tmo)) { if (mrb_symbol(tmo) == mrb_intern_lit(mrb, "polling")) { return (TMO)TMO_POL; } if (mrb_symbol(tmo) == mrb_intern_lit(mrb, "forever")) { return (TMO)TMO_FEVR; } } mrb_raisef(mrb, E_TYPE_ERROR, "wrong timeout value (%S)", tmo); }
/* set_scancode * * Parameters: * - value: SDL_Scancode */ mrb_value mrb_SDL_SDLKeysym_set_scancode(mrb_state* mrb, mrb_value self) { struct SDL_Keysym * native_self = mruby_unbox_SDL_Keysym(self); mrb_value ruby_field; mrb_get_args(mrb, "o", &ruby_field); /* type checking */ TODO_type_check_SDL_Scancode(ruby_field); SDL_Scancode native_field = (SDL_Scancode)mrb_fixnum(ruby_field); native_self->scancode = native_field; return ruby_field; }
static void exc_output_backtrace(mrb_state *mrb, struct RObject *exc, output_stream_func func, void *stream) { mrb_value lastpc; mrb_code *code; lastpc = mrb_obj_iv_get(mrb, exc, mrb_intern_lit(mrb, "lastpc")); if (mrb_nil_p(lastpc)) { code = NULL; } else { code = (mrb_code*)mrb_cptr(lastpc); } output_backtrace(mrb, mrb_fixnum(mrb_obj_iv_get(mrb, exc, mrb_intern_lit(mrb, "ciidx"))), code, func, stream); }
static int64_t value_int64(mrb_state *mrb, mrb_value x) { switch (mrb_type(x)) { case MRB_TT_FIXNUM: return (int64_t)mrb_fixnum(x); break; case MRB_TT_FLOAT: return (int64_t)mrb_float(x); default: mrb_raise(mrb, E_TYPE_ERROR, "cannot convert to Integer"); break; } /* not reached */ return 0; }
/* * call-seq: * LED.color = col # => nil * * Light LED. * * Parameters: * +col+ LED color * LED::OFF * LED::RED * LED::GREEN * LED::ORANGE * * Returns nil. */ static mrb_value mrb_led_color(mrb_state *mrb, mrb_value self) { mrb_value cmap = mrb_const_get(mrb, self, mrb_intern_lit(mrb, "COLOR")); mrb_sym col; 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 color :%S", mrb_sym2str(mrb, col)); } ev3_led_set_color(mrb_fixnum(colv)); return mrb_nil_value(); }
/* set_format * * Parameters: * - value: Uint32 */ mrb_value mrb_SDL_SDLDisplayMode_set_format(mrb_state* mrb, mrb_value self) { SDL_DisplayMode * native_self = mruby_unbox_SDL_DisplayMode(self); mrb_value ruby_field; mrb_get_args(mrb, "o", &ruby_field); /* type checking */ if (!mrb_obj_is_kind_of(mrb, ruby_field, mrb->fixnum_class)) { mrb_raise(mrb, E_TYPE_ERROR, "Fixnum expected"); return mrb_nil_value(); } Uint32 native_field = mrb_fixnum(ruby_field); native_self->format = native_field; return ruby_field; }
/* set_BytesPerPixel * * Parameters: * - value: Uint8 */ mrb_value mrb_SDL_SDLPixelFormat_set_BytesPerPixel(mrb_state* mrb, mrb_value self) { struct SDL_PixelFormat * native_self = mruby_unbox_SDL_PixelFormat(self); mrb_value ruby_field; mrb_get_args(mrb, "o", &ruby_field); /* type checking */ if (!mrb_obj_is_kind_of(mrb, ruby_field, mrb->fixnum_class)) { mrb_raise(mrb, E_TYPE_ERROR, "Fixnum expected"); return mrb_nil_value(); } Uint8 native_field = mrb_fixnum(ruby_field); native_self->BytesPerPixel = native_field; return ruby_field; }
static mrb_value fix_lshift(mrb_state *mrb, mrb_value x) { mrb_int width, val; fix_shift_get_width(mrb, &width); if (width == 0) { return x; } val = mrb_fixnum(x); if (width < 0) { return rshift(val, -width); } return lshift(mrb, val, width); }
mrb_value mrb_serialport_read_char(mrb_state *mrb, mrb_value self) { char ch[1]; ssize_t len = 0; int fd = mrb_fixnum(IV_GET("@fd")); len = read(fd, ch, sizeof(char)); if ( len == 0 ) { return mrb_nil_value(); } else if ( len < 0 ) { if ( errno == EAGAIN ) return mrb_nil_value(); update_error(mrb, self); mrb_raise(mrb, E_RUNTIME_ERROR, strerror(errno)); } return mrb_str_new_cstr(mrb, ch); }
/* set_num_texture_formats * * Parameters: * - value: Uint32 */ mrb_value mrb_SDL_SDLRendererInfo_set_num_texture_formats(mrb_state* mrb, mrb_value self) { struct SDL_RendererInfo * native_self = mruby_unbox_SDL_RendererInfo(self); mrb_value ruby_field; mrb_get_args(mrb, "o", &ruby_field); /* type checking */ if (!mrb_obj_is_kind_of(mrb, ruby_field, mrb->fixnum_class)) { mrb_raise(mrb, E_TYPE_ERROR, "Fixnum expected"); return mrb_nil_value(); } Uint32 native_field = mrb_fixnum(ruby_field); native_self->num_texture_formats = native_field; return ruby_field; }
static mrb_value mrb_ssp_alarm_stp(mrb_state *mrb, mrb_value self) { ER retval; mrb_value id = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@alarm_id")); mrb_int id_num = mrb_fixnum(id); t_unlock_cpu(); retval = stp_alm(id_num); t_lock_cpu(); if (retval == E_OK) { return(mrb_false_value()); } return(mrb_true_value()); }
/* set_type * * Parameters: * - value: Uint32 */ mrb_value mrb_SDL_SDLSysWMEvent_set_type(mrb_state* mrb, mrb_value self) { struct SDL_SysWMEvent * native_self = mruby_unbox_SDL_SysWMEvent(self); mrb_value ruby_field; mrb_get_args(mrb, "o", &ruby_field); /* type checking */ if (!mrb_obj_is_kind_of(mrb, ruby_field, mrb->fixnum_class)) { mrb_raise(mrb, E_TYPE_ERROR, "Fixnum expected"); return mrb_nil_value(); } Uint32 native_field = mrb_fixnum(ruby_field); native_self->type = native_field; return ruby_field; }
/* set_attack_length * * Parameters: * - value: Uint16 */ mrb_value mrb_SDL_SDLHapticConstant_set_attack_length(mrb_state* mrb, mrb_value self) { struct SDL_HapticConstant * native_self = mruby_unbox_SDL_HapticConstant(self); mrb_value ruby_field; mrb_get_args(mrb, "o", &ruby_field); /* type checking */ if (!mrb_obj_is_kind_of(mrb, ruby_field, mrb->fixnum_class)) { mrb_raise(mrb, E_TYPE_ERROR, "Fixnum expected"); return mrb_nil_value(); } Uint16 native_field = mrb_fixnum(ruby_field); native_self->attack_length = native_field; return ruby_field; }
static mrb_value writer_write(mrb_state *mrb, mrb_value self) { grn_ctx *ctx = (grn_ctx *)mrb->ud; mrb_value target; mrb_get_args(mrb, "o", &target); switch (mrb_type(target)) { case MRB_TT_FALSE : if (mrb_nil_p(target)) { GRN_OUTPUT_NULL(); } else { GRN_OUTPUT_BOOL(GRN_FALSE); } break; case MRB_TT_TRUE : GRN_OUTPUT_BOOL(GRN_TRUE); break; case MRB_TT_FIXNUM : GRN_OUTPUT_INT32(mrb_fixnum(target)); break; case MRB_TT_FLOAT : GRN_OUTPUT_FLOAT(mrb_float(target)); break; case MRB_TT_SYMBOL : { const char *name; mrb_int name_length; name = mrb_sym2name_len(mrb, mrb_symbol(target), &name_length); GRN_OUTPUT_STR(name, name_length); } break; case MRB_TT_STRING : GRN_OUTPUT_STR(RSTRING_PTR(target), RSTRING_LEN(target)); break; default : mrb_raisef(mrb, E_ARGUMENT_ERROR, "must be nil, true, false, number, float, symbol or string: " "%S", target); break; } return mrb_nil_value(); }