C++ (Cpp) JLocalEnvの例

コード例 #1

ファイル: numeric.cpp プロジェクト: nahi/jruby

extern "C" long long
rb_num2ll(VALUE v)
{
    if (FIXNUM_P(v)) {
        return FIX2LONG(v);
    }

    Handle* h = Handle::valueOf(v);
    if (h->getType() == T_FIXNUM) {
        return ((RubyFixnum *) h)->longValue();
    }

    JLocalEnv env;

    jsync(env);

    jvalue params[1];

    params[0].l = valueToObject(env, v);

    jlong result = env->CallStaticLongMethodA(RubyNumeric_class, RubyNumeric_num2long_method, params);
    checkExceptions(env);

    return (long long) result;
}

コード例 #2

ファイル: data-object.cpp プロジェクト: Epictetus/jruby

extern "C" VALUE
rb_data_object_alloc(VALUE klass, void* data, RUBY_DATA_FUNC dmark, RUBY_DATA_FUNC dfree)
{
    JLocalEnv env;

    RubyData* h = new RubyData;

    TAILQ_INSERT_TAIL(&dataHandles, h, dataList);
    h->toRData()->data = data;
    h->toRData()->dmark = dmark;
    h->toRData()->dfree = dfree;
    h->setType(T_DATA);

    jvalue params[3];
    params[0].l = getRuntime();
    params[1].l = valueToObject(env, klass);
    params[2].j = p2j(h);

    jobject obj = env->CallStaticObjectMethodA(RubyData_class, RubyData_newRubyData_method, params);
    checkExceptions(env);

    h->obj = env->NewGlobalRef(obj);
    checkExceptions(env);


    return (VALUE) (uintptr_t) h;
}

コード例 #3

ファイル: exception.cpp プロジェクト: DatekWireless/jruby

extern "C" VALUE
rb_rescue(VALUE (*b_proc)(ANYARGS), VALUE data1, VALUE (*r_proc)(ANYARGS), VALUE data2)
{
    try {
        return (*b_proc)(data1);

    } catch (jruby::JavaException& ex) {
        JLocalEnv env;

        jthrowable t = ex.getCause(env);
        if (!env->IsInstanceOf(t, RaiseException_class)) {
            // Not a ruby exception, just propagate
            throw;
        }

        jobject rubyException = env->GetObjectField(t, RaiseException_exception_field);
        checkExceptions(env);

        VALUE exc = objectToValue(env, rubyException);
        if (rb_obj_is_kind_of(exc, rb_eStandardError)) {

            VALUE result = (*r_proc)(data2);
            env->CallStaticVoidMethod(JRuby_class, JRuby_clearErrorInfo, jruby::getRuntime());

            return result;
        }

        rb_raise(rb_eTypeError, "wrong exception type raised (expected StandardError subclass)");

        return Qnil;
    }
}

コード例 #4

ファイル: object.cpp プロジェクト: BrandonMathis/jruby

extern "C" int
rb_respond_to(VALUE obj, ID id)
{
    JLocalEnv env;
    jboolean ret = env->CallBooleanMethod(valueToObject(env, obj), IRubyObject_respondsTo_method, idToString(env, id));
    checkExceptions(env);
    return ret != JNI_FALSE;
}

コード例 #5

ファイル: numeric.cpp プロジェクト: nahi/jruby

extern "C" char
rb_num2chr(VALUE v)
{
    JLocalEnv env;
    jbyte result = env->CallStaticByteMethod(RubyNumeric_class, RubyNumeric_num2chr_method, valueToObject(env, v));
    checkExceptions(env);
    return (char) result;
}

コード例 #6

ファイル: array.cpp プロジェクト: Epictetus/jruby

extern "C" int
rb_ary_size(VALUE ary)
{
    JLocalEnv env;
    int length = (int)(env->GetIntField(valueToObject(env, ary), RubyArray_length_field));
    checkExceptions(env);
    return length;
}

