示例#1
0
文件: method.c 项目: chasonr/mruby
static mrb_value
method_call(mrb_state *mrb, mrb_value self)
{
  mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "proc"));
  mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@name"));
  mrb_value recv = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@recv"));
  struct RClass *owner = mrb_class_ptr(mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@owner")));
  mrb_int argc;
  mrb_value *argv, ret, block;
  mrb_sym orig_mid;

  mrb_get_args(mrb, "*&", &argv, &argc, &block);
  orig_mid = mrb->c->ci->mid;
  mrb->c->ci->mid = mrb_symbol(name);
  if (mrb_nil_p(proc)) {
    mrb_value missing_argv = mrb_ary_new_from_values(mrb, argc, argv);
    mrb_ary_unshift(mrb, missing_argv, name);
    ret = mrb_funcall_argv(mrb, recv, mrb_intern_lit(mrb, "method_missing"), argc + 1, RARRAY_PTR(missing_argv));
  }
  else if (!mrb_nil_p(block)) {
    /*
      workaround since `mrb_yield_with_class` does not support passing block as parameter
      need new API that initializes `mrb->c->stack[argc+1]` with block passed by argument
    */
    ret = mrb_funcall_with_block(mrb, recv, mrb_symbol(name), argc, argv, block);
  }
  else {
    ret = mrb_yield_with_class(mrb, proc, argc, argv, recv, owner);
  }
  mrb->c->ci->mid = orig_mid;
  return ret;
}
示例#2
0
文件: symbol.c 项目: retrage/mruby
static mrb_value
sym_cmp(mrb_state *mrb, mrb_value s1)
{
  mrb_value s2;
  mrb_sym sym1, sym2;

  mrb_get_args(mrb, "o", &s2);
  if (mrb_type(s2) != MRB_TT_SYMBOL) return mrb_nil_value();
  sym1 = mrb_symbol(s1);
  sym2 = mrb_symbol(s2);
  if (sym1 == sym2) return mrb_fixnum_value(0);
  else {
    const char *p1, *p2;
    int retval;
    mrb_int len, len1, len2;

    p1 = mrb_sym2name_len(mrb, sym1, &len1);
    p2 = mrb_sym2name_len(mrb, sym2, &len2);
    len = lesser(len1, len2);
    retval = memcmp(p1, p2, len);
    if (retval == 0) {
      if (len1 == len2) return mrb_fixnum_value(0);
      if (len1 > len2)  return mrb_fixnum_value(1);
      return mrb_fixnum_value(-1);
    }
    if (retval > 0) return mrb_fixnum_value(1);
    return mrb_fixnum_value(-1);
  }
}
示例#3
0
文件: class.c 项目: bearmini/mruby
mrb_value
mrb_mod_const_defined(mrb_state *mrb, mrb_value mod)
{
  mrb_value id;
  mrb_bool const_defined_p;

  id = get_sym_or_str_arg(mrb);
  if (mrb_type(id) == MRB_TT_SYMBOL) {
    check_const_name_sym(mrb, mrb_symbol(id));
    const_defined_p = mrb_const_defined(mrb, mod, mrb_symbol(id));
  }
  else {
    mrb_value sym;
    check_const_name_str(mrb, id);
    sym = mrb_check_intern_str(mrb, id);
    if (mrb_nil_p(sym)) {
      const_defined_p = FALSE;
    }
    else {
      const_defined_p = mrb_const_defined(mrb, mod, mrb_symbol(sym));
    }
  }

  return mrb_bool_value(const_defined_p);
}
示例#4
0
文件: method.c 项目: chasonr/mruby
static mrb_value
method_eql(mrb_state *mrb, mrb_value self)
{
  mrb_value other, receiver, orig_proc, other_proc;
  struct RClass *owner, *klass;
  struct RProc *orig_rproc, *other_rproc;

  mrb_get_args(mrb, "o", &other);
  if (!mrb_obj_is_instance_of(mrb, other, mrb_class(mrb, self)))
    return mrb_false_value();

  if (mrb_class(mrb, self) != mrb_class(mrb, other))
    return mrb_false_value();

  klass = mrb_class_ptr(IV_GET(self, "@klass"));
  if (klass != mrb_class_ptr(IV_GET(other, "@klass")))
    return mrb_false_value();

  owner = mrb_class_ptr(IV_GET(self, "@owner"));
  if (owner != mrb_class_ptr(IV_GET(other, "@owner")))
    return mrb_false_value();

  receiver = IV_GET(self, "@recv");
  if (!mrb_obj_equal(mrb, receiver, IV_GET(other, "@recv")))
    return mrb_false_value();

  orig_proc = IV_GET(self, "proc");
  other_proc = IV_GET(other, "proc");
  if (mrb_nil_p(orig_proc) && mrb_nil_p(other_proc)) {
    if (mrb_symbol(IV_GET(self, "@name")) == mrb_symbol(IV_GET(other, "@name")))
      return mrb_true_value();
    else
      return mrb_false_value();
  }

  if (mrb_nil_p(orig_proc))
    return mrb_false_value();
  if (mrb_nil_p(other_proc))
    return mrb_false_value();

  orig_rproc = mrb_proc_ptr(orig_proc);
  other_rproc = mrb_proc_ptr(other_proc);
  if (MRB_PROC_CFUNC_P(orig_rproc)) {
    if (!MRB_PROC_CFUNC_P(other_rproc))
      return mrb_false_value();
    if (orig_rproc->body.func != other_rproc->body.func)
      return mrb_false_value();
  }
  else {
    if (MRB_PROC_CFUNC_P(other_rproc))
      return mrb_false_value();
    if (orig_rproc->body.irep != other_rproc->body.irep)
      return mrb_false_value();
  }

  return mrb_true_value();
}
示例#5
0
文件: class.c 项目: AndreOF/ArangoDB
mrb_value
mrb_mod_alias(mrb_state *mrb, mrb_value mod)
{
  struct RClass *c = mrb_class_ptr(mod);
  mrb_value new_value, old_value;

  mrb_get_args(mrb, "oo", &new_value, &old_value);
  mrb_alias_method(mrb, c, mrb_symbol(new_value), mrb_symbol(old_value));
  return mrb_nil_value();
}
示例#6
0
文件: symbol.c 项目: iij/mruby
/*
 * call-seq:
 *   sym.length    -> integer
 *
 * Same as <code>sym.to_s.length</code>.
 */
