Examples with Node com.oracle.truffle.api.nodes.Node used on opensource projects

Example 91 with Node

use of com.oracle.truffle.api.nodes.Node in project graal by oracle.

the class VarArgsTest method testPathsGet.

@Test
public void testPathsGet() throws InteropException {
    Node n = Message.createInvoke(1).createNode();
    TruffleObject paths = JavaInterop.asTruffleObject(Paths.class);
    TruffleObject result;
    result = (TruffleObject) ForeignAccess.sendInvoke(n, paths, "get", "dir");
    assertEquals("dir", JavaInterop.asJavaObject(Path.class, result).toString());
    result = (TruffleObject) ForeignAccess.sendInvoke(n, paths, "get", "dir1", "dir2");
    assertEquals("dir1/dir2", JavaInterop.asJavaObject(Path.class, result).toString());
    result = (TruffleObject) ForeignAccess.sendInvoke(n, paths, "get", "dir1", "dir2", "dir3");
    assertEquals("dir1/dir2/dir3", JavaInterop.asJavaObject(Path.class, result).toString());
    result = (TruffleObject) ForeignAccess.sendInvoke(n, paths, "get", "dir1", JavaInterop.asTruffleObject(new String[] { "dir2", "dir3" }));
    assertEquals("dir1/dir2/dir3", JavaInterop.asJavaObject(Path.class, result).toString());
}

Example 92 with Node

use of com.oracle.truffle.api.nodes.Node in project graal by oracle.

the class VarArgsTest method testOverloadedVarArgsPrimitive.

@Test
public void testOverloadedVarArgsPrimitive() throws InteropException {
    Node n = Message.createInvoke(1).createNode();
    TruffleObject paths = JavaInterop.asTruffleObject(Sum.class);
    Object result;
    result = ForeignAccess.sendInvoke(n, paths, "sum", 10);
    assertEquals("I", result);
    result = ForeignAccess.sendInvoke(n, paths, "sum", 10, 20);
    assertEquals("DD", result);
    result = ForeignAccess.sendInvoke(n, paths, "sum", 10, 20, 30);
    assertEquals("I[I", result);
}

Example 93 with Node

use of com.oracle.truffle.api.nodes.Node in project graal by oracle.

the class EmptyKeys method interopSupport.

@Override
protected InteropSupport interopSupport() {
    return new InteropSupport() {

        @Override
        public boolean canHandle(Object foreignAccess, Object receiver) {
            ForeignAccess fa = (ForeignAccess) foreignAccess;
            TruffleObject obj = (TruffleObject) receiver;
            return fa.canHandle(obj);
        }

        @Override
        public CallTarget canHandleTarget(Object access) {
            ForeignAccess fa = (ForeignAccess) access;
            return fa.checkLanguage();
        }

        @Override
        public boolean isTruffleObject(Object value) {
            return value instanceof TruffleObject;
        }

        @Override
        public void checkInteropType(Object result) {
            InteropAccessNode.checkInteropType(result);
        }

        @Override
        public Object createDefaultNodeObject(Node node) {
            return EmptyTruffleObject.INSTANCE;
        }

        @Override
        public boolean isValidNodeObject(Object obj) {
            if (obj instanceof TruffleObject) {
                TruffleObject tObj = (TruffleObject) obj;
                if (!ForeignAccess.sendHasKeys(Message.HAS_KEYS.createNode(), tObj)) {
                    throw new AssertionError("Invalid node object: must return true for the HAS_KEYS message.");
                }
                Object keys;
                try {
                    keys = ForeignAccess.sendKeys(Message.KEYS.createNode(), tObj);
                } catch (UnsupportedMessageException e) {
                    throw new AssertionError("Invalid node object: must support the KEYS message.", e);
                }
                if (!(keys instanceof TruffleObject)) {
                    throw new AssertionError("Invalid node object: the returned KEYS object must be a TruffleObject.");
                }
                TruffleObject tKeys = (TruffleObject) keys;
                Node hasSize = Message.HAS_SIZE.createNode();
                if (!ForeignAccess.sendHasSize(hasSize, tKeys)) {
                    throw new AssertionError("Invalid node object: the returned KEYS object must support HAS_SIZE.");
                }
                Node getSize = Message.GET_SIZE.createNode();
                Number size;
                try {
                    size = (Number) ForeignAccess.sendGetSize(getSize, tKeys);
                } catch (UnsupportedMessageException e) {
                    throw new AssertionError("Invalid node object: the returned KEYS object must have a size.");
                }
                Node readKeyNode = Message.READ.createNode();
                Node readElementNode = Message.READ.createNode();
                Node keyInfoNode = Message.KEY_INFO.createNode();
                long longValue = size.longValue();
                for (long i = 0; i < longValue; i++) {
                    Object key;
                    try {
                        key = ForeignAccess.sendRead(readKeyNode, tKeys, i);
                    } catch (UnknownIdentifierException | UnsupportedMessageException e) {
                        throw new AssertionError("Invalid node object: the returned KEYS object must be readable at number identifier " + i);
                    }
                    if (!(key instanceof String)) {
                        throw new AssertionError("Invalid node object: the returned KEYS object must return a string at number identifier " + i + ". But was " + key.getClass().getName() + ".");
                    }
                    try {
                        ForeignAccess.sendRead(readElementNode, tObj, key);
                    } catch (UnknownIdentifierException | UnsupportedMessageException e) {
                        throw new AssertionError("Invalid node object: the returned KEYS element must be readable with identifier " + key);
                    }
                    int keyInfo = ForeignAccess.sendKeyInfo(keyInfoNode, tObj, key);
                    if (KeyInfo.isWritable(keyInfo)) {
                        throw new AssertionError("Invalid node object: The key " + key + " is marked as writable but node objects must not be writable.");
                    }
                }
                Node node = Message.HAS_SIZE.createNode();
                if (ForeignAccess.sendHasSize(node, tObj)) {
                    throw new AssertionError("Invalid node object: the node object must not return true for HAS_SIZE.");
                }
                return true;
            } else {
                throw new AssertionError("Invalid node object: Node objects must be of type TruffleObject.");
            }
        }
    };
}

