VALUE
rb_check_funcall(VALUE recv, ID mid, int argc, const VALUE *argv)
{
    return rb_check_funcall_default(recv, mid, argc, argv, Qundef);
}

VALUE
rb_check_funcall_default(VALUE recv, ID mid, int argc, const VALUE *argv, VALUE def)
{
    VALUE klass = CLASS_OF(recv);
    const rb_callable_method_entry_t *me;
    rb_thread_t *th = GET_THREAD();
    int respond = check_funcall_respond_to(th, klass, recv, mid);

    if (!respond) // if check_funcall_respond_to returns 0, return Qundef
    return def;

    me = rb_search_method_entry(recv, mid);
    if (!check_funcall_callable(th, me)) {
    return check_funcall_missing(th, klass, recv, mid, argc, argv,
                     respond, def);
    }
    stack_check(th);
    return vm_call0(th, recv, mid, argc, argv, me);
}

static int
check_funcall_respond_to(rb_thread_t *th, VALUE klass, VALUE recv, ID mid)
{
    return vm_respond_to(th, klass, recv, mid, TRUE);
}

static int
vm_respond_to(rb_thread_t *th, VALUE klass, VALUE obj, ID id, int priv)
{
    VALUE defined_class;
    const ID resid = idRespond_to;
// This is looking up respond_to? on the metaclass of the object
    const rb_method_entry_t *const me =
    method_entry_get(klass, resid, &defined_class);

    if (!me) return -1; // if no respond_to?, assume it's OK
    if (METHOD_ENTRY_BASIC(me)) {
// if respond_to? is built-in (maybe we could just check if it is Kernel#respond_to?
// since that is the only built-in respond_to?), return -1 which means "OK keep going"
    return -1;
    }
    else {
// Some arity checking, doesnt seem important for now
    int argc = 1;
    VALUE args[2];
    VALUE result;

    args[0] = ID2SYM(id);
    args[1] = Qtrue;
    if (priv) {
        argc = rb_method_entry_arity(me);
        if (argc > 2) {
        rb_raise(rb_eArgError,
             "respond_to? must accept 1 or 2 arguments (requires %d)",
             argc);
        }
        if (argc != 1) {
        argc = 2;
        }
        else if (!NIL_P(ruby_verbose)) {
        VALUE location = rb_method_entry_location(me);
        rb_warn("%"PRIsVALUE"%c""respond_to?(:%"PRIsVALUE") uses"
            " the deprecated method signature, which takes one parameter",
            (FL_TEST(klass, FL_SINGLETON) ? obj : klass),
            (FL_TEST(klass, FL_SINGLETON) ? '.' : '#'),
            QUOTE_ID(id));
        if (!NIL_P(location)) {
            VALUE path = RARRAY_AREF(location, 0);
            VALUE line = RARRAY_AREF(location, 1);
            if (!NIL_P(path)) {
            rb_compile_warn(RSTRING_PTR(path), NUM2INT(line),
                    "respond_to? is defined here");
            }
        }
        }
    }
// if obj's respond_to? is not Kernel's and is defined, actually call it
// aka !!meth.call(name)
    result = call_method_entry(th, defined_class, obj, resid, me, argc, args);
    return RTEST(result);
    }
}