static mrb_value
mrb_sym_length(mrb_state *mrb, mrb_value self)
{
  mrb_int len;
#ifdef MRB_UTF8_STRING
  mrb_int byte_len;
  const char *name = mrb_sym2name_len(mrb, mrb_symbol(self), &byte_len);
  len = mrb_utf8_len(name, byte_len);
#else
  mrb_sym2name_len(mrb, mrb_symbol(self), &len);
#endif
  return mrb_fixnum_value(len);
}
示例#7
0
static mrb_value
mrb_thread_init(mrb_state* mrb, mrb_value self) {
  mrb_value proc = mrb_nil_value();
  mrb_int argc;
  mrb_value* argv;
  mrb_get_args(mrb, "&*", &proc, &argv, &argc);
  if (!mrb_nil_p(proc) && MRB_PROC_CFUNC_P(mrb_proc_ptr(proc))) {
    mrb_raise(mrb, E_RUNTIME_ERROR, "forking C defined block");
  }
  if (!mrb_nil_p(proc)) {
    int i, l;
    mrb_thread_context* context = (mrb_thread_context*) malloc(sizeof(mrb_thread_context));
    context->mrb_caller = mrb;
    context->mrb = mrb_open_allocf(mrb->allocf, mrb->allocf_ud);
    migrate_all_symbols(mrb, context->mrb);
    context->proc = mrb_proc_new(mrb, mrb_proc_ptr(proc)->body.irep);
    context->proc->target_class = context->mrb->object_class;
    context->argc = argc;
    context->argv = calloc(sizeof (mrb_value), context->argc);
    context->result = mrb_nil_value();
    context->alive = TRUE;
    for (i = 0; i < context->argc; i++) {
      context->argv[i] = migrate_simple_value(mrb, argv[i], context->mrb);
    }

    {
      mrb_value gv = mrb_funcall(mrb, self, "global_variables", 0, NULL);
      l = RARRAY_LEN(gv);
      for (i = 0; i < l; i++) {
        mrb_int len;
        int ai = mrb_gc_arena_save(mrb);
        mrb_value k = mrb_ary_entry(gv, i);
        mrb_value o = mrb_gv_get(mrb, mrb_symbol(k));
        if (is_safe_migratable_simple_value(mrb, o, context->mrb)) {
          const char *p = mrb_sym2name_len(mrb, mrb_symbol(k), &len);
          mrb_gv_set(context->mrb,
            mrb_intern_static(context->mrb, p, len),
            migrate_simple_value(mrb, o, context->mrb));
        }
        mrb_gc_arena_restore(mrb, ai);
      }
    }

    mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "context"), mrb_obj_value(
      Data_Wrap_Struct(mrb, mrb->object_class,
      &mrb_thread_context_type, (void*) context)));

    pthread_create(&context->thread, NULL, &mrb_thread_func, (void*) context);
  }
  return self;
}
bool rubyval_to_ccvaluemapintkey(mrb_state* mrb, mrb_value arg, cocos2d::ValueMapIntKey* ret, const char* funcName)
{
    if (! mrb_hash_p(arg)) {
        return false;
    }
    
    mrb_value key_arr = mrb_hash_keys(mrb, arg);
    mrb_int len = mrb_ary_len(mrb, key_arr);
    ValueMapIntKey& dict = *ret;
    for (mrb_int i = 0; i < len; i++) {
        mrb_value hk = mrb_ary_ref(mrb, key_arr, i);
        mrb_value hv = mrb_hash_get(mrb, arg, hk);
        int int_key = 0;
        
        if (mrb_string_p(hk)) {
            char *kstr = mrb_str_to_cstr(mrb, hk);
            int_key = atoi(kstr);
        } else if (mrb_symbol_p(hk)) {
            mrb_sym sym = mrb_symbol(hk);
            const char* kstr = mrb_sym2name(mrb, sym);
            int_key = atoi(kstr);
        } else {
            return false;
        }
        Value val;
        if (! rubyval_to_ccvalue(mrb, hv, &val)) {
            return false;
        }
        
        dict[int_key] = val;
    }
    return true;
}
bool rubyval_to_dictionary(mrb_state* mrb, mrb_value arg, __Dictionary** outValue, const char* funcName)
{
    if (! mrb_hash_p(arg)) {
        return false;
    }
    
    mrb_value key_arr = mrb_hash_keys(mrb, arg);
    mrb_int len = mrb_ary_len(mrb, key_arr);
    __Dictionary* dic = __Dictionary::create();
    for (mrb_int i = 0; i < len; i++) {
        mrb_value hk = mrb_ary_ref(mrb, key_arr, i);
        mrb_value hv = mrb_hash_get(mrb, arg, hk);
        if (mrb_string_p(hk)) {
            char *kstr = mrb_str_to_cstr(mrb, hk);
            Ref* ref = to_ref_value(mrb, hv);
            dic->setObject(ref, std::string(kstr));
        } else if (mrb_symbol_p(hk)) {
            mrb_sym sym = mrb_symbol(hk);
            const char* kstr = mrb_sym2name(mrb, sym);
            Ref* ref = to_ref_value(mrb, hv);
            dic->setObject(ref, std::string(kstr));
        } else {
            CCASSERT(false, "not supported key value type");
        }
    }
    *outValue = dic;
    
    return true;
}
示例#10
0
文件: symbol.c 项目: ASnow/mruby
/*
 * call-seq:
 *   sym.length    -> integer
 *
 * Same as <code>sym.to_s.length</code>.
 */
