Example #1
0
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();
}
Example #2
0
File: gc.c Project: forkall/groonga
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();
}
Example #3
0
File: hash.c Project: Zyxwvu/mruby
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);
}
Example #4
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();
}
Example #5
0
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();
}
Example #6
0
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();
}
Example #7
0
File: io.c Project: asfluido/mruby
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();
}
Example #8
0
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();
}
Example #9
0
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();
  }
}
Example #10
0
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();
}
Example #11
0
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();
}
Example #12
0
/*
 *  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();
}
Example #13
0
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();
}
Example #14
0
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();
}
Example #15
0
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();
}
Example #16
0
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();
}
Example #17
0
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();
}
Example #18
0
/*
 *  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();
}
Example #19
0
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();
}
Example #20
0
/*
 *  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();
}
Example #21
0
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();
}
Example #22
0
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();
  }
}
Example #23
0
File: hash.c Project: gaffo/mruby
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();
}
Example #24
0
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();
}
Example #25
0
/*
 *  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();
}
Example #26
0
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);
}
Example #27
0
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();
}
Example #28
0
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();
}
Example #29
0
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();
}
Example #30
0
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();
}