@Override Object execute(TruffleObject[] scopes, int length, Object[] arguments, int offset) throws InteropException { String identifier = expectIdentifier(arguments, offset, Message.KEY_INFO); int keyInfo = KeyInfo.NONE; for (int i = 0; i < length; i++) { TruffleObject scopeObject = scopes[i]; int currentInfo = ForeignAccess.sendKeyInfo(keyInfoNode, scopeObject, identifier); if (KeyInfo.isExisting(currentInfo)) { keyInfo = currentInfo; break; } else if (KeyInfo.isInsertable(currentInfo)) { keyInfo = currentInfo; } } return keyInfo; }
@Override public boolean isInternal() { checkValid(); return KeyInfo.isInternal(keyInfo); }
@Override protected Object executeImpl(int keyInfo) { return KeyInfo.isInvocable(keyInfo); }
assertFalse("An unknown property", KeyInfo.isExisting(keyInfo)); int ro = object.ro(); if (KeyInfo.isExisting(ro)) { assertTrue(KeyInfo.isReadable(ro)); assertFalse(KeyInfo.isWritable(ro)); assertFalse(KeyInfo.isInternal(ro)); numKeys++; if (KeyInfo.isExisting(wo)) { assertFalse(KeyInfo.isReadable(wo)); assertTrue(KeyInfo.isWritable(wo)); assertFalse(KeyInfo.isInternal(wo)); numKeys++; if (KeyInfo.isExisting(rw)) { assertTrue(KeyInfo.isReadable(rw)); assertTrue(KeyInfo.isWritable(rw)); assertFalse(KeyInfo.isInternal(rw)); numKeys++; if (KeyInfo.isExisting(rm)) { assertTrue(KeyInfo.isRemovable(rm)); numKeys++; if (KeyInfo.isExisting(invocable)) { assertTrue(KeyInfo.isInvocable(invocable)); assertFalse(KeyInfo.isInternal(invocable)); numKeys++;
@Override Object execute(TruffleObject[] scopes, int length, Object[] arguments, int offset) throws InteropException { String identifier = expectIdentifier(arguments, offset, Message.REMOVE); if (isConstantSingleLength()) { return ForeignAccess.sendRemove(removeNode, scopes[0], identifier); } else if (length > 0) { for (int i = 0; i < length; i++) { TruffleObject scopeObject = scopes[i]; int keyInfo = ForeignAccess.sendKeyInfo(keyInfoNode, scopeObject, identifier); if (KeyInfo.isRemovable(keyInfo)) { return ForeignAccess.sendRemove(removeNode, scopeObject, identifier); } else if (KeyInfo.isExisting(keyInfo)) { CompilerDirectives.transferToInterpreter(); throw UnsupportedMessageException.raise(Message.REMOVE); } } } CompilerDirectives.transferToInterpreter(); throw UnknownIdentifierException.raise(identifier); }
@Override public boolean isReadable() { checkValid(); return KeyInfo.isReadable(keyInfo); }
Object value = args[offset + 1]; int info = sendKeyInfo(keyInfo, receiver, key); if (!KeyInfo.isExisting(info) || (KeyInfo.isWritable(info) && KeyInfo.isReadable(info))) { if (KeyInfo.isExisting(info)) { try { result = toHost.execute(sendRead(read, receiver, key), cache.valueClass, cache.valueType, languageContext);
Object lookupGuest(String symbolName) { ensureInitialized(null); Iterable<?> topScopes = VMAccessor.instrumentAccess().findTopScopes(env); for (Object topScope : topScopes) { Scope scope = (Scope) topScope; TruffleObject variables = (TruffleObject) scope.getVariables(); int symbolInfo = ForeignAccess.sendKeyInfo(keyInfoNode, variables, symbolName); if (KeyInfo.isExisting(symbolInfo) && KeyInfo.isReadable(symbolInfo)) { try { return ForeignAccess.sendRead(readNode, variables, symbolName); } catch (InteropException ex) { throw new AssertionError(symbolName, ex); } } } return null; }
@Override public boolean isWritable() { checkValid(); return KeyInfo.isWritable(keyInfo); }
if (invokeOrReadAndExecuteProfile.profile(KeyInfo.isInvocable(keyInfo))) { try { return ForeignAccess.sendInvoke(invokeNode, receiver, name, arguments); } else if (KeyInfo.isReadable(keyInfo)) { Object readValue = ForeignAccess.sendRead(readNode, receiver, name); if (readValue instanceof TruffleObject) {
@Override protected Object executeImpl(int keyInfo) { return KeyInfo.isExisting(keyInfo); }
/** * @since 0.26 * @deprecated in 0.33 use integer constants in {@link KeyInfo} instead. For example * <code> KeyInfo.newBuilder().setWritable(true).setReadable(true).build()</code> * becomes <code> * {@link #READABLE READABLE} | {@link #MODIFIABLE MODIFIABLE} | {@link #INSERTABLE * INSERTABLE}</code> */ @Deprecated public static Builder newBuilder() { return new KeyInfo().new Builder(); }
@Override public boolean hasReadSideEffects() { checkValid(); return KeyInfo.hasReadSideEffects(keyInfo); }
} else { int keyInfo = ForeignAccess.sendKeyInfo(keyInfoNode, truffleReceiver, key); if (KeyInfo.isRemovable(keyInfo)) { return ForeignAccess.sendRemove(removeMemberNode, truffleReceiver, key); } else { if (KeyInfo.isExisting(keyInfo) || !ForeignAccess.sendHasKeys(hasKeysNode, truffleReceiver)) { CompilerDirectives.transferToInterpreter(); return polyglot.getMemberUnsupported(receiver, key); if (KeyInfo.isExisting(keyInfo) || !ForeignAccess.sendHasKeys(hasKeysNode, truffleReceiver)) { polyglot.removeMemberUnsupported(receiver);
@Override public boolean isReadable() { checkValid(); return KeyInfo.isReadable(keyInfo); }
Object value = args[ARGUMENT_OFFSET + 1]; int info = sendKeyInfo(keyInfo, receiver, key); if (!KeyInfo.isExisting(info) || (KeyInfo.isWritable(info) && KeyInfo.isReadable(info))) { if (KeyInfo.isExisting(info)) { try { result = toHost.execute(sendRead(read, receiver, key), cache.valueClass, cache.valueType, languageContext);
} else { int keyInfo = ForeignAccess.sendKeyInfo(keyInfoNode, truffleReceiver, key); if (KeyInfo.isReadable(keyInfo)) { value = toHostValue.execute(ForeignAccess.sendRead(readMemberNode, truffleReceiver, key)); } else { if (KeyInfo.isExisting(keyInfo) || !ForeignAccess.sendHasKeys(hasKeysNode, truffleReceiver)) { CompilerDirectives.transferToInterpreter(); return polyglot.getMemberUnsupported(receiver, key); if (KeyInfo.isExisting(keyInfo) || !ForeignAccess.sendHasKeys(hasKeysNode, truffleReceiver)) { return polyglot.getMemberUnsupported(receiver, key);
@Override public boolean isWritable() { checkValid(); return KeyInfo.isWritable(keyInfo); }
if (invokeOrReadAndExecuteProfile.profile(KeyInfo.isInvocable(keyInfo))) { try { return ForeignAccess.sendInvoke(invokeNode, receiver, name, arguments); } else if (KeyInfo.isReadable(keyInfo)) { Object readValue = ForeignAccess.sendRead(readNode, receiver, name); if (readValue instanceof TruffleObject) {
@Override protected Object executeImpl(Object receiver, Object[] args) { String key = (String) args[1]; int keyInfo = ForeignAccess.sendKeyInfo(keyInfoNode, (TruffleObject) receiver, key); return KeyInfo.isExisting(keyInfo); }