コード例 #7

ファイル: module.cpp プロジェクト: ajeygore/jruby

extern "C" VALUE
rb_define_module(const char* name)
{
    JLocalEnv env;
    jobject mod = env->CallObjectMethod(getRuntime(), Ruby_defineModule_method, env->NewStringUTF(name));
    checkExceptions(env);
    return objectToValue(env, mod);
}

コード例 #8

ファイル: module.cpp プロジェクト: ajeygore/jruby

extern "C" void
rb_define_const(VALUE module, const char* name, VALUE obj)
{
    JLocalEnv env;
    jmethodID mid = getMethodID(env, RubyModule_class, "defineConstant",
            "(Ljava/lang/String;Lorg/jruby/runtime/builtin/IRubyObject;)V");
    env->CallVoidMethod(valueToObject(env, module), mid, env->NewStringUTF(name), valueToObject(env, obj));
    checkExceptions(env);
}

コード例 #9

ファイル: kernel.cpp プロジェクト: BrandonMathis/jruby

extern "C" VALUE
rb_block_proc()
{
    JLocalEnv env;
    jobject proc = env->CallStaticObjectMethod(JRuby_class, JRuby_getBlockProc, getRuntime());
    checkExceptions(env);

    return objectToValue(env, proc);
}

コード例 #10

ファイル: thread.cpp プロジェクト: Epictetus/jruby

extern "C" VALUE
rb_thread_create(VALUE (*fn)(ANYARGS), void* arg)
{
    JLocalEnv env;
    jobject ret = env->CallStaticObjectMethod(JRuby_class, JRuby_newThread, getRuntime(),
                p2j((void*)fn), valueToObject(env, (arg == NULL ? rb_ary_new() : (VALUE)arg)));
    checkExceptions(env);
    return objectToValue(env, ret);
}

コード例 #11

ファイル: class.cpp プロジェクト: Vouters/jruby

extern "C" VALUE
rb_class_new(VALUE klass)
{
    JLocalEnv env;
    jobject jklass = env->CallStaticObjectMethod(RubyClass_class, RubyClass_newClass_method,
            getRuntime(), valueToObject(env, klass));
    checkExceptions(env);
    return objectToValue(env, jklass);
}

コード例 #12

ファイル: class.cpp プロジェクト: Vouters/jruby

extern "C" VALUE
rb_path2class(const char* path)
{
    JLocalEnv env;
    jobject klass = env->CallObjectMethod(getRuntime(), Ruby_getClassFromPath_method, env->NewStringUTF(path));
    checkExceptions(env);

    return objectToValue(env, klass);
}

コード例 #13

ファイル: class.cpp プロジェクト: Vouters/jruby

extern "C" VALUE 
rb_path_to_class(VALUE pathname)
{
    JLocalEnv env;
    jobject klass = env->CallObjectMethod(getRuntime(), Ruby_getClassFromPath_method, env->NewStringUTF(rb_str_ptr_readonly(pathname)));
    checkExceptions(env);

    return objectToValue(env, klass);
}

コード例 #14

ファイル: kernel.cpp プロジェクト: BrandonMathis/jruby

extern "C" VALUE
rb_yield_splat(VALUE array)
{
    JLocalEnv env;
    jobject retval = env->CallStaticObjectMethod(JRuby_class, JRuby_yield, getRuntime(), valueToObject(env, array));
    checkExceptions(env);

    return objectToValue(env, retval);
}

コード例 #15

ファイル: string.cpp プロジェクト: RB-DPR/RB-DPR

extern "C" void
rb_str_modify(VALUE str)
{
    JLocalEnv env;
    jmethodID mid = getCachedMethodID(env, RubyString_class, "modify", "()V");

    env->CallVoidMethod(valueToObject(env, str), mid);
    checkExceptions(env);
}

コード例 #16

ファイル: jruby.cpp プロジェクト: DatekWireless/jruby