static mrb_value
mrb_sym_length(mrb_state *mrb, mrb_value self)
{
  mrb_int len;
  mrb_sym2name_len(mrb, mrb_symbol(self), &len);
  return mrb_fixnum_value(len);
}
示例#11
0
static mrb_value ngx_mrb_var_method_missing(mrb_state *mrb, mrb_value self)
{
  mrb_value name, *a;
  int alen, c_len;
  mrb_value s_name;
  char *c_name;
  ngx_http_request_t *r;

  r = ngx_mrb_get_request();

  // get var symble from method_missing(sym, *args)
  mrb_get_args(mrb, "n*", &name, &a, &alen);

  // name is a symble obj
  // first init name with mrb_symbol
  // second get mrb_string with mrb_sym2str
  s_name = mrb_sym2str(mrb, mrb_symbol(name));
  c_name = mrb_str_to_cstr(mrb, s_name);
  c_len = RSTRING_LEN(s_name);

  if (c_name[c_len-1] == '=') {
    return ngx_mrb_var_set(mrb, self, strtok(c_name, "="), a[0], r);
  }
  else {
    return ngx_mrb_var_get(mrb, self, c_name, c_len, r);
  }
}
示例#12
0
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);
}
示例#13
0
文件: struct.c 项目: nyanp/mruby
/*
 *  call-seq:
 *     struct[symbol]    -> anObject
 *     struct[fixnum]    -> anObject
 *
 *  Attribute Reference---Returns the value of the instance variable
 *  named by <i>symbol</i>, or indexed (0..length-1) by
 *  <i>fixnum</i>. Will raise <code>NameError</code> if the named
 *  variable does not exist, or <code>IndexError</code> if the index is
 *  out of range.
 *
 *     Customer = Struct.new(:name, :address, :zip)
 *     joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
 *
 *     joe["name"]   #=> "Joe Smith"
 *     joe[:name]    #=> "Joe Smith"
 *     joe[0]        #=> "Joe Smith"
 */
