@Override public Object toJava(Node javaNode, Class<?> rawType, Type genericType, Object value, Object polyglotContext) { ToJavaNode toJavaNode = (ToJavaNode) javaNode; return toJavaNode.execute(value, rawType, genericType, polyglotContext); }
@Override public Object execute(VirtualFrame frame) { return node.execute(value, type, null, currentPolyglotContext()); } }
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; }
@SuppressWarnings("unchecked") @TruffleBoundary @Specialization(guards = {"isList(receiver)"}) protected Object doListIntIndex(JavaObject receiver, int index, Object value) { final Object javaValue = toJavaNode.execute(value, Object.class, null, receiver.languageContext); try { List<Object> list = ((List<Object>) receiver.obj); if (index == list.size()) { list.add(javaValue); } else { list.set(index, javaValue); } return value; } catch (IndexOutOfBoundsException e) { CompilerDirectives.transferToInterpreter(); throw UnknownIdentifierException.raise(String.valueOf(index)); } }
@Specialization(replaces = "doCached") void doUncached(SingleFieldDesc field, JavaObject object, Object rawValue) { Object val = toJava.execute(rawValue, field.getType(), field.getGenericType(), object.languageContext); field.set(object.obj, val); } }
private static Object[] prepareArgumentsUncached(SingleMethodDesc method, Object[] args, Object languageContext, ToJavaNode toJavaNode, ConditionProfile isVarArgsProfile) { Class<?>[] types = method.getParameterTypes(); Type[] genericTypes = method.getGenericParameterTypes(); Object[] convertedArguments = new Object[args.length]; if (isVarArgsProfile.profile(method.isVarArgs()) && asVarArgs(args, method)) { int parameterCount = method.getParameterCount(); for (int i = 0; i < args.length; i++) { Class<?> expectedType = i < parameterCount - 1 ? types[i] : types[parameterCount - 1].getComponentType(); Type expectedGenericType = i < parameterCount - 1 ? genericTypes[i] : getGenericComponentType(genericTypes[parameterCount - 1]); convertedArguments[i] = toJavaNode.execute(args[i], expectedType, expectedGenericType, languageContext); } convertedArguments = createVarArgsArray(method, convertedArguments, parameterCount); } else { for (int i = 0; i < args.length; i++) { convertedArguments[i] = toJavaNode.execute(args[i], types[i], genericTypes[i], languageContext); } } return convertedArguments; }
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); }
@SuppressWarnings("unused") @Specialization(guards = {"field == cachedField"}, limit = "LIMIT") void doCached(SingleFieldDesc field, JavaObject object, Object rawValue, @Cached("field") SingleFieldDesc cachedField) { Object val = toJava.execute(rawValue, cachedField.getType(), cachedField.getGenericType(), object.languageContext); cachedField.set(object.obj, val); }
@Override protected Object executeImpl(Object languageContext, TruffleObject receiver, Object[] args, int offset) { Object key = args[offset]; Object result = null; if (isValidKey(receiver, key) && KeyInfo.isReadable(sendKeyInfo(keyInfo, receiver, key))) { try { result = toHost.execute(sendRead(read, receiver, key), cache.valueClass, cache.valueType, languageContext); } catch (ClassCastException | NullPointerException e) { // expected exceptions from casting to the host value. throw e; } catch (UnknownIdentifierException e) { return null; } catch (UnsupportedMessageException e) { // be robust for misbehaving languages return null; } } return result; }
@SuppressWarnings("unused") @Specialization(guards = {"method.isVarArgs()", "method == cachedMethod"}, limit = "LIMIT") Object doVarArgs(SingleMethodDesc method, Object obj, Object[] args, Object languageContext, @Cached("method") SingleMethodDesc cachedMethod, @Cached("create()") ToJavaNode toJavaNode, @Cached("createClassProfile()") ValueProfile receiverProfile) { int parameterCount = cachedMethod.getParameterCount(); int minArity = parameterCount - 1; if (args.length < minArity) { throw ArityException.raise(minArity, args.length); } Class<?>[] types = cachedMethod.getParameterTypes(); Type[] genericTypes = cachedMethod.getGenericParameterTypes(); Object[] convertedArguments = new Object[args.length]; for (int i = 0; i < minArity; i++) { convertedArguments[i] = toJavaNode.execute(args[i], types[i], genericTypes[i], languageContext); } if (asVarArgs(args, cachedMethod)) { for (int i = minArity; i < args.length; i++) { Class<?> expectedType = types[minArity].getComponentType(); Type expectedGenericType = getGenericComponentType(genericTypes[minArity]); convertedArguments[i] = toJavaNode.execute(args[i], expectedType, expectedGenericType, languageContext); } convertedArguments = createVarArgsArray(cachedMethod, convertedArguments, parameterCount); } else { convertedArguments[minArity] = toJavaNode.execute(args[minArity], types[minArity], genericTypes[minArity], languageContext); } return doInvoke(cachedMethod, receiverProfile.profile(obj), convertedArguments, languageContext); }
if (KeyInfo.isReadable(info)) { try { result = toHost.execute(sendRead(read, receiver, key), cache.valueClass, cache.valueType, languageContext); } catch (UnknownIdentifierException e) { } catch (UnsupportedMessageException e) {
if (KeyInfo.isReadable(info)) { try { result = toHost.execute(sendRead(read, receiver, key), cache.valueClass, cache.valueType, languageContext); } catch (UnknownIdentifierException e) { } catch (UnsupportedMessageException e) {
@SuppressWarnings("unused") @ExplodeLoop @Specialization(guards = {"method == cachedMethod", "checkArgTypes(args, cachedArgTypes, toJavaNode, asVarArgs)"}, limit = "LIMIT") Object doOverloadedCached(OverloadedMethodDesc method, Object obj, Object[] args, Object languageContext, @Cached("method") OverloadedMethodDesc cachedMethod, @Cached("create()") ToJavaNode toJavaNode, @Cached(value = "createArgTypesArray(args)", dimensions = 1) Type[] cachedArgTypes, @Cached("selectOverload(method, args, languageContext, toJavaNode, cachedArgTypes)") SingleMethodDesc overload, @Cached("asVarArgs(args, overload)") boolean asVarArgs, @Cached("createClassProfile()") ValueProfile receiverProfile) { assert overload == selectOverload(method, args, languageContext, toJavaNode); Class<?>[] types = overload.getParameterTypes(); Type[] genericTypes = overload.getGenericParameterTypes(); Object[] convertedArguments = new Object[cachedArgTypes.length]; if (asVarArgs) { assert overload.isVarArgs(); int parameterCount = overload.getParameterCount(); for (int i = 0; i < cachedArgTypes.length; i++) { Class<?> expectedType = i < parameterCount - 1 ? types[i] : types[parameterCount - 1].getComponentType(); Type expectedGenericType = i < parameterCount - 1 ? genericTypes[i] : getGenericComponentType(genericTypes[parameterCount - 1]); convertedArguments[i] = toJavaNode.execute(args[i], expectedType, expectedGenericType, languageContext); } convertedArguments = createVarArgsArray(overload, convertedArguments, parameterCount); } else { for (int i = 0; i < cachedArgTypes.length; i++) { convertedArguments[i] = toJavaNode.execute(args[i], types[i], genericTypes[i], languageContext); } } return doInvoke(overload, receiverProfile.profile(obj), convertedArguments, languageContext); }
@Override protected Object executeImpl(Object languageContext, TruffleObject receiver, Object[] args, int offset) { Object key = args[offset]; Object result = null; assert key instanceof Integer; if (sendHasSize(hasSize, receiver)) { if (KeyInfo.isReadable(sendKeyInfo(keyInfo, receiver, key))) { try { result = toHost.execute(sendRead(read, receiver, key), cache.valueClass, cache.valueType, languageContext); } catch (UnknownIdentifierException e) { } catch (UnsupportedMessageException e) { } } try { sendRemove(remove, receiver, key); } catch (UnknownIdentifierException e) { CompilerDirectives.transferToInterpreter(); throw JavaInteropErrors.invalidListIndex(languageContext, receiver, cache.valueType, (int) key); } catch (UnsupportedMessageException e) { CompilerDirectives.transferToInterpreter(); throw JavaInteropErrors.listUnsupported(languageContext, receiver, cache.valueType, "remove"); } return cache.valueClass.cast(result); } else { CompilerDirectives.transferToInterpreter(); throw JavaInteropErrors.listUnsupported(languageContext, receiver, cache.valueType, "remove"); } } }
if (KeyInfo.isExisting(info)) { try { result = toHost.execute(sendRead(read, receiver, key), cache.valueClass, cache.valueType, languageContext); } catch (UnknownIdentifierException e) { } catch (UnsupportedMessageException e) {
@SuppressWarnings("unused") @ExplodeLoop @Specialization(guards = {"!method.isVarArgs()", "method == cachedMethod"}, limit = "LIMIT") Object doFixed(SingleMethodDesc method, Object obj, Object[] args, Object languageContext, @Cached("method") SingleMethodDesc cachedMethod, @Cached("createToJava(method.getParameterCount())") ToJavaNode[] toJavaNodes, @Cached("createClassProfile()") ValueProfile receiverProfile) { int arity = cachedMethod.getParameterCount(); if (args.length != arity) { throw ArityException.raise(arity, args.length); } Class<?>[] types = cachedMethod.getParameterTypes(); Type[] genericTypes = cachedMethod.getGenericParameterTypes(); Object[] convertedArguments = new Object[args.length]; for (int i = 0; i < toJavaNodes.length; i++) { convertedArguments[i] = toJavaNodes[i].execute(args[i], types[i], genericTypes[i], languageContext); } return doInvoke(cachedMethod, receiverProfile.profile(obj), convertedArguments, languageContext); }
@Override protected Object executeImpl(Object languageContext, TruffleObject receiver, Object[] args, int offset) { Object key = args[offset]; Object result = null; assert key instanceof Integer; if (sendHasSize(hasSize, receiver)) { if (KeyInfo.isReadable(sendKeyInfo(keyInfo, receiver, key))) { try { result = toHost.execute(sendRead(read, receiver, key), cache.valueClass, cache.valueType, languageContext); } catch (UnknownIdentifierException e) { CompilerDirectives.transferToInterpreter(); throw JavaInteropErrors.invalidListIndex(languageContext, receiver, cache.valueType, (int) key); } catch (UnsupportedMessageException e) { CompilerDirectives.transferToInterpreter(); throw JavaInteropErrors.listUnsupported(languageContext, receiver, cache.valueType, "get()"); } } else { CompilerDirectives.transferToInterpreter(); throw JavaInteropErrors.invalidListIndex(languageContext, receiver, cache.valueType, (int) key); } } else { CompilerDirectives.transferToInterpreter(); throw JavaInteropErrors.listUnsupported(languageContext, receiver, cache.valueType, "get()"); } return result; }
throw JavaInteropErrors.executeUnsupported(languageContext, function); return toHost.execute(result, resultClass, resultType, languageContext);
return toJava.execute(result, returnClass, returnType, languageContext);