@Override public ForeignAccess getForeignAccess() { return ForeignAccess.create(this); }
@Override public Object execute(VirtualFrame frame) { BoxedValue boxed = (BoxedValue) ForeignAccess.getReceiver(frame); return boxed.value; } });
@TruffleBoundary private Object collectKeys(TruffleObject[] scopes) throws UnsupportedMessageException { // unfortunately we cannot do much butter as scopes might have // overlapping keys. So we need to make the set unique. Set<String> keySet = new HashSet<>(); for (TruffleObject scope : scopes) { TruffleObject keys = ForeignAccess.sendKeys(keysNode, scope); int size = ((Number) ForeignAccess.sendGetSize(getSizeNode, keys)).intValue(); for (int i = 0; i < size; i++) { try { keySet.add((String) ForeignAccess.sendRead(readNode, keys, i)); } catch (UnknownIdentifierException e) { } } } return new DefaultScope.VariableNamesObject(keySet); }
@Override protected Object executeImpl(PolyglotLanguageContext languageContext, TruffleObject receiver, Object[] args) { int size = 0; if (sendHasSize(hasSize, receiver)) { try { size = ((Number) sendGetSize(getSize, receiver)).intValue(); } catch (UnsupportedMessageException e) { size = 0; } } return size; }
@Override @SuppressWarnings("deprecation") protected Object executeImpl(VirtualFrame frame) { final TruffleObject receiver = ForeignAccess.getReceiver(frame); final Object[] args = ForeignAccess.getArguments(frame).toArray(); unwrapArgs(engine, args); Object tmp = ForeignAccess.execute(messageNode, null, receiver, args); return returnConvertNode.convert(tmp); } }
Object unbox(TruffleObject value) { if (!ForeignAccess.sendIsBoxed(isBoxedNode, value)) { return null; } Object result; try { result = ForeignAccess.sendUnbox(unboxNode, value); } catch (UnsupportedMessageException e) { return null; } if (result instanceof TruffleObject && isNull((TruffleObject) result)) { return null; } else { return result; } }
@Override public Object execute(VirtualFrame frame) { Object receiver = ForeignAccess.getReceiver(frame); Object identifier = ForeignAccess.getArguments(frame).get(0); try { return node.executeWithTarget(frame, receiver, identifier); } catch (UnsupportedSpecializationException e) { if (e.getNode() instanceof VarsMapKeyInfoSubNode) { throw UnsupportedTypeException.raise(e, e.getSuppliedValues()); } else { throw e; } } }
private static Object handleMessage(Message message, Node messageNode, TruffleObject obj, String name, Object[] args) throws InteropException { if (message == Message.WRITE) { ForeignAccess.sendWrite(messageNode, obj, name, args[0]); return null; } if (message == Message.HAS_SIZE || message == Message.IS_BOXED || message == Message.IS_EXECUTABLE || message == Message.IS_NULL || message == Message.GET_SIZE) { return ForeignAccess.send(messageNode, obj); } if (message == Message.KEY_INFO) { return ForeignAccess.sendKeyInfo(messageNode, obj, name); } if (message == Message.READ) { return ForeignAccess.sendRead(messageNode, obj, name); } if (message == Message.UNBOX) { return ForeignAccess.sendUnbox(messageNode, obj); } if (Message.createExecute(0).equals(message)) { return ForeignAccess.sendExecute(messageNode, obj, args); } if (Message.createInvoke(0).equals(message)) { return ForeignAccess.sendInvoke(messageNode, obj, name, args); } if (Message.createNew(0).equals(message)) { return ForeignAccess.sendNew(messageNode, obj, args); } CompilerDirectives.transferToInterpreter(); throw UnsupportedMessageException.raise(message); }
boolean executable = condition.profile(sendIsExecutable(isExecutable, function)); try { if (executable) { result = sendExecute(execute, function, functionArgs); } else if (sendIsInstantiable(isInstantiable, function)) { result = sendNew(instantiate, function, functionArgs); } else { CompilerDirectives.transferToInterpreter();
@Override public Object getValue() { try { return ForeignAccess.sendRead(nodes.read, object, key); } catch (UnknownIdentifierException | UnsupportedMessageException ex) { throw ex.raise(); } }
@TruffleBoundary Object invoke(PolyglotLanguageContext context, ProxyObject object, String key, Object[] arguments) { if (object.hasMember(key)) { Object member = context.toGuestValue(object.getMember(key)); if (member instanceof TruffleObject && ForeignAccess.sendIsExecutable(isExecutable, (TruffleObject) member)) { try { return ForeignAccess.sendExecute(executeNode, ((TruffleObject) member), copyFromStart(arguments, 2)); } catch (InteropException e) { throw e.raise(); } } else { throw UnknownIdentifierException.raise(key); } } else { throw UnknownIdentifierException.raise(key); } } }
@Deprecated public static ForeignAccess createAccess() { return ForeignAccess.createAccess(new NullValueForeign(), null); }
private Object convert(TruffleObject obj) { boolean isBoxedResult = ForeignAccess.sendIsBoxed(isBoxed, obj); if (isBoxedProfile.profile(isBoxedResult)) { try { Object newValue = ForeignAccess.sendUnbox(unbox, obj); return new ConvertedObject(obj, newValue); } catch (UnsupportedMessageException e) { return new ConvertedObject(obj, null); } } else { boolean isNullResult = ForeignAccess.sendIsNull(isNull, obj); if (isNullResult) { return new ConvertedObject(obj, null); } } return obj; } }
@Override Object execute(TruffleObject[] scopes, int length, Object[] arguments, int offset) throws UnknownIdentifierException, UnsupportedMessageException { String identifier = expectIdentifier(arguments, offset, Message.READ); if (isConstantSingleLength()) { return ForeignAccess.sendRead(readNode, scopes[0], identifier); } else if (length > 0) { for (int i = 0; i < length; i++) { TruffleObject scopeObject = scopes[i]; if (KeyInfo.isReadable(ForeignAccess.sendKeyInfo(keyInfoNode, scopeObject, identifier))) { return ForeignAccess.sendRead(readNode, scopeObject, identifier); } } } throw UnknownIdentifierException.raise(identifier); }
@Override public int size() { try { Number size = (Number) ForeignAccess.sendGetSize(nodes.getSize, object); return size.intValue(); } catch (UnsupportedMessageException ex) { return 0; } }
@Override protected Object executeImpl(PolyglotLanguageContext context, Object receiver, Object[] args) { return ForeignAccess.sendIsExecutable(isExecutableNode, (TruffleObject) receiver); }
private Object doExecute(TruffleObject compiledRegexObject, RegexObject regexObject, Object input, Object fromIndex) { try { return ForeignAccess.sendExecute(executeNode, compiledRegexObject, regexObject, input, fromIndex); } catch (InteropException ex) { throw ex.raise(); } } }
boolean isBoxed(TruffleObject foreignObject) { return ForeignAccess.sendIsBoxed(isBoxedNode, foreignObject); }
public Object execute(VirtualFrame frame) { return ForeignAccess.getArguments(frame).get(argIndex); } }
@Override public Object execute(VirtualFrame frame) { Object receiver = ForeignAccess.getReceiver(frame); Object identifier = ForeignAccess.getArguments(frame).get(0); try { return node.executeWithTarget(frame, receiver, identifier); } catch (UnsupportedSpecializationException e) { if (e.getNode() instanceof VarsMapReadSubNode) { throw UnsupportedTypeException.raise(e, e.getSuppliedValues()); } else { throw e; } } }