mrb_value
mrb_struct_aref_n(mrb_state *mrb, mrb_value s, mrb_value idx)
{
  mrb_int i;

  if (mrb_string_p(idx)) {
    mrb_value sym = mrb_check_intern_str(mrb, idx);

    if (mrb_nil_p(sym)) {
      mrb_raisef(mrb, E_INDEX_ERROR, "no member '%S' in struct", idx);
    }
    idx = sym;
  }
  if (mrb_symbol_p(idx)) {
    return mrb_struct_aref_id(mrb, s, mrb_symbol(idx));
  }

  i = mrb_fixnum(idx);
  if (i < 0) i = RSTRUCT_LEN(s) + i;
  if (i < 0)
      mrb_raisef(mrb, E_INDEX_ERROR,
                 "offset %S too small for struct(size:%S)",
                 mrb_fixnum_value(i), mrb_fixnum_value(RSTRUCT_LEN(s)));
  if (RSTRUCT_LEN(s) <= i)
    mrb_raisef(mrb, E_INDEX_ERROR,
               "offset %S too large for struct(size:%S)",
               mrb_fixnum_value(i), mrb_fixnum_value(RSTRUCT_LEN(s)));
  return RSTRUCT_PTR(s)[i];
}
示例#14
0
文件: marshal.cpp 项目: cjv123/RPG
static mrb_value
read_object(MarshalContext *ctx)
{
	mrb_state *mrb = ctx->mrb;
	mrb_value class_path = read_value(ctx);

	struct RClass *klass =
		mrb_class_from_path(mrb, class_path);

	mrb_value obj = mrb_obj_value(mrb_obj_alloc(mrb, MRB_TT_OBJECT, klass));

	ctx->objects.add(obj);

	int iv_count = read_fixnum(ctx);
	int i;

	for (i = 0; i < iv_count; ++i)
	{
		mrb_value iv_name = read_value(ctx);
		mrb_value iv_value = read_value(ctx);

		mrb_obj_iv_set(mrb, mrb_obj_ptr(obj),
		               mrb_symbol(iv_name), iv_value);
	}

	return obj;
}
示例#15
0
static mrb_value
mrb_struct_aset_sym(mrb_state *mrb, mrb_value s, mrb_sym id, mrb_value val)
{
  mrb_value members, *ptr;
  const mrb_value *ptr_members;
  mrb_int i, len;

  members = struct_members(mrb, s);
  len = RARRAY_LEN(members);
  if (RSTRUCT_LEN(s) != len) {
    mrb_raisef(mrb, E_TYPE_ERROR,
               "struct size differs (%S required %S given)",
               mrb_fixnum_value(len), mrb_fixnum_value(RSTRUCT_LEN(s)));
  }
  ptr = RSTRUCT_PTR(s);
  ptr_members = RARRAY_PTR(members);
  for (i=0; i<len; i++) {
    if (mrb_symbol(ptr_members[i]) == id) {
      ptr[i] = val;
      return val;
    }
  }
  mrb_name_error(mrb, id, "no member '%S' in struct", mrb_sym2str(mrb, id));
  return val;                   /* not reach */
}
示例#16
0
文件: struct.c 项目: nyanp/mruby
static mrb_value
mrb_struct_set(mrb_state *mrb, mrb_value obj, mrb_value val)
{
  const char *name;
  size_t i, len;
  mrb_int slen;
  mrb_sym mid;
  mrb_value members, slot, *ptr, *ptr_members;

  /* get base id */
  name = mrb_sym2name_len(mrb, mrb->c->ci->mid, &slen);
  mid = mrb_intern(mrb, name, slen-1); /* omit last "=" */

  members = mrb_struct_members(mrb, obj);
  ptr_members = RARRAY_PTR(members);
  len = RARRAY_LEN(members);
  ptr = RSTRUCT_PTR(obj);
  for (i=0; i<len; i++) {
    slot = ptr_members[i];
    if (mrb_symbol(slot) == mid) {
      return ptr[i] = val;
    }
  }
  mrb_raisef(mrb, E_INDEX_ERROR, "`%S' is not a struct member", mrb_sym2str(mrb, mid));
  return mrb_nil_value();       /* not reached */
}
示例#17
0
static mrb_value
mrb_struct_aset(mrb_state *mrb, mrb_value s)
{
  mrb_int i;
  mrb_value idx;
  mrb_value val;

  mrb_get_args(mrb, "oo", &idx, &val);

  if (mrb_string_p(idx)) {
    mrb_value sym = mrb_check_intern_str(mrb, idx);

    if (mrb_nil_p(sym)) {
      mrb_name_error(mrb, mrb_intern_str(mrb, idx), "no member '%S' in struct", idx);
    }
    idx = sym;
  }
  if (mrb_symbol_p(idx)) {
    return mrb_struct_aset_sym(mrb, s, mrb_symbol(idx), val);
  }

  i = mrb_int(mrb, idx);
  if (i < 0) i = RSTRUCT_LEN(s) + i;
  if (i < 0) {
    mrb_raisef(mrb, E_INDEX_ERROR,
               "offset %S too small for struct(size:%S)",
               mrb_fixnum_value(i), mrb_fixnum_value(RSTRUCT_LEN(s)));
  }
  if (RSTRUCT_LEN(s) <= i) {
    mrb_raisef(mrb, E_INDEX_ERROR,
               "offset %S too large for struct(size:%S)",
               mrb_fixnum_value(i), mrb_fixnum_value(RSTRUCT_LEN(s)));
  }
  return RSTRUCT_PTR(s)[i] = val;
}
示例#18
0
/*
 *  call-seq:
 *     obj.method_missing(symbol [, *args] )   -> result
 *
 *  Invoked by Ruby when <i>obj</i> is sent a message it cannot handle.
 *  <i>symbol</i> is the symbol for the method called, and <i>args</i>
 *  are any arguments that were passed to it. By default, the interpreter
 *  raises an error when this method is called. However, it is possible
 *  to override the method to provide more dynamic behavior.
 *  If it is decided that a particular method should not be handled, then
 *  <i>super</i> should be called, so that ancestors can pick up the
 *  missing method.
 *  The example below creates
 *  a class <code>Roman</code>, which responds to methods with names
 *  consisting of roman numerals, returning the corresponding integer
 *  values.
 *
 *     class Roman
 *       def romanToInt(str)
 *         # ...
 *       end
 *       def method_missing(methId)
 *         str = methId.id2name
 *         romanToInt(str)
 *       end
 *     end
 *
 *     r = Roman.new
 *     r.iv      #=> 4
 *     r.xxiii   #=> 23
 *     r.mm      #=> 2000
 */