VALUE
jruby::getSymbol(const char* name)
{
    JLocalEnv env;
    jobject result = env->CallObjectMethod(getRuntime(), Ruby_newSymbol_method, env->NewStringUTF(name));
    checkExceptions(env);

    return objectToValue(env, result);
}

コード例 #17

ファイル: module.cpp プロジェクト: ajeygore/jruby

extern "C" void
rb_const_set(VALUE parent, ID name, VALUE object)
{
    JLocalEnv env;
    jmethodID mid = getMethodID(env, RubyModule_class, "setConstant",
            "(Ljava/lang/String;Lorg/jruby/runtime/builtin/IRubyObject;)Lorg/jruby/runtime/builtin/IRubyObject;");
    env->CallObjectMethod(valueToObject(env, parent), mid, idToString(env, name),
            valueToObject(env, object));
    checkExceptions(env);
}

コード例 #18

ファイル: kernel.cpp プロジェクト: BrandonMathis/jruby

extern "C" void
rb_define_alias(VALUE klass, const char* new_name, const char* old_name)
{
    JLocalEnv env;
    jmethodID mid = getCachedMethodID(env, RubyModule_class, "defineAlias",
            "(Ljava/lang/String;Ljava/lang/String;)V");
    env->CallVoidMethod(valueToObject(env, klass), mid, env->NewStringUTF(new_name),
            env->NewStringUTF(old_name));
    checkExceptions(env);
}

コード例 #19

ファイル: module.cpp プロジェクト: GregMefford/jruby

extern "C" void
rb_undef_method(VALUE klass, const char* method)
{
    JLocalEnv env;

    jobject ctxt = env->CallObjectMethod(getRuntime(), Ruby_getCurrentContext_method);
    checkExceptions(env);
    env->CallObjectMethod(valueToObject(env, klass), RubyModule_undef_method, ctxt, env->NewStringUTF(method));
    checkExceptions(env);
}

コード例 #20

ファイル: class.cpp プロジェクト: Vouters/jruby

extern "C" VALUE
rb_obj_alloc(VALUE klass)
{
    JLocalEnv env;
    jobject allocator = getDefaultAllocator(env, klass);
    jobject instance = env->CallObjectMethod(allocator, ObjectAllocator_allocate_method,
            getRuntime(), valueToObject(env, klass));
    checkExceptions(env);

    return objectToValue(env, instance);
}

コード例 #21

ファイル: module.cpp プロジェクト: ajeygore/jruby

extern "C" VALUE
rb_const_get_from(VALUE module, ID symbol)
{
    JLocalEnv env;
    jmethodID mid = getMethodID(env, RubyModule_class, "getConstantFrom",
            "(Ljava/lang/String;)Lorg/jruby/runtime/builtin/IRubyObject;");
    jobject c = env->CallObjectMethod(valueToObject(env, module), mid, idToString(env, symbol));
    checkExceptions(env);

    return objectToValue(env, c);
}

コード例 #22

ファイル: object.cpp プロジェクト: BrandonMathis/jruby

extern "C" void
jruby_infect(VALUE object1, VALUE object2)
{
    if (OBJ_TAINTED(object1)) {
        JLocalEnv env;
        jmethodID mid = getCachedMethodID(env, IRubyObject_class, "infectBy",
            "(Lorg/jruby/runtime/builtin/IRubyObject;)Lorg/jruby/runtime/builtin/IRubyObject;");
        env->CallObjectMethod(valueToObject(env, object2), mid, object1);
        checkExceptions(env);
    }
}

コード例 #23

ファイル: string.cpp プロジェクト: brasten/jruby

extern "C" VALUE
rb_str_resize(VALUE str, long size) {
    long length = (long) jruby_str_length(str);
    if (size != length) {
        JLocalEnv env;
        env->CallVoidMethod(valueToObject(env, str), RubyString_resize_method, (jint)size);
        checkExceptions(env);
        jruby_rstring(str)->len = size;
    }
    return str;
}

コード例 #24

