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

annotate truffle/com.oracle.truffle.api.vm/src/com/oracle/truffle/api/vm/TruffleVM.java @ 22219:1c0f490984d5

Merge with f47b601edbc626dcfe8b3636933b4834c89f7779

author	Michael Van De Vanter <michael.van.de.vanter@oracle.com>
date	Wed, 16 Sep 2015 15:36:22 -0700
parents	dc83cc1f94f2 7c8c03389f0f
children	20380d1d41f2

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
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	27 import java.io.Closeable;
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	28 import java.io.File;
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	29 import java.io.IOException;
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	30 import java.io.InputStreamReader;
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	31 import java.io.InterruptedIOException;
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	32 import java.io.OutputStreamWriter;
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	33 import java.io.Reader;
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	34 import java.io.Writer;
22141 46384e637592 Make sure the proper TruffleVM execution context is re-set before invoking an operation on a JavaInterop wrapper obtained via Symbol.as method. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	35 import java.lang.reflect.InvocationHandler;
46384e637592 Make sure the proper TruffleVM execution context is re-set before invoking an operation on a JavaInterop wrapper obtained via Symbol.as method. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	36 import java.lang.reflect.Method;
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	37 import java.net.URI;
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	38 import java.net.URL;
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	39 import java.net.URLConnection;
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	40 import java.nio.file.Files;
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	41 import java.util.ArrayList;
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	42 import java.util.Arrays;
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	43 import java.util.Collections;
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	44 import java.util.HashMap;
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	45 import java.util.LinkedHashSet;
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	46 import java.util.List;
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	47 import java.util.Map;
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	48 import java.util.Set;
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	49 import java.util.concurrent.CountDownLatch;
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	50 import java.util.concurrent.Executor;
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	51 import java.util.logging.Level;
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	52 import java.util.logging.Logger;
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	53
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	54 import com.oracle.truffle.api.CallTarget;
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	55 import com.oracle.truffle.api.TruffleLanguage;
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	56 import com.oracle.truffle.api.TruffleLanguage.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	57 import com.oracle.truffle.api.TruffleLanguage.Registration;
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	58 import com.oracle.truffle.api.debug.DebugSupportProvider;
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	59 import com.oracle.truffle.api.debug.Debugger;
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	60 import com.oracle.truffle.api.debug.ExecutionEvent;
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	61 import com.oracle.truffle.api.debug.SuspendedEvent;
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.impl.Accessor;
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	63 import com.oracle.truffle.api.instrument.ASTProber;
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	64 import com.oracle.truffle.api.instrument.Instrumenter;
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	65 import com.oracle.truffle.api.instrument.Probe;
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	66 import com.oracle.truffle.api.instrument.ToolSupportProvider;
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	67 import 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	68 import com.oracle.truffle.api.interop.java.JavaInterop;
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	69 import com.oracle.truffle.api.source.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	70
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	71 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	72 * <em>Virtual machine</em> for Truffle based languages. Term virtual machine is a bit overloaded,
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	73 * so don't think of <em>Java virtual machine</em> here - while we are running and using
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	74 * {@link TruffleVM} inside of a <em>JVM</em> there can be multiple instances (some would say
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	75 * tenants) of {@link TruffleVM} running next to each other in a single <em>JVM</em> with a complete
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	76 * mutual isolation. There is 1:N mapping between <em>JVM</em> and {@link TruffleVM}.
f879b1fe3773 Separating 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>
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	78 * It would not be correct to think of a {@link TruffleVM} as a runtime for a single Truffle
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	79 * language (Ruby, Python, R, C, JavaScript, etc.) either. {@link TruffleVM} can host as many of
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	80 * Truffle languages as {@link Registration registered on a class path} of your <em>JVM</em>
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	81 * application. {@link TruffleVM} orchestrates these languages, manages exchange of objects 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	82 * calls among them. While it may happen that there is just one activated language inside of 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	83 * {@link TruffleVM}, the greatest strength of {@link TruffleVM} is in interoperability between all
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	84 * Truffle languages. There is 1:N mapping between {@link TruffleVM} and {@link TruffleLanguage
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	85 * Truffle language implementations}.
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	86 * <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	87 * Use {@link #newVM()} to create new isolated virtual machine ready for execution of various
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	88 * languages. All the languages in a single virtual machine see each other exported global symbols
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	89 * and can cooperate. Use {@link #newVM()} multiple times to create different, isolated virtual
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	90 * machines completely separated from each other.
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	91 * <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	92 * 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	93 * 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	94 * 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	95 * 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	96 * 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	97 * <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	98 * The <code>TruffleVM</code> is single-threaded and tries to enforce that. It records the thread 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	99 * has been {@link Builder#build() created} by and checks that all subsequent calls are coming from
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	100 * the same thread. There is 1:1 mapping between {@link TruffleVM} and a thread that can tell 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	101 * what to do.
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	102 */
f879b1fe3773 Separating 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 @SuppressWarnings("rawtypes")
f879b1fe3773 Separating 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 public final class TruffleVM {
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	105 static final Logger LOG = Logger.getLogger(TruffleVM.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	106 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	107 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	108 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	109 private final Map<String, Language> 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	110 private final Reader 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	111 private final Writer 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	112 private final Writer 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	113 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	114 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	115 private final Instrumenter 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	116 private Debugger debugger;
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	117
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	118 /**
f879b1fe3773 Separating 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 * 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	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 TruffleVM() {
f879b1fe3773 Separating 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 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	123 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	124 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	125 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	126 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	127 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	128 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	129 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	130 this.instrumenter = 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	131 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	132
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	133 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	134 * 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	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 private TruffleVM(Executor executor, Map<String, Object> globals, Writer out, Writer err, Reader in, 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	137 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	138 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	139 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	140 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	141 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	142 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	143 this.globals = new HashMap<>(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	144 this.instrumenter = SPI.createInstrumenter();
22137 1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	145 Map<String, Language> map = new HashMap<>();
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	146 for (Map.Entry<String, LanguageCache> en : LanguageCache.languages().entrySet()) {
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	147 map.put(en.getKey(), new Language(en.getValue()));
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	148 }
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 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	150 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	151
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	152 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	153 * 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	154 * 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	155 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	156 * <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	157 * {@link TruffleVM} vm = {@link TruffleVM}.{@link TruffleVM#newVM() newVM()}
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	158 * .{@link Builder#stdOut(java.io.Writer) stdOut}({@link Writer yourWriter})
f879b1fe3773 Separating 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 * .{@link Builder#stdErr(java.io.Writer) stdErr}({@link Writer yourWriter})
f879b1fe3773 Separating 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 * .{@link Builder#stdIn(java.io.Reader) stdIn}({@link Reader yourReader})
f879b1fe3773 Separating 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 * .{@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	162 * </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	163 *
f879b1fe3773 Separating 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 * 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	165 * 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	166 * {@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	167 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	168 * @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	169 */
f879b1fe3773 Separating 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 public static TruffleVM.Builder newVM() {
f879b1fe3773 Separating 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 // 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	172 // nasty trick to avoid the Builder class to appear
f879b1fe3773 Separating 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 // in Javadoc next to TruffleVM 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	174 TruffleVM vm = new TruffleVM();
f879b1fe3773 Separating 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 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	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
f879b1fe3773 Separating 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 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	179 * Builder for a new {@link TruffleVM}. Call various configuration methods in a chain and at 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	180 * end create new {@link TruffleVM 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	181 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	182 * <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	183 * {@link TruffleVM} vm = {@link TruffleVM}.{@link TruffleVM#newVM() newVM()}
f879b1fe3773 Separating 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 * .{@link Builder#stdOut(java.io.Writer) stdOut}({@link Writer yourWriter})
f879b1fe3773 Separating 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 * .{@link Builder#stdErr(java.io.Writer) stdErr}({@link Writer yourWriter})
f879b1fe3773 Separating 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 * .{@link Builder#stdIn(java.io.Reader) stdIn}({@link Reader yourReader})
f879b1fe3773 Separating 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 * .{@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	188 * </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	189 */
f879b1fe3773 Separating 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 public final class 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	191 private Writer 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	192 private Writer 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	193 private Reader 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	194 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	195 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	196 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	197
f879b1fe3773 Separating 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 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	199 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	200
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	201 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	202 * Changes the default output for languages running in <em>to be created</em>
f879b1fe3773 Separating 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 * {@link TruffleVM virtual machine}. The default is to use {@link System#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	204 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	205 * @param w the writer to use as output
f879b1fe3773 Separating 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 * @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	207 */
f879b1fe3773 Separating 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 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	209 out = 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	210 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	211 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	212
f879b1fe3773 Separating 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 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	214 * Changes the error output for languages running in <em>to be created</em>
f879b1fe3773 Separating 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 * {@link TruffleVM virtual machine}. The default is to use {@link System#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	216 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	217 * @param w the writer to use as output
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	218 * @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	219 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	220 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	221 err = 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	222 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	223 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	224
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	225 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	226 * Changes the default input for languages running in <em>to be created</em>
f879b1fe3773 Separating 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 * {@link TruffleVM virtual machine}. The default is to use {@link System#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	228 *
f879b1fe3773 Separating 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 * @param r the reader to use as input
f879b1fe3773 Separating 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 * @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	231 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	232 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	233 in = 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	234 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	235 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	238 * Registers another instance of {@link EventConsumer} into the to be created
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	239 * {@link TruffleVM}.
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	240 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	241 * @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	242 * @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	243 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	244 public Builder 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	245 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	246 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	247 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	248 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 * Adds global named symbol into the configuration of to-be-built {@link TruffleVM}. 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	252 * symbol will be accessible to all languages via {@link Env#importSymbol(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	253 * and will take precedence over {@link TruffleLanguage#findExportedSymbol symbols exported
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	254 * by languages itself}. Repeated use of <code>globalSymbol</code> is possible; later
f879b1fe3773 Separating 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 * definition of the same name overrides the previous one.
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	256 *
f879b1fe3773 Separating 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 * @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	258 * @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	259 * <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	260 * @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	261 * @see TruffleVM#findGlobalSymbol(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	262 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	263 public Builder globalSymbol(String name, Object 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	264 globals.put(name, 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	265 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	266 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	267
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	268 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	269 * Provides own executor for running {@link TruffleVM} scripts. By default
f879b1fe3773 Separating 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 * {@link TruffleVM#eval(com.oracle.truffle.api.source.Source)} 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	271 * {@link Symbol#invoke(java.lang.Object, java.lang.Object...)} are executed synchronously
f879b1fe3773 Separating 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 * in the calling thread. Sometimes, however it is more beneficial to run them
f879b1fe3773 Separating 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 * asynchronously - the easiest way to do so is to provide own executor when configuring 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	274 * { {@link #executor(java.util.concurrent.Executor) the builder}. The executor is expected
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	275 * to execute all {@link Runnable runnables} passed into its
f879b1fe3773 Separating 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 * {@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	277 * 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	278 *
f879b1fe3773 Separating 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 * @param executor the executor to use for internal execution inside the {@link #build() to
f879b1fe3773 Separating 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 * be created} {@link TruffleVM}
f879b1fe3773 Separating 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 * @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	282 */
f879b1fe3773 Separating 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 @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	284 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	285 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	286 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	287 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	288
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	289 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	290 * Creates the {@link TruffleVM Truffle virtual machine}. The configuration is taken from
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	291 * values passed into configuration methods in this 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	292 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	293 * @return 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	294 */
f879b1fe3773 Separating 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 public TruffleVM 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	296 if (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	297 out = new OutputStreamWriter(System.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	298 }
f879b1fe3773 Separating 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 if (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	300 err = new OutputStreamWriter(System.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	301 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	302 if (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	303 in = new InputStreamReader(System.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	304 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	305 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	306 @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	307 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	308 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	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 return new TruffleVM(nonNullExecutor, globals, out, err, in, handlers.toArray(new EventConsumer[0]));
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	312 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	313 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	314
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	315 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	316 * 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	317 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	318 * @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	319 * 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	320 */
f879b1fe3773 Separating 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 public Map<String, Language> getLanguages() {
f879b1fe3773 Separating 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 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	323 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 * 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	327 * 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	328 * 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	329 *
f879b1fe3773 Separating 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 * @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	331 * @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	332 * @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	333 * 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	334 * @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	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 @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	337 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	338 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	339 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	340 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	341 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	342 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	343 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	344 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	345 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	346 } 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	347 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	348 } 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	349 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	350 } 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	351 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	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 } 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	354 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	355 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	356 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	357 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	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 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	360 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	361 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	362 }
f879b1fe3773 Separating 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 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	364 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	365
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	366 /**
f879b1fe3773 Separating 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 * 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	368 * {@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	369 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	370 * @param 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	371 * @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	372 * @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	373 * @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	374 * @deprecated use {@link #eval(com.oracle.truffle.api.source.Source)}
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	375 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	376 @Deprecated
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	377 public Object eval(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	378 checkThread();
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	379 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	380 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	381 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	382 }
f879b1fe3773 Separating 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 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	384 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 /**
f879b1fe3773 Separating 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 * 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	388 * {@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	389 *
f879b1fe3773 Separating 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 * @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	391 * @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	392 * @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	393 * @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	394 * @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	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 @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	397 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	398 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	399 Language l = langs.get(mimeType);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	400 if (l == null) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	401 throw new IOException("No language for MIME type " + mimeType + " found. Supported types: " + langs.keySet());
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	402 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	403 return eval(l, 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	404 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	405
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	406 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	407 * Evaluates 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	408 * {@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	409 * 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	410 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	411 * @param source code snippet to execute
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	412 * @return a {@link Symbol} object that holds result of an execution, never <code>null</code>
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	413 * @throws IOException thrown to signal errors while processing the code
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	414 */
f879b1fe3773 Separating 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 public Symbol eval(Source source) 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	416 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	417 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	418 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	419 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	420 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	421 }
f879b1fe3773 Separating 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 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	423 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	424
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	425 private Symbol eval(final Language l, final 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	426 final Debugger[] fillIn = {debugger};
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	427 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	428 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	429 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	430 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	431 @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	432 public void run() {
22133 c334865b9d42 Make sure TruffleLanguage.createEnv is only called when Accessor.CURRENT_VM is known Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22132 diff changeset	433 evalImpl(fillIn, lang, s, result, l, ready);
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	434 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	435 });
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	436 exceptionCheck(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	437 return new Symbol(lang[0], result, 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	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
22132 19205292b0c7 Suppressing "try" lints Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22129 diff changeset	440 @SuppressWarnings("try")
22133 c334865b9d42 Make sure TruffleLanguage.createEnv is only called when Accessor.CURRENT_VM is known Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22132 diff changeset	441 private void evalImpl(Debugger[] fillIn, TruffleLanguage<?>[] fillLang, Source s, Object[] result, Language l, CountDownLatch ready) {
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	442 try (Closeable d = SPI.executionStart(this, fillIn, s)) {
22137 1957c49a979d (Re)Introducing LanguageCache - e.g. data that hold the essential static information about Truffle languages. Pre-initializing the data if AOT property is specified. Use mx -J-Dcom.oracle.truffle.aot=true unittest to validate proper behavior of AOT mode. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22135 diff changeset	443 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	444 fillLang[0] = langImpl;
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	445 if (debugger == null) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	446 debugger = fillIn[0];
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	447 }
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	448 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	449 } 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	450 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	451 } 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	452 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	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 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	455
f879b1fe3773 Separating 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 /**
f879b1fe3773 Separating 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 * 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	458 * 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	459 * 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	460 * <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	461 * 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	462 * 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	463 * <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	464 * <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	465 * <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	466 * </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	467 * 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	468 * 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	469 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	470 * @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	471 * @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	472 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	473 public Symbol findGlobalSymbol(final String 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	474 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	475 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	476 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	477 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	478 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	479 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	480 @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	481 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	482 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	483 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	484 });
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	485 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	486 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	487 } 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	488 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	489 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	490 } 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	491 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	492 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	493 return obj[0] == null ? null : new Symbol(lang[0], obj, 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	494 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	495
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	496 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	497 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	498 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	499 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	500 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	501 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	502 }
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	503 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	504 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	505 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	506 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	507 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	508 }
f879b1fe3773 Separating 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 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	511 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	512 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	513 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	514 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	515 }
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	516 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	517 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	518 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	519 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	520 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	521 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	522 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	523 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	524 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 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	527 if (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	528 throw new IllegalStateException("TruffleVM created on " + initThread.getName() + " but used on " + Thread.currentThread().getName());
f879b1fe3773 Separating 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
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	532 @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	533 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	534 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	535 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	536 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	537 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	538 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	539 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	540 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	541 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	542 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	543
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	544 @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	545 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	546 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	547
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	548 @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	549 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	550 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	551
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	552 @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	553 <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	554 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	555 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	556 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	557 }
f879b1fe3773 Separating 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 }
f879b1fe3773 Separating 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 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 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	562 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	563 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	564 }
f879b1fe3773 Separating 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 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	566 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	567 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 /**
f879b1fe3773 Separating 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 * Represents {@link TruffleVM#findGlobalSymbol(java.lang.String) global symbol} provided by one
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	572 * of the initialized languages in {@link TruffleVM 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	573 */
f879b1fe3773 Separating 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 public class 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	575 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	576 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	577 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	578 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	579
f879b1fe3773 Separating 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 Symbol(TruffleLanguage<?> language, Object[] result, 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	581 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	582 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	583 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	584 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 /**
f879b1fe3773 Separating 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 * 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	588 * 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	589 * {@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	590 * 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	591 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	592 * @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	593 * @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	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 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	596 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	597 exceptionCheck(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	598 return result[0];
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	599 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	600
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	601 /**
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	602 * 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	603 * 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	604 * {@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	605 * just handles primitive types as well.
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	606 *
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	607 * @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	608 * @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	609 * @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	610 * @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	611 * @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	612 */
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	613 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	614 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	615 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	616 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	617 }
22141 46384e637592 Make sure the proper TruffleVM execution context is re-set before invoking an operation on a JavaInterop wrapper obtained via Symbol.as method. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	618 T wrapper = JavaInterop.asJavaObject(representation, (TruffleObject) obj);
46384e637592 Make sure the proper TruffleVM execution context is re-set before invoking an operation on a JavaInterop wrapper obtained via Symbol.as method. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	619 return JavaWrapper.create(representation, wrapper, this);
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	620 }
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	621
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	622 /**
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	623 * 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	624 * 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	625 * 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	626 * 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	627 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	628 * @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	629 * 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	630 * @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	631 * @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	632 * <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	633 * @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	634 */
f879b1fe3773 Separating 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 public Symbol invoke(final Object thiz, final Object... args) 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	636 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	637 final Debugger[] fillIn = {debugger};
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	638 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	639 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	640 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	641 @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	642 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	643 invokeImpl(fillIn, thiz, args, res, done);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	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 exceptionCheck(res);
f879b1fe3773 Separating 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 return new Symbol(language, res, done);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	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
22132 19205292b0c7 Suppressing "try" lints Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22129 diff changeset	650 @SuppressWarnings("try")
22141 46384e637592 Make sure the proper TruffleVM execution context is re-set before invoking an operation on a JavaInterop wrapper obtained via Symbol.as method. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	651 final Symbol invokeProxy(final InvocationHandler chain, final Object wrapper, final Method method, final Object[] args) throws IOException {
46384e637592 Make sure the proper TruffleVM execution context is re-set before invoking an operation on a JavaInterop wrapper obtained via Symbol.as method. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	652 final Debugger[] fillIn = {debugger};
46384e637592 Make sure the proper TruffleVM execution context is re-set before invoking an operation on a JavaInterop wrapper obtained via Symbol.as method. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	653 final CountDownLatch done = new CountDownLatch(1);
46384e637592 Make sure the proper TruffleVM execution context is re-set before invoking an operation on a JavaInterop wrapper obtained via Symbol.as method. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	654 final Object[] res = {null, null};
46384e637592 Make sure the proper TruffleVM execution context is re-set before invoking an operation on a JavaInterop wrapper obtained via Symbol.as method. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	655 executor.execute(new Runnable() {
46384e637592 Make sure the proper TruffleVM execution context is re-set before invoking an operation on a JavaInterop wrapper obtained via Symbol.as method. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	656 @Override
46384e637592 Make sure the proper TruffleVM execution context is re-set before invoking an operation on a JavaInterop wrapper obtained via Symbol.as method. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	657 public void run() {
46384e637592 Make sure the proper TruffleVM execution context is re-set before invoking an operation on a JavaInterop wrapper obtained via Symbol.as method. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	658 try (final Closeable c = SPI.executionStart(TruffleVM.this, fillIn, null)) {
46384e637592 Make sure the proper TruffleVM execution context is re-set before invoking an operation on a JavaInterop wrapper obtained via Symbol.as method. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	659 if (debugger == null) {
46384e637592 Make sure the proper TruffleVM execution context is re-set before invoking an operation on a JavaInterop wrapper obtained via Symbol.as method. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	660 debugger = fillIn[0];
46384e637592 Make sure the proper TruffleVM execution context is re-set before invoking an operation on a JavaInterop wrapper obtained via Symbol.as method. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	661 }
46384e637592 Make sure the proper TruffleVM execution context is re-set before invoking an operation on a JavaInterop wrapper obtained via Symbol.as method. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	662 res[0] = chain.invoke(wrapper, method, args);
46384e637592 Make sure the proper TruffleVM execution context is re-set before invoking an operation on a JavaInterop wrapper obtained via Symbol.as method. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	663 } catch (IOException ex) {
46384e637592 Make sure the proper TruffleVM execution context is re-set before invoking an operation on a JavaInterop wrapper obtained via Symbol.as method. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	664 res[1] = ex;
46384e637592 Make sure the proper TruffleVM execution context is re-set before invoking an operation on a JavaInterop wrapper obtained via Symbol.as method. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	665 } catch (Throwable ex) {
46384e637592 Make sure the proper TruffleVM execution context is re-set before invoking an operation on a JavaInterop wrapper obtained via Symbol.as method. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	666 res[1] = ex;
46384e637592 Make sure the proper TruffleVM execution context is re-set before invoking an operation on a JavaInterop wrapper obtained via Symbol.as method. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	667 } finally {
46384e637592 Make sure the proper TruffleVM execution context is re-set before invoking an operation on a JavaInterop wrapper obtained via Symbol.as method. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	668 done.countDown();
46384e637592 Make sure the proper TruffleVM execution context is re-set before invoking an operation on a JavaInterop wrapper obtained via Symbol.as method. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	669 }
46384e637592 Make sure the proper TruffleVM execution context is re-set before invoking an operation on a JavaInterop wrapper obtained via Symbol.as method. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	670 }
46384e637592 Make sure the proper TruffleVM execution context is re-set before invoking an operation on a JavaInterop wrapper obtained via Symbol.as method. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	671 });
46384e637592 Make sure the proper TruffleVM execution context is re-set before invoking an operation on a JavaInterop wrapper obtained via Symbol.as method. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	672 exceptionCheck(res);
46384e637592 Make sure the proper TruffleVM execution context is re-set before invoking an operation on a JavaInterop wrapper obtained via Symbol.as method. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	673 return new Symbol(language, res, done);
46384e637592 Make sure the proper TruffleVM execution context is re-set before invoking an operation on a JavaInterop wrapper obtained via Symbol.as method. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	674 }
46384e637592 Make sure the proper TruffleVM execution context is re-set before invoking an operation on a JavaInterop wrapper obtained via Symbol.as method. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	675
46384e637592 Make sure the proper TruffleVM execution context is re-set before invoking an operation on a JavaInterop wrapper obtained via Symbol.as method. Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22137 diff changeset	676 @SuppressWarnings("try")
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	677 private void invokeImpl(Debugger[] fillIn, Object thiz, Object[] args, Object[] res, CountDownLatch done) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	678 try (final Closeable c = SPI.executionStart(TruffleVM.this, fillIn, 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	679 if (debugger == null) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	680 debugger = fillIn[0];
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	681 }
f879b1fe3773 Separating 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 List<Object> arr = 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	683 if (thiz == null && language != 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	684 Object global = SPI.languageGlobal(SPI.findLanguage(TruffleVM.this, language.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	685 if (global != 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	686 arr.add(global);
f879b1fe3773 Separating 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 }
f879b1fe3773 Separating 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 } 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	689 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	690 }
f879b1fe3773 Separating 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 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	692 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	693 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	694 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	695 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	696 }
f879b1fe3773 Separating 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 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	698 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	699 } 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	700 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	701 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	702 }
f879b1fe3773 Separating 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 } 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	704 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	705 } 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	706 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	707 } 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	708 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	709 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	710 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	711
f879b1fe3773 Separating 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 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	713 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	714 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	715 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	716 } 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	717 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	718 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	719 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	720 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	721
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	722 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	723 * Description of a language registered in {@link TruffleVM Truffle virtual machine}. 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	724 * are registered by {@link Registration} annotation which stores necessary information into 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	725 * descriptor inside of the language's JAR file. When a new {@link TruffleVM} is created, 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	726 * reads all available descriptors and creates {@link Language} objects to represent them. One
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	727 * can obtain a {@link #getName() name} or list of supported {@link #getMimeTypes() 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	728 * for each language. The actual language implementation is not initialized until
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	729 * {@link TruffleVM#eval(java.lang.String, java.lang.String) a code is evaluated} in 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	730 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	731 public final 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	732 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	733 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	734
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	735 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	736 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	737 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 * 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	741 *
f879b1fe3773 Separating 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 * @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	743 */
f879b1fe3773 Separating 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 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	745 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	746 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	747
f879b1fe3773 Separating 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 /**
f879b1fe3773 Separating 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 * 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	750 *
f879b1fe3773 Separating 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 * @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	752 */
f879b1fe3773 Separating 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 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	754 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	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 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	758 * 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	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 * @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	761 */
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	762 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	763 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	764 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	765
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	766 /**
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	767 * 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	768 *
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	769 * @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	770 */
f879b1fe3773 Separating 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 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	772 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	773 }
c334865b9d42 Make sure TruffleLanguage.createEnv is only called when Accessor.CURRENT_VM is known Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22132 diff changeset	774
c334865b9d42 Make sure TruffleLanguage.createEnv is only called when Accessor.CURRENT_VM is known Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: 22132 diff changeset	775 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	776 getEnv(create);
22219 1c0f490984d5 Merge with f47b601edbc626dcfe8b3636933b4834c89f7779 Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22157 22217 diff changeset	777 TruffleLanguage<?> impl = info.getImpl(false);
1c0f490984d5 Merge with f47b601edbc626dcfe8b3636933b4834c89f7779 Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22157 22217 diff changeset	778 if (impl != null) {
1c0f490984d5 Merge with f47b601edbc626dcfe8b3636933b4834c89f7779 Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22157 22217 diff changeset	779 ASTProber prober = SPI.getDefaultASTProber(impl);
1c0f490984d5 Merge with f47b601edbc626dcfe8b3636933b4834c89f7779 Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22157 22217 diff changeset	780 if (prober != null) {
1c0f490984d5 Merge with f47b601edbc626dcfe8b3636933b4834c89f7779 Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22157 22217 diff changeset	781 instrumenter.registerASTProber(prober);
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	782 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	783 }
f879b1fe3773 Separating 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 return impl;
f879b1fe3773 Separating 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
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	787 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	788 if (env == null && 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	789 env = SPI.attachEnv(TruffleVM.this, info.getImpl(true), out, err, in);
22128 f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	790 }
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	791 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	792 }
f879b1fe3773 Separating 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 @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	795 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	796 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	797 }
f879b1fe3773 Separating 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 } // 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	799
f879b1fe3773 Separating 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 //
f879b1fe3773 Separating 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 // 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	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
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	804 TruffleLanguage<?> findLanguage(Class<? extends TruffleLanguage> 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	805 for (Map.Entry<String, Language> entrySet : langs.entrySet()) {
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	806 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	807 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	808 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	809 return impl;
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	810 }
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	811 }
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	812 throw new IllegalStateException("Cannot find language " + languageClazz + " among " + langs);
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	813 }
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	814
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 TruffleLanguage<?> findLanguage(Probe probe) {
22219 1c0f490984d5 Merge with f47b601edbc626dcfe8b3636933b4834c89f7779 Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22157 22217 diff changeset	816 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	817 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 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	820 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	821 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	822 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	823 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	824 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	825 }
f879b1fe3773 Separating 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 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	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
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	830 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	831 @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	832 public Object importSymbol(Object vmObj, TruffleLanguage<?> ownLang, String 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	833 TruffleVM vm = (TruffleVM) vmObj;
f879b1fe3773 Separating 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 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	835 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	836 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	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 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	839 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	840 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	841 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	842 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	843 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	844 }
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	845 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	846 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	847 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	848 }
f879b1fe3773 Separating 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 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	851 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	852 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	853 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	854 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	855 }
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	856 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	857 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	858 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	859 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	860 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	861 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	862 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	863
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	864 @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	865 public Env attachEnv(Object obj, TruffleLanguage<?> language, Writer stdOut, Writer stdErr, Reader stdIn) {
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	866 TruffleVM vm = (TruffleVM) 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	867 return super.attachEnv(vm, language, stdOut, stdErr, stdIn);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	868 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	870 @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	871 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	872 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	873 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating 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 @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	876 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	877 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	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 @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	881 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	882 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	883 }
f879b1fe3773 Separating 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
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	885 @SuppressWarnings("deprecation")
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	886 @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	887 public ToolSupportProvider getToolSupport(TruffleLanguage<?> l) {
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	888 throw new UnsupportedOperationException();
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	889 }
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	890
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	891 @SuppressWarnings("deprecation")
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	892 @Override
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	893 public DebugSupportProvider getDebugSupport(TruffleLanguage<?> l) {
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	894 throw new UnsupportedOperationException();
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	895 }
f879b1fe3773 Separating 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 @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	898 protected Instrumenter createInstrumenter() {
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	899 return super.createInstrumenter();
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	900 }
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	901
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	902 @Override
22219 1c0f490984d5 Merge with f47b601edbc626dcfe8b3636933b4834c89f7779 Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22157 22217 diff changeset	903 protected ASTProber getDefaultASTProber(TruffleLanguage impl) {
1c0f490984d5 Merge with f47b601edbc626dcfe8b3636933b4834c89f7779 Michael Van De Vanter <michael.van.de.vanter@oracle.com> parents: 22157 22217 diff changeset	904 return super.getDefaultASTProber(impl);
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	905 }
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	906
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	907 @Override
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	908 protected Instrumenter getInstrumenter(Object obj) {
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	909 final TruffleVM vm = (TruffleVM) obj;
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	910 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	911 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	912
f879b1fe3773 Separating 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 @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	914 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	915 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	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
f879b1fe3773 Separating 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 @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	919 protected Env findLanguage(Object obj, Class<? extends TruffleLanguage> 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	920 TruffleVM vm = (TruffleVM) 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	921 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	922 }
f879b1fe3773 Separating 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
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	924 @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	925 protected TruffleLanguage findLanguageImpl(Object obj, Class<? extends TruffleLanguage> 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	926 final TruffleVM vm = (TruffleVM) obj;
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	927 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	928 }
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	929
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	930 @Override
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	931 protected Closeable executionStart(Object obj, Debugger[] fillIn, 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	932 TruffleVM vm = (TruffleVM) 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	933 return super.executionStart(vm, fillIn, s);
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	934 }
f879b1fe3773 Separating the TruffleVM into its own project makes it possible to cleanup various system parts interations Jaroslav Tulach <jaroslav.tulach@oracle.com> parents: diff changeset	935
f879b1fe3773 Separating 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 @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	937 protected void dispatchEvent(Object obj, Object 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	938 TruffleVM vm = (TruffleVM) 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	939 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	940 }
f879b1fe3773 Separating 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 } // 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	942 }

Mercurial > hg > truffle

annotate truffle/com.oracle.truffle.api.vm/src/com/oracle/truffle/api/vm/TruffleVM.java @ 22219:1c0f490984d5