static mrb_value
mrb_bob_missing(mrb_state *mrb, mrb_value mod)
{
  mrb_value name, *a;
  int alen;
  mrb_value inspect;

  mrb_get_args(mrb, "o*", &name, &a, &alen);
  if (!mrb_symbol_p(name)) {
    mrb_raise(mrb, E_TYPE_ERROR, "name should be a symbol");
  }

  if (mrb_respond_to(mrb,mod,mrb_intern2(mrb,"inspect",7))){
    inspect = mrb_funcall(mrb, mod, "inspect", 0);
    if (RSTRING_LEN(inspect) > 64) {
      inspect = mrb_any_to_s(mrb, mod);
    }
  }
  else {
    inspect = mrb_any_to_s(mrb, mod);
  }

  mrb_raisef(mrb, E_NOMETHOD_ERROR, "undefined method '%S' for %S",
             mrb_sym2str(mrb, mrb_symbol(name)), inspect);
  /* not reached */
  return mrb_nil_value();
}
示例#19
0
static int
trap_signm(mrb_state *mrb, mrb_value vsig)
{
  int sig = -1;
  const char *s;

  switch (mrb_type(vsig)) {
    case MRB_TT_FIXNUM:
      sig = mrb_fixnum(vsig);
      if (sig < 0 || sig >= NSIG) {
        mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid signal number (%S)", vsig);
      }
      break;
    case MRB_TT_SYMBOL:
      s = mrb_sym2name(mrb, mrb_symbol(vsig));
      if (!s) mrb_raise(mrb, E_ARGUMENT_ERROR, "bad signal");
      goto str_signal;
    default:
      vsig = mrb_string_type(mrb, vsig);
      s = RSTRING_PTR(vsig);

str_signal:
      if (memcmp("SIG", s, 3) == 0)
        s += 3;
      sig = signm2signo(s);
      if (sig == 0 && strcmp(s, "EXIT") != 0)
        mrb_raise(mrb, E_ARGUMENT_ERROR, "unsupported signal");
      break;
  }
  return sig;
}
示例#20
0
/*
 *  call-seq:
 *     obj.respond_to?(symbol, include_private=false) -> true or false
 *
 *  Returns +true+ if _obj_ responds to the given
 *  method. Private methods are included in the search only if the
 *  optional second parameter evaluates to +true+.
 *
 *  If the method is not implemented,
 *  as Process.fork on Windows, File.lchmod on GNU/Linux, etc.,
 *  false is returned.
 *
 *  If the method is not defined, <code>respond_to_missing?</code>
 *  method is called and the result is returned.
 */