ファイル: thread.cpp プロジェクト: Epictetus/jruby

extern "C" VALUE
rb_thread_blocking_region(rb_blocking_function_t func, void* data, rb_unblock_function_t ub_func, void* data2)
{
    JLocalEnv env;
    jlong jret = env->CallStaticLongMethod(JRuby_class, JRuby_nativeBlockingRegion, getRuntime(),
            p2j((void *)func), p2j(data),
            p2j((void *)ub_func), p2j(data2));
    checkExceptions(env);

    return (VALUE)(j2p(jret));
}

コード例 #25

ファイル: module.cpp プロジェクト: ajeygore/jruby

extern "C" void
rb_undef_method(VALUE klass, const char* method)
{
    JLocalEnv env;

    jmethodID undef = getMethodID(env, RubyModule_class, "undef",
            "(Lorg/jruby/runtime/ThreadContext;Ljava/lang/String;)V");
    jobject ctxt = env->CallObjectMethod(getRuntime(), Ruby_getCurrentContext_method);
    checkExceptions(env);
    env->CallObjectMethod(valueToObject(env, klass), undef, ctxt, env->NewStringUTF(method));
    checkExceptions(env);
}

コード例 #26

ファイル: object.cpp プロジェクト: BrandonMathis/jruby

extern "C" VALUE
rb_singleton_class(VALUE obj)
{
    JLocalEnv env;

    jmethodID IRubyObject_getSingletonClass_method = getCachedMethodID(env, IRubyObject_class, "getSingletonClass",
            "()Lorg/jruby/RubyClass;");
    jobject singleton = env->CallObjectMethod(valueToObject(env, obj), IRubyObject_getSingletonClass_method);
    checkExceptions(env);

    return objectToValue(env, singleton);
}

コード例 #27

ファイル: bignum.cpp プロジェクト: ajeygore/jruby

extern "C" double
rb_big2dbl(VALUE obj)
{
    JLocalEnv env;
    jvalue params[1];

    params[0].l = valueToObject(env, obj);
    jdouble result = env->CallStaticDoubleMethodA(RubyBignum_class, RubyBignum_big2dbl_method, params);
    checkExceptions(env);

    return result;
}

コード例 #28

ファイル: class.cpp プロジェクト: Vouters/jruby

extern "C" VALUE
rb_define_class(const char* name, VALUE parent)
{
    JLocalEnv env;
    VALUE super = parent ? parent : rb_cObject;

    jobject result = env->CallObjectMethod(getRuntime(), Ruby_defineClass_method,
            env->NewStringUTF(name), valueToObject(env, super), getDefaultAllocator(env, super));
    checkExceptions(env);

    return objectToValue(env, result);
}

コード例 #29

ファイル: class.cpp プロジェクト: Vouters/jruby

extern "C" void
rb_define_alloc_func(VALUE klass, VALUE (*fn)(VALUE))
{
    JLocalEnv env;

    jobject allocator = env->NewObject(NativeObjectAllocator_class,
            getMethodID(env, NativeObjectAllocator_class, "<init>", "(J)V"),
            p2j((void *) fn));
    checkExceptions(env);

    env->CallVoidMethod(valueToObject(env, klass), RubyClass_setAllocator_method, allocator);
}

コード例 #30

ファイル: module.cpp プロジェクト: ajeygore/jruby

extern "C" VALUE
rb_const_get_at(VALUE module, ID symbol)
{
    JLocalEnv env;
    jmethodID mid = getMethodID(env, RubyModule_class, "getConstantAt",
            "(Ljava/lang/String;)Lorg/jruby/runtime/builtin/IRubyObject;");
    jobject c = env->CallObjectMethod(valueToObject(env, module), mid, idToString(env, symbol));
    checkExceptions(env);

    // Check for null return and call const_missing, if neccessary
    return c == NULL ? callMethod(module, "const_missing", 1, ID2SYM(symbol)) : objectToValue(env, c);
}