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