Example 94 with Node

use of com.oracle.truffle.api.nodes.Node in project graal by oracle.

the class TruffleStackTrace method fillIn.

@TruffleBoundary
static TruffleStackTrace fillIn(Throwable t) {
    if (t instanceof ControlFlowException) {
        return EMPTY;
    }
    LazyStackTrace lazy = findImpl(t);
    if (lazy == null) {
        Throwable insertCause = findInsertCause(t);
        if (insertCause == null) {
            return null;
        }
        insert(insertCause, lazy = new LazyStackTrace());
    }
    if (lazy.stackTrace != null) {
        // stack trace already exists
        return lazy.stackTrace;
    }
    int stackFrameLimit;
    Node topCallSite;
    if (t instanceof TruffleException) {
        TruffleException te = (TruffleException) t;
        topCallSite = te.getLocation();
        stackFrameLimit = te.getStackTraceElementLimit();
    } else {
        topCallSite = null;
        stackFrameLimit = -1;
    }
    // add the lazily captured stack frames above the manually queried ones
    ArrayList<TracebackElement> elements = new ArrayList<>();
    TracebackElement currentElement = lazy.current;
    while (currentElement != null) {
        elements.add(currentElement);
        currentElement = currentElement.last;
    }
    Collections.reverse(elements);
    List<TruffleStackTraceElement> frames = new ArrayList<>();
    for (TracebackElement element : elements) {
        if (element.root != null) {
            frames.add(new TruffleStackTraceElement(topCallSite, element.root, element.frame));
            topCallSite = null;
        }
        if (element.callNode != null) {
            topCallSite = element.callNode;
        }
    }
    int lazyFrames = frames.size();
    // attach the remaining stack trace elements
    addStackFrames(stackFrameLimit, lazyFrames, topCallSite, frames);
    return lazy.stackTrace = new TruffleStackTrace(frames, lazyFrames);
}

Example 95 with Node

use of com.oracle.truffle.api.nodes.Node in project graal by oracle.

the class LanguageSPIHostInteropTest method notUnboxable.

@Test
public void notUnboxable() {
    Node unboxNode = Message.UNBOX.createNode();
    assertError(() -> ForeignAccess.sendUnbox(unboxNode, (TruffleObject) env.asGuestValue(null)), UnsupportedMessageException.class);
    assertError(() -> ForeignAccess.sendUnbox(unboxNode, (TruffleObject) env.asGuestValue(new Object())), UnsupportedMessageException.class);
    assertError(() -> ForeignAccess.sendUnbox(unboxNode, (TruffleObject) env.asGuestValue(Object.class)), UnsupportedMessageException.class);
}