static mrb_value mrb_mutex_try_lock(mrb_state* mrb, mrb_value self) { mrb_mutex_context* context = DATA_PTR(self); if (pthread_mutex_trylock(&context->mutex) == 0) { context->locked = TRUE; return mrb_true_value(); } return mrb_false_value(); }
static mrb_value gc_disable(mrb_state *mrb, mrb_value obj) { int old = mrb->gc_disabled; mrb->gc_disabled = TRUE; if (old) return mrb_true_value(); return mrb_false_value(); }
static mrb_value hash_equal(mrb_state *mrb, mrb_value hash1, mrb_value hash2, int eql) { if (mrb_obj_equal(mrb, hash1, hash2)) return mrb_true_value(); if (mrb_type(hash2) != MRB_TT_HASH) { if (!mrb_respond_to(mrb, hash2, mrb_intern(mrb, "to_hash"))) { return mrb_false_value(); } if (eql) return mrb_fixnum_value(mrb_eql(mrb, hash2, hash1)); else return mrb_fixnum_value(mrb_equal(mrb, hash2, hash1)); } if (RHASH_SIZE(hash1) != RHASH_SIZE(hash2)) return mrb_false_value(); if (!RHASH(hash1)->ht || !RHASH(hash2)->ht) return mrb_true_value(); return mrb_exec_recursive_paired(mrb, recursive_eql, hash1, hash2, (void*)0); }
static mrb_value mrb_thread_alive(mrb_state* mrb, mrb_value self) { mrb_value value_context = mrb_iv_get(mrb, self, mrb_intern_cstr(mrb, "context")); mrb_thread_context* context = NULL; Data_Get_Struct(mrb, value_context, &mrb_thread_context_type, context); context->mrb = NULL; return context->mrb != NULL ? mrb_true_value() : mrb_false_value(); }
mrb_value mrb_mod_const_defined(mrb_state *mrb, mrb_value mod) { mrb_value sym; mrb_get_args(mrb, "o", &sym); if(mrb_const_defined(mrb, mod, mrb_sym_value(mrb, sym))) { return mrb_true_value(); } return mrb_false_value(); }
mrb_value mrb_mraa_uart_data_available(mrb_state *mrb, mrb_value self) { mraa_uart_context uart; unsigned int millis, nargs; nargs = mrb_get_args(mrb, "|i", &millis); if (nargs == 0) millis = 0; uart = (mraa_uart_context)mrb_data_get_ptr(mrb, self, &mrb_mraa_uart_ctx_type); return ( mraa_uart_data_available(uart, millis) == 1 ) ? mrb_true_value() : mrb_false_value(); }
mrb_value mrb_io_isatty(mrb_state *mrb, mrb_value self) { struct mrb_io *fptr; fptr = io_get_open_fptr(mrb, self); if (isatty(fptr->fd) == 0) return mrb_false_value(); return mrb_true_value(); }
static mrb_value mrb_mod_eqq(mrb_state *mrb, mrb_value mod) { mrb_value obj; mrb_get_args(mrb, "o", &obj); if (!mrb_obj_is_kind_of(mrb, obj, mrb_class_ptr(mod))) return mrb_false_value(); return mrb_true_value(); }
static mrb_value mrb_ary_eql(mrb_state *mrb, mrb_value ary1) { mrb_value ary2; mrb_get_args(mrb, "o", &ary2); if (mrb_obj_equal(mrb, ary1, ary2)) return mrb_true_value(); if (mrb_type(ary2) != MRB_TT_ARRAY) return mrb_false_value(); if (RARRAY_LEN(ary1) != RARRAY_LEN(ary2)) return mrb_false_value(); else { int i; for (i=0; i<RARRAY_LEN(ary1); i++) { if (!mrb_eql(mrb, ary_elt(ary1, i), ary_elt(ary2, i))) return mrb_false_value(); } return mrb_true_value(); } }
static mrb_value cmp_lt(mrb_state *mrb, mrb_value x, mrb_value y) { mrb_value c; c = mrb_funcall(mrb, x, "<=>", 1, y); if (mrb_cmpint(mrb, c, x, y) < 0) return mrb_true_value(); return mrb_false_value(); }
static mrb_value mrb_sdl2_mixer_open(mrb_state *mrb, mrb_value self) { int result; mrb_int freq, format, channels, chunksize; mrb_get_args(mrb, "iiii", &freq, &format, &channels, &chunksize); result = Mix_OpenAudio((int) freq, (Uint16) format, (int) channels, (int) chunksize); return (result == -1) ? mrb_false_value() : mrb_true_value(); }
/* * call-seq: * block_given? -> true or false * iterator? -> true or false * * Returns <code>true</code> if <code>yield</code> would execute a * block in the current context. The <code>iterator?</code> form * is mildly deprecated. * * def try * if block_given? * yield * else * "no block" * end * end * try #=> "no block" * try { "hello" } #=> "hello" * try do "hello" end #=> "hello" */ static mrb_value mrb_f_block_given_p_m(mrb_state *mrb, mrb_value self) { mrb_callinfo *ci = &mrb->c->ci[-1]; mrb_callinfo *cibase = mrb->c->cibase; mrb_value *bp; struct RProc *p; if (ci <= cibase) { /* toplevel does not have block */ return mrb_false_value(); } p = ci->proc; /* search method/class/module proc */ while (p) { if (MRB_PROC_SCOPE_P(p)) break; p = p->upper; } if (p == NULL) return mrb_false_value(); /* search ci corresponding to proc */ while (cibase < ci) { if (ci->proc == p) break; ci--; } if (ci == cibase) { return mrb_false_value(); } else if (ci->env) { struct REnv *e = ci->env; int bidx; /* top-level does not have block slot (always false) */ if (e->stack == mrb->c->stbase) return mrb_false_value(); /* use saved block arg position */ bidx = MRB_ENV_BIDX(e); /* bidx may be useless (e.g. define_method) */ if (bidx >= MRB_ENV_STACK_LEN(e)) return mrb_false_value(); bp = &e->stack[bidx]; } else { bp = ci[1].stackent+1; if (ci->argc >= 0) { bp += ci->argc; } else { bp++; } } if (mrb_nil_p(*bp)) return mrb_false_value(); return mrb_true_value(); }
static mrb_value set_scale(mrb_state *mrb, mrb_value self) { mrb_float scale; PP_Bool ret; mrb_get_args(mrb, "f", &scale); ret = PPB(Graphics2D)->SetScale(MRB_PP_RESOURCE(self), scale); return (ret == PP_TRUE) ? mrb_true_value() : mrb_false_value(); }
static mrb_value cmp_ge_m(mrb_state *mrb, mrb_value x) { mrb_value y, c; mrb_get_args(mrb, "o", &y); c = mrb_funcall(mrb, x, "<=>", 1, y); if (mrb_cmpint(mrb, c, x, y) >= 0) return mrb_true_value(); return mrb_false_value(); }
static mrb_value cmp_between(mrb_state *mrb, mrb_value x) { mrb_value min, max; mrb_get_args(mrb, "oo", &min, &max); if (mrb_test(cmp_lt(mrb, x, min))) return mrb_false_value(); if (mrb_test(cmp_gt(mrb, x, max))) return mrb_false_value(); return mrb_true_value(); }
static mrb_value mrb_sdl2_joystick_joystick_get_button(mrb_state *mrb, mrb_value self) { Uint8 result; mrb_int button; SDL_Joystick * joystick_p = mrb_sdl2_joystick_joystick_get_ptr(mrb, self); mrb_get_args(mrb, "i", &button); result = SDL_JoystickGetButton(joystick_p, button); return (0 == result) ? mrb_false_value() : mrb_true_value(); }
static mrb_value mrb_require_load_rb_str(mrb_state *mrb, mrb_value self) { char *path_ptr = NULL; char tmpname[] = "tmp.XXXXXXXX"; mode_t mask; FILE *tmpfp = NULL; int fd = -1, ret; mrb_irep *irep; mrb_value code, path = mrb_nil_value(); mrb_get_args(mrb, "S|S", &code, &path); if (!mrb_string_p(path)) { path = mrb_str_new_cstr(mrb, "-"); } path_ptr = mrb_str_to_cstr(mrb, path); mask = umask(077); fd = mkstemp(tmpname); if (fd == -1) { mrb_sys_fail(mrb, "can't create mkstemp() at mrb_require_load_rb_str"); } umask(mask); tmpfp = fopen(tmpname, "w+"); if (tmpfp == NULL) { mrb_sys_fail(mrb, "can't open temporay file at mrb_require_load_rb_str"); } ret = compile_rb2mrb(mrb, RSTRING_PTR(code), RSTRING_LEN(code), path_ptr, tmpfp); if (ret != MRB_DUMP_OK) { fclose(tmpfp); remove(tmpname); mrb_raisef(mrb, E_LOAD_ERROR, "can't load file -- %S", path); return mrb_nil_value(); } rewind(tmpfp); irep = mrb_read_irep_file(mrb, tmpfp); fclose(tmpfp); remove(tmpname); if (irep) { eval_load_irep(mrb, irep); } else if (mrb->exc) { // fail to load longjmp(*(jmp_buf*)mrb->jmp, 1); } else { mrb_raisef(mrb, E_LOAD_ERROR, "can't load file -- %S", path); return mrb_nil_value(); } return mrb_true_value(); }
/* * call-seq: * hsh.empty? -> true or false * * Returns <code>true</code> if <i>hsh</i> contains no key-value pairs. * * {}.empty? #=> true * */ static mrb_value mrb_hash_empty_p(mrb_state *mrb, mrb_value self) { khash_t(ht) *h = RHASH_TBL(self); if (h) { if (kh_size(h) == 0) return mrb_true_value(); } return mrb_false_value(); }
static mrb_value mrb_mruby_lcd_print(mrb_state *mrb, mrb_value self) { mrb_value s; char *msg; mrb_get_args(mrb, "S", &s); msg = mrb_str_to_cstr(mrb, s); ev3_lcd_fill_rect(0, 0, EV3_LCD_WIDTH, EV3_LCD_HEIGHT, EV3_LCD_WHITE); ev3_lcd_draw_string(msg, 0, CALIB_FONT_HEIGHT*1); return mrb_true_value(); }
/* * call-seq: * obj.instance_variable_defined?(symbol) -> true or false * * Returns <code>true</code> if the given instance variable is * defined in <i>obj</i>. * * class Fred * def initialize(p1, p2) * @a, @b = p1, p2 * end * end * fred = Fred.new('cat', 99) * fred.instance_variable_defined?(:@a) #=> true * fred.instance_variable_defined?("@b") #=> true * fred.instance_variable_defined?("@c") #=> false */ mrb_value mrb_obj_ivar_defined(mrb_state *mrb, mrb_value self) { mrb_sym mid; mrb_get_args(mrb, "n", &mid); check_iv_name(mrb, mid); if (mrb_obj_iv_defined(mrb, mrb_obj_ptr(self), mid)) return mrb_true_value(); return mrb_false_value(); }
mrb_value mrb_io_closed(mrb_state *mrb, mrb_value io) { struct mrb_io *fptr; fptr = (struct mrb_io *)mrb_get_datatype(mrb, io, &mrb_io_type); if (fptr->fd >= 0) { return mrb_false_value(); } return mrb_true_value(); }
static mrb_value mrb_entropy_gather(mrb_state *mrb, mrb_value self) { entropy_context *entropy; entropycheck(mrb, self, &entropy); if( entropy_gather( entropy ) == 0 ) { return mrb_true_value(); } else { return mrb_false_value(); } }
static mrb_value hash_equal(mrb_state *mrb, mrb_value hash1, mrb_value hash2, int eql) { khash_t(ht) *h1, *h2; if (mrb_obj_equal(mrb, hash1, hash2)) return mrb_true_value(); if (!mrb_hash_p(hash2)) { if (!mrb_respond_to(mrb, hash2, mrb_intern(mrb, "to_hash"))) { return mrb_false_value(); } if (eql) return mrb_fixnum_value(mrb_eql(mrb, hash2, hash1)); else return mrb_fixnum_value(mrb_equal(mrb, hash2, hash1)); } h1 = RHASH_TBL(hash1); h2 = RHASH_TBL(hash2); if (!h1) { if (!h2) return mrb_true_value(); return mrb_false_value(); } if (!h2) return mrb_false_value(); if (kh_size(h1) != kh_size(h2)) return mrb_false_value(); else { khiter_t k1, k2; mrb_value key; for (k1 = kh_begin(h1); k1 != kh_end(h1); k1++) { if (!kh_exist(h1, k1)) continue; key = kh_key(h1,k1); k2 = kh_get(ht, h2, key); if (k2 != kh_end(h2)) { if (mrb_equal(mrb, kh_value(h1,k1), kh_value(h2,k2))) { continue; /* next key */ } } return mrb_false_value(); } } return mrb_true_value(); }
static mrb_value mrb_ssl_set_socket(mrb_state *mrb, mrb_value self) { ssl_context *ssl; struct mrb_io *fptr; mrb_value socket; mrb_get_args(mrb, "o", &socket); mrb_data_check_type(mrb, socket, &mrb_io_type); fptr = DATA_CHECK_GET_PTR(mrb, socket, &mrb_io_type, struct mrb_io); ssl = DATA_CHECK_GET_PTR(mrb, self, &mrb_ssl_type, ssl_context); ssl_set_bio( ssl, net_recv, &fptr->fd, net_send, &fptr->fd ); return mrb_true_value(); }
/* * call-seq: * block_given? -> true or false * iterator? -> true or false * * Returns <code>true</code> if <code>yield</code> would execute a * block in the current context. The <code>iterator?</code> form * is mildly deprecated. * * def try * if block_given? * yield * else * "no block" * end * end * try #=> "no block" * try { "hello" } #=> "hello" * try do "hello" end #=> "hello" */ static mrb_value mrb_f_block_given_p_m(mrb_state *mrb, mrb_value self) { mrb_callinfo *ci = mrb->ci; mrb_value *bp; bp = mrb->stbase + ci->stackidx + 1; ci--; if (ci <= mrb->cibase) return mrb_false_value(); /* block_given? called within block; check upper scope */ if (ci->proc->env && ci->proc->env->stack) { if (ci->proc->env->stack == mrb->stbase || mrb_nil_p(ci->proc->env->stack[1])) return mrb_false_value(); return mrb_true_value(); } if (ci->argc > 0) { bp += ci->argc; } if (mrb_nil_p(*bp)) return mrb_false_value(); return mrb_true_value(); }
static mrb_value range_eql(mrb_state *mrb, mrb_value range) { mrb_value obj; mrb_get_args(mrb, "o", &obj); if (mrb_obj_equal(mrb, range, obj)) return mrb_true_value(); if (!mrb_obj_is_kind_of(mrb, obj, mrb->range_class)) return mrb_false_value(); return mrb_exec_recursive_paired(mrb, recursive_eql, range, obj, &obj); }
static mrb_value hs_regexp_casefold_p(mrb_state *mrb, mrb_value self) { struct mrb_hs_regexp *self_reg; self_reg = DATA_PTR(self); if (!self_reg){ mrb_raise(mrb, E_RUNTIME_ERROR, "Invalid HsRegexp"); } return (self_reg->flag & REGEXP_FLAG_IGNORECASE) ? mrb_true_value() : mrb_false_value(); }
mrb_value mrb_filetest_s_exist_p(mrb_state *mrb, mrb_value klass) { struct stat st; mrb_value obj; mrb_get_args(mrb, "o", &obj); if (mrb_stat(mrb, obj, &st) < 0) return mrb_false_value(); return mrb_true_value(); }
static mrb_value mrb_ssl_set_rng(mrb_state *mrb, mrb_value self) { ssl_context *ssl; ctr_drbg_context *ctr_drbg; mrb_value rng; mrb_get_args(mrb, "o", &rng); mrb_data_check_type(mrb, rng, &mrb_ctr_drbg_type); ctr_drbg = DATA_CHECK_GET_PTR(mrb, rng, &mrb_ctr_drbg_type, ctr_drbg_context); ssl = DATA_CHECK_GET_PTR(mrb, self, &mrb_ssl_type, ssl_context); ssl_set_rng(ssl, ctr_drbg_random, ctr_drbg); return mrb_true_value(); }
static mrb_value mrb_ssl_close_notify(mrb_state *mrb, mrb_value self) { ssl_context *ssl; int ret; ssl = DATA_CHECK_GET_PTR(mrb, self, &mrb_ssl_type, ssl_context); ret = ssl_close_notify(ssl); if (ret < 0) { mrb_raise(mrb, E_SSL_ERROR, "ssl_close_notify() returned E_SSL_ERROR"); } return mrb_true_value(); }