static void
rb_set_intersect_callback(const void *value, void *context)
{
CFMutableSetRef *sets = (CFMutableSetRef *)context;
if (CFSetContainsValue(sets[0], RB2OC(value)))
CFSetAddValue(sets[1], RB2OC(value));
}
static void
rb_set_subtract_callback(const void *value, void *context)
{
CFMutableSetRef *sets = context;
if (CFSetContainsValue(sets[0], RB2OC(value)))
CFSetRemoveValue(sets[1], RB2OC(value));
}
static void
rb_set_union_callback(const void *value, void *context)
{
CFMutableSetRef set = context;
if (!CFSetContainsValue(set, RB2OC(value)))
CFSetAddValue(set, RB2OC(value));
}
static VALUE
merge_i(VALUE val, VALUE *args)
{
VALUE set = (VALUE)args;
if (!CFSetContainsValue((CFMutableSetRef)set, (const void *)RB2OC(val))) {
CFSetAddValue((CFMutableSetRef)set, (const void *)RB2OC(val));
}
return Qnil;
}
static VALUE
rb_set_delete2(VALUE set, SEL sel, VALUE obj)
{
rb_set_modify_check(set);
if (CFSetContainsValue((CFMutableSetRef)set, (const void *)RB2OC(obj))) {
CFSetRemoveValue((CFMutableSetRef)set, (const void *)RB2OC(obj));
return set;
} else
return Qnil;
}
static VALUE
rb_set_add2(VALUE set, SEL sel, VALUE obj)
{
rb_set_modify_check(set);
if (CFSetContainsValue((CFMutableSetRef)set, (const void *)RB2OC(obj))) {
return Qnil;
}
CFSetAddValue((CFMutableSetRef)set, (const void *)RB2OC(obj));
return set;
}
static VALUE
rb_set_delete(VALUE set, SEL sel, VALUE obj)
{
rb_set_modify_check(set);
CFSetRemoveValue((CFMutableSetRef)set, (const void *)RB2OC(obj));
return set;
}
static void *
imp_rhash_objectForKey(void *rcv, SEL sel, void *key)
{
VALUE val;
if (!st_lookup(RHASH(rcv)->tbl, OC2RB(key), &val)) {
return NULL;
}
return RB2OC(val);
}
static VALUE
rb_set_add(VALUE set, VALUE obj)
{
rb_set_modify_check(set);
CFSetAddValue((CFMutableSetRef)set, (const void *)RB2OC(obj));
return set;
}
static void *
imp_rhash_keyenum_nextObject(void *rcv, SEL sel)
{
rb_hash_keyenum_t *ke = (rb_hash_keyenum_t *)rcv;
if (ke->pos == RARRAY_LEN(ke->keys)) {
return NULL;
}
VALUE key = RARRAY_AT(ke->keys, ke->pos);
ke->pos++;
return (void *)RB2OC(key);
}
static VALUE
rb_set_s_create(int argc, VALUE *argv, VALUE klass)
{
int i;
VALUE set = set_alloc(klass);
for (i = 0; i < argc; i++)
CFSetAddValue((CFMutableSetRef)set, RB2OC(argv[i]));
return set;
}
PRIMITIVE void
vm_rval_to_ocval(VALUE rval, void **ocval)
{
*ocval = rval == Qnil ? NULL : RB2OC(rval);
}
VALUE
rb_vm_dispatch(void *_vm, struct mcache *cache, VALUE top, VALUE self,
Class klass, SEL sel, rb_vm_block_t *block, unsigned char opt,
int argc, const VALUE *argv)
{
RoxorVM *vm = (RoxorVM *)_vm;
#if ROXOR_VM_DEBUG
bool cached = true;
#endif
bool cache_method = true;
Class current_super_class = vm->get_current_super_class();
SEL current_super_sel = vm->get_current_super_sel();
if (opt & DISPATCH_SUPER) {
// TODO
goto recache;
}
if (cache->sel != sel || cache->klass != klass || cache->flag == 0) {
recache:
#if ROXOR_VM_DEBUG
cached = false;
#endif
Method method;
if (opt & DISPATCH_SUPER) {
if (!sel_equal(klass, current_super_sel, sel)) {
current_super_sel = sel;
current_super_class = klass;
}
else {
// Let's make sure the current_super_class is valid before
// using it; we check this by verifying that it's a real
// super class of the current class, as we may be calling
// a super method of the same name but on a totally different
// class hierarchy.
Class k = klass;
bool current_super_class_ok = false;
while (k != NULL) {
if (k == current_super_class) {
current_super_class_ok = true;
break;
}
k = class_getSuperclass(k);
}
if (!current_super_class_ok) {
current_super_class = klass;
}
}
method = rb_vm_super_lookup(current_super_class, sel,
¤t_super_class);
}
else {
current_super_sel = 0;
method = class_getInstanceMethod(klass, sel);
}
if (method != NULL) {
recache2:
IMP imp = method_getImplementation(method);
if (UNAVAILABLE_IMP(imp)) {
// Method was undefined.
goto call_method_missing;
}
rb_vm_method_node_t *node = GET_CORE()->method_node_get(method);
if (node != NULL) {
// ruby call
fill_rcache(cache, klass, sel, node);
}
else {
// objc call
fill_ocache(cache, self, klass, imp, sel, method, argc);
}
if (opt & DISPATCH_SUPER) {
cache->flag |= MCACHE_SUPER;
}
}
else {
// Method is not found...
#if !defined(MACRUBY_STATIC)
// Force a method resolving, because the objc cache might be
// wrong.
if (rb_vm_resolve_method(klass, sel)) {
goto recache;
}
#endif
// Does the receiver implements -forwardInvocation:?
if ((opt & DISPATCH_SUPER) == 0
&& rb_objc_supports_forwarding(self, sel)) {
//#if MAC_OS_X_VERSION_MAX_ALLOWED < 1070
// In earlier versions of the Objective-C runtime, there seems
// to be a bug where class_getInstanceMethod isn't atomic,
// and might return NULL while at the exact same time another
// thread registers the related method.
// As a work-around, we double-check if the method still does
// not exist here. If he does, we can dispatch it properly.
// note: OS X 10.7 also, this workaround is required. see #1476
method = class_getInstanceMethod(klass, sel);
if (method != NULL) {
goto recache2;
}
//#endif
fill_ocache(cache, self, klass, (IMP)objc_msgSend, sel, NULL,
argc);
goto dispatch;
}
// Let's see if are not trying to call a Ruby method that accepts
// a regular argument then an optional Hash argument, to be
// compatible with the Ruby specification.
const char *selname = (const char *)sel;
size_t selname_len = strlen(selname);
if (argc > 1) {
const char *p = strchr(selname, ':');
if (p != NULL && p + 1 != '\0') {
char *tmp = (char *)malloc(selname_len + 1);
assert(tmp != NULL);
strncpy(tmp, selname, p - selname + 1);
tmp[p - selname + 1] = '\0';
sel = sel_registerName(tmp);
VALUE h = rb_hash_new();
bool ok = true;
p += 1;
for (int i = 1; i < argc; i++) {
const char *p2 = strchr(p, ':');
if (p2 == NULL) {
ok = false;
break;
}
strlcpy(tmp, p, selname_len);
tmp[p2 - p] = '\0';
p = p2 + 1;
rb_hash_aset(h, ID2SYM(rb_intern(tmp)), argv[i]);
}
free(tmp);
tmp = NULL;
if (ok) {
argc = 2;
((VALUE *)argv)[1] = h; // bad, I know...
Method m = class_getInstanceMethod(klass, sel);
if (m != NULL) {
method = m;
cache_method = false;
goto recache2;
}
}
}
}
// Enable helpers for classes which are not RubyObject based.
if ((RCLASS_VERSION(klass) & RCLASS_IS_OBJECT_SUBCLASS)
!= RCLASS_IS_OBJECT_SUBCLASS) {
// Let's try to see if we are not given a helper selector.
SEL new_sel = helper_sel(selname, selname_len);
if (new_sel != NULL) {
Method m = class_getInstanceMethod(klass, new_sel);
if (m != NULL) {
sel = new_sel;
method = m;
// We need to invert arguments because
// #[]= and setObject:forKey: take arguments
// in a reverse order
if (new_sel == selSetObjectForKey && argc == 2) {
VALUE swap = argv[0];
((VALUE *)argv)[0] = argv[1];
((VALUE *)argv)[1] = swap;
cache_method = false;
}
goto recache2;
}
}
}
// Let's see if we are not trying to call a BridgeSupport function.
if (selname[selname_len - 1] == ':') {
selname_len--;
}
std::string name(selname, selname_len);
bs_element_function_t *bs_func = GET_CORE()->find_bs_function(name);
if (bs_func != NULL) {
if ((unsigned)argc < bs_func->args_count
|| ((unsigned)argc > bs_func->args_count
&& bs_func->variadic == false)) {
rb_raise(rb_eArgError, "wrong number of arguments (%d for %d)",
argc, bs_func->args_count);
}
std::string types;
vm_gen_bs_func_types(argc, argv, bs_func, types);
cache->flag = MCACHE_FCALL;
cache->sel = sel;
cache->klass = klass;
cache->as.fcall.bs_function = bs_func;
cache->as.fcall.imp = (IMP)dlsym(RTLD_DEFAULT, bs_func->name);
assert(cache->as.fcall.imp != NULL);
cache->as.fcall.stub = (rb_vm_c_stub_t *)GET_CORE()->gen_stub(
types, bs_func->variadic, bs_func->args_count, false);
}
else {
// Still nothing, then let's call #method_missing.
goto call_method_missing;
}
}
}
dispatch:
if (cache->flag & MCACHE_RCALL) {
if (!cache_method) {
cache->flag = 0;
}
#if ROXOR_VM_DEBUG
printf("ruby dispatch %c[<%s %p> %s] (imp %p block %p argc %d opt %d cache %p cached %s)\n",
class_isMetaClass(klass) ? '+' : '-',
class_getName(klass),
(void *)self,
sel_getName(sel),
cache->as.rcall.node->ruby_imp,
block,
argc,
opt,
cache,
cached ? "true" : "false");
#endif
bool block_already_current = vm->is_block_current(block);
Class current_klass = vm->get_current_class();
if (!block_already_current) {
vm->add_current_block(block);
}
vm->set_current_class(NULL);
Class old_current_super_class = vm->get_current_super_class();
vm->set_current_super_class(current_super_class);
SEL old_current_super_sel = vm->get_current_super_sel();
vm->set_current_super_sel(current_super_sel);
const bool should_pop_broken_with =
sel != selInitialize && sel != selInitialize2;
struct Finally {
bool block_already_current;
Class current_class;
Class current_super_class;
SEL current_super_sel;
bool should_pop_broken_with;
RoxorVM *vm;
Finally(bool _block_already_current, Class _current_class,
Class _current_super_class, SEL _current_super_sel,
bool _should_pop_broken_with, RoxorVM *_vm) {
block_already_current = _block_already_current;
current_class = _current_class;
current_super_class = _current_super_class;
current_super_sel = _current_super_sel;
should_pop_broken_with = _should_pop_broken_with;
vm = _vm;
}
~Finally() {
if (!block_already_current) {
vm->pop_current_block();
}
vm->set_current_class(current_class);
if (should_pop_broken_with) {
vm->pop_broken_with();
}
vm->set_current_super_class(current_super_class);
vm->set_current_super_sel(current_super_sel);
vm->pop_current_binding();
}
} finalizer(block_already_current, current_klass,
old_current_super_class, old_current_super_sel,
should_pop_broken_with, vm);
// DTrace probe: method__entry
if (MACRUBY_METHOD_ENTRY_ENABLED()) {
char *class_name = (char *)rb_class2name((VALUE)klass);
char *method_name = (char *)sel_getName(sel);
char file[PATH_MAX];
unsigned long line = 0;
GET_CORE()->symbolize_backtrace_entry(1, file, sizeof file, &line,
NULL, 0);
MACRUBY_METHOD_ENTRY(class_name, method_name, file, line);
}
VALUE v = ruby_dispatch(top, self, sel, cache->as.rcall.node,
opt, argc, argv);
// DTrace probe: method__return
if (MACRUBY_METHOD_RETURN_ENABLED()) {
char *class_name = (char *)rb_class2name((VALUE)klass);
char *method_name = (char *)sel_getName(sel);
char file[PATH_MAX];
unsigned long line = 0;
GET_CORE()->symbolize_backtrace_entry(1, file, sizeof file, &line,
NULL, 0);
MACRUBY_METHOD_RETURN(class_name, method_name, file, line);
}
return v;
}
else if (cache->flag & MCACHE_OCALL) {
if (cache->as.ocall.argc != argc) {
goto recache;
}
if (!cache_method) {
cache->flag = 0;
}
if (block != NULL) {
rb_warn("passing a block to an Objective-C method - " \
"will be ignored");
}
else if (sel == selNew) {
if (self == rb_cNSMutableArray) {
self = rb_cRubyArray;
}
}
else if (sel == selClass) {
// Because +[NSObject class] returns self.
if (RCLASS_META(klass)) {
return RCLASS_MODULE(self) ? rb_cModule : rb_cClass;
}
// Because the CF classes should be hidden, for Ruby compat.
if (self == Qnil) {
return rb_cNilClass;
}
if (self == Qtrue) {
return rb_cTrueClass;
}
if (self == Qfalse) {
return rb_cFalseClass;
}
return rb_class_real((VALUE)klass, true);
}
#if ROXOR_VM_DEBUG
printf("objc dispatch %c[<%s %p> %s] imp=%p cache=%p argc=%d (cached=%s)\n",
class_isMetaClass(klass) ? '+' : '-',
class_getName(klass),
(void *)self,
sel_getName(sel),
cache->as.ocall.imp,
cache,
argc,
cached ? "true" : "false");
#endif
id ocrcv = RB2OC(self);
if (cache->as.ocall.bs_method != NULL) {
Class ocklass = object_getClass(ocrcv);
for (int i = 0; i < (int)cache->as.ocall.bs_method->args_count;
i++) {
bs_element_arg_t *arg = &cache->as.ocall.bs_method->args[i];
if (arg->sel_of_type != NULL) {
// BridgeSupport tells us that this argument contains a
// selector of the given type, but we don't have any
// information regarding the target. RubyCocoa and the
// other ObjC bridges do not really require it since they
// use the NSObject message forwarding mechanism, but
// MacRuby registers all methods in the runtime.
//
// Therefore, we apply here a naive heuristic by assuming
// that either the receiver or one of the arguments of this
// call is the future target.
const int arg_i = arg->index;
assert(arg_i >= 0 && arg_i < argc);
if (argv[arg_i] != Qnil) {
ID arg_selid = rb_to_id(argv[arg_i]);
SEL arg_sel = sel_registerName(rb_id2name(arg_selid));
if (reinstall_method_maybe(ocklass, arg_sel,
arg->sel_of_type)) {
goto sel_target_found;
}
for (int j = 0; j < argc; j++) {
if (j != arg_i && !SPECIAL_CONST_P(argv[j])) {
if (reinstall_method_maybe(*(Class *)argv[j],
arg_sel, arg->sel_of_type)) {
goto sel_target_found;
}
}
}
}
sel_target_found:
// There can only be one sel_of_type argument.
break;
}
}
}
return __rb_vm_objc_dispatch(cache->as.ocall.stub, cache->as.ocall.imp,
ocrcv, sel, argc, argv);
}
else if (cache->flag & MCACHE_FCALL) {
#if ROXOR_VM_DEBUG
printf("C dispatch %s() imp=%p argc=%d (cached=%s)\n",
cache->as.fcall.bs_function->name,
cache->as.fcall.imp,
argc,
cached ? "true" : "false");
#endif
return (*cache->as.fcall.stub)(cache->as.fcall.imp, argc, argv);
}
printf("method dispatch is b0rked\n");
abort();
call_method_missing:
// Before calling method_missing, let's check if we are not in the following
// cases:
//
// def foo; end; foo(42)
// def foo(x); end; foo
//
// If yes, we need to raise an ArgumentError exception instead.
const char *selname = sel_getName(sel);
const size_t selname_len = strlen(selname);
SEL new_sel = 0;
if (argc > 0 && selname[selname_len - 1] == ':') {
char buf[100];
assert(sizeof buf > selname_len - 1);
strlcpy(buf, selname, sizeof buf);
buf[selname_len - 1] = '\0';
new_sel = sel_registerName(buf);
}
else if (argc == 0) {
char buf[100];
snprintf(buf, sizeof buf, "%s:", selname);
new_sel = sel_registerName(buf);
}
if (new_sel != 0) {
Method m = class_getInstanceMethod(klass, new_sel);
if (m != NULL) {
IMP mimp = method_getImplementation(m);
if (!UNAVAILABLE_IMP(mimp)) {
unsigned expected_argc;
rb_vm_method_node_t *node = GET_CORE()->method_node_get(m);
if (node != NULL) {
expected_argc = node->arity.min;
}
else {
expected_argc = rb_method_getNumberOfArguments(m);
expected_argc -= 2; // removing receiver and selector
}
rb_raise(rb_eArgError, "wrong number of arguments (%d for %d)",
argc, expected_argc);
}
}
}
rb_vm_method_missing_reason_t status;
if (opt & DISPATCH_VCALL) {
status = METHOD_MISSING_VCALL;
}
else if (opt & DISPATCH_SUPER) {
status = METHOD_MISSING_SUPER;
}
else {
status = METHOD_MISSING_DEFAULT;
}
return method_missing((VALUE)self, sel, block, argc, argv, status);
}
static VALUE
rb_set_equal(VALUE set, SEL sel, VALUE other)
{
return CFEqual((CFTypeRef)set, (CFTypeRef)RB2OC(other)) ? Qtrue : Qfalse;
}
static VALUE
rb_set_include(VALUE set, SEL sel, VALUE obj)
{
return CFSetContainsValue((CFMutableSetRef)set, (const void *)RB2OC(obj)) ? Qtrue : Qfalse;
}
/*
* call-seq: configure(opts)
*
* Configure this State instance with the Hash _opts_, and return
* itself.
*/
static inline VALUE cState_configure(VALUE self, VALUE opts)
{
VALUE tmp;
GET_STATE(self);
tmp = rb_convert_type(opts, T_HASH, "Hash", "to_hash");
if (NIL_P(tmp)) tmp = rb_convert_type(opts, T_HASH, "Hash", "to_h");
if (NIL_P(tmp)) {
rb_raise(rb_eArgError, "opts has to be hash like or convertable into a hash");
}
opts = tmp;
tmp = rb_hash_aref(opts, ID2SYM(i_indent));
if (RTEST(tmp)) {
Check_Type(tmp, T_STRING);
state->indent = tmp;
}
tmp = rb_hash_aref(opts, ID2SYM(i_space));
if (RTEST(tmp)) {
Check_Type(tmp, T_STRING);
state->space = tmp;
}
tmp = rb_hash_aref(opts, ID2SYM(i_space_before));
if (RTEST(tmp)) {
Check_Type(tmp, T_STRING);
state->space_before = tmp;
}
tmp = rb_hash_aref(opts, ID2SYM(i_array_nl));
if (RTEST(tmp)) {
Check_Type(tmp, T_STRING);
state->array_nl = tmp;
}
tmp = rb_hash_aref(opts, ID2SYM(i_object_nl));
if (RTEST(tmp)) {
Check_Type(tmp, T_STRING);
state->object_nl = tmp;
}
tmp = ID2SYM(i_check_circular);
#if WITH_OBJC
if (CFDictionaryGetValueIfPresent((CFDictionaryRef)opts, (const void *)RB2OC(tmp), 0)) {
#else
if (st_lookup(RHASH_TBL(opts), tmp, 0)) {
#endif
tmp = rb_hash_aref(opts, ID2SYM(i_check_circular));
state->check_circular = RTEST(tmp);
} else {
state->check_circular = 1;
}
tmp = ID2SYM(i_max_nesting);
state->max_nesting = 19;
#if WITH_OBJC
if (CFDictionaryGetValueIfPresent((CFDictionaryRef)opts, (const void *)RB2OC(tmp), 0)) {
#else
if (st_lookup(RHASH_TBL(opts), tmp, 0)) {
#endif
VALUE max_nesting = rb_hash_aref(opts, tmp);
if (RTEST(max_nesting)) {
Check_Type(max_nesting, T_FIXNUM);
state->max_nesting = FIX2LONG(max_nesting);
} else {
state->max_nesting = 0;
}
}
tmp = rb_hash_aref(opts, ID2SYM(i_allow_nan));
state->allow_nan = RTEST(tmp);
return self;
}
/*
* call-seq: to_h
*
* Returns the configuration instance variables as a hash, that can be
* passed to the configure method.
*/
static VALUE cState_to_h(VALUE self)
{
VALUE result = rb_hash_new();
GET_STATE(self);
rb_hash_aset(result, ID2SYM(i_indent), state->indent);
rb_hash_aset(result, ID2SYM(i_space), state->space);
rb_hash_aset(result, ID2SYM(i_space_before), state->space_before);
rb_hash_aset(result, ID2SYM(i_object_nl), state->object_nl);
rb_hash_aset(result, ID2SYM(i_array_nl), state->array_nl);
rb_hash_aset(result, ID2SYM(i_check_circular), state->check_circular ? Qtrue : Qfalse);
rb_hash_aset(result, ID2SYM(i_allow_nan), state->allow_nan ? Qtrue : Qfalse);
rb_hash_aset(result, ID2SYM(i_max_nesting), LONG2FIX(state->max_nesting));
return result;
}
/*
* call-seq: new(opts = {})
*
* Instantiates a new State object, configured by _opts_.
*
* _opts_ can have the following keys:
*
* * *indent*: a string used to indent levels (default: ''),
* * *space*: a string that is put after, a : or , delimiter (default: ''),
* * *space_before*: a string that is put before a : pair delimiter (default: ''),
* * *object_nl*: a string that is put at the end of a JSON object (default: ''),
* * *array_nl*: a string that is put at the end of a JSON array (default: ''),
* * *check_circular*: true if checking for circular data structures
* should be done, false (the default) otherwise.
* * *allow_nan*: true if NaN, Infinity, and -Infinity should be
* generated, otherwise an exception is thrown, if these values are
* encountered. This options defaults to false.
*/
static VALUE cState_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE opts;
GET_STATE(self);
rb_scan_args(argc, argv, "01", &opts);
state->indent = rb_str_new2("");
state->space = rb_str_new2("");
state->space_before = rb_str_new2("");
state->array_nl = rb_str_new2("");
state->object_nl = rb_str_new2("");
if (NIL_P(opts)) {
state->check_circular = 1;
state->allow_nan = 0;
state->max_nesting = 19;
} else {
cState_configure(self, opts);
}
state->seen = rb_hash_new();
state->memo = Qnil;
state->depth = INT2FIX(0);
return self;
}