mrb_value
obj_respond_to(mrb_state *mrb, mrb_value self)
{
  mrb_value *argv;
  int argc;
  mrb_value mid, priv;
  mrb_sym id, rtm_id;
  mrb_bool respond_to_p = TRUE;

  mrb_get_args(mrb, "*", &argv, &argc);
  mid = argv[0];
  if (argc > 1) priv = argv[1];
  else priv = mrb_nil_value();

  if (mrb_symbol_p(mid)) {
    id = mrb_symbol(mid);
  }
  else {
    mrb_value tmp;
    if (!mrb_string_p(mid)) {
      tmp = mrb_check_string_type(mrb, mid);
      if (mrb_nil_p(tmp)) {
        tmp = mrb_inspect(mrb, mid);
        mrb_raisef(mrb, E_TYPE_ERROR, "%S is not a symbol", tmp);
      }
    }
    tmp = mrb_check_intern_str(mrb, mid);
    if (mrb_nil_p(tmp)) {
      respond_to_p = FALSE;
    }
    else {
      id = mrb_symbol(tmp);
    }
  }

  if (respond_to_p) {
    respond_to_p = basic_obj_respond_to(mrb, self, id, !mrb_test(priv));
  }

  if (!respond_to_p) {
    rtm_id = mrb_intern2(mrb, "respond_to_missing?", 19);
    if (basic_obj_respond_to(mrb, self, rtm_id, !mrb_test(priv))) {
      return mrb_funcall_argv(mrb, self, rtm_id, argc, argv);
    }
  }
  return mrb_bool_value(respond_to_p);
}
示例#21
0
int
mrb_class_defined(mrb_state *mrb, const char *name)
{
  mrb_value sym = mrb_check_intern_cstr(mrb, name);
  if (mrb_nil_p(sym)) {
    return FALSE;
  }
  return mrb_const_defined(mrb, mrb_obj_value(mrb->object_class), mrb_symbol(sym));
}
Ref* to_ref_value(mrb_state* mrb, mrb_value val)
{
    switch (val.tt) {
        case mrb_vtype::MRB_TT_FIXNUM:
        {
            mrb_int v = mrb_fixnum(val);
            return Integer::create((int)v);
        }
        case mrb_vtype::MRB_TT_FLOAT:
        {
            mrb_float v = mrb_float(val);
            return Double::create((double)v);
        }
        case mrb_vtype::MRB_TT_FALSE:
        case mrb_vtype::MRB_TT_TRUE:
        {
            return Bool::create(mrb_bool(val));
        }
        case mrb_vtype::MRB_TT_STRING:
        {
            char* str = mrb_str_to_cstr(mrb, val);
            return String::createWithFormat("%s", str);
        }
        case mrb_vtype::MRB_TT_SYMBOL:
        {
            mrb_sym sym = mrb_symbol(val);
            const char* str = mrb_sym2name(mrb, sym);
            return String::createWithFormat("%s", str);
        }
        case mrb_vtype::MRB_TT_RANGE:
        {
            // TODO: range
            /*
             mrb_int beg;
             mrb_int len;
             mrb_range_beg_len(mrb, val, &beg, &len, 0);
             */
            break;
        }
        case mrb_vtype::MRB_TT_OBJECT:
        {
            // TODO: ruby object
            break;
        }
        case mrb_vtype::MRB_TT_DATA:
        {
            Ref* ref =static_cast<Ref*>(mrb_get_datatype(mrb, val, &ruby_cocos2dx_Ref_type));
            return ref;
        }
        case mrb_vtype::MRB_TT_UNDEF:
            break;
        default:
            CCASSERT(false, "not supported type");
    }
    return nullptr;
}
示例#23
0
文件: symbol.c 项目: retrage/mruby
/*
 *  call-seq:
 *     sym.id2name   -> string
 *     sym.to_s      -> string
 *
 *  Returns the name or string corresponding to <i>sym</i>.
 *
 *     :fred.id2name   #=> "fred"
 */
