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 @ 22266:0d36601f233e

Merge revised Instrumentation framework into the Polyglot API - Required language implementation support now in TruffleLanguage - Instrumentation services provided by the new Instrumenter class - Reduced public API exposure; communication with other components via Accessor - Several methods removed from the Node class - Many test rewritten or using a new "test mode" because of limited access to Engine services Merge with c66f520ad8562b906a878e9b3293aaf54270db90

author	Michael Van De Vanter <michael.van.de.vanter@oracle.com>
date	Wed, 30 Sep 2015 16:33:56 -0700
parents	truffle/com.oracle.truffle.api.vm/src/com/oracle/truffle/api/vm/TruffleVM.java@b73205fe7cf3 truffle/com.oracle.truffle.api.vm/src/com/oracle/truffle/api/vm/TruffleVM.java@7abcbeb12d08
children	b56fe0d3b560

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.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	58 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	59 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	60 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	61 import com.oracle.truffle.api.impl.Accessor;
22215 d3bdaa91bc82 Truffle/Instrumentation: method signature on TruffleLanguage for getting each language's "default" ASTProber Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22214 diff changeset	62 import com.oracle.truffle.api.instrument.Instrumenter;
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	63 import com.oracle.truffle.api.instrument.Probe;
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	64 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	65 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	66 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	67 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	68 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	69
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	70 /**
22171 41c5f430ce37 Using buildNew as that more directly indicates the use of Builder pattern Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22170 diff changeset	71 * 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	72 * 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	73 * 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	74 * 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	75 * 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	76 * 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	77 * <p>
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	78 * 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	79 * {@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	80 * {@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	81 * 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	82 * 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	83 * 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	84 * {@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	85 * 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	86 * 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	87 * <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	88 * 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	89 * 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	90 * 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	91 * 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	92 * <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	93 * 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	94 * 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	95 * 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	96 * 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	97 * 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	98 * <p>
22172 b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	99 * 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	100 * {@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	101 * 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	102 * 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	103 */
f879b1fe3773 Separating 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 @SuppressWarnings("rawtypes")
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	105 public class PolyglotEngine {
796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	106 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	107 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	108 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	109 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	110 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	111 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	112 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	113 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	114 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	115 private final Map<String, Object> globals;
22214 3aad794eec0e Truffle/Instrumentation: first large merge of instrumentation code into the TruffleVM framework Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22135 diff changeset	116 private final Instrumenter instrumenter;
22238 cccb1ac700bd Team/Instrumentation: the TruflfeVM Debugger is now created eagerly at VM "build" time Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22237 diff changeset	117 private final 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;
22214 3aad794eec0e Truffle/Instrumentation: first large merge of instrumentation code into the TruffleVM framework Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22135 diff changeset	132 this.instrumenter = null;
22238 cccb1ac700bd Team/Instrumentation: the TruflfeVM Debugger is now created eagerly at VM "build" time Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22237 diff changeset	133 this.debugger = 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	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
f879b1fe3773 Separating 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 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	137 * 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	138 */
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	139 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	140 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	141 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	142 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	143 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	144 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	145 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	146 this.globals = new HashMap<>(globals);
22220 20380d1d41f2 Truffle/Instrumentation: second merge of instrumentation code into the TruffleVM framework Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22219 diff changeset	147 this.instrumenter = SPI.createInstrumenter(this);
22238 cccb1ac700bd Team/Instrumentation: the TruflfeVM Debugger is now created eagerly at VM "build" time Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22237 diff changeset	148 this.debugger = SPI.createDebugger(this, this.instrumenter);
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	149 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	150 /* 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	151 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	152 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	153 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	154 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	155 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	156 }
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	157 }
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	158 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	159 }
f879b1fe3773 Separating 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 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	162 * 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	163 * 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	164 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	165 * <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	166 * {@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	167 * .{@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	168 * .{@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	169 * .{@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	170 * .{@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	171 * </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	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 * 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	174 * 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	175 * {@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	176 *
f879b1fe3773 Separating 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 * @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	178 */
22171 41c5f430ce37 Using buildNew as that more directly indicates the use of Builder pattern Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22170 diff changeset	179 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	180 // 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	181 // 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	182 // in Javadoc next to PolyglotEngine class
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	183 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	184 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	185 }
f879b1fe3773 Separating 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 /**
22172 b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	188 * 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	189 * 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	190 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	191 * <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	192 * {@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	193 * .{@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	194 * .{@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	195 * .{@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	196 * .{@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	197 * </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	198 */
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	199 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	200 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	201 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	202 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	203 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	204 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	205 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	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 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	208 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	210 /**
f879b1fe3773 Separating 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 * 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	212 * {@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	213 *
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	214 * @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	215 * @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	216 */
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	217 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	218 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	219 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	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
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	222 /**
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	223 * @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	224 */
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	225 @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	226 @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	227 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	228 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	229 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	231 /**
22172 b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	232 * 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	233 * {@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	234 *
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	235 * @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	236 * @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	237 */
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	238 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	239 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	240 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	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
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	243 /**
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	244 * @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	245 */
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	246 @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	247 @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	248 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	249 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	250 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	252 /**
22172 b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	253 * 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	254 * {@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	255 *
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	256 * @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	257 * @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	258 */
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	259 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	260 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	261 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	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
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	264 /**
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	265 * @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	266 */
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	267 @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	268 @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	269 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	270 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	271 }
f879b1fe3773 Separating 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 /**
f879b1fe3773 Separating 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 * 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	275 * {@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	276 *
f879b1fe3773 Separating 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 * @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	278 * @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	279 */
f879b1fe3773 Separating 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 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	281 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	282 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	283 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	284 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	285
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	286 /**
22172 b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	287 * 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	288 * 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	289 * {@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	290 * {@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	291 * 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	292 * 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	293 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	294 * @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	295 * @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	296 * <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	297 * @return instance of this builder
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	298 * @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	299 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	300 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	301 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	302 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	303 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	304 } 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	305 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	306 }
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	307 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	308 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	309 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	310
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	311 /**
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	312 * Provides own executor for running {@link PolyglotEngine} scripts. By default
796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	313 * {@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	314 * {@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	315 * 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	316 * 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	317 * {@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	318 * 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	319 * {@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	320 * 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	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 * @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	323 * 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	324 * @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	325 */
f879b1fe3773 Separating 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 @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	327 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	328 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	329 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	330 }
f879b1fe3773 Separating 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 /**
22172 b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	333 * 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	334 * 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	335 *
f879b1fe3773 Separating 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 * @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	337 */
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	338 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	339 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	340 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	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 (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	343 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	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 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	346 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	347 }
f879b1fe3773 Separating 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 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	349 @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	350 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	351 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	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 };
22266 0d36601f233e Merge revised Instrumentation framework into the Polyglot API Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22261 22200 diff changeset	354 return new PolyglotEngine(nonNullExecutor, globals, out, err, in, handlers.toArray(new EventConsumer[0]));
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	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 }
f879b1fe3773 Separating 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 /**
f879b1fe3773 Separating 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 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	360 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	361 * @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	362 * 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	363 */
22169 307a4ed5430e Two more changes to guarantee better compatibility with TruffleVM Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22168 diff changeset	364 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	365 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	366 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 /**
f879b1fe3773 Separating 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 * 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	370 * 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	371 * 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	372 *
f879b1fe3773 Separating 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 * @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	374 * @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	375 * @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	376 * 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	377 * @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	378 */
f879b1fe3773 Separating 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 @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	380 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	381 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	382 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	383 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	384 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	385 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	386 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	387 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	388 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	389 } 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	390 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	391 } 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	392 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	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 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	395 }
f879b1fe3773 Separating 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 } 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	397 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	398 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	399 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	400 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	401 }
f879b1fe3773 Separating 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 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	403 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	404 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	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 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	407 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 * 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	411 * {@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	412 *
f879b1fe3773 Separating 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 * @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	414 * @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	415 * @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	416 * @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	417 * @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	418 */
f879b1fe3773 Separating 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 @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	420 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	421 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	422 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	423 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	424 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	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 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	427 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 * 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	431 * {@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	432 *
f879b1fe3773 Separating 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 * @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	434 * @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	435 * @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	436 * @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	437 * @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	438 */
f879b1fe3773 Separating 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 @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	440 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	441 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	442 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	443 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	444 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	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 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	447 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 /**
f879b1fe3773 Separating 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 * 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	451 * {@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	452 * 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	453 *
f879b1fe3773 Separating 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 * @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	455 * @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	456 * @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	457 */
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	458 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	459 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	460 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	461 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	462 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	463 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	464 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	465 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	466 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	467
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	468 /**
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 * 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	470 * {@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	471 * 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	472 * 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	473 * <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	474 * 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	475 * {@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	476 */
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 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	478 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	479 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	480 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	481 @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	482 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	483 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	484 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	485 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	486 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	487 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	488 } 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	489 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	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 }
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	494 });
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	495 }
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	496
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	497 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	498 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	499 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	500 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	501 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	502 @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	503 public void run() {
22238 cccb1ac700bd Team/Instrumentation: the TruflfeVM Debugger is now created eagerly at VM "build" time Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22237 diff changeset	504 evalImpl(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	505 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	506 });
f879b1fe3773 Separating 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 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	508 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	509 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	510
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	511 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	512 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	513 }
22172 b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	514
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	515 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	516 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	517 }
ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	518
22132 19205292b0c7 Suppressing "try" lints Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22129 diff changeset	519 @SuppressWarnings("try")
22238 cccb1ac700bd Team/Instrumentation: the TruflfeVM Debugger is now created eagerly at VM "build" time Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22237 diff changeset	520 private void evalImpl(TruffleLanguage<?>[] fillLang, Source s, Object[] result, Language l, CountDownLatch ready) {
cccb1ac700bd Team/Instrumentation: the TruflfeVM Debugger is now created eagerly at VM "build" time Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22237 diff changeset	521 try (Closeable d = SPI.executionStart(this, debugger, 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	522 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	523 fillLang[0] = langImpl;
c334865b9d42 Make sure TruffleLanguage.createEnv is only called when Accessor.CURRENT_VM is known Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22132 diff changeset	524 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	525 } 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	526 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	527 } 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	528 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	529 }
f879b1fe3773 Separating 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 }
f879b1fe3773 Separating 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
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	532 @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	533 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	534 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	535 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	536 @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	537 public void run() {
22266 0d36601f233e Merge revised Instrumentation framework into the Polyglot API Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22261 22200 diff changeset	538 try (final Closeable c = SPI.executionStart(PolyglotEngine.this, debugger, null)) {
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	539 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	540 } 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	541 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	542 } 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	543 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	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 }
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 });
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 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	548 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	549 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	550 } 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	551 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	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 }
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
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	555 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	556 * 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	557 * 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	558 * 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	559 * <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	560 * 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	561 * 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	562 * <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	563 * <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	564 * <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	565 * </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	566 * 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	567 * 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	568 *
f879b1fe3773 Separating 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 * @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	570 * @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	571 */
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	572 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	573 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	574 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	575 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	576 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	577 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	578 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	579 @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	580 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	581 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	582 }
f879b1fe3773 Separating 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 });
f879b1fe3773 Separating 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 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	585 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	586 } 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	587 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	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 } 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	590 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	591 }
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	592 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	593 }
f879b1fe3773 Separating 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 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	596 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	597 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	598 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	599 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	600 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	601 }
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	602 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	603 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	604 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	605 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	606 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	607 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	608 }
f879b1fe3773 Separating 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) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	610 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	611 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	612 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	613 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	614 }
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	615 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	616 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	617 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	618 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	619 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	620 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	621 }
f879b1fe3773 Separating 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 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	623 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 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	626 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	627 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	628 }
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	629 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	630 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	631 }
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	632 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	633
f879b1fe3773 Separating 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 @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	635 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	636 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	637 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	638 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	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 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	641 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	642 }
f879b1fe3773 Separating 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 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	644 }
f879b1fe3773 Separating 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 @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	647 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	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
f879b1fe3773 Separating 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 @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	651 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	652 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 @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	655 <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	656 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	657 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	658 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	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 }
f879b1fe3773 Separating 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 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 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	664 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	665 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	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 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	668 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	669 }
f879b1fe3773 Separating 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 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 /**
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	673 * 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	674 * {@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	675 * {@link PolyglotEngine#findGlobalSymbol(java.lang.String)} and
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	676 * {@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	677 * {@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	678 * {@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	679 * {@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	680 * {@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	681 * 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	682 */
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	683 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	684 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	685 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	686 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	687 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	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 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	690 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	691 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	692 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	693 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	695 /**
f879b1fe3773 Separating 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 * 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	697 * 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	698 * {@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	699 * 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	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 * @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	702 * @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	703 */
f879b1fe3773 Separating 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 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	705 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	706 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	707 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	708 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	709 } 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	710 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	711 }
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	712 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	713
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	714 /**
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	715 * 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	716 * 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	717 * {@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	718 * 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	719 *
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	720 * @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	721 * @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	722 * @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	723 * @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	724 * @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	725 */
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 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	727 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	728 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	729 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	730 }
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	731 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	732 }
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
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 /**
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	735 * 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	736 * 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	737 * 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	738 * 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	739 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	740 * @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	741 * 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	742 * @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	743 * @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	744 * <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	745 * @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	746 */
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	747 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	748 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	749 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	750 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	751 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	752 @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	753 public void run() {
22238 cccb1ac700bd Team/Instrumentation: the TruflfeVM Debugger is now created eagerly at VM "build" time Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22237 diff changeset	754 invokeImpl(thiz, args, 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	755 }
f879b1fe3773 Separating 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 });
f879b1fe3773 Separating 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 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	758 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	759 }
f879b1fe3773 Separating 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
22132 19205292b0c7 Suppressing "try" lints Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22129 diff changeset	761 @SuppressWarnings("try")
22238 cccb1ac700bd Team/Instrumentation: the TruflfeVM Debugger is now created eagerly at VM "build" time Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22237 diff changeset	762 private void invokeImpl(Object thiz, Object[] args, Object[] res, CountDownLatch done) {
22266 0d36601f233e Merge revised Instrumentation framework into the Polyglot API Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22261 22200 diff changeset	763 try (final Closeable c = SPI.executionStart(PolyglotEngine.this, debugger, 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	764 List<Object> arr = new ArrayList<>();
22179 ee9ae440f1eb Testing behavior of invoke when calling asTruffleFunction Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22174 diff changeset	765 if (thiz == null) {
ee9ae440f1eb Testing behavior of invoke when calling asTruffleFunction Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22174 diff changeset	766 if (language != null) {
ee9ae440f1eb Testing behavior of invoke when calling asTruffleFunction Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22174 diff changeset	767 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	768 if (global != null) {
ee9ae440f1eb Testing behavior of invoke when calling asTruffleFunction Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22174 diff changeset	769 arr.add(global);
ee9ae440f1eb Testing behavior of invoke when calling asTruffleFunction Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22174 diff changeset	770 }
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 }
f879b1fe3773 Separating 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 } 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	773 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	774 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	775 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	776 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	777 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	778 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	779 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	780 }
f879b1fe3773 Separating 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 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	782 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	783 } 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	784 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	785 }
f879b1fe3773 Separating 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 }
f879b1fe3773 Separating 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 } 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	788 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	789 } 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	790 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	791 } 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	792 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	793 }
f879b1fe3773 Separating 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 }
f879b1fe3773 Separating 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 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	797 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	798 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	799 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	800 } 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	801 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	802 }
f879b1fe3773 Separating 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 /**
22172 b31dcacfc8ff Replacing more TruffleVM references in comments with the new PolyglotEngine name Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22171 diff changeset	807 * 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	808 * 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	809 * 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	810 * {@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	811 * {@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	812 * 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	813 * implementation is not initialized until
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	814 * {@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	815 */
22168 ffadd23c63c8 Introducing Portaal into the isolated world of each and any TruffleLanguage. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	816 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	817 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	818 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	819
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	820 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	821 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	822 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	823
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	824 /**
f879b1fe3773 Separating 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 * 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	826 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	827 * @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	828 */
f879b1fe3773 Separating 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 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	830 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	831 }
f879b1fe3773 Separating 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 * 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	835 *
f879b1fe3773 Separating 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 * @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	837 */
f879b1fe3773 Separating 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 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	839 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	840 }
f879b1fe3773 Separating 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 * 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	844 *
f879b1fe3773 Separating 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 * @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	846 */
f879b1fe3773 Separating 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 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	848 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	849 }
f879b1fe3773 Separating 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 * 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	853 *
f879b1fe3773 Separating 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 * @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	855 */
f879b1fe3773 Separating 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 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	857 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	858 }
c334865b9d42 Make sure TruffleLanguage.createEnv is only called when Accessor.CURRENT_VM is known Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22132 diff changeset	859
c334865b9d42 Make sure TruffleLanguage.createEnv is only called when Accessor.CURRENT_VM is known Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22132 diff changeset	860 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	861 getEnv(create);
22219 1c0f490984d5 Merge with f47b601edbc626dcfe8b3636933b4834c89f7779 Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22157 22217 diff changeset	862 TruffleLanguage<?> impl = info.getImpl(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	863 return impl;
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	864 }
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	865
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	866 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	867 if (env == null && create) {
22266 0d36601f233e Merge revised Instrumentation framework into the Polyglot API Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22261 22200 diff changeset	868 env = SPI.attachEnv(PolyglotEngine.this, info.getImpl(true), out, err, in, instrumenter);
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	869 }
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	870 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	871 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	872
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	873 @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	874 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	875 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	876 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	877 } // 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	878
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	879 //
f879b1fe3773 Separating 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 // 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	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
22214 3aad794eec0e Truffle/Instrumentation: first large merge of instrumentation code into the TruffleVM framework Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22135 diff changeset	883 TruffleLanguage<?> findLanguage(Class<? extends TruffleLanguage> languageClazz) {
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	884 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	885 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	886 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	887 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	888 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	889 }
f879b1fe3773 Separating 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 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	892 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 TruffleLanguage<?> findLanguage(Probe probe) {
22219 1c0f490984d5 Merge with f47b601edbc626dcfe8b3636933b4834c89f7779 Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22157 22217 diff changeset	895 return findLanguage(SPI.findLanguage(probe));
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	896 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	897
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	898 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	899 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	900 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	901 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	902 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	903 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	904 }
f879b1fe3773 Separating 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 }
f879b1fe3773 Separating 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 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	907 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	908
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	909 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	910 @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	911 public Object importSymbol(Object vmObj, TruffleLanguage<?> ownLang, String globalName) {
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	912 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	913 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	914 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	915 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	916 }
f879b1fe3773 Separating 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 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	918 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	919 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	920 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	921 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	922 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	923 }
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	924 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	925 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	926 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	927 }
f879b1fe3773 Separating 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 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	929 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	930 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	931 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	932 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	933 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	934 }
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	935 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	936 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	937 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	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 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	940 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	941 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	942
f879b1fe3773 Separating 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 @Override
22237 c4e7737981d3 Truffle/Instrumentation: make the Instrumenter available to language implementations via Env.getInstrumenter() Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22232 diff changeset	944 protected Env attachEnv(Object obj, TruffleLanguage<?> language, OutputStream stdOut, OutputStream stdErr, InputStream stdIn, Instrumenter instrumenter) {
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	945 PolyglotEngine vm = (PolyglotEngine) obj;
22237 c4e7737981d3 Truffle/Instrumentation: make the Instrumenter available to language implementations via Env.getInstrumenter() Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22232 diff changeset	946 return super.attachEnv(vm, language, stdOut, stdErr, stdIn, instrumenter);
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	947 }
f879b1fe3773 Separating 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 @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	950 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	951 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	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
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	954 @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	955 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	956 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	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 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	961 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	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
22220 20380d1d41f2 Truffle/Instrumentation: second merge of instrumentation code into the TruffleVM framework Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22219 diff changeset	965 protected Instrumenter createInstrumenter(Object vm) {
20380d1d41f2 Truffle/Instrumentation: second merge of instrumentation code into the TruffleVM framework Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22219 diff changeset	966 return super.createInstrumenter(vm);
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	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
22238 cccb1ac700bd Team/Instrumentation: the TruflfeVM Debugger is now created eagerly at VM "build" time Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22237 diff changeset	970 protected Debugger createDebugger(Object vm, Instrumenter instrumenter) {
cccb1ac700bd Team/Instrumentation: the TruflfeVM Debugger is now created eagerly at VM "build" time Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22237 diff changeset	971 return super.createDebugger(vm, instrumenter);
cccb1ac700bd Team/Instrumentation: the TruflfeVM Debugger is now created eagerly at VM "build" time Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22237 diff changeset	972 }
cccb1ac700bd Team/Instrumentation: the TruflfeVM Debugger is now created eagerly at VM "build" time Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22237 diff changeset	973
cccb1ac700bd Team/Instrumentation: the TruflfeVM Debugger is now created eagerly at VM "build" time Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22237 diff changeset	974 @Override
22214 3aad794eec0e Truffle/Instrumentation: first large merge of instrumentation code into the TruffleVM framework Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22135 diff changeset	975 protected Instrumenter getInstrumenter(Object obj) {
22266 0d36601f233e Merge revised Instrumentation framework into the Polyglot API Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22261 22200 diff changeset	976 final PolyglotEngine vm = (PolyglotEngine) obj;
22214 3aad794eec0e Truffle/Instrumentation: first large merge of instrumentation code into the TruffleVM framework Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22135 diff changeset	977 return vm.instrumenter;
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	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
f879b1fe3773 Separating 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 @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	981 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	982 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	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
f879b1fe3773 Separating 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 @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	986 protected Env findLanguage(Object obj, Class<? extends TruffleLanguage> languageClass) {
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	987 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	988 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	989 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	991 @Override
22214 3aad794eec0e Truffle/Instrumentation: first large merge of instrumentation code into the TruffleVM framework Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22135 diff changeset	992 protected TruffleLanguage findLanguageImpl(Object obj, Class<? extends TruffleLanguage> languageClazz) {
22266 0d36601f233e Merge revised Instrumentation framework into the Polyglot API Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22261 22200 diff changeset	993 final PolyglotEngine vm = (PolyglotEngine) obj;
22214 3aad794eec0e Truffle/Instrumentation: first large merge of instrumentation code into the TruffleVM framework Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22135 diff changeset	994 return vm.findLanguage(languageClazz);
3aad794eec0e Truffle/Instrumentation: first large merge of instrumentation code into the TruffleVM framework Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22135 diff changeset	995 }
3aad794eec0e Truffle/Instrumentation: first large merge of instrumentation code into the TruffleVM framework Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22135 diff changeset	996
3aad794eec0e Truffle/Instrumentation: first large merge of instrumentation code into the TruffleVM framework Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22135 diff changeset	997 @Override
22238 cccb1ac700bd Team/Instrumentation: the TruflfeVM Debugger is now created eagerly at VM "build" time Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22237 diff changeset	998 protected Closeable executionStart(Object obj, Debugger debugger, Source s) {
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	999 PolyglotEngine vm = (PolyglotEngine) obj;
22238 cccb1ac700bd Team/Instrumentation: the TruflfeVM Debugger is now created eagerly at VM "build" time Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22237 diff changeset	1000 return super.executionStart(vm, debugger, 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	1001 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	1003 @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	1004 protected void dispatchEvent(Object obj, Object event) {
22170 796f0fef110e Renaming to PolyglotEngine Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22169 diff changeset	1005 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	1006 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	1007 }
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	1008
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 @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	1010 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	1011 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	1012 }
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	1013 } // 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	1014 }

Mercurial > hg > truffle

annotate truffle/com.oracle.truffle.api.vm/src/com/oracle/truffle/api/vm/PolyglotEngine.java @ 22266:0d36601f233e