static JavaObject forObject(Object object, Object languageContext) { assert object != null && !(object instanceof Class<?>); return new JavaObject(object, languageContext, false); }
@Override public String toString() { if (obj == null) { return "null"; } if (isClass()) { return "JavaClass[" + asClass().getTypeName() + "]"; } return "JavaObject[" + obj + " (" + getObjectClass().getTypeName() + ")" + "]"; } }
/** * Gets the {@link Class} for member lookups. */ Class<?> getLookupClass() { if (obj == null) { return null; } else if (isStaticClass()) { return asStaticClass(); } else { return obj.getClass(); } }
@TruffleBoundary public Object access(JavaObject receiver, boolean includeInternal) { if (receiver.isNull()) { throw UnsupportedMessageException.raise(Message.KEYS); } String[] fields = TruffleOptions.AOT ? new String[0] : JavaInteropReflect.findUniquePublicMemberNames(receiver.getLookupClass(), receiver.isStaticClass(), includeInternal); return JavaObject.forObject(fields, receiver.languageContext); } }
public Object access(JavaObject object, String name) { if (TruffleOptions.AOT || object.isNull()) { throw UnsupportedMessageException.raise(Message.READ); } boolean isStatic = object.isStaticClass(); Class<?> lookupClass = object.getLookupClass(); JavaFieldDesc foundField = lookupField().execute(lookupClass, name, isStatic); if (foundField != null) { return readField().execute(foundField, object); } JavaMethodDesc foundMethod = lookupMethod().execute(lookupClass, name, isStatic); if (foundMethod != null) { return new JavaFunctionObject(foundMethod, object.obj, object.languageContext); } if (isStatic) { LookupInnerClassNode lookupInnerClassNode = lookupInnerClass(); if ("class".equals(name)) { return JavaObject.forClass(lookupClass, object.languageContext); } Class<?> innerclass = lookupInnerClassNode.execute(lookupClass, name); if (innerclass != null) { return JavaObject.forStaticClass(innerclass, object.languageContext); } } throw UnknownIdentifierException.raise(name); }
public int access(JavaObject receiver, String name) { if (receiver.isNull()) { throw UnsupportedMessageException.raise(Message.KEY_INFO); } if (TruffleOptions.AOT) { return 0; } return keyInfoCache().execute(receiver.getLookupClass(), name, receiver.isStaticClass()); }
} else if (obj instanceof Class) { if (asStaticClass) { return JavaObject.forStaticClass((Class<?>) obj, languageContext); } else { return JavaObject.forClass((Class<?>) obj, languageContext); return JavaObject.forObject(obj, languageContext); } else if (obj instanceof TruffleList) { return ((TruffleList<?>) obj).guestObject; return ((TruffleFunction<?, ?>) obj).guestObject; } else if (TruffleOptions.AOT) { return JavaObject.forObject(obj, languageContext); } else { return JavaInteropReflect.asTruffleViaReflection(obj, languageContext);
private Object newArray(JavaObject receiver, Object[] args) { if (args.length != 1) { throw ArityException.raise(1, args.length); } if (toJava == null) { CompilerDirectives.transferToInterpreterAndInvalidate(); toJava = insert(ToJavaNode.create()); } int length; try { length = (int) toJava.execute(args[0], int.class, null, receiver.languageContext); } catch (ClassCastException | NullPointerException e) { // conversion failed by ToJavaNode throw UnsupportedTypeException.raise(e, args); } Object array = Array.newInstance(receiver.asClass().getComponentType(), length); return JavaObject.forObject(array, receiver.languageContext); }
public int access(JavaObject receiver, int index) { if (index < 0) { return 0; } if (receiver.isArray()) { int length = Array.getLength(receiver.obj); if (index < length) { return KeyInfo.READABLE | KeyInfo.MODIFIABLE; } } else if (receiver.obj instanceof List) { int length = listSize((List<?>) receiver.obj); if (index < length) { return KeyInfo.READABLE | KeyInfo.MODIFIABLE | KeyInfo.REMOVABLE; } else if (index == length) { return KeyInfo.INSERTABLE; } } return KeyInfo.NONE; }
Class<?> asClass() { assert isClass(); return (Class<?>) obj; }
static TruffleObject asTruffleViaReflection(Object obj, Object languageContext) { if (obj instanceof Proxy) { return asTruffleObjectProxy(obj, languageContext); } return JavaObject.forObject(obj, languageContext); }
private JavaMethodDesc lookupFunctionalInterfaceMethod(JavaObject receiver) { if (lookupMethod == null) { CompilerDirectives.transferToInterpreterAndInvalidate(); lookupMethod = insert(LookupFunctionalMethodNode.create()); } return lookupMethod.execute(receiver.getLookupClass()); } }
if (!(arg instanceof JavaObject && ((JavaObject) arg).getObjectClass() == ((JavaObjectType) argType).clazz)) { return false;
@Override public Object asStaticClassObject(Class<?> clazz, Object hostLanguageContext) { return JavaObject.forStaticClass(clazz, hostLanguageContext); } };
/** * Finds a Java class representation for the provided object. If the object was created via * {@link #asTruffleObject(java.lang.Object) asTruffleObject(original)} call, then it is * unwrapped and the result is equal to {@link #asTruffleObject(java.lang.Object) * asTruffleObject(original.getClass())}. * <p> * This method works only on objects that wrap plain Java objects. * * @param obj object expected to be created by {@link #asTruffleObject(java.lang.Object)} or * similar methods * @return object representing {@link #asTruffleObject(java.lang.Object) wrapper} around * original Java object's {@link Object#getClass() type} if any. Otherwise * <code>null</code> * @since 0.26 */ public static TruffleObject toJavaClass(TruffleObject obj) { if (obj instanceof JavaObject) { JavaObject receiver = (JavaObject) obj; if (receiver.obj == null) { return JavaObject.NULL; } else { return JavaObject.forClass(receiver.obj.getClass(), receiver.languageContext); } } else { return null; } }
public Object access(JavaObject receiver, String name, Object value) { if (TruffleOptions.AOT || receiver.isNull()) { throw UnsupportedMessageException.raise(Message.WRITE); } JavaFieldDesc f = lookupField().execute(receiver.getLookupClass(), name, receiver.isStaticClass()); if (f == null) { throw UnknownIdentifierException.raise(name); } try { writeField().execute(f, receiver, value); } catch (ClassCastException | NullPointerException e) { // conversion failed by ToJavaNode throw UnsupportedTypeException.raise(e, new Object[]{value}); } return JavaObject.NULL; }
public Object access(JavaObject receiver, Object[] args) { if (TruffleOptions.AOT) { throw UnsupportedMessageException.raise(NEW); } if (receiver.isClass()) { Class<?> javaClass = receiver.asClass(); if (javaClass.isArray()) { return newArray(receiver, args); } JavaMethodDesc constructor = lookupConstructor().execute(javaClass); if (constructor != null) { return executeMethod().execute(constructor, null, args, receiver.languageContext); } } throw UnsupportedMessageException.raise(NEW); }
private Object doArrayAccess(JavaObject receiver, int index, Object value) { Object obj = receiver.obj; assert receiver.isArray(); final Object javaValue = toJavaNode.execute(value, obj.getClass().getComponentType(), null, receiver.languageContext); try { Array.set(obj, index, javaValue); } catch (ArrayIndexOutOfBoundsException outOfBounds) { CompilerDirectives.transferToInterpreter(); throw UnknownIdentifierException.raise(String.valueOf(index)); } return JavaObject.NULL; }
public Object access(JavaObject receiver) { if (TruffleOptions.AOT) { return false; } return receiver.obj != null && !receiver.isClass() && lookupFunctionalInterfaceMethod(receiver) != null; }