static mrb_value
mrb_sym_to_s(mrb_state *mrb, mrb_value sym)
{
  mrb_sym id = mrb_symbol(sym);
  const char *p;
  mrb_int len;

  p = mrb_sym2name_len(mrb, id, &len);
  return mrb_str_new_static(mrb, p, len);
}
示例#24
0
static mrb_value
mrb_mod_method_defined(mrb_state *mrb, mrb_value mod)
{
  mrb_value id;
  mrb_bool method_defined_p;

  id = get_sym_or_str_arg(mrb);
  if (mrb_symbol_p(id)) {
    method_defined_p = mrb_obj_respond_to(mrb_class_ptr(mod), mrb_symbol(id));
  } else {
    mrb_value sym = mrb_check_intern_str(mrb, id);
    if (mrb_nil_p(sym)) {
      method_defined_p = FALSE;
    }
    else {
      method_defined_p = mrb_obj_respond_to(mrb_class_ptr(mod), mrb_symbol(sym));
    }
  }
  return mrb_bool_value(method_defined_p);
}
示例#25
0
文件: object.c 项目: 14923523/mruby
MRB_API mrb_bool
mrb_obj_eq(mrb_state *mrb, mrb_value v1, mrb_value v2)
{
  if (mrb_type(v1) != mrb_type(v2)) return FALSE;
  switch (mrb_type(v1)) {
  case MRB_TT_TRUE:
    return TRUE;

  case MRB_TT_FALSE:
  case MRB_TT_FIXNUM:
    return (mrb_fixnum(v1) == mrb_fixnum(v2));
  case MRB_TT_SYMBOL:
    return (mrb_symbol(v1) == mrb_symbol(v2));

  case MRB_TT_FLOAT:
    return (mrb_float(v1) == mrb_float(v2));

  default:
    return (mrb_ptr(v1) == mrb_ptr(v2));
  }
}
static int32_t
compare_break_method( mrb_state *mrb, mrb_debug_breakpoint *bp, struct RClass *class_obj, mrb_sym method_sym, mrb_bool* isCfunc )
{
  const char* class_name;
  const char* method_name;
  struct RProc* m;
  struct RClass* sc;
  const char* sn;
  mrb_sym ssym;
  mrb_debug_methodpoint *method_p;
  mrb_bool is_defined;

  method_name = mrb_sym2name(mrb, method_sym);

  method_p = &bp->point.methodpoint;
  if(strcmp(method_p->method_name, method_name) == 0) {
    class_name = get_class_name(mrb, class_obj);
    if(class_name == NULL) {
      if(method_p->class_name == NULL) {
        return bp->bpno;
      }
    }
    else if(method_p->class_name != NULL) {
      m = mrb_method_search_vm(mrb, &class_obj, method_sym);
      if(m == NULL) {
        return MRB_DEBUG_OK;
      }
      if(MRB_PROC_CFUNC_P(m)) {
        *isCfunc = TRUE;
      }

      is_defined = mrb_class_defined(mrb, method_p->class_name);
      if(is_defined == FALSE) {
        return MRB_DEBUG_OK;
      }

      sc = mrb_class_get(mrb, method_p->class_name);
      ssym = mrb_symbol(mrb_check_intern_cstr(mrb, method_p->method_name));
      m = mrb_method_search_vm(mrb, &sc, ssym);
      if(m == NULL) {
        return MRB_DEBUG_OK;
      }

      class_name = get_class_name(mrb, class_obj);
      sn = get_class_name(mrb, sc);
      if(strcmp(sn, class_name) == 0) {
        return bp->bpno;
      }
    }
  }
  return MRB_DEBUG_OK;
}
示例#27
0
static sighandler_t
trap_handler(mrb_state *mrb, mrb_value *cmd, int sig)
{
  sighandler_t func = sighandler;
  mrb_value command;

  if (mrb_nil_p(*cmd)) {
    func = SIG_IGN;
  }
  else {
    command = *cmd;
    if (mrb_type(command) == MRB_TT_SYMBOL) {
      command = mrb_sym2str(mrb, mrb_symbol(command));
      if (mrb_undef_p(command))
        mrb_raise(mrb, E_ARGUMENT_ERROR, "bad handler");
    }
    if (mrb_string_p(command)) {
      *cmd = command;
      switch (RSTRING_LEN(command)) {
        case 0:
          goto sig_ign;
          break;
        case 6:
          if (memcmp(RSTRING_PTR(command), "IGNORE", 6) == 0) {
            goto sig_ign;
          }
          break;
        case 7:
          if (memcmp(RSTRING_PTR(command), "SIG_IGN", 7) == 0) {
sig_ign:
            func = SIG_IGN;
            *cmd = mrb_true_value();
          }
          else if (memcmp(RSTRING_PTR(command), "SIG_DFL", 7) == 0) {
sig_dfl:
            func = default_handler(sig);
            *cmd = mrb_true_value();
          }
          else if (memcmp(RSTRING_PTR(command), "DEFAULT", 7) == 0) {
            goto sig_dfl;
          }
          break;
        case 4:
          if (memcmp(RSTRING_PTR(command), "EXIT", 4) == 0) {
            *cmd = mrb_undef_value();
          }
          break;
      }
    }
  }
  return func;
}
示例#28
0
static mrb_sym
mrb_sym_value(mrb_state *mrb, mrb_value val)
{
  if(val.tt == MRB_TT_STRING) {
    return mrb_intern(mrb, RSTRING_PTR(val));
  }
  else if(val.tt != MRB_TT_SYMBOL) {
    mrb_value obj = mrb_funcall(mrb, val, "inspect", 0);
    mrb_raise(mrb, E_TYPE_ERROR, "%s is not a symbol",
         mrb_string_value_ptr(mrb, obj));
  }
  return mrb_symbol(val);
}
示例#29
0
文件: class.c 项目: AndreOF/ArangoDB
static mrb_sym
mrb_sym_value(mrb_state *mrb, mrb_value val)
{
  if (mrb_string_p(val)) {
    return mrb_intern_str(mrb, val);
  }
  else if(!mrb_symbol_p(val)) {
    mrb_value obj = mrb_funcall(mrb, val, "inspect", 0);
    mrb_raisef(mrb, E_TYPE_ERROR, "%s is not a symbol",
         mrb_string_value_ptr(mrb, obj));
  }
  return mrb_symbol(val);
}
示例#30
0
mrb_value
mrb_mod_remove_method(mrb_state *mrb, mrb_value mod)
{
  int argc;
  mrb_value *argv;

  mrb_get_args(mrb, "*", &argv, &argc);
  while (argc--) {
    remove_method(mrb, mod, mrb_symbol(*argv));
    argv++;
  }
  return mod;
}