truffle: truffle/com.oracle.truffle.api.vm/src/com/oracle/truffle/api/vm/PolyglotEngine.java annotate

annotate truffle/com.oracle.truffle.api.vm/src/com/oracle/truffle/api/vm/PolyglotEngine.java @ 22200:7abcbeb12d08

Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs.

author	Jaroslav Tulach <jaroslav.tulach@oracle.com>
date	Fri, 25 Sep 2015 16:53:27 +0200
parents	364e3f024643
children	dcee887614b1 0d36601f233e

rev	line source
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	1 /*
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	2 * Copyright (c) 2014, 2015, Oracle and/or its affiliates. All rights reserved.
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	4 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	7 * published by the Free Software Foundation. Oracle designates this
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	8 * particular file as subject to the "Classpath" exception as provided
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	9 * by Oracle in the LICENSE file that accompanied this code.
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	10 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	11 * This code is distributed in the hope that it will be useful, but WITHOUT
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	14 * version 2 for more details (a copy is included in the LICENSE file that
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	15 * accompanied this code).
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	16 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	17 * You should have received a copy of the GNU General Public License version
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	18 * 2 along with this work; if not, write to the Free Software Foundation,
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	20 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	22 * or visit www.oracle.com if you need additional information or have any
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	23 * questions.
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	24 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	25 package com.oracle.truffle.api.vm;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	26
22157 dc83cc1f94f2 Using fully qualified imports Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22141 diff changeset	27 import java.io.Closeable;
dc83cc1f94f2 Using fully qualified imports Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22141 diff changeset	28 import java.io.File;
dc83cc1f94f2 Using fully qualified imports Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22141 diff changeset	29 import java.io.IOException;
22165 67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	30 import java.io.InputStream;
22157 dc83cc1f94f2 Using fully qualified imports Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22141 diff changeset	31 import java.io.InterruptedIOException;
22165 67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	32 import java.io.OutputStream;
22157 dc83cc1f94f2 Using fully qualified imports Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22141 diff changeset	33 import java.io.Reader;
dc83cc1f94f2 Using fully qualified imports Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22141 diff changeset	34 import java.io.Writer;
dc83cc1f94f2 Using fully qualified imports Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22141 diff changeset	35 import java.net.URI;
dc83cc1f94f2 Using fully qualified imports Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22141 diff changeset	36 import java.net.URL;
dc83cc1f94f2 Using fully qualified imports Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22141 diff changeset	37 import java.net.URLConnection;
dc83cc1f94f2 Using fully qualified imports Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22141 diff changeset	38 import java.nio.file.Files;
dc83cc1f94f2 Using fully qualified imports Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22141 diff changeset	39 import java.util.ArrayList;
dc83cc1f94f2 Using fully qualified imports Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22141 diff changeset	40 import java.util.Arrays;
dc83cc1f94f2 Using fully qualified imports Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22141 diff changeset	41 import java.util.Collections;
dc83cc1f94f2 Using fully qualified imports Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22141 diff changeset	42 import java.util.HashMap;
22194 7afb5e5cc3ca Fix use just one language instance per LanguageCache instead of one per mime-type. Christian Humer <christian.humer@oracle.com> parents: 22186 diff changeset	43 import java.util.HashSet;
22157 dc83cc1f94f2 Using fully qualified imports Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22141 diff changeset	44 import java.util.LinkedHashSet;
dc83cc1f94f2 Using fully qualified imports Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22141 diff changeset	45 import java.util.List;
dc83cc1f94f2 Using fully qualified imports Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22141 diff changeset	46 import java.util.Map;
dc83cc1f94f2 Using fully qualified imports Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22141 diff changeset	47 import java.util.Set;
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	48 import java.util.concurrent.CountDownLatch;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	49 import java.util.concurrent.Executor;
22157 dc83cc1f94f2 Using fully qualified imports Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22141 diff changeset	50 import java.util.logging.Level;
dc83cc1f94f2 Using fully qualified imports Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22141 diff changeset	51 import java.util.logging.Logger;
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	52
22194 7afb5e5cc3ca Fix use just one language instance per LanguageCache instead of one per mime-type. Christian Humer <christian.humer@oracle.com> parents: 22186 diff changeset	53 import com.oracle.truffle.api.CallTarget;
7afb5e5cc3ca Fix use just one language instance per LanguageCache instead of one per mime-type. Christian Humer <christian.humer@oracle.com> parents: 22186 diff changeset	54 import com.oracle.truffle.api.TruffleLanguage;
7afb5e5cc3ca Fix use just one language instance per LanguageCache instead of one per mime-type. Christian Humer <christian.humer@oracle.com> parents: 22186 diff changeset	55 import com.oracle.truffle.api.TruffleLanguage.Env;
7afb5e5cc3ca Fix use just one language instance per LanguageCache instead of one per mime-type. Christian Humer <christian.humer@oracle.com> parents: 22186 diff changeset	56 import com.oracle.truffle.api.TruffleLanguage.Registration;
7afb5e5cc3ca Fix use just one language instance per LanguageCache instead of one per mime-type. Christian Humer <christian.humer@oracle.com> parents: 22186 diff changeset	57 import com.oracle.truffle.api.debug.DebugSupportProvider;
7afb5e5cc3ca Fix use just one language instance per LanguageCache instead of one per mime-type. Christian Humer <christian.humer@oracle.com> parents: 22186 diff changeset	58 import com.oracle.truffle.api.debug.Debugger;
7afb5e5cc3ca Fix use just one language instance per LanguageCache instead of one per mime-type. Christian Humer <christian.humer@oracle.com> parents: 22186 diff changeset	59 import com.oracle.truffle.api.debug.ExecutionEvent;
7afb5e5cc3ca Fix use just one language instance per LanguageCache instead of one per mime-type. Christian Humer <christian.humer@oracle.com> parents: 22186 diff changeset	60 import com.oracle.truffle.api.debug.SuspendedEvent;
22200 7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	61 import com.oracle.truffle.api.frame.VirtualFrame;
22194 7afb5e5cc3ca Fix use just one language instance per LanguageCache instead of one per mime-type. Christian Humer <christian.humer@oracle.com> parents: 22186 diff changeset	62 import com.oracle.truffle.api.impl.Accessor;
7afb5e5cc3ca Fix use just one language instance per LanguageCache instead of one per mime-type. Christian Humer <christian.humer@oracle.com> parents: 22186 diff changeset	63 import com.oracle.truffle.api.instrument.Probe;
7afb5e5cc3ca Fix use just one language instance per LanguageCache instead of one per mime-type. Christian Humer <christian.humer@oracle.com> parents: 22186 diff changeset	64 import com.oracle.truffle.api.instrument.ToolSupportProvider;
22200 7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	65 import com.oracle.truffle.api.interop.ForeignAccess;
22194 7afb5e5cc3ca Fix use just one language instance per LanguageCache instead of one per mime-type. Christian Humer <christian.humer@oracle.com> parents: 22186 diff changeset	66 import com.oracle.truffle.api.interop.TruffleObject;
7afb5e5cc3ca Fix use just one language instance per LanguageCache instead of one per mime-type. Christian Humer <christian.humer@oracle.com> parents: 22186 diff changeset	67 import com.oracle.truffle.api.interop.java.JavaInterop;
22200 7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	68 import com.oracle.truffle.api.nodes.Node;
22194 7afb5e5cc3ca Fix use just one language instance per LanguageCache instead of one per mime-type. Christian Humer <christian.humer@oracle.com> parents: 22186 diff changeset	69 import com.oracle.truffle.api.source.Source;
7afb5e5cc3ca Fix use just one language instance per LanguageCache instead of one per mime-type. Christian Humer <christian.humer@oracle.com> parents: 22186 diff changeset	70
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	71 /**
22171 41c5f430ce37 Using buildNew as that more directly indicates the use of Builder pattern Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22170 diff changeset	72 * Gate way into the world of {@link TruffleLanguage Truffle languages}. {@link #buildNew()
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	73 * Instantiate} your own portal into the isolated, multi language system with all the registered
22172 b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	74 * languages ready for your use. A {@link PolyglotEngine} runs inside of a <em>JVM</em>, there can
b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	75 * however be multiple instances (some would say tenants) of {@link PolyglotEngine} running next to
b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	76 * each other in a single <em>JVM</em> with a complete mutual isolation. There is 1:N mapping
b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	77 * between <em>JVM</em> and {@link PolyglotEngine}.
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	78 * <p>
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	79 * It would not be correct to think of a {@link PolyglotEngine} as a runtime for a single
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	80 * {@link TruffleLanguage Truffle language} (Ruby, Python, R, C, JavaScript, etc.) either.
22172 b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	81 * {@link PolyglotEngine} can host as many of Truffle languages as {@link Registration registered on
b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	82 * a class path} of your <em>JVM</em> application. {@link PolyglotEngine} orchestrates these
b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	83 * languages, manages exchange of objects and calls among them. While it may happen that there is
b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	84 * just one activated language inside of a {@link PolyglotEngine}, the greatest strength of
b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	85 * {@link PolyglotEngine} is in inter-operability between all Truffle languages. There is 1:N
b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	86 * mapping between {@link PolyglotEngine} and {@link TruffleLanguage Truffle language
b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	87 * implementations}.
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	88 * <p>
22171 41c5f430ce37 Using buildNew as that more directly indicates the use of Builder pattern Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22170 diff changeset	89 * Use {@link #buildNew()} to create new isolated portal ready for execution of various languages.
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	90 * All the languages in a single portal see each other exported global symbols and can cooperate.
22171 41c5f430ce37 Using buildNew as that more directly indicates the use of Builder pattern Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22170 diff changeset	91 * Use {@link #buildNew()} multiple times to create different, isolated portal environment
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	92 * completely separated from each other.
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	93 * <p>
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	94 * Once instantiated use {@link #eval(java.net.URI)} with a reference to a file or URL or directly
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	95 * pass code snippet into the virtual machine via {@link #eval(java.lang.String, java.lang.String)}.
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	96 * Support for individual languages is initialized on demand - e.g. once a file of certain MIME type
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	97 * is about to be processed, its appropriate engine (if found), is initialized. Once an engine gets
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	98 * initialized, it remains so, until the virtual machine isn't garbage collected.
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	99 * <p>
22172 b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	100 * The engine is single-threaded and tries to enforce that. It records the thread it has been
b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	101 * {@link Builder#build() created} by and checks that all subsequent calls are coming from the same
b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	102 * thread. There is 1:1 mapping between {@link PolyglotEngine} and a thread that can tell it what to
b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	103 * do.
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	104 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	105 @SuppressWarnings("rawtypes")
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	106 public class PolyglotEngine {
796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	107 static final Logger LOG = Logger.getLogger(PolyglotEngine.class.getName());
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	108 private static final SPIAccessor SPI = new SPIAccessor();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	109 private final Thread initThread;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	110 private final Executor executor;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	111 private final Map<String, Language> langs;
22165 67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	112 private final InputStream in;
67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	113 private final OutputStream err;
67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	114 private final OutputStream out;
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	115 private final EventConsumer<?>[] handlers;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	116 private final Map<String, Object> globals;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	117 private Debugger debugger;
22183 1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	118 private boolean disposed;
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	119
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	120 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	121 * Private & temporary only constructor.
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	122 */
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	123 PolyglotEngine() {
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	124 this.initThread = null;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	125 this.in = null;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	126 this.err = null;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	127 this.out = null;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	128 this.langs = null;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	129 this.handlers = null;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	130 this.globals = null;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	131 this.executor = null;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	132 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	133
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	134 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	135 * Real constructor used from the builder.
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	136 */
22174 0bcfe8c6088f The central API to invoke various programs is now PolyglotEngine - a polyglot-ready enhancement of JDK's ScriptEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 22173 diff changeset	137 PolyglotEngine(Executor executor, Map<String, Object> globals, OutputStream out, OutputStream err, InputStream in, EventConsumer<?>[] handlers) {
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	138 this.executor = executor;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	139 this.out = out;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	140 this.err = err;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	141 this.in = in;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	142 this.handlers = handlers;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	143 this.initThread = Thread.currentThread();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	144 this.globals = new HashMap<>(globals);
22137 1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	145 Map<String, Language> map = new HashMap<>();
22194 7afb5e5cc3ca Fix use just one language instance per LanguageCache instead of one per mime-type. Christian Humer <christian.humer@oracle.com> parents: 22186 diff changeset	146 /* We want to create a language instance but per LanguageCache and not per mime type. */
7afb5e5cc3ca Fix use just one language instance per LanguageCache instead of one per mime-type. Christian Humer <christian.humer@oracle.com> parents: 22186 diff changeset	147 Set<LanguageCache> uniqueCaches = new HashSet<>(LanguageCache.languages().values());
7afb5e5cc3ca Fix use just one language instance per LanguageCache instead of one per mime-type. Christian Humer <christian.humer@oracle.com> parents: 22186 diff changeset	148 for (LanguageCache languageCache : uniqueCaches) {
7afb5e5cc3ca Fix use just one language instance per LanguageCache instead of one per mime-type. Christian Humer <christian.humer@oracle.com> parents: 22186 diff changeset	149 Language newLanguage = new Language(languageCache);
7afb5e5cc3ca Fix use just one language instance per LanguageCache instead of one per mime-type. Christian Humer <christian.humer@oracle.com> parents: 22186 diff changeset	150 for (String mimeType : newLanguage.getMimeTypes()) {
7afb5e5cc3ca Fix use just one language instance per LanguageCache instead of one per mime-type. Christian Humer <christian.humer@oracle.com> parents: 22186 diff changeset	151 map.put(mimeType, newLanguage);
7afb5e5cc3ca Fix use just one language instance per LanguageCache instead of one per mime-type. Christian Humer <christian.humer@oracle.com> parents: 22186 diff changeset	152 }
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	153 }
22137 1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	154 this.langs = map;
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	155 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	156
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	157 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	158 * Creation of new Truffle virtual machine. Use the {@link Builder} methods to configure your
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	159 * virtual machine and then create one using {@link Builder#build()}:
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	160 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	161 * <pre>
22171 41c5f430ce37 Using buildNew as that more directly indicates the use of Builder pattern Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22170 diff changeset	162 * {@link PolyglotEngine} vm = {@link PolyglotEngine}.{@link PolyglotEngine#buildNew() buildNew()}
22167 0480c4873a4a Fixing Javadoc, imports and adding suppression to methods that are being deprecated Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22165 diff changeset	163 * .{@link Builder#setOut(java.io.OutputStream) setOut}({@link OutputStream yourOutput})
0480c4873a4a Fixing Javadoc, imports and adding suppression to methods that are being deprecated Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22165 diff changeset	164 * .{@link Builder#setErr(java.io.OutputStream) setrr}({@link OutputStream yourOutput})
0480c4873a4a Fixing Javadoc, imports and adding suppression to methods that are being deprecated Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22165 diff changeset	165 * .{@link Builder#setIn(java.io.InputStream) setIn}({@link InputStream yourInput})
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	166 * .{@link Builder#build() build()};
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	167 * </pre>
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	168 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	169 * It searches for {@link Registration languages registered} in the system class loader and
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	170 * makes them available for later evaluation via
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	171 * {@link #eval(java.lang.String, java.lang.String)} methods.
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	172 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	173 * @return new, isolated virtual machine with pre-registered languages
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	174 */
22171 41c5f430ce37 Using buildNew as that more directly indicates the use of Builder pattern Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22170 diff changeset	175 public static PolyglotEngine.Builder buildNew() {
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	176 // making Builder non-static inner class is a
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	177 // nasty trick to avoid the Builder class to appear
22172 b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	178 // in Javadoc next to PolyglotEngine class
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	179 PolyglotEngine vm = new PolyglotEngine();
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	180 return vm.new Builder();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	181 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	182
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	183 /**
22172 b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	184 * Builder for a new {@link PolyglotEngine}. Call various configuration methods in a chain and
b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	185 * at the end create new {@link PolyglotEngine virtual machine}:
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	186 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	187 * <pre>
22171 41c5f430ce37 Using buildNew as that more directly indicates the use of Builder pattern Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22170 diff changeset	188 * {@link PolyglotEngine} vm = {@link PolyglotEngine}.{@link PolyglotEngine#buildNew() buildNew()}
22167 0480c4873a4a Fixing Javadoc, imports and adding suppression to methods that are being deprecated Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22165 diff changeset	189 * .{@link Builder#setOut(java.io.OutputStream) setOut}({@link OutputStream yourOutput})
0480c4873a4a Fixing Javadoc, imports and adding suppression to methods that are being deprecated Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22165 diff changeset	190 * .{@link Builder#setErr(java.io.OutputStream) setrr}({@link OutputStream yourOutput})
0480c4873a4a Fixing Javadoc, imports and adding suppression to methods that are being deprecated Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22165 diff changeset	191 * .{@link Builder#setIn(java.io.InputStream) setIn}({@link InputStream yourInput})
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	192 * .{@link Builder#build() build()};
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	193 * </pre>
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	194 */
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	195 public class Builder {
22165 67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	196 private OutputStream out;
67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	197 private OutputStream err;
67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	198 private InputStream in;
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	199 private final List<EventConsumer<?>> handlers = new ArrayList<>();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	200 private final Map<String, Object> globals = new HashMap<>();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	201 private Executor executor;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	202
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	203 Builder() {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	204 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	205
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	206 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	207 * Changes the default output for languages running in <em>to be created</em>
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	208 * {@link PolyglotEngine virtual machine}. The default is to use {@link System#out}.
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	209 *
22165 67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	210 * @param os the stream to use as output
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	211 * @return instance of this builder
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	212 */
22165 67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	213 public Builder setOut(OutputStream os) {
67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	214 out = os;
67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	215 return this;
67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	216 }
67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	217
67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	218 /**
67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	219 * @deprecated does nothing
67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	220 */
67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	221 @Deprecated
22167 0480c4873a4a Fixing Javadoc, imports and adding suppression to methods that are being deprecated Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22165 diff changeset	222 @SuppressWarnings("unused")
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	223 public Builder stdOut(Writer w) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	224 return this;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	225 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	226
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	227 /**
22172 b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	228 * Changes the error output for languages running in <em>to be created</em>
b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	229 * {@link PolyglotEngine virtual machine}. The default is to use {@link System#err}.
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	230 *
22165 67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	231 * @param os the stream to use as output
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	232 * @return instance of this builder
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	233 */
22165 67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	234 public Builder setErr(OutputStream os) {
67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	235 err = os;
67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	236 return this;
67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	237 }
67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	238
67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	239 /**
67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	240 * @deprecated does nothing
67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	241 */
67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	242 @Deprecated
22167 0480c4873a4a Fixing Javadoc, imports and adding suppression to methods that are being deprecated Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22165 diff changeset	243 @SuppressWarnings("unused")
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	244 public Builder stdErr(Writer w) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	245 return this;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	246 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	247
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	248 /**
22172 b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	249 * Changes the default input for languages running in <em>to be created</em>
22174 0bcfe8c6088f The central API to invoke various programs is now PolyglotEngine - a polyglot-ready enhancement of JDK's ScriptEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 22173 diff changeset	250 * {@link PolyglotEngine virtual machine}. The default is to use {@link System#in}.
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	251 *
22165 67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	252 * @param is the stream to use as input
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	253 * @return instance of this builder
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	254 */
22165 67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	255 public Builder setIn(InputStream is) {
67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	256 in = is;
67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	257 return this;
67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	258 }
67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	259
67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	260 /**
67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	261 * @deprecated does nothing
67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	262 */
67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	263 @Deprecated
22167 0480c4873a4a Fixing Javadoc, imports and adding suppression to methods that are being deprecated Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22165 diff changeset	264 @SuppressWarnings("unused")
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	265 public Builder stdIn(Reader r) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	266 return this;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	267 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	268
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	269 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	270 * Registers another instance of {@link EventConsumer} into the to be created
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	271 * {@link PolyglotEngine}.
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	272 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	273 * @param handler the handler to register
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	274 * @return instance of this builder
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	275 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	276 public Builder onEvent(EventConsumer<?> handler) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	277 handler.getClass();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	278 handlers.add(handler);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	279 return this;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	280 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	281
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	282 /**
22172 b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	283 * Adds global named symbol into the configuration of to-be-built {@link PolyglotEngine}.
b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	284 * This symbol will be accessible to all languages via
b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	285 * {@link Env#importSymbol(java.lang.String)} and will take precedence over
b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	286 * {@link TruffleLanguage#findExportedSymbol symbols exported by languages itself}. Repeated
b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	287 * use of <code>globalSymbol</code> is possible; later definition of the same name overrides
b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	288 * the previous one.
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	289 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	290 * @param name name of the symbol to register
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	291 * @param obj value of the object - expected to be primitive wrapper, {@link String} or
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	292 * <code>TruffleObject</code> for mutual inter-operability
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	293 * @return instance of this builder
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	294 * @see PolyglotEngine#findGlobalSymbol(java.lang.String)
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	295 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	296 public Builder globalSymbol(String name, Object obj) {
22196 364e3f024643 Java objects passed into globalSymbol should be converted into something that Truffle languages can understand - e.g. TruffleObject instances. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22194 diff changeset	297 final Object truffleReady;
364e3f024643 Java objects passed into globalSymbol should be converted into something that Truffle languages can understand - e.g. TruffleObject instances. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22194 diff changeset	298 if (obj instanceof Number \|\| obj instanceof String \|\| obj instanceof Character \|\| obj instanceof Boolean) {
364e3f024643 Java objects passed into globalSymbol should be converted into something that Truffle languages can understand - e.g. TruffleObject instances. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22194 diff changeset	299 truffleReady = obj;
364e3f024643 Java objects passed into globalSymbol should be converted into something that Truffle languages can understand - e.g. TruffleObject instances. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22194 diff changeset	300 } else {
364e3f024643 Java objects passed into globalSymbol should be converted into something that Truffle languages can understand - e.g. TruffleObject instances. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22194 diff changeset	301 truffleReady = JavaInterop.asTruffleObject(obj);
364e3f024643 Java objects passed into globalSymbol should be converted into something that Truffle languages can understand - e.g. TruffleObject instances. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22194 diff changeset	302 }
364e3f024643 Java objects passed into globalSymbol should be converted into something that Truffle languages can understand - e.g. TruffleObject instances. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22194 diff changeset	303 globals.put(name, truffleReady);
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	304 return this;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	305 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	306
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	307 /**
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	308 * Provides own executor for running {@link PolyglotEngine} scripts. By default
796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	309 * {@link PolyglotEngine#eval(com.oracle.truffle.api.source.Source)} and
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	310 * {@link Value#invoke(java.lang.Object, java.lang.Object[])} are executed synchronously in
ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	311 * the calling thread. Sometimes, however it is more beneficial to run them asynchronously -
ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	312 * the easiest way to do so is to provide own executor when configuring the {
ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	313 * {@link #executor(java.util.concurrent.Executor) the builder}. The executor is expected to
ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	314 * execute all {@link Runnable runnables} passed into its
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	315 * {@link Executor#execute(java.lang.Runnable)} method in the order they arrive and in a
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	316 * single (yet arbitrary) thread.
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	317 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	318 * @param executor the executor to use for internal execution inside the {@link #build() to
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	319 * be created} {@link PolyglotEngine}
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	320 * @return instance of this builder
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	321 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	322 @SuppressWarnings("hiding")
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	323 public Builder executor(Executor executor) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	324 this.executor = executor;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	325 return this;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	326 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	327
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	328 /**
22172 b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	329 * Creates the {@link PolyglotEngine Truffle virtual machine}. The configuration is taken
b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	330 * from values passed into configuration methods in this class.
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	331 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	332 * @return new, isolated virtual machine with pre-registered languages
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	333 */
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	334 @SuppressWarnings("deprecation")
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	335 public PolyglotEngine build() {
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	336 if (out == null) {
22165 67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	337 out = System.out;
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	338 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	339 if (err == null) {
22165 67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	340 err = System.err;
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	341 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	342 if (in == null) {
22165 67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	343 in = System.in;
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	344 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	345 Executor nonNullExecutor = executor != null ? executor : new Executor() {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	346 @Override
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	347 public void execute(Runnable command) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	348 command.run();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	349 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	350 };
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	351 return new TruffleVM(nonNullExecutor, globals, out, err, in, handlers.toArray(new EventConsumer[0]));
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	352 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	353 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	354
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	355 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	356 * Descriptions of languages supported in this Truffle virtual machine.
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	357 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	358 * @return an immutable map with keys being MIME types and values the {@link Language
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	359 * descriptions} of associated languages
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	360 */
22169 307a4ed5430e Two more changes to guarantee better compatibility with TruffleVM Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22168 diff changeset	361 public Map<String, ? extends Language> getLanguages() {
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	362 return Collections.unmodifiableMap(langs);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	363 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	364
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	365 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	366 * Evaluates file located on a given URL. Is equivalent to loading the content of a file and
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	367 * executing it via {@link #eval(java.lang.String, java.lang.String)} with a MIME type guess
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	368 * based on the file's extension and/or content.
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	369 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	370 * @param location the location of a file to execute
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	371 * @return result of a processing the file, possibly <code>null</code>
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	372 * @throws IOException exception to signal I/O problems or problems with processing the file's
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	373 * content
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	374 * @deprecated use {@link #eval(com.oracle.truffle.api.source.Source)}
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	375 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	376 @Deprecated
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	377 public Object eval(URI location) throws IOException {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	378 checkThread();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	379 Source s;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	380 String mimeType;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	381 if (location.getScheme().equals("file")) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	382 File file = new File(location);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	383 s = Source.fromFileName(file.getPath(), true);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	384 if (file.getName().endsWith(".c")) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	385 mimeType = "text/x-c";
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	386 } else if (file.getName().endsWith(".sl")) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	387 mimeType = "application/x-sl";
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	388 } else if (file.getName().endsWith(".R") \|\| file.getName().endsWith(".r")) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	389 mimeType = "application/x-r";
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	390 } else {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	391 mimeType = Files.probeContentType(file.toPath());
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	392 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	393 } else {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	394 URL url = location.toURL();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	395 s = Source.fromURL(url, location.toString());
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	396 URLConnection conn = url.openConnection();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	397 mimeType = conn.getContentType();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	398 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	399 Language l = langs.get(mimeType);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	400 if (l == null) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	401 throw new IOException("No language for " + location + " with MIME type " + mimeType + " found. Supported types: " + langs.keySet());
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	402 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	403 return eval(l, s).get();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	404 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	405
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	406 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	407 * Evaluates code snippet. Chooses a language registered for a given MIME type (throws
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	408 * {@link IOException} if there is none). And passes the specified code to it for execution.
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	409 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	410 * @param mimeType MIME type of the code snippet - chooses the right language
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	411 * @param reader the source of code snippet to execute
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	412 * @return result of an execution, possibly <code>null</code>
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	413 * @throws IOException thrown to signal errors while processing the code
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	414 * @deprecated use {@link #eval(com.oracle.truffle.api.source.Source)}
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	415 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	416 @Deprecated
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	417 public Object eval(String mimeType, Reader reader) throws IOException {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	418 checkThread();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	419 Language l = langs.get(mimeType);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	420 if (l == null) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	421 throw new IOException("No language for MIME type " + mimeType + " found. Supported types: " + langs.keySet());
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	422 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	423 return eval(l, Source.fromReader(reader, mimeType)).get();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	424 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	425
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	426 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	427 * Evaluates code snippet. Chooses a language registered for a given MIME type (throws
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	428 * {@link IOException} if there is none). And passes the specified code to it for execution.
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	429 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	430 * @param mimeType MIME type of the code snippet - chooses the right language
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	431 * @param code the code snippet to execute
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	432 * @return result of an execution, possibly <code>null</code>
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	433 * @throws IOException thrown to signal errors while processing the code
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	434 * @deprecated use {@link #eval(com.oracle.truffle.api.source.Source)}
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	435 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	436 @Deprecated
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	437 public Object eval(String mimeType, String code) throws IOException {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	438 checkThread();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	439 Language l = langs.get(mimeType);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	440 if (l == null) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	441 throw new IOException("No language for MIME type " + mimeType + " found. Supported types: " + langs.keySet());
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	442 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	443 return eval(l, Source.fromText(code, mimeType)).get();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	444 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	445
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	446 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	447 * Evaluates provided source. Chooses language registered for a particular
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	448 * {@link Source#getMimeType() MIME type} (throws {@link IOException} if there is none). The
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	449 * language is then allowed to parse and execute the source.
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	450 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	451 * @param source code snippet to execute
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	452 * @return a {@link Value} object that holds result of an execution, never <code>null</code>
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	453 * @throws IOException thrown to signal errors while processing the code
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	454 */
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	455 public Value eval(Source source) throws IOException {
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	456 String mimeType = source.getMimeType();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	457 checkThread();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	458 Language l = langs.get(mimeType);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	459 if (l == null) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	460 throw new IOException("No language for MIME type " + mimeType + " found. Supported types: " + langs.keySet());
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	461 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	462 return eval(l, source);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	463 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	464
22183 1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	465 /**
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	466 * Dispose instance of this engine. A user can explicitly
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	467 * {@link TruffleLanguage#disposeContext(java.lang.Object) dispose all resources} allocated by
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	468 * the languages active in this engine, when it is known the system is not going to be used in
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	469 * the future.
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	470 * <p>
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	471 * Calling any other method of this class after the dispose has been done yields an
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	472 * {@link IllegalStateException}.
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	473 */
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	474 public void dispose() {
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	475 checkThread();
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	476 disposed = true;
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	477 executor.execute(new Runnable() {
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	478 @Override
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	479 public void run() {
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	480 for (Language language : getLanguages().values()) {
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	481 TruffleLanguage<?> impl = language.getImpl(false);
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	482 if (impl != null) {
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	483 try {
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	484 SPI.dispose(impl, language.getEnv(true));
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	485 } catch (Exception \| Error ex) {
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	486 LOG.log(Level.SEVERE, "Error disposing " + impl, ex);
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	487 }
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	488 }
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	489 }
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	490 }
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	491 });
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	492 }
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	493
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	494 private Value eval(final Language l, final Source s) throws IOException {
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	495 final Debugger[] fillIn = {debugger};
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	496 final Object[] result = {null, null};
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	497 final CountDownLatch ready = new CountDownLatch(1);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	498 final TruffleLanguage[] lang = {null};
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	499 executor.execute(new Runnable() {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	500 @Override
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	501 public void run() {
22133 c334865b9d42 Make sure TruffleLanguage.createEnv is only called when Accessor.CURRENT_VM is known Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22132 diff changeset	502 evalImpl(fillIn, lang, s, result, l, ready);
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	503 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	504 });
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	505 exceptionCheck(result);
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	506 return createValue(lang[0], result, ready);
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	507 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	508
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	509 Value createValue(TruffleLanguage lang, Object[] result, CountDownLatch ready) {
ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	510 return new Value(lang, result, ready);
ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	511 }
22172 b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	512
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	513 Language createLanguage(Map.Entry<String, LanguageCache> en) {
ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	514 return new Language(en.getValue());
ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	515 }
ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	516
22132 19205292b0c7 Suppressing "try" lints Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22129 diff changeset	517 @SuppressWarnings("try")
22133 c334865b9d42 Make sure TruffleLanguage.createEnv is only called when Accessor.CURRENT_VM is known Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22132 diff changeset	518 private void evalImpl(Debugger[] fillIn, TruffleLanguage<?>[] fillLang, Source s, Object[] result, Language l, CountDownLatch ready) {
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	519 try (Closeable d = SPI.executionStart(this, fillIn, s)) {
22137 1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	520 TruffleLanguage<?> langImpl = l.getImpl(true);
22133 c334865b9d42 Make sure TruffleLanguage.createEnv is only called when Accessor.CURRENT_VM is known Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22132 diff changeset	521 fillLang[0] = langImpl;
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	522 PolyglotEngine.findDebuggerSupport(langImpl);
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	523 if (debugger == null) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	524 debugger = fillIn[0];
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	525 }
22133 c334865b9d42 Make sure TruffleLanguage.createEnv is only called when Accessor.CURRENT_VM is known Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22132 diff changeset	526 result[0] = SPI.eval(langImpl, s);
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	527 } catch (IOException ex) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	528 result[1] = ex;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	529 } finally {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	530 ready.countDown();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	531 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	532 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	533
22200 7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	534 @SuppressWarnings("try")
7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	535 final Object invokeForeign(final Node foreignNode, final VirtualFrame frame, final TruffleObject receiver) throws IOException {
7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	536 final Debugger[] fillIn = {debugger};
7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	537 final Object[] res = {null, null};
7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	538 executor.execute(new Runnable() {
7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	539 @Override
7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	540 public void run() {
7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	541 try (final Closeable c = SPI.executionStart(PolyglotEngine.this, fillIn, null)) {
7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	542 if (debugger == null) {
7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	543 debugger = fillIn[0];
7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	544 }
7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	545 res[0] = ForeignAccess.execute(foreignNode, frame, receiver, ForeignAccess.getArguments(frame).toArray());
7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	546 } catch (IOException ex) {
7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	547 res[1] = ex;
7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	548 } catch (Throwable ex) {
7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	549 res[1] = ex;
7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	550 }
7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	551 }
7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	552 });
7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	553 exceptionCheck(res);
7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	554 if (res[0] instanceof TruffleObject) {
7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	555 return new EngineTruffleObject(this, (TruffleObject) res[0]);
7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	556 } else {
7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	557 return res[0];
7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	558 }
7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	559 }
7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	560
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	561 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	562 * Looks global symbol provided by one of initialized languages up. First of all execute your
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	563 * program via one of your {@link #eval(java.lang.String, java.lang.String)} and then look
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	564 * expected symbol up using this method.
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	565 * <p>
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	566 * The names of the symbols are language dependent, but for example the Java language bindings
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	567 * follow the specification for method references:
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	568 * <ul>
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	569 * <li>"java.lang.Exception::new" is a reference to constructor of {@link Exception}
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	570 * <li>"java.lang.Integer::valueOf" is a reference to static method in {@link Integer} class
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	571 * </ul>
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	572 * Once an symbol is obtained, it remembers values for fast access and is ready for being
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	573 * invoked.
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	574 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	575 * @param globalName the name of the symbol to find
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	576 * @return found symbol or <code>null</code> if it has not been found
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	577 */
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	578 public Value findGlobalSymbol(final String globalName) {
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	579 checkThread();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	580 final TruffleLanguage<?>[] lang = {null};
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	581 final Object[] obj = {globals.get(globalName), null};
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	582 final CountDownLatch ready = new CountDownLatch(1);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	583 if (obj[0] == null) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	584 executor.execute(new Runnable() {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	585 @Override
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	586 public void run() {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	587 findGlobalSymbolImpl(obj, globalName, lang, ready);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	588 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	589 });
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	590 try {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	591 ready.await();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	592 } catch (InterruptedException ex) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	593 LOG.log(Level.SEVERE, null, ex);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	594 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	595 } else {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	596 ready.countDown();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	597 }
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	598 return obj[0] == null ? null : createValue(lang[0], obj, ready);
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	599 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	600
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	601 private void findGlobalSymbolImpl(Object[] obj, String globalName, TruffleLanguage<?>[] lang, CountDownLatch ready) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	602 if (obj[0] == null) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	603 for (Language dl : langs.values()) {
22137 1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	604 TruffleLanguage.Env env = dl.getEnv(false);
1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	605 if (env == null) {
22133 c334865b9d42 Make sure TruffleLanguage.createEnv is only called when Accessor.CURRENT_VM is known Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22132 diff changeset	606 continue;
c334865b9d42 Make sure TruffleLanguage.createEnv is only called when Accessor.CURRENT_VM is known Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22132 diff changeset	607 }
22137 1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	608 obj[0] = SPI.findExportedSymbol(env, globalName, true);
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	609 if (obj[0] != null) {
22137 1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	610 lang[0] = dl.getImpl(true);
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	611 break;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	612 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	613 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	614 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	615 if (obj[0] == null) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	616 for (Language dl : langs.values()) {
22137 1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	617 TruffleLanguage.Env env = dl.getEnv(false);
1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	618 if (env == null) {
22133 c334865b9d42 Make sure TruffleLanguage.createEnv is only called when Accessor.CURRENT_VM is known Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22132 diff changeset	619 continue;
c334865b9d42 Make sure TruffleLanguage.createEnv is only called when Accessor.CURRENT_VM is known Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22132 diff changeset	620 }
22137 1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	621 obj[0] = SPI.findExportedSymbol(env, globalName, true);
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	622 if (obj[0] != null) {
22137 1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	623 lang[0] = dl.getImpl(true);
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	624 break;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	625 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	626 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	627 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	628 ready.countDown();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	629 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	630
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	631 private void checkThread() {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	632 if (initThread != Thread.currentThread()) {
22172 b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	633 throw new IllegalStateException("PolyglotEngine created on " + initThread.getName() + " but used on " + Thread.currentThread().getName());
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	634 }
22183 1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	635 if (disposed) {
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	636 throw new IllegalStateException("Engine has already been disposed");
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	637 }
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	638 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	639
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	640 @SuppressWarnings("unchecked")
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	641 void dispatch(Object ev) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	642 Class type = ev.getClass();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	643 if (type == SuspendedEvent.class) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	644 dispatchSuspendedEvent((SuspendedEvent) ev);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	645 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	646 if (type == ExecutionEvent.class) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	647 dispatchExecutionEvent((ExecutionEvent) ev);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	648 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	649 dispatch(type, ev);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	650 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	651
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	652 @SuppressWarnings("unused")
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	653 void dispatchSuspendedEvent(SuspendedEvent event) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	654 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	655
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	656 @SuppressWarnings("unused")
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	657 void dispatchExecutionEvent(ExecutionEvent event) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	658 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	659
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	660 @SuppressWarnings("unchecked")
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	661 <Event> void dispatch(Class<Event> type, Event event) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	662 for (EventConsumer handler : handlers) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	663 if (handler.type == type) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	664 handler.on(event);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	665 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	666 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	667 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	668
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	669 static void exceptionCheck(Object[] result) throws RuntimeException, IOException {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	670 if (result[1] instanceof IOException) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	671 throw (IOException) result[1];
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	672 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	673 if (result[1] instanceof RuntimeException) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	674 throw (RuntimeException) result[1];
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	675 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	676 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	677
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	678 /**
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	679 * A future value wrapper. A user level wrapper around values returned by evaluation of various
22172 b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	680 * {@link PolyglotEngine} functions like
b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	681 * {@link PolyglotEngine#findGlobalSymbol(java.lang.String)} and
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	682 * {@link PolyglotEngine#eval(com.oracle.truffle.api.source.Source)} or value returned by
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	683 * {@link #invoke(java.lang.Object, java.lang.Object...) sbbsequent of execution}. In case the
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	684 * {@link PolyglotEngine} has been initialized for
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	685 * {@link Builder#executor(java.util.concurrent.Executor) asynchronous excution}, the
ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	686 * {@link Value} represents a future - e.g. it is returned immediately, leaving the execution
ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	687 * running on behind.
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	688 */
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	689 public class Value {
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	690 private final TruffleLanguage<?> language;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	691 private final Object[] result;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	692 private final CountDownLatch ready;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	693 private CallTarget target;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	694
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	695 Value(TruffleLanguage<?> language, Object[] result, CountDownLatch ready) {
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	696 this.language = language;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	697 this.result = result;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	698 this.ready = ready;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	699 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	700
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	701 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	702 * Obtains the object represented by this symbol. The <em>raw</em> object can either be a
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	703 * wrapper about primitive type (e.g. {@link Number}, {@link String}, {@link Character},
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	704 * {@link Boolean}) or a <em>TruffleObject</em> representing more complex object from a
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	705 * language. The method can return <code>null</code>.
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	706 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	707 * @return the object or <code>null</code>
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	708 * @throws IOException in case it is not possible to obtain the value of the object
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	709 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	710 public Object get() throws IOException {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	711 waitForSymbol();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	712 exceptionCheck(result);
22200 7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	713 if (result[0] instanceof TruffleObject) {
7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	714 return new EngineTruffleObject(PolyglotEngine.this, (TruffleObject) result[0]);
7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	715 } else {
7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	716 return result[0];
7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	717 }
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	718 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	719
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	720 /**
22135 e70b20f4bb00 Implementing API for Java/Truffle interop. Based around JavaInterop.asJavaObject and JavaInterop.asTruffleObject methods. Connected to TruffleVM via Symbol.as(Class) wrapper. Verified by extended TCK. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22133 diff changeset	721 * Obtains Java view of the object represented by this symbol. The method basically
e70b20f4bb00 Implementing API for Java/Truffle interop. Based around JavaInterop.asJavaObject and JavaInterop.asTruffleObject methods. Connected to TruffleVM via Symbol.as(Class) wrapper. Verified by extended TCK. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22133 diff changeset	722 * delegates to
e70b20f4bb00 Implementing API for Java/Truffle interop. Based around JavaInterop.asJavaObject and JavaInterop.asTruffleObject methods. Connected to TruffleVM via Symbol.as(Class) wrapper. Verified by extended TCK. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22133 diff changeset	723 * {@link JavaInterop#asJavaObject(java.lang.Class, com.oracle.truffle.api.interop.TruffleObject)}
e70b20f4bb00 Implementing API for Java/Truffle interop. Based around JavaInterop.asJavaObject and JavaInterop.asTruffleObject methods. Connected to TruffleVM via Symbol.as(Class) wrapper. Verified by extended TCK. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22133 diff changeset	724 * just handles primitive types as well.
22194 7afb5e5cc3ca Fix use just one language instance per LanguageCache instead of one per mime-type. Christian Humer <christian.humer@oracle.com> parents: 22186 diff changeset	725 *
22135 e70b20f4bb00 Implementing API for Java/Truffle interop. Based around JavaInterop.asJavaObject and JavaInterop.asTruffleObject methods. Connected to TruffleVM via Symbol.as(Class) wrapper. Verified by extended TCK. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22133 diff changeset	726 * @param <T> the type of the view one wants to obtain
e70b20f4bb00 Implementing API for Java/Truffle interop. Based around JavaInterop.asJavaObject and JavaInterop.asTruffleObject methods. Connected to TruffleVM via Symbol.as(Class) wrapper. Verified by extended TCK. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22133 diff changeset	727 * @param representation the class of the view interface (it has to be an interface)
e70b20f4bb00 Implementing API for Java/Truffle interop. Based around JavaInterop.asJavaObject and JavaInterop.asTruffleObject methods. Connected to TruffleVM via Symbol.as(Class) wrapper. Verified by extended TCK. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22133 diff changeset	728 * @return instance of the view wrapping the object of this symbol
e70b20f4bb00 Implementing API for Java/Truffle interop. Based around JavaInterop.asJavaObject and JavaInterop.asTruffleObject methods. Connected to TruffleVM via Symbol.as(Class) wrapper. Verified by extended TCK. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22133 diff changeset	729 * @throws IOException in case it is not possible to obtain the value of the object
e70b20f4bb00 Implementing API for Java/Truffle interop. Based around JavaInterop.asJavaObject and JavaInterop.asTruffleObject methods. Connected to TruffleVM via Symbol.as(Class) wrapper. Verified by extended TCK. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22133 diff changeset	730 * @throws ClassCastException if the value cannot be converted to desired view
e70b20f4bb00 Implementing API for Java/Truffle interop. Based around JavaInterop.asJavaObject and JavaInterop.asTruffleObject methods. Connected to TruffleVM via Symbol.as(Class) wrapper. Verified by extended TCK. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22133 diff changeset	731 */
e70b20f4bb00 Implementing API for Java/Truffle interop. Based around JavaInterop.asJavaObject and JavaInterop.asTruffleObject methods. Connected to TruffleVM via Symbol.as(Class) wrapper. Verified by extended TCK. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22133 diff changeset	732 public <T> T as(Class<T> representation) throws IOException {
e70b20f4bb00 Implementing API for Java/Truffle interop. Based around JavaInterop.asJavaObject and JavaInterop.asTruffleObject methods. Connected to TruffleVM via Symbol.as(Class) wrapper. Verified by extended TCK. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22133 diff changeset	733 Object obj = get();
e70b20f4bb00 Implementing API for Java/Truffle interop. Based around JavaInterop.asJavaObject and JavaInterop.asTruffleObject methods. Connected to TruffleVM via Symbol.as(Class) wrapper. Verified by extended TCK. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22133 diff changeset	734 if (representation.isInstance(obj)) {
e70b20f4bb00 Implementing API for Java/Truffle interop. Based around JavaInterop.asJavaObject and JavaInterop.asTruffleObject methods. Connected to TruffleVM via Symbol.as(Class) wrapper. Verified by extended TCK. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22133 diff changeset	735 return representation.cast(obj);
e70b20f4bb00 Implementing API for Java/Truffle interop. Based around JavaInterop.asJavaObject and JavaInterop.asTruffleObject methods. Connected to TruffleVM via Symbol.as(Class) wrapper. Verified by extended TCK. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22133 diff changeset	736 }
22200 7abcbeb12d08 Creating a TruffleObject that knows its PolyglotEngine and wrapping all values returned from the engine by it, so it is always clear into which engine context an object belongs. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22196 diff changeset	737 return JavaInterop.asJavaObject(representation, (TruffleObject) obj);
22135 e70b20f4bb00 Implementing API for Java/Truffle interop. Based around JavaInterop.asJavaObject and JavaInterop.asTruffleObject methods. Connected to TruffleVM via Symbol.as(Class) wrapper. Verified by extended TCK. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22133 diff changeset	738 }
e70b20f4bb00 Implementing API for Java/Truffle interop. Based around JavaInterop.asJavaObject and JavaInterop.asTruffleObject methods. Connected to TruffleVM via Symbol.as(Class) wrapper. Verified by extended TCK. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22133 diff changeset	739
e70b20f4bb00 Implementing API for Java/Truffle interop. Based around JavaInterop.asJavaObject and JavaInterop.asTruffleObject methods. Connected to TruffleVM via Symbol.as(Class) wrapper. Verified by extended TCK. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22133 diff changeset	740 /**
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	741 * Invokes the symbol. If the symbol represents a function, then it should be invoked with
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	742 * provided arguments. If the symbol represents a field, then first argument (if provided)
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	743 * should set the value to the field; the return value should be the actual value of the
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	744 * field when the <code>invoke</code> method returns.
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	745 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	746 * @param thiz this/self in language that support such concept; use <code>null</code> to let
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	747 * the language use default this/self or ignore the value
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	748 * @param args arguments to pass when invoking the symbol
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	749 * @return symbol wrapper around the value returned by invoking the symbol, never
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	750 * <code>null</code>
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	751 * @throws IOException signals problem during execution
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	752 */
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	753 public Value invoke(final Object thiz, final Object... args) throws IOException {
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	754 get();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	755 final Debugger[] fillIn = {debugger};
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	756 final CountDownLatch done = new CountDownLatch(1);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	757 final Object[] res = {null, null};
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	758 executor.execute(new Runnable() {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	759 @Override
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	760 public void run() {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	761 invokeImpl(fillIn, thiz, args, res, done);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	762 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	763 });
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	764 exceptionCheck(res);
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	765 return createValue(language, res, done);
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	766 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	767
22132 19205292b0c7 Suppressing "try" lints Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22129 diff changeset	768 @SuppressWarnings("try")
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	769 private void invokeImpl(Debugger[] fillIn, Object thiz, Object[] args, Object[] res, CountDownLatch done) {
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	770 try (final Closeable c = SPI.executionStart(PolyglotEngine.this, fillIn, null)) {
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	771 if (debugger == null) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	772 debugger = fillIn[0];
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	773 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	774 List<Object> arr = new ArrayList<>();
22179 ee9ae440f1eb Testing behavior of invoke when calling asTruffleFunction Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22174 diff changeset	775 if (thiz == null) {
ee9ae440f1eb Testing behavior of invoke when calling asTruffleFunction Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22174 diff changeset	776 if (language != null) {
ee9ae440f1eb Testing behavior of invoke when calling asTruffleFunction Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22174 diff changeset	777 Object global = SPI.languageGlobal(SPI.findLanguage(PolyglotEngine.this, language.getClass()));
ee9ae440f1eb Testing behavior of invoke when calling asTruffleFunction Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22174 diff changeset	778 if (global != null) {
ee9ae440f1eb Testing behavior of invoke when calling asTruffleFunction Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22174 diff changeset	779 arr.add(global);
ee9ae440f1eb Testing behavior of invoke when calling asTruffleFunction Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22174 diff changeset	780 }
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	781 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	782 } else {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	783 arr.add(thiz);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	784 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	785 arr.addAll(Arrays.asList(args));
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	786 for (;;) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	787 try {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	788 if (target == null) {
22129 0589cc5cab30 TruffleVM can now depend on api.interop and thus there is no need for indirection between SymbolInvoker and its Impl. Enough to do direct calls. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22128 diff changeset	789 target = SymbolInvokerImpl.createCallTarget(language, result[0], arr.toArray());
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	790 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	791 res[0] = target.call(arr.toArray());
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	792 break;
22129 0589cc5cab30 TruffleVM can now depend on api.interop and thus there is no need for indirection between SymbolInvoker and its Impl. Enough to do direct calls. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22128 diff changeset	793 } catch (ArgumentsMishmashException ex) {
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	794 target = null;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	795 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	796 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	797 } catch (IOException ex) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	798 res[1] = ex;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	799 } catch (RuntimeException ex) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	800 res[1] = ex;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	801 } finally {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	802 done.countDown();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	803 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	804 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	805
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	806 private void waitForSymbol() throws InterruptedIOException {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	807 checkThread();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	808 try {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	809 ready.await();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	810 } catch (InterruptedException ex) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	811 throw (InterruptedIOException) new InterruptedIOException(ex.getMessage()).initCause(ex);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	812 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	813 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	814 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	815
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	816 /**
22172 b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	817 * Description of a language registered in {@link PolyglotEngine Truffle virtual machine}.
b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	818 * Languages are registered by {@link Registration} annotation which stores necessary
b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	819 * information into a descriptor inside of the language's JAR file. When a new
b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	820 * {@link PolyglotEngine} is created, it reads all available descriptors and creates
b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	821 * {@link Language} objects to represent them. One can obtain a {@link #getName() name} or list
b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	822 * of supported {@link #getMimeTypes() MIME types} for each language. The actual language
b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	823 * implementation is not initialized until
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	824 * {@link PolyglotEngine#eval(java.lang.String, java.lang.String) a code is evaluated} in it.
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	825 */
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	826 public class Language {
22137 1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	827 private final LanguageCache info;
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	828 private TruffleLanguage.Env env;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	829
22137 1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	830 Language(LanguageCache info) {
1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	831 this.info = info;
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	832 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	833
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	834 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	835 * MIME types recognized by the language.
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	836 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	837 * @return returns immutable set of recognized MIME types
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	838 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	839 public Set<String> getMimeTypes() {
22137 1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	840 return info.getMimeTypes();
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	841 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	842
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	843 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	844 * Human readable name of the language. Think of C, Ruby, JS, etc.
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	845 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	846 * @return string giving the language a name
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	847 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	848 public String getName() {
22137 1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	849 return info.getName();
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	850 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	851
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	852 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	853 * Name of the language version.
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	854 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	855 * @return string specifying the language version
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	856 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	857 public String getVersion() {
22137 1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	858 return info.getVersion();
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	859 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	860
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	861 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	862 * Human readable string that identifies the language and version.
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	863 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	864 * @return string describing the specific language version
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	865 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	866 public String getShortName() {
22137 1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	867 return getName() + "(" + getVersion() + ")";
22133 c334865b9d42 Make sure TruffleLanguage.createEnv is only called when Accessor.CURRENT_VM is known Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22132 diff changeset	868 }
c334865b9d42 Make sure TruffleLanguage.createEnv is only called when Accessor.CURRENT_VM is known Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22132 diff changeset	869
c334865b9d42 Make sure TruffleLanguage.createEnv is only called when Accessor.CURRENT_VM is known Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22132 diff changeset	870 TruffleLanguage<?> getImpl(boolean create) {
22137 1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	871 getEnv(create);
1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	872 return info.getImpl(false);
1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	873 }
1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	874
1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	875 TruffleLanguage.Env getEnv(boolean create) {
1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	876 if (env == null && create) {
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	877 env = SPI.attachEnv(PolyglotEngine.this, info.getImpl(true), out, err, in);
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	878 }
22137 1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	879 return env;
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	880 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	881
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	882 @Override
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	883 public String toString() {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	884 return "[" + getShortName() + " for " + getMimeTypes() + "]";
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	885 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	886 } // end of Language
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	887
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	888 //
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	889 // Accessor helper methods
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	890 //
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	891
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	892 TruffleLanguage<?> findLanguage(Probe probe) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	893 Class<? extends TruffleLanguage> languageClazz = SPI.findLanguage(probe);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	894 for (Map.Entry<String, Language> entrySet : langs.entrySet()) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	895 Language languageDescription = entrySet.getValue();
22137 1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	896 final TruffleLanguage<?> impl = languageDescription.getImpl(false);
1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	897 if (languageClazz.isInstance(impl)) {
1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	898 return impl;
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	899 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	900 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	901 throw new IllegalStateException("Cannot find language " + languageClazz + " among " + langs);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	902 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	903
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	904 Env findEnv(Class<? extends TruffleLanguage> languageClazz) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	905 for (Map.Entry<String, Language> entrySet : langs.entrySet()) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	906 Language languageDescription = entrySet.getValue();
22137 1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	907 Env env = languageDescription.getEnv(false);
1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	908 if (env != null && languageClazz.isInstance(languageDescription.getImpl(false))) {
1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	909 return env;
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	910 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	911 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	912 throw new IllegalStateException("Cannot find language " + languageClazz + " among " + langs);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	913 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	914
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	915 static DebugSupportProvider findDebuggerSupport(TruffleLanguage<?> l) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	916 return SPI.getDebugSupport(l);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	917 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	918
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	919 private static class SPIAccessor extends Accessor {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	920 @Override
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	921 public Object importSymbol(Object vmObj, TruffleLanguage<?> ownLang, String globalName) {
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	922 PolyglotEngine vm = (PolyglotEngine) vmObj;
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	923 Object g = vm.globals.get(globalName);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	924 if (g != null) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	925 return g;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	926 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	927 Set<Language> uniqueLang = new LinkedHashSet<>(vm.langs.values());
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	928 for (Language dl : uniqueLang) {
22137 1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	929 TruffleLanguage<?> l = dl.getImpl(false);
1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	930 TruffleLanguage.Env env = dl.getEnv(false);
1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	931 if (l == ownLang \|\| l == null \|\| env == null) {
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	932 continue;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	933 }
22137 1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	934 Object obj = SPI.findExportedSymbol(env, globalName, true);
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	935 if (obj != null) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	936 return obj;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	937 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	938 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	939 for (Language dl : uniqueLang) {
22137 1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	940 TruffleLanguage<?> l = dl.getImpl(false);
1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	941 TruffleLanguage.Env env = dl.getEnv(false);
1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	942 if (l == ownLang \|\| l == null \|\| env == null) {
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	943 continue;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	944 }
22137 1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	945 Object obj = SPI.findExportedSymbol(env, globalName, false);
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	946 if (obj != null) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	947 return obj;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	948 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	949 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	950 return null;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	951 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	952
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	953 @Override
22165 67f75f61c974 Certain languages (like FastR) prefer access to raw byte streams. Offering it. One always has an option to wrap Input and Output Streams into character based Readers and Writers Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22157 diff changeset	954 protected Env attachEnv(Object obj, TruffleLanguage<?> language, OutputStream stdOut, OutputStream stdErr, InputStream stdIn) {
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	955 PolyglotEngine vm = (PolyglotEngine) obj;
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	956 return super.attachEnv(vm, language, stdOut, stdErr, stdIn);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	957 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	958
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	959 @Override
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	960 public Object eval(TruffleLanguage<?> l, Source s) throws IOException {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	961 return super.eval(l, s);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	962 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	963
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	964 @Override
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	965 public Object findExportedSymbol(TruffleLanguage.Env env, String globalName, boolean onlyExplicit) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	966 return super.findExportedSymbol(env, globalName, onlyExplicit);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	967 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	968
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	969 @Override
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	970 protected Object languageGlobal(TruffleLanguage.Env env) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	971 return super.languageGlobal(env);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	972 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	973
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	974 @Override
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	975 public ToolSupportProvider getToolSupport(TruffleLanguage<?> l) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	976 return super.getToolSupport(l);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	977 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	978
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	979 @Override
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	980 public DebugSupportProvider getDebugSupport(TruffleLanguage<?> l) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	981 return super.getDebugSupport(l);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	982 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	983
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	984 @Override
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	985 protected Class<? extends TruffleLanguage> findLanguage(Probe probe) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	986 return super.findLanguage(probe);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	987 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	988
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	989 @Override
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	990 protected Env findLanguage(Object obj, Class<? extends TruffleLanguage> languageClass) {
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	991 PolyglotEngine vm = (PolyglotEngine) obj;
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	992 return vm.findEnv(languageClass);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	993 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	994
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	995 @Override
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	996 protected Closeable executionStart(Object obj, Debugger[] fillIn, Source s) {
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	997 PolyglotEngine vm = (PolyglotEngine) obj;
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	998 return super.executionStart(vm, fillIn, s);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	999 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	1000
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	1001 @Override
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	1002 protected void dispatchEvent(Object obj, Object event) {
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	1003 PolyglotEngine vm = (PolyglotEngine) obj;
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	1004 vm.dispatch(event);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	1005 }
22183 1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	1006
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	1007 @Override
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	1008 protected void dispose(TruffleLanguage<?> impl, TruffleLanguage.Env env) {
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	1009 super.dispose(impl, env);
1421041175a7 Adding dispose() and TruffleLanguage.disposeContext to allow user request and languages explicitly free the resources Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22167 diff changeset	1010 }
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	1011 } // end of SPIAccessor
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	1012 }

Mercurial > hg > truffle

annotate truffle/com.oracle.truffle.api.vm/src/com/oracle/truffle/api/vm/PolyglotEngine.java @ 22200:7abcbeb12d08